Create a complex task sequence with travel activities

00:03

In a process flow, a task sequence is a series of tasks that are performed together and assigned to a task executer,

00:10

such as an Operator or a Transporter.

00:13

Additionally, you can use travel activities in your task sequence to capture more detailed metrics on the utilization of task executers.

00:22

Here, you see a Model with multiple items coming from multiple Queues.

00:26

To transport these items, you can create a task sequence with multiple operators in your process flow.

00:33

Begin by adding a Schedule Source in the ProcessFlow.

00:37

In this scenario, items enter both Queues from the Source and are pushed to a List.

00:42

When the token identifies items to be pulled from the List, an Operator will be assigned to load and unload the items.

00:50

Here, you see a List and Resource added to the ProcessFlow as well.

00:54

Now, set up the List.

00:57

In the ProcessFlow Toolbox, select Add > Global List > Item List.

01:04

In List Properties, name the List “Items”, and then click OK.

01:10

To send the items entering the Queues to this List, in the Model, select both Queues.

01:17

In Properties, expand the Send to Port drop-down and select Use List > Push to Item List.

01:24

In the popup, with the Items list already selected, expand the dialog.

01:31

For the Partition ID, type “current” to partition the items by their current Queue.

01:37

In the Toolbox, right-click the Items list and select View Entries.

01:43

This opens a window showing that the items are entries, and they are partitioned by the two Queues.

01:49

Next, designate an Operator for each Queue.

01:52

Select Queue6.

01:55

In Properties, under Labels, click Add, then select Add Pointer Label.

02:03

For the Label name, type “Operator”.

02:07

Click in the Label field, select the Sampler, and then, in the Model, sample Operator2.

02:16

Repeat these steps for Queue7, this time sampling Operator3.

02:22

Now, in the ProcessFlow, set up the flow so that two tokens are created, one representing each Queue.

02:30

Each token will pull from the List and assign the task sequence to the designated Operator for that Queue.

02:36

Open the Source Quick Properties, and in the table, adjust the Quantity to 2.

02:43

Under Assign Labels to Created Tokens, click Add.

02:48

Name the Label “Queue”.

02:50

To include a Value for the Label, first, set up the Queues as a group.

02:55

In the Model, select both Queues, then right-click and select Object Groups > Add to New Group.

03:03

Name the group “ItemQueues”, and then Close the Group Properties.

03:08

Back in the Source Quick Properties, set the Value to include an index of the tokens in each ItemQueues Group by entering the code shown.

03:16

The Model is stepped forward to generate the tokens in the ProcessFlow,

03:21

and each token is selected to verify that the label is set up correctly, with Queue7 and Queue6, respectively.

03:29

In the Source Quick Properties, Add another label named “OperatorPull”,

03:33

and then set the Value to the Operator for that Queue by entering the code “token.Queue.Operator”.

03:41

Add a third label, named “Drop” for the unload location.

03:45

Using the Sampler, in the Model, select EntryTransfer 2 on the Conveyor.

03:52

Next, set up the List and Resource.

03:55

In the List Quick Properties, rename the List to “Items”.

03:60

Then, in the List drop-down, select Global List > Items to reference the Global List you created.

04:07

Rename Resource to “Operators”.

04:11

To add the Operators to a Group, in the Model, select both Operators, then right-click and select Object Groups > Add to New Group.

04:22

Rename the Group “Operators”, then Close the Group Properties.

04:28

Back in the Operators Quick Properties, expand the Reference drop-down and select Group > Operators to reference that group.

04:37

Add a connection from the Source, and then, in the Quick Library, add a Pull from List activity, then click the Sampler and select the Items list.

04:48

In the Pull from List Quick Properties, set the Request Number to 4 and the Require Number to 2

04:56

for a maximum of four and a minimum of two items pulling from the List.

05:01

In the Assign To field, enter “token.items”, and set the Partition ID to “token.queue”.

05:09

Here, Source is renamed “Source: create tokens for work” and Pull from List is renamed to “Pull Items”.

05:17

Next, add an Acquire activity, use the Sampler to connect it to Operators, and rename it “Acquire Operator”.

05:27

In the Assign To Label field, enter “token.Operator”.

05:31

In Source Quick Properties, notice that the Label is set up as OperatorPull, which labels the Operator based on the assigned Queue.

05:39

Back in the Acquire Operator Quick Properties, set this activity to Query the OperatorPull label by entering “token.OperatorPull”.

05:48

Now, begin your task sequence.

05:51

Add a Create Task Sequence activity and set its Task Executer / Dispatcher to “token.Operator”.

05:60

Next, add a Travel to Object activity and set the Destination to “token.Queue”.

06:07

Because there are multiple items, add a Run Sub Flow activity to unload and load the items.

06:14

Here, the Travel activity is renamed to “Travel to Queue” and the Run Sub Flow to “Load Items”.

06:21

In Quick Properties, for the Load Items Destination, use the Sampler to select a Start point in the ProcessFlow.

06:29

Change the Quantity to run for the length of the items by entering “token.items.length”.

06:36

Select Run Tokens One at a Time.

06:40

Under Assign Labels to Children, click Add.

06:44

Type “item” for the Name, noting that labels are case sensitive.

06:49

Then, set the Value to provide the index rank for each child token created by entering the code shown.

06:57

In the ProcessFlow, below Start, add another Travel activity,

07:03

then change its Destination to “token.item” to direct the Operators to the items in the Queue.

07:09

To represent loading time, add a Delay activity, set the Delay Time to 2 seconds, and set the State to 18 – loading.

07:21

Add a Load activity and keep the default fields.

07:24

Then, add a Finish Sub Flow activity.

07:28

Reset and Run the simulation to ensure that the flow is set up properly so far.

07:33

The tokens are created, and with the simulation paused and the Delay token selected, you can see that the Labels are appropriately applied.

07:43

Run the Simulation again, and both Operators travel to the Queue and begin loading items.

07:50

Now, you can finish the task sequence.

07:53

Add a Connection from Load Items, and from the Quick Library, add another Travel activity.

07:59

This time, use the token label designated for the drop—shown here in the Source properties—by setting the Destination to “token.drop”.

08:10

Now, add another Run Sub Flow for the unload task sequence and rename it “Unload Items”.

08:17

Several other activities are renamed in this example to reflect the action that occurs during each activity,

08:23

including “Travel to Drop”, “Travel to item”, “Load item”, and “Load Delay”.

08:32

Next, for the Unload Items sub flow, follow steps similar to the setup for the Load Items sub flow.

08:39

Here, you can see that Unload Items is set up to run for the length of the items,

08:44

and a label is added to provide the index rank for each child token created.

08:50

A Delay activity is added to the Sub Flow, with a “1” second per item delay, a State of 19 – unloading, and a name of “Unload Delay”.

09:02

An Unload activity is then added, and the Station is set to the unload area, or “token.drop”, which is that entry transfer.

09:12

A Finish Sub Flow is added.

09:15

At this point, you are done with the task sequence,

09:18

and can add the last two steps, which must be added for the task sequence to finish.

09:23

First, add a Finish Task Sequence, and finally, add a Release Resource activity.

09:30

In Quick Properties, the Resource Assigned To is set to “token.Operator” to release the Operator.

09:38

The renamed Release Operator activity is then connected back to the start of the Task sequence, to Pull Items,

09:44

so that the process flow can repeat.

09:47

When the simulation is Reset and Run, it seems to be running as planned,

09:52

but if you watch the boxes being unloaded, there is actually one error in the setup.

09:57

In the Unload Items Quick Properties, select Run Tokens One at a Time to ensure that the Delay and Unload activities happen per item,

10:06

and not all at once.

10:09

Reset and Run again, and now you can see that the task sequence is performing as expected, with a slight delay between unloaded items.

10:17

Lastly, take a moment to understand how the Travel activities used in this example

10:23

help you to capture enhanced metrics on task executer utilization.

10:28

Here, you have two models: one that was created previously with a simple task sequence and without travel activities,

10:36

and the other is the model that was just created.

10:39

A Dashboard for Operator Utilization has been set up.

10:43

The simulation is Reset and Run for both flows.

10:48

For the flow without travel activities, or Operator1, three states are captured—Idle, Offset travel empty, and Offset travel loaded.

11:00

However, for the flow with travel activities,

11:03

in the other two operators, five states are captured—Idle, Travel empty, Travel loaded, Loading, and Unloading.

11:15

The travel activity captures more detail for task executer utilization, allowing for a more accurate assessment of your resources.