跟讀練習: PLC Programming #5: User-Defined Data Types (UDTs) Explained - 通過影片學習英語口語

選擇練習模式

每種模式都會開啟全屏練習室。

183 句

如果句子過短或過長，請點選 Edit 進行調整。

Hello and welcome back to the channel.

In today's video, we'll be continuing our PLC tutorial series.

And today we'll be looking at user -defined data types, UDTs, which are a super important concept in PLC programming.

Okay, so today's tutorial is going to be a little bit different

because I've been doing a lot of code along tutorials in this series, but today's video is going to need to feature a fair bit of structured text,

which I haven't gone super deep into on the channel. And

so I think what would be more valuable than sharing the

writing of this code line by line is talk about the concept and show it in a practical use environment.

And then I'll explain to you the code I generated for this.

start very high level with the concept,

a user defined data type is essentially a grouping of tags that you want associated with a shared type of device.

So a very common example is in a big chemical plant, you'd make a user defined data type for every valve, every pump and motor.

And sometimes you go even more generic and you say every two state device is going to have auto manual commands,

it'll have alarms, overrides, and a whole bunch more features.

Every single device of this type is going to have these things.

So you bunch a bunch of features together for shared objects in a data type.

The example that I'm going to show with you guys today is going to be alarms.

This is very common, regardless of the size of your system, to want a bunch of shared alarms in your factory.

So if you're building a little standalone system, there still could be 15, 20 things that go wrong with it.

And if you're controlling an entire factory from this PLC, there could be hundreds or thousands of things that could go wrong with it.

So in TIA Portal, there's a folder called PLC data types over on the left in the system tree.

In Rockwell, I think there's a section called UDTs, user -defined data types.

And most other PLC platforms, it'll be pretty clear.

It'll be something that says data types.

And when you make a new one, you go to add new data type.

I've already generated the base code for alarm.

And here's where I think it's really clear what's going on.

You're saying, what does every alarm have?

that's going to trigger it initially

and then it's going to need to give me the option to acknowledge

that alarm and say yep i've seen it because

when you trigger an alarm the most normal response case is

that a light would turn on to say hey i'm in

alarm state you would shut down the logic until someone had come over

and said i see the alarm it's okay to resume

So then there will be this bit tracking if that alarm is active, if it has not yet been acknowledged.

And then when someone does try to acknowledge it, we need to retain that bit because there's a chance someone hits acknowledge, but the trigger condition is still active.

In that case, we need to see that it's been acknowledged, but not yet cleared.

sort of SCADA software so you can track alarms over time

and then we'll just give a couple identifying things so id

and message could just be like enumerated one through 20

and message could be like here's the thing that just happened

so you put that information again on an HMI

and we'll say every alarm in our system we want to share these

and you can see we have booleans we have long date say no matter how many alarms we make,

we want to keep track of all of these alarms.

And then to show where this gets really useful, we make a data block, we make a global database apologies.

And we say, hey, we're going to store all the information about all these alarms inside of this database.

So I go and make an array of 20 alarms.

And right off the bat, I get 20 individual Initially,

I have one of these tied to a physical push button.

I have another one tied to a PLC bit.

I could come right in here and I could say this is actually my third alarm.

It doesn't matter.

And then we'll say and this ID is two.

And you can see this is the default timestamp it loads in at.

So this has never been triggered.

OK, but I get all of this information for 20 objects, 21, really, just by making an array from zero to 20 of alarm.

I can make infinite numbers of that data type and I get all of those tags populated every time.

And then I made one individual outside of the array to say current alarm

because a really common thing in big systems in particular is alarm fatigue

and so many alarms go off when something shuts down

that you lose sight of what has happened most recently or what the most critical one is.

So I made a separate one and for the sake of this demonstration today this will be really valuable whatever triggered last.

So you can see the last alarm that I triggered was the button trigger, the one that's tied to the button.

So I'm going to drag that off to the side, we'll pull that back up later.

But now we've created a bunch of these objects, right, they live in this DB alarms, but we're not doing anything with them yet.

And this is where the structured text is going to come in.

So buckle up.

An important thing to understand is for loops are not super easy to

something kind of brute force with like counter variables and move blocks.

But almost the whole reason structured text became a thing.

And in Siemens, it's called SCL structured command language.

It is Siemens version of structured text, all the syntax people can calm down.

The reason structured text kind of emerged as a viable PLC programming language is

because loops and other sort of more advanced programming concepts are really tricky to do in ladder.

Rockwell does have a four block, but honestly, if you can pick up a little bit of structured text, you're going to be a better PLC programmer anyways.

And I'll talk you through what's happening here.

And let's talk through how you would want alarms in your factory to work.

Any alarm goes off in my system and I want it to activate the alarm light, the, hey, you have an alarm and it hasn't been acknowledged light.

So that's my light zero right here.

last alarm that occurred is into my current alarm field.

Okay, this is partly for me for this tutorial.

So I can keep it up over here on the right and show you how this code works.

But this is also a very real world scenario where you'd want to keep track of whatever the last alarm

that went off was and show that on the HMI

or you might want to do it where the first right the oldest unacknowledged alarm was

that might be more useful if you're doing like root cause analysis.

pretty easily in structured text.

And what we're going to do here is we're going to talk through the code

that I have set up in my alarm processing routine.

And then if you're doing this in kind of a follow along fashion, feel free to pause and copy it.

Um, and then But anyways, the first thing we're going to do is we're just going to check the local time.

This is useful when we're doing time comparisons later.

And then we're going to reset the light to zero.

So the way functions work, and this is in a function, not a function block, the way functions work is they don't have memory.

So we're going to start every scan of the alarm logic as if there is no alarm active.

And so we're going to turn the light off unless we find

that one of the alarms is active as we iterate through on our for loop.

100

that's when we'll turn the light back on as we'll see in a bit.

101

Okay.

102

And then latest time and latest index are just going to be, they're going to be checkers for us to see if we've iterated through the whole loop.

103

And if we found alarms that have gone off more recently than the kind of initial time, right?

104

The default time when you first set up a new tag.

105

Okay.

106

So hopefully that or Python programming, Arduino.

107

Hopefully this looks pretty familiar to you at the beginning.

108

Now, the meat of what the alarm handler is doing for us is it's iterating from zero to 20, right?

109

Because we made an array of zero to 20 alarms.

110

So important to note, If you made a new array with 50 new alarms and you call them something different, you do need to make a new version of this

111

or at least update this counter with your new array size and you need to point it at the right input tags.

112

Okay.

113

But anyways, for zero to 20, which is going to iterate through all of our alarms in our database of alarms.

114

First, we're going to check if the trigger is active.

115

So if it's actively having the alarm condition trigger it, and it hasn't already been active so if the triggers on

116

but we've already seen

117

that it's active on past cycles doesn't make sense to do all this initial stuff again

118

but what we'll do then is we'll say okay active is true we'll reset acknowledged

119

because even if for some reason it had been previously acknowledged the alarm is still occurring

120

so we'll make that false and then we'll set the time stamp

121

that this alarm has last gone off at as temp time so this will give us a snapshot of the triggered.

122

Then we'll also say if acknowledge is true, or this is something I forgot to mention, acknowledge all.

123

So what I have physically is two push buttons, one I'm going to use to trigger one of the alarms.

124

The other one I want to use as an acknowledge all button.

125

Okay, if you've been in an industrial environment, it's very normal for a cabinet to have like an alarm acknowledge push button on the outside.

126

So I have an acknowledge all push button here.

127

So if I acknowledge just or I press acknowledge all,

128

then I want acknowledged acknowledged past tense to go equal to true and then I can reset acknowledge equal to false.

129

Again, acknowledged is that intermediate value that's checking to see if acknowledged has been true, then I should reset the thing.

130

If trigger is not currently active and acknowledged is true, then we want to set active back equal to false.

131

And we don't really need an and if active check here

132

because there's no harm in setting a value that's already false equal to false again.

133

So And then again, if we get any alarm that is currently active, let's have our active alarm light just be on.

134

And then this little bit here is just for us to be able to track the most recently triggered

135

and active alarm and move it into our global alarm.

136

So that's this line down here, whatever our latest time and latest alarm indexes, let's go ahead and copy that whole thing into the current alarm.

137

And then the last thing we'll do is we'll assume ACK all is equal to false, right?

138

So if we detect that it's true, we'll go ahead and reset it at the end.

139

This we could actually delete most likely now that I'm reading it to you, but we're going to leave it as is because I know this is working.

140

So I put all that logic in a function I called alarm handler.

141

And then in main, I call two things, I call the alarm handler, and then I call another function called alarm setup.

142

And this one I made purely for the sake of demonstrating how this works.

143

Okay.

144

So like I I'm the first one tied to zero on my PLC.

145

I'm going to use it to simulate the trigger for alarm zero.

146

And then I made a memory tag called trigger one, I'll use that to simulate triggering alarm one.

147

And then my other push button tied to input one, I'll use that as the acknowledge all signal.

148

Okay, again, I hope this is making sense in terms of why to use it, I set up alarm zero and alarm one to be a button trigger and a PLC bit trigger.

149

I trigger them here on the left, you'll see them populate this current alarm on the right, and you'll get a good sense of the benefit of a UDT.

150

So if I push the start push button, you can see on the left side there that activates alarm zero in the field, my output, my light is on now.

151

And if I go ahead and press stop, all that'll trigger acknowledge all the light is off.

152

And what you can see in current alarm here in the bottom right, is we got an updated timestamp and it says, hey, the button trigger was the last alarm to go off.

153

Now, if I modify to one, what's cool is the light just turned on in the field.

154

So the same output triggered, that's my, hey, an alarm is active and hasn't been acknowledged yet.

155

And here you can see PLC bit trigger is the last alarm that got triggered.

156

And the ID is one, and I got an updated timestamp.

157

So again, I'll press acknowledge, but it's not going to actually trigger condition is still true.

158

If I modify to zero, the trigger condition goes away.

159

Now I can clear the thing.

160

So I'm able to generate a lot of alarms with shared logic very quickly

161

and they all have a trigger and acknowledge and active acknowledge timestamp.

162

They have all these shared conditions

163

and I know they're going to work the same way thanks to the UDT that I generate.

164

But I can still reference the individual tags under each of those alarms and use them to program unique functionality.

165

So if only one or two of these alarms need to open up a vent valve or stop a certain pump, I could still do that with these UDTs.

166

Hopefully that's a useful practical tutorial for you.

167

Apologies, this is a little bit of a chaotic tutorial, but this is honestly a pretty tricky one to teach

168

because I didn't want to get super in the weeds on structured text with you

169

and the lines and the use cases between UDTs and function blocks and instance data blocks do get a little bit blurry.

170

that you want every device of a certain type to have access to, to one master data type tag,

171

like an alarm that needs a trigger, acknowledge, active, and timestamp.

172

It's also totally common practice to create UDTs, data types for devices like alarms, pumps, motors, valves, analog sensors,

173

and combine that with function blocks.

174

So it's not either or user defined data types or function

175

be combined and that's how you can make some really powerful clean well -structured code okay

176

so i still hope this practical tutorial was useful for you as always

177

if you have questions

178

or there are things i forgot to cover in this feel

179

free to ask them in the comments below i'll get back

180

to you as soon as i can let me know what

181

you want to see next on the channel in the comments

182

and please don't forget to leave a like on the video subscribe to the channel

183

if you're finding this content useful thanks for watching good luck with your projects and see you next time Bye.

下載應用

流利口語所需的一切

AI 發音評分逐句打分

音標練習掌握每個音

詞彙學習建立你的詞庫

詞彙遊戲邊玩邊學

掃碼

Download on theApp Store Get it onGoogle Play

同頻道

Types of Proximity Sensors! #automation #engineering #science #robotics #electronics

Daily ConversationUniversity StudentsWorking Adults

Adding an E-Stop to our Conveyor Build! #plc #automation #engineering #robotics #mechatronics

Business EnglishUniversity StudentsWorking Adults

FOR YOU

關於本課

在本課中，學習者將通過觀看一段關於使用者定義資料型別（UDTs）的程式設計影片，深入瞭解PLC程式設計的基本概念。您將練習專業術語的發音，瞭解如何在實際環境中應用這些概念，進而提升您的英語表達能力。通過這種方式，您不僅能夠提高英語發音，還能夠理解程式語言中的重要術語，從而更自信地進行技術交流。

關鍵詞彙與短語

使用者定義資料型別 (UDT)
報警 (Alarm)
觸發條件 (Trigger Condition)
確認 (Acknowledge)
狀態 (State)
共享物件 (Shared Objects)
全域性資料庫 (Global Database)
系統樹 (System Tree)

練習技巧

在進行英語發音練習時，您可以採用“shadowing”技術，模仿影片中的講述。不論是聲音的音調、語速還是語氣，都要儘量保持一致。由於影片的講解節奏較快，建議您可以先慢速播放影片，專注於模仿每個技術術語的發音。例如，當聽到“使用者定義資料型別”時，暫停並嘗試重複，確保每一個音節都準確清晰。隨著練習的深入，您可以逐漸提升播放速度，挑戰自己的發音能力。

在模仿的過程中，嘗試將學習的詞彙和短語嵌入到自己的日常對話中，幫助鞏固記憶。可以設定每週的目標，例如使用不同的語境講述智慧工廠的概念，或者在與他人討論時穿插理解的程式設計術語，增強自信心和流利度。

通過觀看這類影片，如“看YouTube學英語”，您不僅能學到專業的技術內容，還能提高英語能力，特別是在雅思口語練習中，準確的發音是成功的關鍵。利用這種方法，您將能夠在職業生涯和學術上取得更大的進步，成為更自信的英語使用者。

影片中的語法

說話人最常用的結構，並附上影片中的原話：

結構	影片中的用法
條件句 if + 從句，will/would + 動詞 — 條件及其結果	if we detect that it's true, we'll go
現在完成時 have/has + 過去分詞 — 過去發生但與現在仍有關聯的事	haven't gone · I've already generated · i've seen
被動語態 be + 過去分詞 — 強調發生了什麼，而不是誰做的	been acknowledged · been triggered · be combined

什麼是跟讀法？

跟讀法 (Shadowing) 是一種有科學依據的語言學習技巧，最初開發用於專業口譯員的培訓，並由多語言者Alexander Arguelles博士普及。這個方法簡單而強大：您在聽英語母語原聲的同時立即大聲重複——就像是一個延遲1-2秒緊跟說話者的影子。與被動聽力或語法練習不同，跟讀法強迫您的大腦和口腔肌肉同時處理並模模擬實的講話模式。研究表明它能顯著提高發音準確性，語調，節奏，連讀，聽力理解和口語流利度——使其成為雅思口語備考和真實英語交流最有效的方法之一。

影子跟讀法: 閱讀完整分步指南 →

跟讀練習: PLC Programming #5: User-Defined Data Types (UDTs) Explained - 通過影片學習英語口語

選擇練習模式

下載應用

同頻道

Types of Proximity Sensors! #automation #engineering #science #robotics #electronics

PLC Programming #4: Functions, Function Blocks & Organization Blocks Explained

Going Online with a PLC, Uploading and Downloading Code!

PLC Programming Tutorial - Ladder Logic #3: Math and Calculations

What is a PLC and how does it work?

How to Scale Analog Values in PLC Programming!

PLC Programming Tutorial - Ladder Logic #1: Binary & Boolean Operations

PLC Programming Tutorial - Ladder Logic #2: Timers and Counters

How to Get Started with C# in Visual Studio Code! Full Tutorial for Beginners

PLC State Machines Explained

Adding an E-Stop to our Conveyor Build! #plc #automation #engineering #robotics #mechatronics

推薦影片

Learn Data Modeling in 8 minutes: Dimensional Data Modeling, Data Vault, and One Big Table

#03 Strategic Types of Human Resources Management

What is clean code? - Uncle Bob

Claude Code: The Advanced Guide (99% of Devs Skip These Features)

Understanding BGA Pads: Solder Mask Defined vs Non-Defined

Introduction to RTOS Part 1 - What is a Real-Time Operating System (RTOS)? | Digi-Key Electronics

Introduction to Constrained Planning

Cursed Units 2: Curseder Units

Civil 3D course for beginners - Part 1 of 3

P1 机器学习的应用【2024公认最好的 | 吴恩达机器学习 | 教程 | Machine Learning Specialization(超爽中英!)】

關於本課

關鍵詞彙與短語

練習技巧

影片中的語法

什麼是跟讀法？