Simulate a picking process using Lists

00:03

In your process flow you can simulate a picking process in your model by using Lists to manage and track items.

00:11

In this example, the foundation of a model is already set up.

00:16

Here, a Source generates items on a rack, with Operators that will pick the items and transport them to the Conveyor,

00:25

where the items will travel to the Sink.

00:29

The Operators are set up with labels to indicate which Section—1 through 5—they operate in,

00:36

as well as a pointer label called Drop to identify the respective Entry Transfer of the Operator on the conveyor.

00:43

Two global tables have also been created.

00:47

The OrderTable randomly generates order numbers with SKUs and includes the Section for each SKU.

00:56

The SKUList global table contains 20 unique SKUs, each with a Section and a Bay to indicate the position of the SKU on the rack.

01:06

The Source is set up with an arrival schedule of 1500 flow items, and the items have been set up as small boxes.

01:16

Additionally, four labels are applied to each item.

01:22

The first is a Type of between 1 and 20, which is applied as a uniform distribution.

01:29

The Type is then referenced in a standard Table lookup to apply the other three labels—the SKU, the Section, and the Bay.

01:41

Once on the rack, a Slot Assignment Strategy sorts the Items by Bay, Level, and Slot ID.

01:51

Now that you understand the initial model setup,

01:54

you can begin creating the ProcessFlow using Lists—in this case, one List to control Orders, and one to control Inventory.

02:04

First, in the Toolbar, expand Process Flow and select Add a General Process Flow.

02:14

Then, use the Quick Library to add a Source and name it “Source: Populate Orders List”.

02:23

This is a regular Schedule Source that creates one token.

02:27

Next, assign labels to the token to reference the OrderTable and the total number of rows in the table.

02:35

Add a Label called “OrderTable”, with a Value of “Table(“OrderTable”)”.

02:42

Then, Add a second Label called “NumRow”, with a Value of “Table(token.OrderTable).numRows”.

02:51

Now, create a sub flow to pull the column values for each row in the OrderTable.

02:56

Add a connector from the Source, and then use the Quick Library to add a Run Sub Flow activity.

03:05

Select the Sampler to add a Start activity.

03:08

In the Run Sub Flow Quick Properties, rename the activity to “For Each Row”,

03:15

then set the Quantity to “token.NumRows”

03:19

In the Source activity, you can see that this corresponds to the NumRows label you already set.

03:27

Back in Quick Properties, to Assign Labels to Children, click Add, and then set the Label Name to “Row”, with a Value of “creationRank”.

03:40

Next, add an Assign Labels activity below Start, and in Quick Properties, rename it to “Assign Labels from Table”.

03:51

Add a Label named OrderNumber, another named SKU, and a third named Section.

04:00

Then set up the Value as a Table lookup that pulls the respective label from the OrderTable, using this code:

04:07

“Table(token.OrderTable)[token.Row][“OrderNumber”]”.

04:18

Repeat this code for each Label, replacing “OrderNumber” with “SKU” and “Section” respectively.

04:26

Next, add a Push to List activity, and use the Sampler to point it to a List with the name “Orders”.

04:34

In the Toolbox, select Global List, then General List.

04:42

In the List Properties, name the list “Orders”.

04:47

Click Add, then select Label three times.

04:54

Set one Label field for the OrderNumber, one for the SKU, and one for the Section.

05:03

Click Apply and then OK.

05:07

Back in the ProcessFlow, in the Orders Quick Properties, expand List,

05:15

select Global List and then select Orders to apply the Global List.

05:20

In this example, the simulation is Run with View Entries open to verify that the List works properly.

05:28

Here, you can see that the List captures the OrderNumber, SKU, and Section as planned.

05:37

Back in the ProcessFlow, add a Finish Sub Flow activity to the Sub Flow.

05:43

Then, add a Sink and a connector from the sub flow—For Each Row—to the Sink.

05:51

Now, you need to create the activity set for the Operator work.

05:56

First, add a Source named “Source: Operator Work”.

06:03

Then, set the Arrival 1: Quantity to “Group(“Operators”).subnodes.length”

06:10

to do a group lookup and create one token for each Operator in the group.

06:15

Next, assign labels to the created tokens.

06:20

In this example, Add a reference to the Operator in the Group by applying an Operator Label with a Value of “Group(“Operators”)[tokenIndex]”.

06:32

Then, reference the labels that are already applied to the Operators;

06:37

this includes a Section Label with a Value of “token.Operator.Section”, and a Drop Label with a Value of “token.Operator.Drop”.

06:47

Add a connector from the Source to a Pull from List activity.

06:53

Name this activity, “Pull Order” and use the Sampler to point it to the Orders List.

07:01

Open the Pull Order Quick Properties to add a Query that will select the SKU from the specified order when the Section matches the Operator.

07:10

In this case, the code is “SELECT SKU, OrderNumber WHERE Section = Puller.Section”.

07:19

Then, add another Pull from List activity and use the Sampler to add and connect it to another List.

07:28

Rename the List “Inventory”, and rename the Pull from List activity “Pull from Inventory”.

07:37

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

07:43

In the List Properties, name the list “Inventory”, and keep the remaining fields shown.

07:51

Click Apply, and then OK.

07:55

Next, items from the rack need to be pushed to the Inventory List.

08:01

Select the Rack and in Properties, under Triggers, click Add > On Entry.

08:12

For On Entry, click Add and then select Lists > Push to List.

08:21

Expand the List drop-down and select Inventory.

08:27

Then, set the Partition to “item.SKU” to sort the List by SKU.

08:34

In the Pull from Inventory Quick Properties, set the Partition ID to “token.SKU” as well.

08:42

In the Inventory Quick Properties, link the Global List.

08:48

Expand the List drop-down and select Global List > Inventory.

08:54

Now, the simulation is Run to test that the Inventory List is functioning properly.

09:01

Select a token in the Pull from Inventory activity, and you can see in Properties that the appropriate Labels are applied.

09:10

Open the View Entries dialog for the Inventory List, and you can see that the entries are partitioned by SKU.

09:19

Back in the Pull from Inventory Quick Properties, change the Assign To entry to “token.item”.

09:27

Now, create the operator task sequence.

09:31

Add a Create Task Sequence activity and in Quick Properties, adjust the Task Executer to “token.Operator”.

09:41

Then, add a Load activity and an Unload activity, with a Station of “token.Drop”.

09:51

Add a Finish Task Sequence activity,

09:54

and finally, add a connector from Finish TS to Pull Order to create a loop for the Operator to repeat the task sequence.

10:02

The simulation is Reset and Run to show that the process flow and Lists function as planned to simulate a simple picking process.

10:12

Here, you can see the Operators picking items based on orders and delivering them to the conveyor.