Starting/Stopping OEE Runs and Traceability Operations

Episode 1: Flatten-the-Stack Webinar Series

56-minute video  //  45-minute read

Starting/Stopping OEE Runs and Traceability Operations Overview

Starting and stopping OEE runs and traceability operations are integral to the successful transformation of your raw materials into finished goods. This webinar features our best practices and helps you explore how to efficiently start and stop your OEE production runs and enhance your traceability operations! We’ve received an abundance of feedback that have placed OEE runs and traceability operations among the top of our list so we thought it best to provide this webinar as not only a reference, but a guide as well.

As we guide you through the best practices surrounding your implementation, we’ll explore the ISA-95 standard and how that applies to your OEE Operations.

Excited to learn more? Reach out to us to schedule a live demo today!

Schedule a Demo

Starting/Stopping OEE Runs and Traceability Operations Transcript

Tom Hechtman (0:00)
Hello, everyone. Thank you for coming today. This is a new series that we plan to have on a monthly cadence, and the name is Flattening the Stack with Keith. Keith will get into the description of why that was selected, but I just kind of wanted to let everybody know real briefly, this is kind of a direct result of the tech support, the most common issues and such, so we’ll have a webinar to cover it, and one of the biggest items in tech support is stopping and starting OEE runs and Track & Trace operations, so we selected that as our first Flatten-the-Stack webinar.

So, with that, we’ll get right into it. I’ll turn it over to Keith.

Keith Adair (0:58)
Alright, hi, folks. Like Tom said, my name is Keith Adair. I’m actually the MES Product Manager here at Sepasoft, and I’ll be leading these every week. So it’s a pleasure to be talking with you folks. Along the way…

Every month. I’m sorry, I said every week, it’s every month. Along the way, if you have questions, feel free to use the GoToWebinar interface to add those questions to the list, we’ll have a Question and Answer session towards the end, where we’ll kind of delve into your questions, and your queries, and those can be about the topic at hand, or they can be about anything.

In this series, we’ll do new product announcements occasionally, but the main driving factor is making things better for you folks, our integrators. So, here we go. Just a bit about the name…so we call this Flattening-the-Stack. They call this the Purdue Model. It’s that stack between your ERP system, your MES system, and your HMI/SCADA system. And our goal at Sepasoft is always trying to make that whole flow easier, making it all simpler here. And so we’re trying to bring those levels closer together.

Now, we’re already a long way towards that, because our MES platform installs right into your Ignition server, it acts as a part of your Ignition gateway. And so at those two levels, your level 3, level 0, 1, 2, are already pretty close together there, and we have our new Business Connector modules we’ll talk about in a future webinar, I’m sure, that can help us with the ERP side of things. But like Tom said, it’s driven by support topics, but if you have any interest or ideas about topics for future webinars, feel free to let us know, and we’re happy to have some thoughts about that, share those with you.

And you folks probably know who we are, but we were incorporated in 2003. We are one of the two Inductive Automation strategic third-party module partners, and we develop and support the MES modules for Ignition. We have lots of customers, we’re growing rapidly. We have 600 MES implementations worldwide, we have more than 30 MES-Certified systems integrators and we’re hoping for more.

And a little bit about our solutions…we try to be flexible, from local to enterprise level. We try to be flexible and scalable…and, of course, we’re based on the ISA-95 platform, which we’ll talk a lot about over the course of this meeting today. We are cross-platform compatible, configurable, and customizable. We really focus on making you efficient, making this offering easy to use, and all of that here.

And then here, just for you folks on this call, just a reminder of our development roadmap. This is of special interest to me as Product Manager. We are currently in the process of developing two major additions to our software. One is the Business Connector module here. And the other is the Enterprise functionality for our MES software. Both of those pieces of software are in a late beta status, and we are working through the kinks on those, finalizing those, and we’re looking to have those released before ICC (Ignition Community Conference) this year, in September.

We are also finalizing our OEE Lite module, which is a simplified version of the OEE module, that allows for fewer inputs, but really gives you the chance to install a more affordable version of the module that gets you right to what you need, and just gets you a single line collecting your OEE values.

Also, due for ICC — so as you can tell, it’s a big time for us — are the Perspective-compatible versions of our modules. So right now, if you want to use our software, using the new Ignition Perspective module, you have to use our scripting API to do so. Come ICC time, we hope to have the operator-side components working by then. And then following that time, we’ll be releasing the configuration-side.

Then off into the future — and this is what’s really exciting — we’re working on a Batch engine module. And then off further into the future is the Maintenance Management module. And we can talk about those in future calls as well, but those are kind of in the whiteboard stage of their progress, but we’re hoping to get moving on those really quickly here.

You folks have seen this probably, but just so you’re aware, that’s the Ignition Software Stack, and you can see where we sit right there, as modules that are part of Ignition. And you’ll see how we implement this and demonstrate this here over the course of this call. I probably did linger here too long, but you folks know about Inductive Automation, and about their platform, Ignition, so I’ll keep moving along here.

Alright, today’s topic is about — and this is again, driven by support — is best practices for starting and stopping operations. That goes for OEE operations, and Track & Trace operations. The frequent goal of integrators, when we speak to them in support and elsewhere, is to reduce the need for operator intervention. So doing that is essential for low-touch projects and implementations. And so we find integrators doing things like starting operations via tag-change event scripts and so on, so forth. And to do that successfully without causing errors or tripping over yourself, it’s really important to use a few best practices. And we’ll go over those over the course of this webinar.

So you folks are familiar with our ISA-95 standard that we rely on here. Operations consists of one or more segments. Those segments have equipment, material, and personnel complex properties. And our modules help you to organize and simplify those hierarchies. So you can create operations that consist of as many segments as you’d like, and those segments all have all these properties you can set on them. And it’s important to know how to use those tools, and when to use which of those tools.

An OEE operation is a particular type of operation that, in our software, consists of two segments: the changeover segment and the production segment. And we expose a few scripting functions that help you transition from idle to changeover to production and back to idle. Those are called beginOEERun(), endOEEChangeover(), and endOEEProduction(). And we provide tools also for you to be aware of what’s already currently happening on your line. So you can use these scripting functions without tripping over yourself, trying to start operations on top of each other. We have tools that help you to do that. So the point of today’s meeting is to show you how to do that both in an OEE context and a Track & Trace context.

So, oops, I went too far. So let’s go to the OEE operations demonstration. I’ll go ahead and hop over to my designer here. And I have developed for today’s webinar a pair of screens that I’ll be distributing to you folks via email after this meeting, and it will contain both a series of screens and controls for OEE operations and Track & Trace operations.

Now, starting with OEE, a lot of this will look familiar to you. We have a few pieces here, the Material Manager, the Work Order Table, the Run Director, and then finally, the scripting implementation of those tools. Let’s start from the top here. As you, of course, know, we define our materials in the Material Manager, so I have a couple of materials here, we’re going to lean on MatDef1 and MatDef2. And as you can see in the bottom of the screen here, we have our line 2, which is an idle. Now we’ve set up this MatDef1 and MatDef2 to run on that line 2 by checking this box here. And likewise, we set up two work orders of MatDef1 and MatDef2, respectively. So, over the course of today, we’ll use just raw material runs and work order operations.

Now, you folks are familiar, I’m sure, with the Run Director, where we just do those things, and the software makes this really easy to do. So if I pick our MatDef1 here, and I go ahead and begin changeover, you’ll see this component go into changeover. I’ll go ahead and hover, and it tells us that our mode is changeover, that’s a code 2, and that our state is non-production for the line. So you see that’s reflected everywhere here. Changeover and non-production for each cell.

And then when I step into production here, those all go green, we get that we’re out of changeover, into production. And notice that the controls are pretty smart here. You can no longer begin operation on this. You can’t begin changeover on this material; we’re already running it. And if I hop over here to MatDef2, then I can’t start an operation there either. There’s some controls and help baked in to keep you from tripping over yourself here.

Now I’ve set this up this way. There’s a property in the component that says “enable simultaneous active”. I’ve set that to false. Now if you set that to true, that’s where the idea of rolling changeover comes in, of gradually progressing from one product to the next. That’s a topic for a different call, and we’ll return to that idea maybe in a future meeting based on your feedback.

But in any case here, if we head over to the scripting implementation, the same idea, the goal is to show you folks how we can develop the same sort of protections that this component offers you on buttons that you can configure yourself, or in tag change event scripts. So we’ll show you how to start material operations and work order operations using the scripting tools in the next tab here.

So let’s hop over there. So on this screen, we have a fairly similar setup. But, instead of having the controls here to start the operation, I have put the script over in buttons, and we’ll walk through those buttons and see what I’m doing to keep myself from causing myself to trip over other operations, or get in trouble with scheduled operations, and those are hidden behind the buttons here.

So we’ll take a look here. Of course the first piece here is the Object Selector. And that is set to show me all of my lines. So it’s checked to show “include MES line objects”. If you look here, I’m not showing anything else. Here it’s a basic component that we have used broadly here. And then, when I choose my line, I’m actually doing some custom script here, so this is kind of nifty. If my custom property is set to materials, I’m going to get the materials available to my line. If it’s set to work orders, I’m going to do a work order filter, and fetch back the work orders that correspond to that line.

So again, I won’t delve too far into this scripting here. You’ll get these screens. But as you can see, when I pick my line, and I pick work orders, I get those work orders, I get these materials, just like I do in the other set of components. And that’s just a very few lines of simple scripting here.

And then, now that I have come into these buttons here, I’m going to draw on the selected either material or work order, and I’m going to begin changeover. And this is where we get to the meat here. If I hop into this button here, you can see that I’m retrieving the line path up here from the MES Object Selector. So that’s where I’m getting my line path, that’s where I’m going to run my operation.

And first, I’m going to check if there’s not already an operation running. I do so via this scripting function. It’s called system.MES.OEE.getOEEAllActiveSegments(). A bit of a mouthful there, but you get the idea. And if we hit control space, we can see the documentation. So we see that it takes a string equipmentPath, and then it’s going to return to me a list of MES object links, one for each response segment. So if you recall from the presentation a moment ago, we have operations and segments. A response segment is the actual execution of a given segment. It’s the live segment that’s running, or it’s a segment that ran in the past, that’s the response segment.

So this scripting function gives you all of the running response segments. And I’m going to say, “Hey…if any current operations exist, then I’m going to throw an error box that says I can’t start this operation; there’s already another operation underway.” Now that’s just what I put in here, but you may do other checks. You may check and see…is another operation running? Well, let’s go ahead and start a rolling changeover. Or you might check for other things. But these are the sorts of things you can do. You can check for current operations, you can get feedback from the system. I urge you to get familiar with the scripting functions available here. So if you pop into OEE here, you can see all the different scripting functions here. They’re plentifully documented over in our documentation base, and you can do these sorts of checks. Looks like I accidentally entered in a couple extra characters here. But now I know I’m not going to start an operation when one’s already active.

Okay, now we’re going to actually get to work here. So first, we’re going to retrieve whether we’re looking at materials or work orders. So I have a property on my container here. So notice I have these materials and work orders in a container, and that’s the container. When I pick materials, it’s going to write materials to a custom property. And you don’t have to do it this way; this is just the way I implemented it. But basically, I’m going to retrieve whether I’m looking at materials or work orders, and I’m going to begin my run.

If I run beginOEErun with material, it requires the selected material, which I retrieve from the dropdown, and it requires the line path, which I get from the MES Object Selector. Likewise, with the work orders, it actually requires two parameters. So if I control + space here again, you’ll see that the work order version requires the work order name and the material name and the equipment path. So if I look here, I supply both those pieces. I get the selected work order, I retrieve the work order object, and I get the material referenced for it. That’s getMaterialRefName(). And again, this is all documented; it’ll all be here for you guys to look at. And I think I’ll come in here after this and chase this down with comments and my codes so you guys see where I’m working with here. But in any case, either way, whether we’re looking at a material or a work order, we’re going to go ahead and begin the OEE run. And so let’s go ahead and do that here.

So we’ll go ahead and begin an operation using MatDef1. And we’ll expand this out. And now we’re beginning changeover. And so we’re in changeover here, just like we did before, only now we have a bit more control. We have the space where we can do whatever we want to do in that button script. And if I go ahead, try to click this again, I get that error. “Error: Cannot start operation. One operation(s) are already underway.” So that way, I have engineered that fail-safe into my system here. Then we can go on to endOEEchangeover. So if I click that button, we are now in production. Let’s look at that button.

So in here, again, we retrieve the line path, and we check for what current segments exist again. And if there are not any current segments, then we’re going to say “We can’t end changeover; there aren’t any operations underway”. So now we’re checking to make sure, okay, are we meaning to end changeover? Is something already happening here? Otherwise, if there are more segments than just one, then we’re going to let you know that so you can triage that. So we’re putting some smarts in these buttons here.

Finally, if changeover is not in the current segment’s name, then it’s not going to let me end changeover, because it’s not in changeover. We’re engineering in these fail-safes, keeping you from getting in trouble here. Looks like we have a spare tab here. Finally, we’re going to go ahead and end OEE changeover; that’s what we did just a minute ago. And again, if I try to hit that button one more time, you’ll get that error we’ve programed in: “Can’t end changeover. The current segment is not in changeover”. It’s that kind of work you’ll be able to do.

Finally, in endOEEproduction looks something like this. First, again, meet our line path, get the current segments. If there aren’t any segments, we’re not going to end production. If there are more than one segments, again, we’re not going to try to end production. And this time, if changeover is in the current segment’s name, we’re going to throw an error. So we’ll go ahead, end production. And we’ll end OEE production. And now the run is over.

So we’re all back to idle. And you can see that we have all these tools that keep us from getting into trouble. We can get at the current segments. We can check how many there are. We can do this work to make sure that we’re doing the right things, we’re not getting in our own way, and all these tools have these fail-safes in.

So when you’re actually working on a project with your end-user, your customer, you can do these kinds of fail-safes. So maybe you have a tag change event script that starts an operation automatically. Maybe you have a big button on the screen that says, “Go.” What have you. I’ve worked with customers who have all of these things. If you have those controls, fail-safes like this are important to use. It’s important to be aware of what’s going on.

So that’s the OEE side and we’ll go on to Track & Trace. And if you had questions about that side, feel free to throw questions. I don’t see any questions yet, but feel free to ask those questions, and I will answer them towards the end.

Alright, I will step forward again here. That was the OEE demonstration. Alright, Track & Trace operations. Now we’ll go over some key concepts here, and I hope this all adds up to you folks. Trace operations can consist of as many segments as you want. So…they represent different phases of your operation: prep, production, inspection, cleanup. Maybe you do different pieces, you’re painting, you’re baking the paint, what have you. You can set up your operation to contain as many segments as you need to properly represent what you’re doing. We provide tools for beginning and ending both operations and segments.

Likewise, if your operations have a one-shot operation, where you’re just going to do something quickly, and you’re not so worried about the length of the operation, you’re not worried about the durations, the counts progressing over time, then we have tools that will allow you to execute segments. So you fire them in one shot, you run them, and so that could be a product movement where you’re not so aware of the rate of movement, if you’re just going to move aloft from one place to another, that could be an inspection, what have you. You can use this to really get at just a quick execution of those segments.

Excuse me, operations and segments are performed in equipment, like lines and cells. So over the course of today’s meeting, we’ll run those operations on lines and cells. And then when you go to start a segment, you’ll do things like set material and set personnel. That’s how you assign materials and personnel to objects. This is all straightforward so far, I hope.

There are three important sets of objects that have to do with operations. We’re going to hit two of those today, in the demonstration. We have definition objects, we have request objects, and we have response objects. So today’s objects that matter are the operations definitions and the operations segments. Those are what you originally configure in the MES Object Editor, and we’ll show you that in a minute here. And our request and response objects derive from those objects. And then operation segments are derived from process segments. So if you have one process that takes place in many operations, you define your process segment, and you can implement that across all your operations. Those are the definitions side.

Our request objects are scheduled instances of that operation. So if you have a paint car operation, and you’re going to do it next Thursday, the objects that exist in our system for that scheduled operation are the request objects. Those are called operations request and request segments. And we’re actually planning for a future session that has to do with those schedule objects and dealing with schedules. That’s for a future session.

But for today, we’re going to lean on the response objects. And your response objects are the objects that are actually executed. It’s like the current operation, it’s past operations, those are responsive objects. Those are called operations response and response segments. Those are what show up in the trace graph. Those are the actually executed versions of those objects. And so over the course of today, when I run scripting functions like create operation, create segment, I am creating the response objects, not the definition objects. Alright, let’s do a demo.

Okay, hop back to our designer here. Alright…and we’ll hop over to my trace screen. Okay, over the course of today, we are going to run a particular operation several times. It’s called Move Lot. And Move Lot comes from a process segment, so here’s the operation. It’s again, a very simple operation where we have an operations definition and an operations segment, this segment being derived from the move lot processing. And this operations segment, if we delve into this here, it has an in material, and an out material, and it’s allowed to run any equipment. So you can see that here just from a glance.

Okay, everything’s okay. The check marks tell me that everything’s configured correctly, or is able to be executed. And you can see, okay which equipment does this run on. Well, it runs on any equipment. Any line or any cell can do a move lot operation. That’s not typically the case. You typically point to a particular equipment class or a particular line, but in this case, I’m just going to say any equipment can run this operation. And I have an in material and an out material. And because this is a very generic operation, I have selected that any material can be run here. And the way you do that is you hop in here, and you get a material class, and one of those classes is any material that comes by default with the software, there’s no special configuration there, you just get that. And it lets you make a generic operation that uses any material. And again, the in lot can be pulled from any equipment, and the out lot can be sent to any equipment. So that’s going to be important here later on in the call.

And then this particular lot just takes whatever lot we give it, and it uses the entire lot quantity. It uses all the pieces that are available to it. And then we have this quantity source link that’s kept in common here. So this quantity source link lets me establish a relationship between the out material and the in material. So that says that the quantity we use for the in material will also be used for the out material. That lets me avoid having to specify quantities, because I’m just going to use everything that’s there, and I’m going to use the same quantity for the out that I do for the in.

Alright…so let’s get going here. So this is the definition side. We’ve defined our operation, and we’re going to go ahead and run that using the trace components. So if I go ahead and grab this line 2 again, and I grab our Move Lot operation, we’re going to do a few steps. We’re going to begin the operation. The operation is now underway. I grab the move lot segments, and it gives me my controls.

So I go ahead and I pick, let’s pick bolts that’s in bin A, and we’re going to move those bolts over to bin B. Now, from here, I can choose whether I want to begin the segment or execute it. Remember, I said begin and end is typically good for an operation where the duration matters. In this case, I’m just going to move it, so I’m going to use the execute button. And then, I’m going to end the operation.

The reason why that’s required is because with this particular operation, I have configured it such that the segment does not automatically end the operation. So “End operation when complete” is set to false. So in this case, to run the operation, like we saw just a moment ago, I have to begin it, I have to execute it, and I have to end the operation. So go ahead and port that here.

So that may or may not be ideal for you. But obviously, what’s not ideal is you don’t want your operators looking on this screen and having to deal with all these components and interfacing with all these pieces here. That’s just too much for them to properly get this right every time, and it’s a click, a very mouse-driven interface. You really want them just to be able to do their work and not worry about this stuff.

So we have scripting functions that make that all very possible. So if I head over to operation execution, I’ve set up here a series of buttons that let me do that same work in the most complex way down to the most simple way. Now there’s a use case for every single version that I’ll show you here today, but I think for this particular operation’s Move Lot operation, you’ll quickly see which is the correct way of doing this.

So let’s work through this here. We have two, what are called, equipment WIPs, or equipment work-in-progress. So this table, right here, its data property is bound to this dropdown. So we have this source equipment selected name, it’s looking at bin A, and that tells us that in bin A, there are these five lots. If I go to bin B, it shows us the one lot, and in fact, that’s what we have down here. We have bin B’s lots, and we have one lot in there. And over the course of these many buttons, we are going to move lots from bin A to bin B or vice-versa.

And we’ll start with this first series here. Now, for these ores here, so you get a sense of the different ways you can execute operations. We’ll start with the most manual way of doing this, and there is a use case here for doing it this way, but we’ll walk through that. Now, like it says here on the screen, this is useful in situations in which multiple segments may be run, and the duration of those segments is important to capture.

So let’s say you have an operation that has three segments in it. Each of those segments takes some quantity of time. We want to begin the operation, begin each segment, end each segment in turn, and once they’re all done, we’re going to end the operation. And the way we do this is defined in each button.

So we’ll begin the operation first. And of course, I’ve hard-coded in the Move Lot operation name, and I’ve hard-coded in the line it’s going to run on. You might have controls for this, but in this case, I want it to be very simple: just hit the button and it does the thing. I get at the current operations right on the line, and if there are current operations, then I don’t let it start. So I’m checking for that like we do for OEE engineering in that fail-safe. And if an operation is not currently underway, then we’re going to go ahead and create the operation, and we’re going to begin the operation.

Now remember, that create operation is not creating the definition; it’s creating the response. And you can see that here in the tool tip here. So you can see it create operation returns an MES Operations Response Object, and it takes the name of the definition. So we create the response object, and we begin the operation. Let’s go ahead and do that here. So we’ll begin operation. And then we’ll go into the segment.

So now the operation has begun. And actually, if we step back into the component here, you can see the operation’s underway. We have begun the operation. That’s confirmed here. Now if we look at the begin segment button, it looks like this: a little bit more complex; we’re doing more here.

So first we have the name of the operation and the segment, that’s why I called it “oper” and “seg” name, it’s called “Move Lot”, and it’s running again on line two. And then, I again check for current operations. If there aren’t any operations, then I can’t start the segment. So I’m having to baby that; I’m having to manage that. If the operation isn’t going, I shouldn’t start this segment. If there are more than one operations running, then I’ll keep track of that too. Finally, if the operation that’s running is not the one that I expect, I can’t start the segment from that operation.

So I am checking to make sure that the currently running operation is, in fact, the one that I expect. I can’t start the segment; the correct operation is not underway. If I’m running a different operation, we hear about it.

Finally, we are going to retrieve the lot that we’re going to use from this table up here. Now notice I’ve given the operator a couple of ways to do this. One, I’m letting them select a row. So basically, if the selected row is not -1. So -1 is the state of that selected row property on this table if you have a selected row. So if I have picked a lot, it’s going to respect the lot that I picked. But if I haven’t, I’m just going to pick the first one that I see.

So let me back up a little bit here. We have our source equipment. That comes from this dropdown. And we have the destination equipment, that comes from this dropdown. You add component source equipments, you add component destination equipment. We get at the current operation from that “current_opers” variable. I’m just getting the one that’s running. And then I’m going to go ahead and create the segment. So I’m taking the operation and I’m creating the segment from the operation. And I’m giving it the name, and I’m not having it set for me the auto-assign option. So that faults here is fault because I don’t want it to just auto-set the materials for me.

Again, so if I haven’t picked a lot, it’s going to go ahead and go and get the available lot. So this is a really great function that lets you get at whether or not a lot exists. So if I go on this segment and I look for all the lots available to it, if there aren’t any, I’m going to throw an error. And I’ll show you guys this in a minute. But if there aren’t any available lots, it’s going to throw an error and say “You cannot start this segment; there aren’t any lots available.” But if there are lots available, then I’ll take the first one in this list, and that’s actually the right thing to do, that lot 0, because you can set the Lot Handling Mode on equipment, and that’s FIFO, first-in, first-out; that’s LIFO, last-in, first-out. And that order respects that setting. So that’s actually the correct way of doing this is to get the first one and use that one here. It’ll respect your LIFO, FIFO setting.

We get at the MES object, we get its name, we get the material name, and then we set the material. So seg.setmaterial. Remember, we have the in material and the out material. We’re going to set both in material and then the lot number, and then seg.setmaterial, the out material with material name and the equipment it’s going to. Then we go ahead and begin the segment. Let’s go ahead and push that button here, see what happens.

So we began the segment and we’ll see two things happen. So this bolts lot appears in the bottom table. Now notice at this moment, this lot exists in both tables, WQ8 BYK, WQ8 BYK. And you can see that the in quantity is 300 up here in the source table, and the out quantity is 300. So there are no total net quantity of material here. We move them all over, but that’s not finalized until we end the segment. So again, we’re in transit here, we’re halfway through.

And so in the End Segment button, we’re doing similar work here. So we’re checking to make sure that the right operation’s underway. We’re checking to see the status of the segments. If it’s the correct segment, then we’ll go ahead and end the segment. You guys can look at this more carefully when you guys get these screens later on, but we’ll go ahead and end this segment and you’ll see this lot disappear. So now that’s gone.

And finally…so the segment’s done. We began it; we ended it. But with the operation still running, as evidenced by the fact that if I come back here to my components, the operation is still running but there’s no segment underway. So I’m going to go ahead and end the operation.

Now look at that button here, and just like before, we’re checking to make sure that there actually are operations underway. We’re checking to make sure that there aren’t more than one underway. And we’re making sure that the right operation, the one that we expect, is the one that we’re actually ending. And finally, we’re actually ending the operation.

So again, that took four button presses and a ream of scripting to make that work. So obviously, begin operation, begin segment, end segment — one time for each segment — is what you need to do if you have multiple segments and they have a duration. But if you’re just doing things in one shot, this may not be the right tool set for you.

So let’s go ahead to a more simple version of this. Now this one only has three buttons: begin operation, execute segment, end operation. And this is useful for situations in which multiple segments may be run, but capturing the duration of those is not necessary. So you can imagine maybe we’re going to move over dozens of lots at a time. We’ll begin the operation, we will execute each segment, one-by-one, and then we’ll end the operation. So in theory here, we can begin the operation and run that segment as many times as we want if we’re doing lots of product moves here.

So that’s the use case for that particular formulation here. And I won’t go into the begin operation and the end operation button; you guys have seen that already. It’s the same as the first time. What’s different here is actually not terribly much. So all this stuff is the same as that begin button last time, so this is functionally the same as the begin button here. Only at the end, I’m not calling seg.begin, I’m calling seg.execute. That’s a one-shot, we’re going to run this.

And so let’s go ahead and try this here. If I begin the operation — we’re underway, we can see the operation’s running again — and I execute the segments. Each time I do that, I’m going to lose a lot from the top table and add one to the bottom table. So now the operation’s running, and I can just keep hitting this middle button until I’m done with this operation, and I can end the operation. So that’s the use case. It’s sort of an edge case. I wouldn’t say it’s a very particular thing that people do all the time, where we begin the operation, do the segment a bunch of times, execute them, and then end it, but it’s there for you.

Over in this third category, we have a new concept: execute immediately. Again, the begin and the end are just the same as the first time, and the execute segment immediately button is just like before, only this time just add another word in there: execute immediately. And execute immediately, what it does is it does a couple fewer checks. So it does not go through all the checks that execute does. So it’s trusting you, as the great integrator that you are, to know that you’ve set things correctly. It will let you do things incorrectly.

My boss Tom, you heard from, he likes to say, “We give you enough rope to hang yourself.” That’s what’s happens with execute immediately. You can run it, and if you time it, if you put it in a timer script, you can see that it actually runs faster. To a minuscule amount, it’s a very small amount faster, but that could be important. We have customers out there in the world who run these operations so frequently, many, many times per minute, and the milliseconds get to be important for them. So we have these tools that let you execute the segment without us making sure your math is right.

And so here, if we take a look here, that just looks just the same, execute immediately. Now actually, the lesson that I want to mention here really quick. In set material, kind of like execute immediately, there is a different version of set material. It looks like this. We’re going to code live here. Seg.setMaterialBypassChecks(). And what that does, just like executeImmediately() does, is it bypasses the checks. It skips the steps that check to make sure your quantities are right. It’s just going to trust you. So if speed is so important to you, then you should use execute immediately, and you should do the bypass checks. That’s the takeaway I’m hoping to give you guys here is there are ways to do things faster if you know what you’re doing here.

Now here’s what I think is really useful is that if your operation, like our operation. So if we head back here and we look at this operation, Move Lot, it only consists of one segment. And so if the operation only has the one segment, then I don’t need to manage the overall operation. So if I take a look here, and I begin the segment and end the segment, it looks like this. So, instead of relying on the current operation, I’m going to create the segment from scratch. So just to compare here really quick. In this begin segment button, I’m going to the operation and I’m creating the segment from the operation. In this case, I’m going to create the segment on its own. Because there’s only one segment in the operation, I don’t need to start the operation first. Rather, if I just call system.MES.createsegment and I pass in that segment name, I can start the segment, and it’ll start the operation for me. So seg.begin here actually starts the operation first, and then the segment, so that way you don’t have to manage the overarching operation.

So if I hit this button here, it’s going to begin the segment. It’s going to grab one of these lots here. It looks like it was 5J6P08, and we have that in and that out, no net quantity, and then I end the segment. Now because I have that property set, that says that these operation doesn’t end automatically when the segment ends, I have to end the operation manually here. If we look back at that object editor, just to remind you folks, if I set this guy here to “true”, then it will end the operation automatically when it’s complete. So that would take us down to just naming two buttons: begin segment and end segment.

Now what if we collapse this all down to one button that does this all in one shot? We can have a quick one-button operation that executes a segment. And this is kind of where it gets really interesting. If you have an operation with a single segment, and you don’t care about duration, you can just execute that segment automatically here.

So we have our operation, and we create the segment directly. We execute the segment. We don’t have to go through the work of starting the operation, of ending the operation, of starting the segment, of ending the segment. We just create the segment, set our properties, do our checks, and execute the segment right away. So it’s very straightforward, we just execute the segment, and in this final button is the ultimate version of this, where we execute it immediately. So, again, not manage the operation begin, not managing the endings, we’re just running this as many times as we need to.

So if I change over to bin B here, just so you have more to work with, and I go to bin A, you can see that I can really just pound on this button, and run it as many times as I want, and it’ll just run really quickly here. It really simplifies things, where you don’t have to totally manage things from cradle to the grave here and keep track of everything. If you just need to do something quickly, we strongly urge creating the segment and executing it directly, and using those set material bypass checks, and execute immediately to do things really rapidly here. And we will, of course, give this to you, but this is, I hope, one of our key takeaways, is that you can really execute those segments quickly, get at that data, do things the way you want to do. And that’s the big idea here is we’re just really trying to make this as efficient as possible, skip the overhead, make things easier.

That takes me to the end of what I wanted to present, Tom.

Tom Hechtman (44:25)
Okay. A question here. So the execute immediately performance versus execute. Is there a difference in the speed that those execute?

Keith Adair (44:37) 
There is. So immediately runs a fair bit quicker. I’ve actually, back in my QA times — my last hat around here was QA — I have a test where I begin and end segments, I execute segments, and I execute segments immediately. And immediately runs a bit faster, just a few milliseconds, but if you stack those on top of each other, if you run those quickly, that really starts to add up. As you folks know, manufacturing is a high-speed thing sometimes. If that matters to you, that’s why immediately comes in. Execute is faster than beginning then ending. And execute immediately is faster than execute. So it’s a big improvement, and our power-users use it a lot.

Tom Hechtman (45:24)
And to elaborate on that a little bit, the execute actually does a begin and end for you. And so when you begin and you have a segment that has a duration, the begin, there’s updates that can happen, there’s accounts that can update while it’s alive and executing, and then when you end, that stops. So execute immediately bypasses all that, just gets the information together, saves it off to the database.

Keith Adair (45:53) 
Tom, are you expanding on the question that you asked me?

Tom Hechtman (45:55)
Yeah, I was. Okay, here’s a question that came in. Where should this logic run? I think they’re talking about gateway or client.

Keith Adair (46:07)
Sure, so in this example here, I just put it in buttons, because it was very easy to walk through and show you folks. But typically, you want to avoid doing this work in the client as much as possible because you can kind of get in your own way. Now, you want, as much as you can, do this on the gateway side. So a tag change event script is a great way of doing it. But we try to help you along your way, but really, when you’re doing things really fast, it’s important to try to do things in the gateway, because that way you’re lowering that communication time from the client to the gateway, and back and forth. If you’re doing things in buttons on screens, then there’s that latency there of getting back to the gateway, and there’s a higher chance that wires can get crossed.

Tom Hechtman (46:54)
Okay. Here’s a question from me, because I’ve seen it a lot. But basically, what happens if you manually started an operation, and then you go to run the segment, and you get an error or one of your checks say don’t continue. What should be done at that point?

Keith Adair (47:13)
I would start to debug the script a little bit.

Tom Hechtman (47:18)
Well, I mean, how should the code be created? Because the operation’s still running. I’ve actually seen this quite a few times. The operation gets manually started, then they go to run the segment, there’s a problem, and then that operation’s just running there, kind of indefinitely until they stop it.

Keith Adair (47:34)
Right, so you can either abort or end the operation. We have a button for that here in this component: abort and end operation. That looks something like this. Let’s see if I can do this on the fly. Thanks for the good question, Tom. We can abort either operations or segments. And those take either an equipment path or — if you want to be more precise — it will take an equipment path and an operations response UID. So if there are three operations running on a piece of equipment, you can end, abort the correct one.

Likewise, there’s an abort for the segment. And the actual objects themselves have these methods too. So if you head to our documentation, and I do this because, frankly folks, I live in our documentation. It’s where all the good stuff is. If you don’t here, you could cause yourself to get into problems. If you look at the response object here, response segment here. And as you can tell by how I got around that so quickly, I’ve been here before. It has abort. It has end. Likewise, on the operation, it has abort. It has end. So if you make use of that abort or that end functionality, you can end the overarching operation.

Tom Hechtman (48:56)
So what is the difference between abort and end?

Keith (48:59)
End actually makes that operation have occurred. So if you end an operation, then it will record off the begin time and the end time, and you’ll actually get the data created by the operation. Abort is as though it never happened. So if you abort an operation, you don’t have a begin in your database. You don’t have an end in your database. It’s as though it never happened. If you abort an operation that started from a schedule, that schedule will go back to where it was. So if you have an operation scheduled for an hour from now, I start it, didn’t mean to, it was an accident. I hit abort, it goes back. So abort is your undo button.

Tom Hechtman (49:40)
Okay. Here’s another question. Somebody that’s apparently familiar with it. What’s the performance impact of using any equipment and any material?

Keith Adair (49:49)
Right, good question. And I might not know the answer off the top of my head. I think that the answer is that it’s actually less performance because it has to go and, if you have a particular equipment selected, it knows which one you’re going to use. But I think if you use any equipment or any material, those can be a bit slower because it has to look for the right equipment or the right material.

Tom Hechtman (50:20)
Yeah, let’s say we’re looking at lots, and you say, “Any equipment. It will go out and get lots for all the equipment.”

Which is going to be slower than getting the lots at a piece of equipment.

Keith Adair (50:33)
Which we see here. So if I go here, because I said any material, it went and got all the lots that exist at my plant, right?

Tom Hechtman (50:41)

Keith Adair (50:42)
That’s an example of that here. So, anyway, good question.

Tom Hechtman (50:49)
Let’s see…we have, I guess it’s a request from Josh. So in this scheduling aspect of OEE, and probably Track & Trace as well, maybe you can just touch on that, Keith, like when you would use scheduling, when you would just use what you showed today.

Keith Adair (51:11)
Right, so that’s a great idea for a future session. In fact, actually, I think, we have a short list of things you want to cover, and schedule management is at or near the top of our list. So you who asked that question, be aware that we’re going to have a future session about that. It’s not the next one. We’ll give you an early preview in a minute here of what the next one is, but we’ll have a future session about schedule management, and about starting and stopping those operations. When you would use this is if the particular time with the plans for your operation, if that does not matter to you, if things are ad hoc or operator-driven, then this is what you’d want to use is controls and ad hoc operations. But you want to stack up those operations and plan for the future, then you definitely want to use our scheduling tools. And we’ll have a session in the near future, where we walk through starting and stopping scheduled operations on the OEE side and the Track & Trace side.

I will say, however, that many of the things we’ve taught today are very much applicable there. So you have the tools to start operations from schedule, in script, and all of these tools, and if you use those same best practices where you check for running operations, you check to make sure your lots are right, you’re going to be in good shape on the schedule side, too. So a lot of what you heard today is applicable there as well, but we will have a about scheduling session later on.

Tom Hechtman (52:48)
Okay. Then early on on the roadmap, you talked about enterprise modules. Is it a module?

Keith Adair (52:56)
It is not, Tom, a module. It is an update to our existing module. So if we hop back there really quickly, and get back over here. Okay, the Enterprise update is actually what’s called the 3.79 or the 3.80 update to our MES modules. So all users of the MES modules, if they have upgrade protection, will get upgraded to that platform 3 version. Now if some of you folks are veterans of the OEE 1 to OEE 2 process, the upgrade from 2 to 3 is nothing like that, so don’t learn any lessons from that. We’re going to make this a very straightforward, just install the modules and you’re done. But we’ve bumped into 3 because we think it’s so important. It revises the versioning scheme. It adds enterprise functionality, where you can manage different sites from one location, and really manage global operations. And it also adds a series of new components.

We can have a session about that later on, but we will also be showing some of this at ICC in our presentation there. So if you folks are interested in that, please come see us at ICC. But everyone will be getting this update to the existing MES modules. It will get passed down to everyone, and we’re working on that right now. Again, it’s in late beta, and we’re looking to deliver that, something like an RC (Release Candidate) next month. That’s really our goal here.

Okay, any more questions?

Tom Hechtman (54:48)
I don’t see any other questions.

Keith Adair (54:52)
All right, cool. Alright, well I thank you for your folks’ time. I thank you for attending. Quick preview of next time, another hot topic is next month’s Flattening-the-Stack is about Ignition 8 and Sepasoft. So there are a variety of questions about Ignition 8. “Hey, Sepasoft, when are you going to get your act together and give us perspective components? Hey, how do the MES modules work in the new global project idea? Where there is no global project, where do the MES modules go?” Some of you may know that already. Some of you may have that data. But we want to lay that out, demonstrate that for you folks, and give best practices for dealing with Ignition 8. Ignition 8 and Sepasoft, that relationship there changes also going to the 3.79, 3.80 upgrade, so we’ll talk about all of that next month. We think that’s an important topic. We want to keep you folks on board on that one.

Alright, well thank you for all your time. There will be a follow-on email to everyone on our list, with not just the slides, but also the screens that we use, so you can see all the scripting functions, and I’ll make sure to go through my code and comment it all up so you folks can read through that. If you have any further questions, don’t hesitate to reach out to me or to support, and we’re happy to help, and happy to help you on your way. And thank you so much, and see you next time.

Interested in a particular webinar topic? Reach out to Keith at