Sequential picking
From PlcWiki
Contents |
Introduction
Sequential picking is a method of preparing parts for the cockpit often at the moment when the production of the cockpit itself has not started on the production line. In SAS, either sequential picking is used, which means preparing parts for pallets based on production data received into the kernel. Each pallet contains parts for multiple cockpits. The second method of preparation of parts is based on the so-called tablet kitting method, where boxes for specific cockpits are prepared and the application on the tablet is used for data. This article discusses sequential picking as implemented on SAS lines in Saarlouis, Boleslav and Wolfsburg, for example.
Dataflow
Data received from the JIS (or other source) travels through the dataflow to the main kernel. There is a branch within the dataflow that belongs to the sequential kernel plc_skrnl. For the sake of clarity, the second instance of the kernel is used as the sequence picking kernel, but even the classic kernel contains sequence picking and can work in this mode.
Kernel and its configuration
The kernel receives data as it enters the system. It gradually prepares the parts in the sequence and places them in pallets. To what palette what part will be driven by the splan configuration file.
Above is an example of such a configuration taken from the SAS SLS plant.
WPID = S2 Name = Clusters MaxPalletItems = 24
These are basic information: pallet identifier and name. Number of parts per pallet.
PickingPartCheck = Yes
This is the parameter for ensuring that parts on the pallet are still scanned for inspection after they are assembled. When set to Yes' , the pallet builder must take the scanner and scan all the parts sequentially. Just for proper assignment of scans to a specific palette, the configuration also includes SelectPattern and ReplacePattern, which takes the specific part from the scan to be compared. SelectPattern 'must match the entire input' , otherwise ReplacePattern will not work correctly.
SelectPattern[0] = ^_((BM5T|CM5T|F1ET|G1ET)-10849-\w{2}).*$
ReplacePattern[0] =
Another parameter in the configuration is
AutomaticPrintWhenReady = No
This determines whether the worker at the sequencing station has to scan the barcode for the pallet (eg PLCPALS2) to start picking it. If this parameter is set to Yes, the palette is ready to fill as soon as all positions in the kernel are filled. The consequence is that a list of the picked parts is printed directly (otherwise it is printed when the worker scans the barcode for the pallet).
Printer = presequencing_printer2
This parameter specifies the printer on which the palette wizard will be printed (the worker actually picks up the parts based on the wizard, basically does not look at the screen). The printer must be defined in 'CUPS' on all sequential stations. The way it works is that all stations connected to a sequential kernel display the same thing, and as soon as they are to be printed, they begin to trample down the printer - the first to do so will physically print. Therefore, the printer must be defined at all, there is never any certainty from where it will actually print, it can be any sequential station connected to a specific skernel.
One of the most important parts of the configuration is the list of parts for the pallet.
BM5T 10849 FU:<>BM5T - F BM5T 10849 GU:<>BM5T - G BM5T 10849 H+:<>BM5T - H BM5T 10849 L+:<>BM5T - L BM5T 10849 BA+:<>BM5T - BA+
This works just like PartDistribution. If the kernel finds the part in the car data (based on the first column), it converts it to the part number (second column) and uses this information for comparison with the station scan. There, the worker must (with PickingPartCheck = Yes) scan all the parts he has stacked in the pallet. Scanning is assigned based on SelectPattern and then a portion of the scanned barcode is converted to PartNumber using standard PartDistribution. 'First match' (Regardless of the position. There may be a problem if there are multiple records in PartDitribution that can match ...) generate a PartNumber (data from the second column) and this data is compared with the data generated in the kernel. If they agree, it is OK and the part turns green. If a worker accidentally scans something else or skip a position, they must scan 'PLCSPCBRK' and start checking again from the beginning. An authorized barcod can also be used, which acts as a responsible confirmation and allows the worker to correct the wrong position (in which case he does not have to scan everything from scratch).
The sequence.dat is generated as follows: If a part of splan.cfg (first column) is found in the data, it is converted to cleverpart (second column in splan.cfg). Cleverpart is then searched for PartDistribution, regardless of the operation - anywhere. If found, it uses the defined barcode from PartDistribution for the last column in sequence.dat.
Basically, the logic is that what cockpit does position on the pallet. In the event that some parts are missing and none of the patterns will fit on the data received from the kernel. It can produce empty positions on the salary. See this sequential client screen.
This can be avoided by specifying the conditions that define which cockpits to pick on the pallet.
Condition = DA05 Condition = INDI|UKRA Condition = !INDI
Only those cockpits that meet the conditions will be picked on the pallet. Others will not be considered and will not create empty positions. You can use a regular expression to define a condition. For example, this
Condition = (?!^.*INDI.*$|^.*UKRA.*$)^.*$
it's the same as this
Condition = !INDI Condition = !UKRA
Important production kernel production files
They are located in the standard / usr / local / plc / var directory. These are files
pallet.dat sequence.dat supply.dat
The sequence.dat structure
1. cockpit number
2. condition
3. pallet
4. pallet in a row
5. number used for sum of cockpits on pallet. Only the first part in the position has meaning (at pickingParcheck) and counting. The rest has 0 and is for information only.
6. sequential number
Sequential Client Colors
The client's top windows are for palettes, each okono means one type of palette defined as a kernel position. A total of five colors are used to highlight the state of the palette.
'blue' - based palette in the kernel where data is still added.
'Green' - Ready for picking, the kernel has filled all positions.
'purple' - currently picked, ie palette to which a dispatch card is printed and the worker is currently physically filling individual positions.
'White' - Physically finished palette, all parts are in their positions.
'grey' - parts are gradually removed from the pallet on the production line (the number in brackets gradually decreases).
The number in the upper right corner of the palette window indicates the current inventory of parts on the line, in other words, the sum of all parts on the white and gray palettes. If the stock of parts is critically low (5 or less parts) the number will turn red.
Selecting parts from the palette
Clients on the line select parts from the 'palette for a specific product' . You must retrieve the pallet ID before removing it from the palette. The selection is then limited to an open palette. The order of the pallets is not checked.
'The exception is' WorkPlace.AlienSeqWPID. When using this parameter, there is no need to open the palette, it is selected from any.
The connection to the sequential kernel is provided by the parameters below.
line.SeqServer = plcpamkrnl line.SeqServerPort = 6799
There are two possible ways to select parts:
a) PartCheck operations
By performing a specific operation on the site, one piece of that position is removed from the currently open (gray) palette for the open product. The part number is also checked during selection. After selecting all positions, you need to open another palette by scanning its ID.
operation.sequencing.seqwpid = comma-separated list of positions on the palette
b) Loading product in the workplace
When the product is loaded in the workplace, one piece of the position is removed from the currently opened (gray) palette. After selecting all positions, you need to open another palette by scanning its ID.
WorkPlace.AlienSeqWPID = comma-separated list of positions on the palette WorkPlace.SeqWPID = comma-separated list of positions on the palette Workplace.PalletSelect = Defines the begining of a string of a palette number
