跟读练习: PLC Programming #5: User-Defined Data Types (UDTs) Explained - 通过视频学习英语口语

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.

📺 同频道

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

Business EnglishUniversity StudentsWorking Adults

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

Business EnglishUniversity StudentsWorking Adults

✨ 推荐视频

120 句

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

Business EnglishUniversity StudentsWorking Adults

406 句

#03 Strategic Types of Human Resources Management

Business EnglishUniversity StudentsWorking Adults

235 句

The GELU, SiLU and SwiGLU activation functions, clearly explained!!!

Business EnglishUniversity StudentsWorking Adults

114 句

BAS Bootcamp: Day 6 Setting up IO Internally

Business EnglishUniversity StudentsWorking Adults

155 句

Every Hardware Protocol Explained Simply in 10 Minutes!

Business EnglishUniversity StudentsWorking Adults

333 句

Master n8n Triggers in 20 Minutes – Automate Anything

Business EnglishUniversity StudentsWorking Adults

236 句

The 7 Quality Control (QC) Tools Explained with an Example!

Business EnglishUniversity StudentsWorking Adults

102 句

What is Docker? Docker container concept explained || Docker Tutorial 1

Business EnglishUniversity StudentsWorking Adults

443 句

Functional-Oriented Documentation in Automation - Eplan & IEC 81346 Explained

Business EnglishUniversity StudentsWorking Adults

423 句

Free CCNA | VLANs (Part 2) | Day 17 | CCNA 200-301 Complete Course

Business EnglishUniversity StudentsWorking Adults

309 句

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

Business EnglishUniversity StudentsWorking Adults

关于本课

在本课中，学习者将通过观看一段关于用户定义数据类型（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

The GELU, SiLU and SwiGLU activation functions, clearly explained!!!

BAS Bootcamp: Day 6 Setting up IO Internally

Every Hardware Protocol Explained Simply in 10 Minutes!

Master n8n Triggers in 20 Minutes – Automate Anything

The 7 Quality Control (QC) Tools Explained with an Example!

What is Docker? Docker container concept explained || Docker Tutorial 1

Functional-Oriented Documentation in Automation - Eplan & IEC 81346 Explained

Free CCNA | VLANs (Part 2) | Day 17 | CCNA 200-301 Complete Course

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

关于本课

关键词汇与短语

练习技巧

视频中的语法

什么是跟读法？