Shadowing Practice: PLC Programming #4: Functions, Function Blocks & Organization Blocks Explained - Learn English Speaking with Video

בחר מצב תרגול

כל מצב פותח חדר תרגול במסך מלא.

276 משפטים

אם המשפטים קצרים או ארוכים מדי, לחץ על ערוך כדי להתאים אותם.

Hello and welcome back to the channel.

In today's video we'll be continuing our PLC tutorial series by looking at functions, function blocks and data blocks, and organization blocks.

The basic structure of how you create a large PLC program.

So of all the videos that we've done so far, this is the first one where much of what I'm saying will be Siemens specific

and there are a few other equipment manufacturers that use a similar structure to Siemens.

And there are some So I will try to call out what those differences are.

Broadly speaking, the topics will still apply to both and more universally any PLC that you're writing code for.

But some of the specific syntax will be Siemens specific in this tutorial.

Let's start from organization block.

The basic thing when you create a new PLC program, whether you're in Allen Bradley,

Rockwell or Siemens, you're going to be given main and it's going to be this special kind of

special kind of routine on both platforms.

Main is the PLC's main object loop.

It is the start here and go as fast as you can by default thing for both PLCs.

So if you remember or if you've seen the how PLCs work video that I published on my channel,

you'll know that we can go into a PLC and we can see how fast it's doing cycles.

That's this cycle time or scan time depending on what

scan of the PLC logic every millisecond

so that's a thousand times per second the longest one it's had is two milliseconds

and that was probably on boot so by default any code

that we drop in main is going to be getting processed as fast as the PLC can so

if we do just the very simplest piece of code we

could do to reorient everyone I have two input push buttons and one output light hooked up with.

If I just basically said, hey, when I push this button, I want this light to turn on,

I can put that in main main is a spot where you can technically write code.

But as we're going to talk about next, organizationally, you don't really want to put any functional code in main, all you want to do is call functions

and function blocks from main for almost any system that's going to be more than a few lines of code long.

So I put that code in and now I can push the start

and I can see the light turn on in the field.

So this is functional code.

But when you get to dozens or hundreds or thousands of IO points in a system, you don't want to put that stuff in main.

Instead, you want to create a new block, and here's where you need to decide between functions and function blocks.

And the number one thing I'm going to say the difference between functions and function blocks is, is memory.

Functions process things every scan, and then they make decisions about outputs, use them to calculate math and scale variables,

but they're not retaining anything in memory.

They don't have anywhere to store calculations in math that they did in the intermediate.

So functions are instantaneous.

So we'll just make an example function here

and we're going to replace this line of code in main

which is an organization block we're going to get rid of this

and instead we're going to call the example function

so this is the main loop saying all right go do this function

and then in this function we're going to evaluate here

and we're actually going to say okay

when I press the start button let's get rid of this momentary coil

and say when I press the start button set the light on and let's add a second rung of code

the stop push button, reset the light or turn it off.

Okay, so we've got this little function that says when the first button is pressed, turn that light on.

When I've got the second button, turn that light back off.

And then from main, which is my organization block, I'm saying, okay, call that function every scan of the cycle time.

Here you can see If I had hundreds of functions,

this main organization block can still stay fairly organized because all it's doing is calling specific functions in specific orders.

And if I had a function for every valve or every group of valves or every pump or every motor, it's still going to be pretty neat from the main organization block to go

and just see what gets called and in what order.

doing.

And they're very focused on a small subset of groups and functions.

So we'll go ahead and we'll download this real quick.

Okay, and now when I'm looking at main, I just see that the example function is lit up green, meaning it's getting called.

And if I go into example function, and I start monitoring it, I can see that the energy right is highlighted left here is green, and it's making it to these buttons.

So if I hold down the start button, and then release it, I've got the it resets it and it turns the light off.

So my function is working great.

And main, my organization block is calling that function.

Now, there's two other types of organization block we're going to touch on super quickly.

And then there's actually a lot more types of organization block, but they're a little more niche and nuanced.

So it's not really worth a high level overview covering them.

But if I go to organization block, I'm going to make one called startup.

And there's actually a block in Siemens called startup.

Alan Bradley, like I said, they don't have a special organization block for startup.

They have a bit that's like S colon FS, and it's a little different.

Logix 500 versus 5000, but they have a way to say, do this only on first scan is what they call it.

But the idea is the same.

Run this cycle of code exactly once when it starts up.

And the reason you might put in a certain state when they start up.

So like if I put the light here and I said, okay, the first time this code runs, I actually want that light to turn on because by default,

I'd like the light to be on until I come in and press the button to turn it off.

This is a spot where I could say right when the PLC boots up, turn that light on, but then it's going to stop getting called after that because it only runs on startup.

Similarly, one other type of organization block I here before we move on.

And you can actually see here a list of all the organization blocks that sort of come with TIA Portal.

But the other one I want to talk about is cyclic interrupt.

So you can have stuff that does not check that absolute as fast as the PLC can process, which is like every millisecond.

Here I can say, actually, I only want it to check 10 times a second.

So every hundred milliseconds or every half second.

So 500 milliseconds.

I can define how frequently I want

have issues with blipping sensors or things that happen way too frequently

and it's just creating noise for your program

or it's a little bit more processor intensive and

so it's actually harder for the plc to process it super

frequently things like pid loops have to go in cyclic interrupt blocks

because you can't update a pid a thousand times per second

and expect the the devices in the field to actually respond to that

so a cyclic interrupt is where you could say like okay

now I'm going to maybe get rid of the example function code where the stop push button is turning the light off.

And instead, I'm going to put this in cyclic interrupt, which means it's possible I'll have to hold that stop push button down for between, you know, one and 500 milliseconds,

depending on where in the scan cycle I am.

So I could drop this in the cyclic interrupt and delete it from example function.

And now I'm going to go ahead and download this.

What you'll notice is organization blocks, I did not have to add to main because organization blocks have rules about when they get called by default,

but you don't have to do anything special to make sure they get called.

100

Half second we made to get called every 500 milliseconds, and startup is going to get called when we boot the PLC up.

101

So I'm going to download this and a recap of everything we should have happen.

102

We're going to go ahead and continue.

103

We're going to have to restart the PLC, and we should have the light turn on.

104

and then we should be able to hold down the stop push button

105

and that'll make it turn off but

106

if I just click the stop push button we're not necessarily guaranteed to have the light turn off.

107

Okay so I can sit here and I can click the stop push button momentarily

108

and it's not turning the light off by default

109

because sometimes I'm clicking it way too fast but

110

if I hold it down I make sure that it gets scanned in

111

that half millisecond time and that actually gets it to turn off.

112

Okay so

113

an introduction to uh organization blocks right we have a startup one

114

that puts that light

115

or pumps valves motors devices in startup state whatever you want them to default to

116

when you first boot a system up main organization block is where we call all the functions

117

and function blocks that we want to have scan every loop of the plc

118

and you can use cyclic interrupts for things we've started covering functions a little bit,

119

let's go ahead and do a little bit more, right?

120

We can do something beyond just check if button pressed and set light on.

121

Something like a very common thing might be scaling a analog value.

122

So if we had a value that was coming in raw from a PLC, zero to 27 ,648, you know,

123

basically an unscaled electrical signal on an IO card, take our raw input

124

and we'll we'll make one up for this it's not a wiring lesson let's go ahead

125

and define a global memory word let's say word

126

and it's going to be an integer okay and let's just say

127

that we have this raw input coming in

128

and we want to divide it by 27 ,678 like I said 27 ,648 sorry it by 100.

129

So this is basically like a very simple scaling function.

130

Allen Bradley, they will call these compute blocks instead of calculate blocks.

131

But the idea is the same, you can take this input one, you can divide it by what's your max span of the unprocessed signal.

132

And then you can multiply it by 100.

133

So you're basically getting a zero to 100 value, not by 100 by input three.

134

There we go.

135

in another tag that we'll call scaled input.

136

OK, and we'll define that as a global memory as well.

137

and that'll be the next integer.

138

Okay.

139

All right.

140

So this is a good example of something you might use a function block for.

141

There's no need to store this in memory because it's something that's getting calculated every scan of the PLC.

142

So if you had a temperature here that's constantly fluctuating, you want to recalculate what the scaled input is every scan of the PLC.

143

One other little syntactic thing it's important to call out is because this is calculating an integer, right?

144

We made that a word.

145

So it's not a real, it's not capable of holding decimal points.

146

We actually want the internal math to be done as reals.

147

And Alan, Siemens does this really nice thing with the indicated with these little squares that it's doing implicit type changing.

148

So it's taking an integer value, it's converting it to a real, it'll do real math, and then I'll convert it to an integer on the outset.

149

Not every PLC platform does that.

150

So, you know, if this was just an

151

be doing this in one divided by into and then rounding to the nearest integer.

152

But the whole point of this is it's taking something

153

that could be up to 27 ,000 scaling it back

154

and then multiplying by 100 to basically get a zero to 100 % percentage.

155

So we want to calculate a real just a little bit of PLC programming fun there for everybody.

156

And let's go ahead and send that live.

157

Basically now input is 59.

158

But if this was some device in the field and oh, it saw a pressure spike or a temperature spike and goes up to 1800, it gets recalculated as a 65.

159

So scaling of analog values is a really great example of something where a function does everything you'd need it to do.

160

There's no need for function blocks here because that's an instantaneous calculation

161

that you want to have done every scan of the PLC.

162

So that's a decent explanation, I think, of functions.

163

Now do want function blocks.

164

But the most important use case is to keep in mind, do I want memory?

165

Do I want something that gets stored and retained between cycles?

166

Pretty simple analogy that I've seen before and had explained to me before is a function is like a vending machine.

167

You walk up, you put in money, you get whatever you ordered out.

168

And a function block is kind of like a bartender where they remember your favorite order

169

and you can walk in and they remember what you got making you your regular.

170

So if you're an analogies person, maybe that helps.

171

But let's use an example of let's say I had not just one light hooked up, but let's go ahead into PLC tags and say I had two lights hooked up.

172

Or, you know, really, you can put yourself in the shoes of like, hey, maybe I have hundreds or thousands of devices in my system.

173

So I have so many pumps or motors or valves, in the same way.

174

So now I have light zero and light one.

175

And I want to write just a light function that is going to handle some code for all of them.

176

So I'll just call this light and I'm going to make it a function block.

177

OK.

178

And the thing I want to retain the memory

179

that I want out of this function block is how long each light has been active.

180

OK, so I want to keep track of my input, which I'm going to come up here in the top section, which is where I can define inputs,

181

outputs, things that need to both get passed in and go out.

182

things, things that are going to get used inside of the routine only, as well as temporary and constant values.

183

Now for the input, I'm going to say, well, that's actually just going to be the light input.

184

Okay, so I'm going to tie whatever light this is keeping track of to this light input parameter

185

when I call the function.

186

And then the main thing I'm going to output is going to be runtime minutes, and I'll make it a real so we can keep track of fractional minutes.

187

And then in here, I'm going to make a very simple little bit of code.

188

I'm going to check when my light input is active.

189

Oh, I need the pound sign.

190

But so we're going to have this light input and we're going to have it activate a retentive timer.

191

Okay.

192

And if you're following along with the series, you're probably familiar with the T O N R, which is a timer that keeps counting up and will retain how long a timer has been active.

193

And we'll call this runtime.

194

because it's happening inside of a data block.

195

So we want it to get generated for every data block like this.

196

Again, single instance, multi -instance, parameter instance, these are all just options of creating timers.

197

The alternative would be you have to generate a new one

198

of these outside of your function every time you made a new one of these.

199

So we're gonna make it a parameter instance and it's going to automatically get dropped in, in, out.

200

We don't actually need it getting passed in or out.

201

video and then I'm gonna make this elapsed timer I'm gonna make it 10 minutes so that's 600 ,000 milliseconds

202

And then we're going to come down here and we're going to move that time value of elapsed time.

203

We're going to go ahead and move it into an intermediate value.

204

So we'll take runtime, hashtag runtime dot elapsed time,

205

and we're going to move it into an intermediate value that we'll just call runtime milliseconds.

206

So this way we can have a tag.

207

This will also be local static.

208

int, that'll be fine, didn't just to make sure it's big enough.

209

And now we have a milliseconds value we can do math on.

210

So then we'll last thing we'll do is we'll make a calculate block, and we'll take runtime milliseconds, and we'll divide it by 60 ,000.

211

Okay, and this will tell us our runtime minutes, whoops, runtime, underscore minutes.

212

Alrighty, and then the function for this in one divided by in two, like that.

213

And I think maybe the only thing we have to do here is say local output, local out, and real.

214

And I'm a little surprised I'm getting this at all.

215

Oh, yes, of course.

216

So the reason I'm getting the red squiggly lines on this first one

217

and down there is I accidentally put the hash signs in these tags when I define them up here, which is not correct.

218

You need the hash signs when you reference them down here, those pound signs, but you don't put them on the tag names up top.

219

So sorry for slipping.

220

These tutorials are a fast.

221

So everyone makes mistakes.

222

Okay, so to recap what we're doing here, we're going to pass in a value of a light, we're going to count up how long that timer has been counting,

223

convert it to a milliseconds value, divide it by 60 ,000 and report back the runtime minutes.

224

And we have two lights now.

225

So we'll go into example function.

226

And we'll say, all right, start push button is going to be button,

227

let's say, will be tied to light one.

228

I'll make these both momentary coils, and I'll just go ahead and delete half second and startup.

229

We don't need those anymore.

230

So basically, I'll even delete this calculate block.

231

We really don't need that either.

232

So basically the total code in the system now is

233

when I'm holding start push button down the light zero should turn on

234

when I'm holding the second button down light one should turn on

235

and I have this function called light that should give me a count up counter for both those lights.

236

But I have to do this last important step similar to the original function, I have to call them both.

237

So here I'm going to say light zero and you can see when I dragged that function block that I just defined.

238

into main to get called, it automatically said, hey, you need to make a data block to store the memory associated with this instance of your function block.

239

So I'll call this light zero data block.

240

And then I'm going to make another light.

241

And this is where you see the power of function blocks.

242

I'm going to make another light and call it light one data block.

243

And I'm going to tie this light input to light zero.

244

And I'm going to type this light input into light one.

245

I'm going to download this PLC function and if we did it right

246

and that's a big if I should have two different timers here

247

That when I hold down the two different buttons They're both going to activate different retentive timers

248

and I get the this functionality of seeing how long they've

249

been running for free Twice even though I only wrote the code once

250

so I'll hold down one button here

251

and the timer does not count up I'll hold down the other that timer does not count up epic

252

we got the wrong type here.

253

So yeah, so we're calculating a dent, which means an integer value, which means it's going to be rounding to the nearest whole minute, which is why nothing happened on the seconds order.

254

Let's go ahead and make that a real and download.

255

All right, but let's go back to main now that we're calculating reels.

256

And actually, you can see immediately, we have these fractional values already, which is cool.

257

So let's try this demo.

258

Let's hold down light one.

259

Okay, and now let's hold down light zero.

260

All right, and hopefully you can see, this is a very simple example because I'm trying to go fast for this YouTube tutorial,

261

but we got retentive timers to tell us how long these lights were running for free by writing general code,

262

generic code in a function block that can be extrapolated away to many instances.

263

So if I made a thousand light objects, I could call all of them from main,

264

And I would get this counter of how long they've each

265

been running just by tying the correct input to each of those data block instances.

266

So that's kind of the main reason to use function blocks and data blocks instead of just plain old functions.

267

That's how organization blocks work.

268

And again, PLC to PLC, these individual things can get called something different.

269

But the main way they work and the main thing they do are pretty universal across every platform.

270

So I hope you found this tutorial useful.

271

been enjoying the controls and automation series.

272

As always, let me know in the comments if you have any questions

273

or what you'd like to see more of on the channel.

274

Please consider leaving a like on the video and subscribing to the channel, and we'll see you next time.

275

Thanks.

276

Bye.

הורד אפליקציה

כל מה שאתה צריך כדי לדבר בשטף

הגיית AIציון לכל משפט

תרגול IPAשלוט בכל צליל

אוצר מיליםבנה את מאגר המילים שלך

משחק אוצר מיליםלמד תוך כדי משחק

סרוק QR

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

המלץ על סרטון

166 משפטים

Can This Robot Be My Personal Assistant

Daily ConversationWorking Adults

114 משפטים

BAS Bootcamp: Day 6 Setting up IO Internally

Daily ConversationWorking Adults

94 משפטים

Your AI broke the layout. Now what?

Daily ConversationWorking Adults

238 משפטים

Wiring Allen Bradley Compactlogix Sinking Inputs and Sourcing Outputs

Daily ConversationWorking Adults

74 משפטים

LangChain in 5 Minutes (Explained Clearly)

Daily ConversationUniversity StudentsWorking Adults

423 משפטים

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

Daily ConversationUniversity StudentsWorking Adults

43 משפטים

SDLC Vs STLC: Software Development Life Cycle and Software Testing Life Cycle

Daily ConversationUniversity StudentsWorking Adults

272 משפטים

How I'd Learn n8n if I had to Start Over in 2026

Daily ConversationUniversity StudentsWorking Adults

108 משפטים

How I Learned Procedural Generation

Daily ConversationUniversity StudentsWorking Adults

223 משפטים

9 Insane Claude Mods I Already Can't live Without

Daily ConversationUniversity StudentsWorking Adults

אוצר מילים והערות הגייה לשיעור הזה

שיעור הדיבור הזה ברמה C1 מבוסס על הסרטון “PLC Programming : Functions, Function Blocks & Organization Blocks Explained”. המילים שחוזרות הכי הרבה: function, block, plc, main, button. בסרטון הזה יש 276 משפטים ו-3752 מילים לתרגול Shadowing. הדיבור נמשך 22:00. הדובר מדבר בקצב טבעי של כ-171 מילים בדקה, קרוב לשיחה יומיומית. 84% מהמילים נמצאות בין 3,000 המילים הנפוצות ביותר באנגלית; כדאי ללמוד את השאר לפני שמתחילים.

אוצר מילים מרכזי בסרטון הזה

15 המילים המתקדמות ביותר בסרטון, עם ההגייה והמשמעות שלהן:

מילה	הגייה	משמעות
timer שם עצם	/ˈtaɪmɚ/	טיימר
scan פועל	/skæn/	סָרַק
calculate פועל	/ˈkælkjʊleɪt/	חישב \ חִשֵּׁב
startup שם עצם	/ˈstɑɹtˌʌp/	סטארטאפ, חברת סטארטאפ
integer שם עצם	/ˈɪn.tɪ.d͡ʒə(ɹ)/	שלם, מספר שלם
cyclic שם תואר	/ˈsaɪ.klɪk/	מחזורי, מחזורית
hash שם עצם	/ˈhæʃ/	סוּלָּמִית
analog שם תואר	/ˈænəlɔɡ/	אָנָלוֹגִי
calculation שם עצם	/ˌkælkjuˈleɪʃn̩/	חִשׁוּב \ חישוב
reset פועל	/ɹiːˈsɛt/	אפס
bartender שם עצם	/ˈbɑɹˌtɛndɚ/	בַּרְמֶן, מוֹזֵג
syntax שם עצם	/ˈsɪn.tæks/	תַּחְבִּיר
subset שם עצם	/ˈsʌbˌsɛt/	תת קבוצה
colon שם עצם	/ˈkoʊ.lən/	נקודתיים
dent שם עצם	/dɛnt/	מַכָּה

Phrasal verbs שתשמעו

מילה	משמעות
turn off פועל	כיבה, כִּבָּה
go out פועל	יָצָא

משפטים שכדאי לחזור עליהם

משפטים קצרים ושלמים מהסרטון שאפשר להשתמש בהם בשיחה יומיומית:

Let's start from organization block.
We're going to go ahead and continue.
Do I want something that gets stored and retained between cycles?
We don't need those anymore.
We really don't need that either.

דקדוק בסרטון הזה

המבנים שהדובר משתמש בהם הכי הרבה, עם המילים המדויקות מהסרטון:

מבנה	בסרטון
משפטי זיקה (Relative clauses) who / which + clause — מידע נוסף על אדם או דבר	main, which is · process, which is · interrupt, which means
הווה מושלם (Present perfect) have/has + past participle — פעולה שקרתה בעבר ועדיין יש לה חשיבות או השפעה עכשיו	we've done · you've seen · we've started
סביל (Passive voice) be + past participle — הדגש הוא על מה שקורה, לא על מי שעושה את הפעולה	be given · is pressed · is lit

הגייה ששווה לשים לב אליה

הדובר משתמש ב-125 קיצורים וצורות מקוצרות, כמו I'm, we're, we'll. אמרו אותם בצורה הקצרה, כפי שאתם שומעים אותם.

הצלילים של “sh” ו-“zh”: fractional /ˈfɹæk.ʃən.əl/, hash /ˈhæʃ/, calculation /ˌkælkjuˈleɪʃn̩/, hashtag /ˈhæʃˌtæɡ/, automation /ˌɔ.təˈmeɪ.ʃən/
מילים ארוכות — שימו לב להטעמה: millisecond /ˈmɪlɪˌsɛkənd/, parameter /pəˈɹæm.ə.tɚ/, intermediate /ɪn.tə(ɹ)ˈmi.di.ət/, instantaneous /ɪnstənˈteɪni.əs/, momentary /ˈmoʊmənˌtɛɹi/

צלילים שדוברי עברית מתקשים בהם:

/æ/ — פתוח יותר מה-“אֶ” העברית, לא כמו “a” ב-“cup”: scan /skæn/, calculate /ˈkælkjʊleɪt/, elapse /ɪˈlæps/, parameter /pəˈɹæm.ə.tɚ/, fractional /ˈfɹæk.ʃən.əl/
/r/ — הלשון לא נוגעת בשום מקום, לא ה-“ר” הגרונית: startup /ˈstɑɹtˌʌp/, integer /ˈɪn.tɪ.d͡ʒə(ɹ)/, interrupt /ˌɪntəˈɹʌpt/, tutorial /ˌtjuːˈtɔːɹɪəl/, retentive /ɹɪˈtɛntɪv/
עיצור קולי בסוף מילה — /b/, /d/, /g/, /z/, /v/ בלי להפוך אותם לאטומים: millisecond /ˈmɪlɪˌsɛkənd/, retentive /ɹɪˈtɛntɪv/, analog /ˈænəlɔɡ/, hashtag /ˈhæʃˌtæɡ/, subscribe /səbˈskɹaɪb/

איך לתרגל עם הסרטון הזה

הקשיבו לכל הסרטון פעם אחת בלי לדבר, ורשמו את המילים שאתם לא מכירים.
התחילו במהירות 0.75×, תרגלו Shadowing משפט אחר משפט, וחזרו למהירות רגילה כשזה מרגיש קל.
הקליטו את עצמכם והשוו למקור, תוך תשומת לב למילים כמו timer, scan, calculate.

מהי טכניקת השאדואינג?

שאדואינג היא טכניקת למידת שפה מבוססת מדע שפותחה במקור להכשרת מתורגמנים מקצועיים ופופולרית על ידי הפוליגלוט ד"ר אלכסנדר ארגואלס. השיטה פשוטה אך עוצמתית: אתה מקשיב לאודיו באנגלית ילידית וחוזר עליו בקול רם מיד — כמו צל העוקב אחרי הדובר עם עיכוב של 1–2 שניות בלבד. בניגוד להאזנה פסיבית או תרגילי דקדוק, שאדואינג מכריח את המוח והשרירים בפה לעבד ולשחזר דפוסי דיבור אמיתיים בו זמנית. מחקרים מראים שזה משפר משמעותית את דיוק ההגייה, האינטונציה, הקצב, הדיבור המחובר, הבנת השמיעה ושטף הדיבור — מה שהופך אותו לאחת השיטות היעילות ביותר להכנה לIELTS Speaking ולתקשורת באנגלית בעולם האמיתי.

טכניקת Shadowing: קרא את המדריך המלא שלב אחר שלב →

Shadowing Practice: PLC Programming #4: Functions, Function Blocks & Organization Blocks Explained - Learn English Speaking with Video

בחר מצב תרגול

הורד אפליקציה

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

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 #5: User-Defined Data Types (UDTs) Explained

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

Can This Robot Be My Personal Assistant

BAS Bootcamp: Day 6 Setting up IO Internally

Your AI broke the layout. Now what?

Wiring Allen Bradley Compactlogix Sinking Inputs and Sourcing Outputs

LangChain in 5 Minutes (Explained Clearly)

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

SDLC Vs STLC: Software Development Life Cycle and Software Testing Life Cycle

How I'd Learn n8n if I had to Start Over in 2026

How I Learned Procedural Generation

9 Insane Claude Mods I Already Can't live Without

אוצר מילים והערות הגייה לשיעור הזה

אוצר מילים מרכזי בסרטון הזה

Phrasal verbs שתשמעו

משפטים שכדאי לחזור עליהם

דקדוק בסרטון הזה

הגייה ששווה לשים לב אליה

איך לתרגל עם הסרטון הזה

מהי טכניקת השאדואינג?