See how simulation improves material handling in our whitepaper!
The Material Handling Library is a major part of AnyLogic and this ‘how-to’ explores how to get started with the library. It is the third in a series – the first two beginning with the basic functionality of the library and how to model conveyors and transporters.
Included in the Material Handling Library is the ability to simulate the processing of items at stations on a conveyor network. This allows you to reproduce production processes and account for the mechanical or manual processing time needed, working hours, and station scheduling.
To do this, AnyLogic uses the Station markup element. It simplifies the modeling of production processes when it can be represented by a delay or the transition of an agent to a new state.
Using the Solar Panel Production Line model, we will explore the Material Handling Library and learn how to use Station element. The model shows the processes that prepare solar cells for solar panels and how the solar modules are manufactured. Model statistics allow you to estimate the total utilization of the conveyor network and equipment, as well as the duration of the production cycle and production rates. This model can be found in the list of examples on the AnyLogic home page, in the Manufacturing section. It can also be launched on this page, directly from AnyLogic Cloud.
Please note: this post is for those who want to understand the intricacies of modeling conveyor networks. If you are not familiar with the new library, we recommend you first read the previous posts in this series (Conveyors and AGVs and transporters). If you have already worked with the library, run AnyLogic and we are ready to go!
Photovoltaic cell preparation
Photovoltaic cells must be prepared for assembly. The process consists of:
- testing on the sun simulator (Cell sun simulation and test processing station);
- soldering cells together (String soldering station).
To simulate a conveyor that transports photovoltaic cells between stations (small conveyor on the left above), we use the solarCellConveyor element (type Conveyor). The model uses a belt type conveyor (Belt option in the Type property). The width of the conveyor is 0.5 meters, the distance between the photovoltaic cells (gap) is 0.04 meters, and the speed is 0.2 m/s.
On the conveyor there are two stations - Cell sun simulation and test, with a delay of 1 second, and String soldering, the delay time for which is set by the solderingTime parameter. The length of the stations - 0.2 meters - is the sum of the length of the photovoltaic cell and the distance to the cell following it. Both stations process only one photovoltaic cell at a time (property Quantity = 1) and simultaneously load and unload agents by conveyor (the Loading property value is set to Simultaneous with unloading).
In reality, at the String soldering station, new photovoltaic cells are soldered to the block of photovoltaic cells emerging from the station. In the model, for soldered objects, it might seem logical to create an agent of a new type, but this is impossible, since only one type of agent can exist on a conveyor line – in our case, SolarCell.
The belt type conveyor and the delay at the String soldering station help to display this soldering process as accurately as possible. The conveyor stops while the object is processed at the station, and then turns on so that the station accepts the next object. Operating like this, the photovoltaic cells are closely located to each other when leaving the station, as if a soldered group of elements.
When a block of 10 photovoltaic cells reaches the end of the conveyor, it is turned over and placed in the buffer. This process is modeled using the flippingStation element (type Station) at the end of the small conveyor.
Photovoltaic cell preparation flowchart
After placing the objects on the small conveyor, you need to specify on the flowchart (the top of the two diagrams in the model) which actions to perform. Photovoltaic cells exit the sourceCells block (type Source) and are placed in a buffer at the beginning of the conveyor using the buffer block (type Queue). In order for the elements to fit on the small conveyor, their dimensions are redefined in the sourceCells block (the Resize option, Length and Width properties — 0.16 m).
As soon as there is space on the conveyor, the toLayup block (type Convey) pulls in the next agent, sending a photovoltaic cell through the entire conveyor line to flippingStation, which is the destination (for the Convey to property - Station and for the Target station - flippingStation value).
After processing at the flippingStation station, the agents are removed from the conveyor, and converted into a connected group of photovoltaic cells (the SolarCellRow agent type) using the assembleString block (Batch type). This group will move further along the flowchart. As a section of photovoltaic cells occupies the buffer (a layupCellBuffer ResourcePool) at the end of the conveyor in the seizeCellBuffer block (Seize type) it captures a robot (layupRobot resource) using the seizeLayupRobot block (Seize type).
After a robot has collected a group of photovoltaic cells, the buffer is released, and a new section of photovoltaic cells can take their place. In the toScanner block (MoveTo type), the robot moves a photovoltaic cell section to the scanner, where the quality of the stringed cells is checked.
At the glassAtStation block (type SelectOutput), the condition layup.isProcessing() checks if the lay-up process has already started at the Layup station (where the soldered photovoltaic cells are transferred onto the glass substrate). If the process has not been started, the section goes to the waitForGlassDelivery block (Delay type) and waits for the delivery of the glass substrate with Type – Until stopDelay() is called selected. If glass is already at the station, a section is moved by robot onto the substrate using the toGlassPanel block (MoveTo type). The robot is then released using the releaseLayupRobot block (Release type) and returns to the waiting point near the scanner with the toInitialPos block (MoveTo type). The code in the releaseLayupRobot block (see screenshot) updates the number of sections located on the solar panel being assembled. As soon as the number of sections reaches the value specified by the nCellsInColumn parameter (the number of sections in the photovoltaic panel is set this way), the process at the station for placing photovoltaic cell blocks on the panel is interrupted and the panel continues to move along the conveyor.
Solar panel production
The process of producing a solar panel from ready-made groups of photovoltaic cells on a large conveyor consists of several stages. In brackets, we indicate the names of the stations in the model through which a solar panel must move.
- cleaning the glass substrate (Glass cleaning);
- glass coating with ethylene vinyl acetate (EVA) film (Feeding EVA Front sheet);
- transfer of soldered photovoltaic cells onto glass (Layup);
- bussing (Manual bussing);
- preliminary testing (Electroluminescence test I);
- glass coating with a second layer of EVA film and a protective coating (Feeding EVA second layer and backsheet);
- lamination (Lamination);
- trimming the edges (Trimming);
- edge sealing (Edge Sealing);
- aluminum frame assembly (Automatic framing);
- installation of junction box (Junction box applying);
- testing on the sun simulator (Solar simulation);
- final testing (Electroluminescence test II);
- labeling (Labeling).
Since the panels can move freely from station to station when there is free space on the conveyor network, we have specified roller type as its type at this stage. Next, in the properties of the elements, the speed of the conveyor and the distance between the panels are specified. The processing time at each station is set by the corresponding parameter. For example, at the Glass cleaning station, it is determined by the glassCleaningTime parameter (the Delay property). The simplest processes at the stations are reflected in delays, however, the functionality of the Station layout element is much broader. To verify this, consider in detail the operation of the stations Layup, Bussing and Laminator.
Processing at the Layup station
At the Layup station, blocks of photovoltaic cells are placed on a glass substrate that is moving along the main conveyor. Since the time glass spends at this station depends on whether the photovoltaic cells were prepared on time and on the speed of the robot moving them, we cannot specify the processing time at the station in advance. Therefore, for the Layup station, set the Delay Type property to the until stopProcess() is called. This will delay the agent at the station until the process is interrupted in the releaseLayupRobot block (Release type), when the last section of the photovoltaic cells is placed on the glass.
In turn, glass can arrive at the station when the photovoltaic cell section is already prepared and waiting in the waitForGlassDelivery block (type Delay). Waiting is interrupted after an agent has completely stopped and started processing at the Layup station. The agent.receive code (“atLayup”), also called at this time, is responsible for moving the agent — the assembled panel — through a state chart, where different states reflect the key stages of assembly.
Processing at the Manual bussing station
In our model, some operations, such as attaching contacts, trimming edges, or mounting a junction box, are performed manually by operators. The Manual bussing station demonstrates the ability to assign resources to a station.
For this, a bussingOperator block (type ResourcePool) is created with the number of resources set to two. A rectangular area is drawn around the Bussing station and attractors are placed on both sides of the conveyor. Operators will appear there when the model is launched. In order to associate a station with a block, the Use resources option is selected in the station properties in the Resources section, and the resources used, and their number are indicated in the fields that appear. This section is a lot like the basic properties of the Seize block, isn't it? Working in shifts, with breaks, switching between different tasks: these resources help to realistically simulate production stops.
Lamination station processing
Three conveyors with laminating equipment are built into the production line. Since lamination lasts longer than other operations, parallelization enables increased throughput.
Unlike other processes, several agents are processed at a lamination station. The number of panels that can be laminated is determined by the value of the laminatorCapacity parameter. In our model, it is 4, so the station will start working when it has accumulated that many. While there are fewer panels in the laminator, the station stays in standby mode. Please note: the length of the station should accommodate the specified number of agents — panels in our case. Running the model with different values for the number of simultaneously laminated panels allows you to see how this parameter affects the production line load.
In addition, the processing time at the station depends on the type of film used and may change dynamically during model operation according to the value returned by the getLaminatorCycleTime() function in the Delay property.
The code executed at the start and end of processing at the station is responsible for the transition of the panel, and the laminator itself, to certain states according to the state charts of these agents.
Panel assembly flowchart
Despite the large number of processing stations, the diagram of the solar panel assembly process is quite simple (the lower diagram of the two diagrams in the model). This simplicity is achieved by using the Convey block. One unit can direct production units through the entire conveyor network: in its properties, you can set the initial and final conveyor, as well as include or exclude conveyors from an agent’s route. For this model, agents pass through all the stations.
At the beginning of the modeled production process, glass substrates — the basis of solar panels — are created in the sourcePanels block. When a substrate leaves the cleaning station (event On trailing edge exit of the Glass cleaning station), the inject() function is called, and a new substrate enters the conveyor. This method is suitable for modeling a continuous production process at the beginning of the conveyor line, when we are sure that the blanks (in this case, the glass substrate) are always delivered to the line on time. Having entered the conveyor in the preLaminationLine block, a panel moves from the beginning of the conveyor to the lamination zone entry point (laminationPhotoEye), located at the end of the conveyor panelEntryConveyor. For how to configure the logic of objects moving along a conveyor, see chapter 1.
Each panel sent to the end of the conveyor by the toEndOfLine block will pass through one of the lamination stations. In order for the entity to move freely to a given point of the conveyor and at the same time pass through one or another conveyor line, you must specify the name of the line in the properties of the Convey block in the Include conveyors field. In our case, the line along which the panel must go can vary depending on the number of solar modules in the lamination zone and station load. The line is selected using the code chooseLaminatingStation(agent).getConveyor(). The function chooseLaminationStation() returns the lamination station through which a panel will pass, and the code as a whole returns the conveyor on which the station is located.
At the end of the production line, assembled panels remain on the end of the conveyor, since the Leave the conveyor on exit property is not turned on. At the same time, panels capture robots that are unloading the conveyor (seizeUnloadRobot block). As soon as a robot gets to a panel, the panel is removed from the conveyor using the leaveConveyor block and is transferred to the stack of finished panels. When 10 units are gathered in a stack of panels, they are combined into a batch (blocks batch, batch1, or batch2), ready to be sent using the forklift to the warehouse in the moveToStorage block (type MoveByTransporter).
Now you know how to simulate technical operations on conveyors! Here is a recap of the key things to remember:
- If processing can be represented by a delay or transition of an agent to a new state, it can be modeled in AnyLogic using the Station markup element.
- If the station can process several agents at the same time, then the processing will begin only when this number of agents are at the station.
- To simulate the dependence of a process on the work of other stations or processes, you can select Delay type until stopProcess() is called. This will delay the agent at the station until the process is explicitly interrupted.
- Agents within a station can only be located one after another. Therefore, stations must be long enough to accommodate the required number of agents.
- Resources, such as vehicles or people, can be added to stations so you can more accurately simulate workflows – switching resources between tasks and downtimes.
- One Convey block can direct agents/units through the entire conveyor network: in its properties, you set the initial and final conveyor, as well as include or exclude conveyors from the route of agents. In this case, agents pass through all the stations on their way.
- Only one type of agent can exist within a single conveyor line.
Get our collected MHL materials in the AnyLogic MHL email pack and, if you have any questions, ask them in the comments below — we will answer.
⭐ If you have already built a model using the new library, upload it to AnyLogiс Cloud and leave the link in the comments. We'll send an AnyLogic t-shirt for the best!