GB2602358A

GB2602358A - Automated stacking arrangement

Info

Publication number: GB2602358A
Application number: GB2103678.5A
Authority: GB
Inventors: Marsh Mark; Murcia Miguel; Marsh Joseph; Marsh Derek; Yates Justin
Original assignee: Granta Automation Ltd
Current assignee: Granta Automation Ltd
Priority date: 2021-03-17
Filing date: 2021-03-17
Publication date: 2022-06-29
Anticipated expiration: 2041-03-17
Also published as: GB202103678D0; GB2602358B

Abstract

A method and apparatus for of generating control commands for a robot 4 to cause it to produce a stack of items 6, by accepting user input of a 3D coordinate of a base frame position, accepting user input of a 3D coordinate of a pre-place position, receiving a 3D digital model of the stack 6 with stack coordinates for each item stored relative to a known reference coordinate, determining whether some of the items to be stacked can be grouped (304 fig. 3B) and therefore picked in a single picking operation, sorting the coordinates for each item into a list of items sorted in vertical position in the stack, extracting an item’s 3D coordinates from the item list in order, generating a placing coordinate by processing an item’s 3D coordinates to apply an offset to each coordinate which is difference between the reference coordinate and the base frame position, issuing a control command to cause the robot to move to the pre-place coordinate position, issuing a control command to cause the robot to move to the placing coordinate position, repeating the loop until the entire item list has been traversed. Optionally, a 3D digital model of the stack may be received by interrogating the 3D model of the stack 6 by cycling through each item and retrieving the 3D coordinates of each item, and storing the retrieved coordinates in the item list, with an entry for each item.

Description

Automated Stacking Arrangement This invention relates to a method of optimising automated packing of a plurality of stackable objects and apparatus for optimising automated packing of a plurality of stackable objects.

This invention attempts to solve common problems encountered when adding robotics to a typical production operation. In particular, this relates to the type of operation in which objects, such as boxed products, need to be stacked in a predefined volume such as for loading on a pallet prior to transportation. Normally, when an investment of this type is considered, the end user is required to take significant risk and make significant capital investments; e.g. there is a requirement to invest heavily in the new equipment and make large down payments, the equipment is subject to an extended delivery, there is no option to return equipment once it has been ordered and configuration and programming is a highly skilled task that costs in the region of £1,000 per day in engineering time.

US2018/032225 discloses the stacking of simple shapes, such as cartons which can typically be stacked in the same way for each application of the system. There is no ability for a user to select a different approach path immediately prior to stacking by providing both a pre-place position and a final place position, or for a user or the system automatically to group items together.

It is an object of the present invention to attempt to reduce at least some of this risk and capital requirement.

In a first aspect, the invention provides a method as set out in claim 1 appended hereto.

The method also includes grouping multiple items together to form a single stack location.

To allow robot control commands to be issued when it is possible to pick multiple items from the infeed conveyor in one robot motion, This means that the final production throughput speed of the palletising solution is greatly increased. This grouping can be either manual via the system's GUI or automated by assessing whether a line of items exist in the stack that have the same orientation and the same X value or the same Y value.

Optionally, the method may include the steps of determining the position of the previous item to have been stacked, comparing the x-coordinate of the previous item with the proposed x-coordinate of the current item and if the previous x-coordinate was less than the current x-coordinate, adding the pre-place X-offset to the next place position, or if the previous x-coordinate was more than the current x-coordinate, subtracting the pre-place X-offset from the next place position.

Optionally, the method may include the steps of determining the position of the previous item to have been stacked, comparing the y-coordinate of the previous item with the proposed y-coordinate of the current item and if the previous y-coordinate was less than the current y-coordinate, adding the pre-place Y-offset to the next place position, or if the previous y-coordinate was more than the current y-coordinate, subtracting the pre-place Y-offset from the next place position.

In a second aspect, the invention may provide apparatus for generating control commands for a robot to cause it to produce a stack of items, comprising computer processing means and computer memory and further comprising a robot control interface and a user interface and being arranged to receive user input via the user interface and to output robot control commands via the robot control interface and being further arranged to carry out the method steps of the first aspect.

The apparatus may include a plc to generate robot commands for directly feeding to a robot.

In a further aspect, the invention may provide a computer readable medium carrying computer program code which when executed on computer hardware, causes the hardware to carry out the method steps of the first aspect above.

The invention centres around producing a palletising cell that is effectively portable and not application specific. In broad terms, the invention concerns the development of robot cell software that can be implemented in multiple installations by non-skilled personnel, and that is easily re-configurable for different end users and scenarios as they arise.

A core point of differentiation for this invention is configurability. To achieve this and as explained in more detail below, it is necessary to ensure that the physical location of each device is adjustable without harming functionality in any respect and this may be achieved simply by entering the 3D coordinate of a base frame position. This adjustability is for three reasons: 1. It means that unlimited variations of the cell can be set up, because of the modular nature of the system, using the same software for each configuration.

2. It means that the cell can be erected and de-commissioned very quickly, saving engineer time and therefore costs.

3. It opens up the possibility of renting heavy industrialised duty robot cells for the first time in history, as the system is semi-mobile.

The software has been developed with this in mind, enabling total configurability by an unskilled operator, without jeopardising the capability of the finished equipment in any way.

In the context of this application, a robot is considered to encompass any automated, programmable handling system that is capable of movement on three or more axes.

The invention will now be described, way of example, with reference to the drawings in which:-Figure 1 is a schematic block diagram of the whole system; Figure 2 is a flow-chart showing the data flow and decisions in the system; Figure 3A shows a plan view of a single layer of a proposed stack; Figure 3B shows grouped items; Figure 30 shows a 3 dimensional proposed stack Figure 4A shows a large gripper holding an item generally in the centre: and Figure 4B shows a large gripper are holding an item generally at one edge.

System Architecture With reference to Figures 1 and 2, the various disciplines involved in getting from user input via a Graphical User Interface (GUI) to a functional automation system with servo-driven motion, are described below. An example architecture is also outlined below.

A user 2 wishes to configure a new palletising cell. The cell typically comprises a robotic arm 4 which is able to move typically in 3 dimensions and also to rotate along at least one axis. It typically also will include some form of picking and placing apparatus (an end effector) and be located within reach of a source of objects/items/goods, such as a conveyor (not shown) so that it can pick items from the conveyor and place them elsewhere. The palletising cell is provided so that a stack of goods 6, may be produced on a pallet for onward transportation, by picking them from the conveyor and placing each one in the correct positions and orientations to form a stable stack.

As noted above, this is a complex problem, which traditionally requires highly skilled (and therefore expensive) operatives to configure and maintain the cell. The apparatus described below provides a tool which automates much of the configuration so that implementation costs may be significantly reduced.

A console 8 is provided for the user to interact with the system, which has graphical user interface (GUI) and typically a keyboard. From the point of user interface, the first element of the GUI is a stack virtualisation system for building a theoretical or virtual representation of a desired final stack of goods (step 100). This may be completed for example using an open source solution, which runs in MS Windows called Stackbuilder 9 by TreeDim (www.treedim.com). The windows nature of this software makes it desirable (but not essential) to include a Windows PC 10 as a starting point for the environment. A Beckhoff industrial PC is a good option as this includes a real-time capable runtime that can be used as a programmable logic controller (PLC) 12 whilst allowing for seamless integration with MS Windows at the same time (Beckhoff TwinCAT). Thus much of the robot control and stack modelling can be carried out on the same hardware.

The stack modelling is carried out to calculate the most efficient way to stack the items within constraints such as the total weight and space constraints of the pallet, overall pallet loading limits, and to produce a stable stack which will also not crush the items at the bottom of the stack.

With reference also to Figures 3A to 3C, grouping of items together in the stack is then managed via the GUI if required and if the hardware permits. For example, in an application where the specified production speed requires two cases to be picked at once, a robot may be fitted with a larger end-effector that can handle two cases. The GUI will then allow users to specify which cases should be picked together and the system will calculate the new stack locations based on a stack location that is central to the two items, rather than central to the top of each individual item.

Figure 3A shows a plan view of a single layer of a stack. It shows several items 300 which are to be stacked in that layer. It will be noted, for example, that the items 302 on the right side of the Figure are all of the same shape and aligned in the same direction. Thus, with reference to Figure 3B, these four items may be grouped into a single pick (Pick 6-304)) 5. Similarly, the other groups of items that are visible in Figure 3A, may be grouped into picks 1 through 6. It will be noted that in this example, the components are aligned to form a long strip of items to be picked, with the short sides of the items abutting. This suits the gripper head on the robot in this example. But grouping might be done in a different way, for example as a group of four, depending on the capability of the gripper. Thus the skilled person will appreciate that the particular grouping shown in these figures are not intended to be limiting.

The user interface GUI may present the stack in the form shown in Figure 3A, and the user may manually group the items visually, as shown in Figure 33. Alternatively, as described elsewhere, the system may automatically detect suitable objects for groupingcoma by finding a series of similarly shaped objects in an X or Y direction in the proposed stack, and either proceed automatically or propose these on the display shown in Figure 3B for user approval.

In this embodiment, because the Stackbuilder software does not provide a suitable interface to extract the complete stack model, the system includes a modification to the Windows open source stack virtualisatior solution, to extract the required data and to write it in the relevant form to drive the robot motion via the Beckhoff PLC runtime.

The Windows environment (and in this embodiment, more Specifically, the Beckhoff runtime environment) allows code to be produced to convert information from the stack virtualisation system and feed it out in a form that the robot controller can understand, preferably over an industrial Ethernet-based protocol (such as EtherCAT).

The system also preferably includes robot application software, such as that written in Kuka KRL language and in the preferred embodiment deployed to a second integrated PC (I PC) 14 that forms a robot controller. This second PC manages the robot motion (typically by converting XYZ Cartesian information into required angles and therefore encoder target positions of each individual axis and then initiating the motion, by driving the robot to the desired location. It also manages the motion safety (typically by dealing with kinematic issues, for example, if the desired motion requires that an axis overrun its travel, the system prevents this from happening by calculating alternatives if possible, or halting the motion if it is not possible) and converts The communication flow from operator to robot therefore runs from operator, to Windows, from Windows to PLC runtime (TwinCAT) 12, from TwinCAT to robot controller and then from robot controller to servo drive 14.

There are a number of requirements to solving the problem or arriving at the concept described above. These are described as individual components in the list below. Their order of implementation within the system is generally sequential in the order listed:- 1. Solve stack pattern configuration from a product size and pallet size input.

2. Extract the individual product positions from the chosen stack pattern configuration.

2a. Group the individual product positions together to form grouped product positions.

3. On the basis of the product input location and the desired output stack locations, convert the information into safe robot code.

3a. Consider position of large gripper in stacking cell 4. Run robot code and control the cell.

5. Ensure that any equipment in the cell can be moved without jeopardising the above four points.

The implementation of these steps is described in detail below.

1 -Solve Stack Pattern Configuration Solving stack pattern configuration options from a given product size and given pallet size is a problem that has already been addressed by existing software applications. This invention therefore uses an existing open source software product to deal with this element of the solution to provide a virtual model of the desired stack pattern.

Treedim StackBuilder software has been used in this case as this is entirely open source and provides for commercial adaptation and resale within the license agreement. This application is aimed at solving homogenous stack patterns only, thus lending itself well to the type of application that is commonly dealt with robotically. It create a digital stack model with a known position for each item in a theoretical stack, aligned to a known base coordinate position, such as one corner of the complete stack. Alternative applications that deal with different-sized packages could be used instead.

However, the output data format from this application is not suitable for onward use in this system and thus a data conversion step 2 as described below, must be carried out.

2-Extract Product Positions In order to generate a pallet stack robotically, the first requirement is to understand specifically where each product in the stack should be placed. Thus an edit to the stack virtualisation open source software is carried out to enable the individual product case positions to be extracted and placed in a collection of data within the software. This collection can then be manipulated in a useable form at machine code level to move the robot to the desired locations.

This element of the invention is implemented in a coordinate translator 16 and has been achieved with a code loop (step 102) that interrogates the StackBuilder analysis for a chosen stack pattern solution and finds the product positions. Having done this, the code cycles through each position, extracting X, Y and Z co-ordinates as well as the orientation of the product in question. This information is written into a new collection (or list of objects) within the invention, which in turn is eventually written into the runtime of the PLC controller for further control and manipulation.

The extracted information takes the form of co-ordinates in relation to a given co-ordinate frame which is entered by the user. This has been related to a Robot base or frame on the robot side which enables the pallet location to be moved around without changing any stack pattern position information. That is, the coordinates are created and stored as relative coordinates relative to a point which is known in relation to the robot's position, but need not be fixed in relation to any other points in space. This is a key element of the system's flexibility as it means that the final robot cell can be reconfigured and re-installed with minimal robot engineer input. The offset may be applied after modelling the stack, or during modelling of the stack.

2a. -Group the individual product positions together Individual items in the stack can be combined into groups in order to enable "multi-picking" or picking of several items in one robot motion. This can be done where the stack pattern requires them to be placed adjacent to each other and they can be marshalled on the infeed conveyor into the correct pattern as defined by the output stack pattern.

In more detail, this involves creating a collection of new objects within the software, known as groups. These groups contain a collection of stack locations with their associated coordinate definitions. Adding items to these groups/collections can be done manually with user input via the GUI, or automatically, by detecting which items are adjacent to each other within a layer.

In order to automate the grouping, the software code cycles through the points in a given layer, establishing if there exists a series of items that have a consistent X or Y value so that they might possibly be handled together. If such a series exists, the code then checks the position definitions in question, to establish that their orientation is consistent throughout the series. To group items together with different orientations would potentially render the later "pre-place" calculation unusable as there may no longer be a clear approach path with no obstructions for the subsequent place position.

Following the above operation, once the system has established that there is a possibility to group several items together, it then performs a hardware compatibility check, namely to check the group against the size of gripper that has been configured into the cell setup. If the group contains more cases than can be picked with the current gripper then the group may need splitting into two picks, and the user will be warned and invited to intervene accordingly.

Once a group has been established, positions within the pallet are re-calculated. When a group object is interrogated for its X and Y values, it returns co-ordinates that are central to the combined group pattern. This is a simple calculation using the items in the group's collection of boxes or products.

3 -Convert Information to Robot Code Initially, the positions are combined with other data such as pallet/slip sheet requirements (step 104), processed for collision problems and to generate kinematic paths (step 106) and checked for interactions with other systems -e.g. multi-lane/safety requirements (step 108).

In more detail, the generation of the motion paths (step 106) for the robot to move the products to the locations is achieved by means of a stack position index and a "new position request" signal that is sent by the robot controller after the previous placement has been completed.

The application program on the robot moves the robot to a position (steps 110 and 112) over a pick location and waits for an inbound product to arrive, e.g. on a conveyor. When this happens, the robot sends a request to the PLC runtime, asking for a new position.

Before placement starts, The PLC runtime 12 sorts the positions in the stack pattern in such a way that the positions with the smallest Z values are first in the position list. Since the Z co-ordinate is the height location, this means that the bottom positions on the pallet are sent to the robot first, so that the stack is built from the bottom up. Having sorted the positions, the PLC then applies an index reference to each one.

When the PLC 12 receives a new position request from the robot, it interrogates the position list for the position with the current index value required and writes the coordinates and orientation values of this position to predefined variables in the robot. The PLC then increments the current index value by one so that the next position in the stack is presented and sent following the next request from the robot.

In order to safely move the product to a position adjoining the previous product, it is necessary to move to a preliminary position that is clear of the final stack and provides a clear path to the final desired location. Failure to do this results in the robot, the end effector and the product being handled potentially colliding with the stack and upsetting and damaging it before stacking is completed. For the purposes of this system, the preliminary position has been called the "pre-place" position. The operator interface allows users to set values for this position in the X, Y and Z directions. These offsets are then applied to the final position co-ordinates and the sum of these is sent to the robot as well as the final position co-ordinates.

A second layer of logic is applied here, as it is necessary to ensure that the "pre-place" position is clear of the previously stacked product in both the X and Y axes. This logic interrogates the previous positions of products that have been already stacked on the pallet, if the last, varying X value was less than the current X value, the clear side of the stack will be positions with a greater X value than the final position X. Therefore the pre-place X-offset should be added to the desired position. If the reverse is true then the pre-place X-offset should be subtracted from the final position X. This logic is also applied to the Y axis, with the result that the operator can simply enter the three offset values and not be concerned about interference between products when they are being stacked.

Having been presented with position information, the robot picks a product and moves to the pre-place position. From here, it has a clear path to the final product position without interfering with any adjoining product or other hardware. Once it has moved to the final product location and placed the product on the stack, the robot then moves up clear of the stack and requests a new position. Then the robot program continues in a cyclic fashion, requesting a new product place position and a new pre-place position each time a product is picked. The top level cell controls pause the process when the stacking index reaches the total number of products that exist on the pallet; meaning the pallet stack is complete (step 114).

3a -Avoid oversell of arimer beyond edae of pallet In a scenario where a large vacuum gripper has been fitted to the robot, for example in a multi-picking application as described above, or where relatively small objects are being picked by an oversized gripper, a further calculation is appropriate in order to generate safe robot paths.

It is usually necessary within most cell configurations to keep the gripper largely within the boundaries of the stack being built while it is executing the stacking motions. This is primarily a function of the physical constraints of the cell, as if a large portion of the gripper overhangs the edge of the stack it is liable to collide with any hardware that is adjacent to the stack location, including the operator safety guarding in some applications.

Figure 4A shows the problem, with a gripper 400 holding a large item in the middle. This causes the item 402 to extend beyond the edge of the pallet.

In order to create an operation that happens within the stack, and is therefore fully configurable, it becomes necessary to pick at varying locations on the gripper when handling individual products, so that the location of the gripper can be managed while stacking. For example, picking may occur so that the individual item is gripped in the centre of the gripper, close to one end, or close to another end. Thus when the item is placed on the stack, the excess capacity of the gripper can be kept within the boundaries of the stack. This is calculated as follows: Firstly, the orientation of the place position in question is established. The gripper could be in one of four orientations in relation to the pallet stack. Outer dimensions of the stack are then established, along with the outer dimensions of the gripper. Since the gripper dimensions are typically smaller than the stack dimensions, a scale factor is then calculated to scale the X dimension of the stack to the X dimension of the gripper, and the Y dimension of the stack to the Y dimension of the gripper. Both of these calculations are performed assuming that the gripper will be in the given orientation. As the gripper orientation changes, so will these scale factors, unless the gripper is square and it's dimensions do not change in X and Y orientations.

Having established these scale factors, the X and Y co-ordinates of the final place position on the stack, are then scaled to the X and Y values of the TOP (tool centre point) on the robot, using these scale factors. Thus the pick position within the boundaries of the gripper will be a scaled version of the same position for the ultimate place position in the stack. Or to put it another way, the proportionate X and Y positions of the ultimate stacking position as a proportion of the whole dimensions of the stack, are applied to the proportionate picking position of the gripper as a proportion of the whole dimension of the gripper head.

Figure 4B shows this in operation with an item 402' gripped at one edge of the gripper in the same scaled position as it is being placed on the pallet 404. In this example, both the item and its position on the pallet are on the far left of the figure.

The result of this is that if, for example, a box is in the extreme corner of a stack, the robot TOP will be overwritten and be picked so that it is gripped in the corresponding extreme corner of the gripper, in the given stack orientation. This means that when the robot moves to pick the box, its pick motion is varied to position the box or product at the desired location within the gripper, and this in turn means that when the box is placed, the gripper will be in-board of the stack, thus controlling the robot motion and preventing collision with other cell objects. This arrangement avoids the need to introduce complex logic to consider the position of the excess dimensional capacity in the gripper when picking individual objects. It also has the added advantage of distributing wear across the gripper components during stacking.

This whole methodology relates to robot frame positions in relation to a secondary robot base. Since bases are totally configurable and adjustable in terms of their X, Y, Z, A, B and C positions (X, Y & Z Cartesian axes and respective rotations A, B, C about those axes) in 3D space, this provides a very flexible solution to creating robot code from the pallet configuration data as the pallet stacking can take place anywhere in the cell and the whole cell configuration can be set up in minutes. This means that the system is able to be installed, de-commissioned and moved very easily. The advantage of this factor is that potential robot users could have the opportunity to rent a robot cell for the first time in robotics. This is made realisable because of the adjustable nature of the software as described above.

4 -Top Level Cell Controls The fourth element of this solution is to use a PLC runtime to control the robot cell in a conventional manner. The individual elements and output devices of any robot cell are switched, managed and speed controlled on the basis of the input devices and sensors.

This is usually done using a PLC controller so the most rational approach involves including this functionality within this system.

Where grouping or multi-picking has been deployed, this also involves controlling the marshalling of incoming products, and orientating them where necessary so that they are in the appropriate groups on the infeed conveyor for the robot to pick. Whether or not an item should be marshalled in this way is controlled by the stack index.

The basic logic surrounding this element of the solution is the same irrespective of how the cell is configured, since the control logic does not differ based on the location of cell hardware. It is made configurable only by the use of universal output devices, universal input devices, and universal input device connections and universal output device connections to the control panel. Operators are then presented with the option to choose which outputs on the control panel are associated with each output device, meaning that cell setup is much easier and quicker in hardware terms.

The skilled person will appreciate that although the preferred embodiments have been described in terms of Cartesian coordinates, other coordinate systems may be substituted.

The skilled person will appreciate that although the preferred embodiments have been described in terms computer hardware running the Windows operating system, other operating systems and/or hardware may be substituted. For example, a separate plc may be used in place of the Windows-based system described above. The skilled person will appreciate that although described on connection with a palletising operation, this invention has general applicability to any automated, robotised stacking operation.

Claims

Claims 1. A method of generating control commands for a robot to cause it to produce a stack of items, the method comprising the steps of:- (a) accepting user input of a 3D coordinate of a base frame position; (b) receiving a 3D digital model of the stack with stack coordinates for each item stored relative to a known reference coordinate, (c) identifying in the 3D digital model of the stack, a group of objects to be stacked which are identical in dimensions and oriented the same way and adapting the digital model to create a group which is to be picked as a group and then treated as a single item in the remainder of the processing, (d) sorting the coordinates for each item into a list of items sorted in vertical position in the stack (e) extracting an item's 3D coordinates from the item list in order and for a group, calculating the centroid position of the whole group, using the individual x y placing coordinates of each item in the group, for example by averaging the outermost coordinates of the group, and returning this as the coordinates for the x y coordinates for the group, generating a placing coordinate by processing an item's 3D coordinates to apply an offset to each coordinate which is the difference between the item's coordinates and the base frame position; (g) issuing a control command to cause the robot to move to the placing coordinate position.repeating steps (e) to (g) until the entire item list has been traversed, accepting user input of a 3D coordinate of a pre-place position, and. determining the position of a previous item to have been stacked, generating a pre-place x position by comparing the x-coordinate of the previous item with a proposed x-coordinate of a current item and (I) if the x-coordinate of the previous item was less than the x-coordinate of the current item, calculating the pre-place x position by adding a pre-place X-offset to the next place position, or (i) if the x-coordinate of the previous item was more than the x-coordinate of the current item, calculating the pre-place x position by subtracting a pre-place X-offset from the next place position.(m) generating a pre-place y position by comparing the y-coordinate of the previous item with the proposed y-coordinate of the current item and if the y-coordinate of the previous item was less than the y-coordinate of the current item, calculating the pre-place y position by adding a pre-place Y-offset to the next place position, or if the y-coordinate of the previous item was more than the y-coordinate of the current item, calculating the pre-place y position by subtracting a pre-place Y-offset from the next place position.
2. A method according to claim 1, in which a group is identified by receiving user input.
3. A method according to claim 1, in which a group is automatically identified:-a) by processing the 3D digital model of the stack to cycle through points in each respective horizontal layer, to identify any series of objects that have a consistent X or Y dimension, and b) once a series is identified, check the position definitions of these objects to determine that their orientation is the same throughout the series.
4. A method according to any preceding claim, including the steps of:- (a) receiving a 3D digital model of the stack by interrogating the 3D model of the stack by cycling through each item and retrieving the 3D coordinates of each item, (b) storing the retrieved coordinates in the item list, with an entry for each item
5. A method according to any preceding claim, including the steps of:- (a) determining the position of the previous item to have been stacked, (b) comparing the x-coordinate of the previous item with the proposed x-coordinate of the current item and if the previous x-coordinate was less than the current x-coordinate, adding the pre-place X-offset to the next place position, or (ii) if the previous x-coordinate was more than the current x-coordinate, subtracting the pre-place X-offset from the next place position.
6. A method according to any preceding claim, including the steps of:- (a) determining the position of the previous item to have been stacked, (b) comparing the y-coordinate of the previous item with the proposed y-coordinate of the current item and if the previous y-coordinate was less than the current y-coordinate, adding the pre-place Y-offset to the next place position, or if the previous y-coordinate was more than the current y-coordinate, subtracting the pre-place Y-offset from the next place position.
7. A method according to any preceding claim including creating the 3D digital model of the stack.
8. A method according to any preceding claim including accepting user input of a 3D coordinate of a pre-place position, and issuing a control command to cause the robot to move to the pre-place coordinate position, before the step of issuing a control command to cause the robot to move to the placing coordinate position.
9. A method according to any preceding claim, including determining the proportionate X and Y positions of the ultimate stacking position as a proportion of the whole dimensions of the stack, and applying that to the proportionate picking coordinate position of the gripper as a proportion of the whole dimension of the gripper head, by adjusting the head tcp value, and issuing a control command to cause the robot to move to the picking coordinate position and to pick at that position,
10. A method of generating control commands for a robot to cause it to produce a stack of items, the method comprising the steps of:- (a) accepting user input of a 3D coordinate of a base frame position; (b) receiving a 3D digital model of the stack with stack coordinates for each item stored relative to a known reference coordinate, (c) sorting the coordinates for each item into a list of items sorted in vertical position in the stack (d) extracting an item's 3D coordinates from the item list in order, (e) generating a placing coordinate by processing an item's 3D coordinates to apply an offset to each coordinate which is the difference between the item's coordinates and the base frame position; (f) determining the proportionate X and Y positions of the ultimate stacking position as a proportion of the whole dimensions of the stack, and applying that to the proportionate picking coordinate position of the gripper as a proportion of the whole dimension of the gripper head, by adjusting the head tcp value, (g) issuing a control command to cause the robot to move to the picking coordinate position and to pick at that position, (h) issuing a control command to cause the robot to move to the placing coordinate position and to place at that position, (i) repeating steps (d) to (h) until the entire item list has been traversed, (j) accepting user input of a 3D coordinate of a pre-place position, and (k) determining the position of a previous item to have been stacked, (I) generating a pre-place x position by comparing the x-coordinate of the previous item with a proposed x-coordinate of a current item and (i) if the x-coordinate of the previous item was less than the x-coordinate of the current item, calculating the pre-place x position by adding a pre-place X-offset to the next place position, or (ii) if the x-coordinate of the previous item was more than the x-coordinate of the current item, calculating the pre-place x position by subtracting a pre-place X-offset from the next place position.(m) generating a pre-place y position by comparing the y-coordinate of the previous item with the proposed y-coordinate of the current item and (0 if the y-coordinate of the previous item was less than the y-coordinate of the current item, calculating the pre-place y position by adding a pre-place Y-offset to the next place position, or (ii) if the y-coordinate of the previous item was more than the y-coordinate of the current item, calculating the pre-place y position by subtracting a pre-place Y-offset from the next place position.
11. A method according to claim 10, including the steps of:- (a) receiving a 3D digital model of the stack by interrogating the 3D model of the stack by cycling through each item and retrieving the 3D coordinates of each item, (b) storing the retrieved coordinates in the item list, with an entry for each item
12. A method according to claim 10 or 11, including the steps of:- (a) determining the position of the previous item to have been stacked, (b) comparing the x-coordinate of the previous item with the proposed x-coordinate of the current item and (i) if the previous x-coordinate was less than the current x-coordinate, adding the pre-place X-offset to the next place position, or (ii) if the previous x-coordinate was more than the current x-coordinate, subtracting the pre-place X-offset from the next place position. 5
13. A method according to any of claims 10 to 12, including the steps of:- (a) determining the position of the previous item to have been stacked, (b) comparing the y-coordinate of the previous item with the proposed y-coordinate of the current item and (i) if the previous y-coordinate was less than the current y-coordinate, adding the pre-place Y-offset to the next place position, or (ii) if the previous y-coordinate was more than the current y-coordinate, subtracting the pre-place Y-offset from the next place position.
14. A method according to any preceding claim including creating the 3D digital model of the stack.
15. A method according to according to any of claims 10 to 12, including accepting user input of a 3D coordinate of a pre-place position, and issuing a control command to cause the robot to move to the pre-place coordinate position, before the step of issuing a control command to cause the robot to move to the placing coordinate position.
16. Apparatus for generating control commands for a robot to cause it to produce a stack of items, comprising computer processing means and computer memory and further comprising a robot control interface and a user interface and being arranged to receive user input via the user interface and to output robot control commands via the robot control interface and being further arranged to carry out the method steps of any preceding claim.
17. Apparatus according to claim 16, wherein the apparatus includes a plc to generate robot commands for directly feeding to a robot.
18. A computer readable medium carrying computer program code which when executed on computer hardware, causes the hardware to carry out the method steps of any of claims 1 to 15.