What to look for on a used robot

Title explains it.

What would you look for when looking at a used robot?

Noises? Checks for backlash?

Type of maintenance? Do they have greese zerks, etc. ?



Next round of questions will be about EOAT sources.
Initially, I'll use a suction cup setup.
So, I'm thinking an air line, for a vacuum inducer, a solenoid, and a vacuum switch to verify part attatchment.

It IS standard operatoing procedure to verify part gripping with the EOAT isn't it?


Also, how about de-stacking infeed parts?
Can I approach the top of the stack, and check for contact, (vacuum) and then conditionally advance to the next lower position.
Or should I use a microswitch to verify contact with the top of the stack?
and again, advance to lower positions until I find a part blank to grab?
That seems safer than relying on a counter to Assume the height of the stack...
(What about a partial stack? etc. )

And on the outfeed stacking, simply keep a counter to track which height to drop the successive parts off at?


Thirdly, the machining center will be using a vacuum chuck.
Current thinking is to remove the finished part, close the door, and using a propellor in the spindle, blow off the fixture to remove small chips.
Open the door and let the robot load the next blank.

Not as fast as having two grip stations on the EOAT, but the blowoff of the fixture will be important.
Unless I can really re-think the fixture design, it does hold chips after a manual part cycle, and needs to be cleaned of chips for each part.
The propellor works pretty well, but it is faster to do it manually, at present.
(I don't think the robot should be blowing off the fixture plate, esp. not while holding a blank and a finished part.)

Thanks for any ideas on all of this...

When this is working, I've got more ideas for the future...


EOAT ...End Of Arm Tooling...

3t3d said:

Title explains it.

What would you look for when looking at a used robot?

Noises? Checks for backlash?

Type of maintenance? Do they have greese zerks, etc. ?

Click to expand...

First question: What brand, model, year and payload? (I recommend Kawasaki if you haven't decided).
Check the hours. Check the joint bearings. Some have external zerks, others are internal. Many require a special grease, and it only needs to be purged about every year or so.
Robots use cycloidal gearing, so there is always some mechanical slop when the axis drives are disabled. The real test is to set up an indicator and see if the robot repeats to different positions within the work envelope to within the mfg's tolerances.
You might want to really look into a new robot, as you get warranty and training with it, the latest controller and it probably won't be very much more cost than a used one.

3t3d said:

Next round of questions will be about EOAT sources.
Initially, I'll use a suction cup setup.
So, I'm thinking an air line, for a vacuum inducer, a solenoid, and a vacuum switch to verify part attatchment.
It IS standard operatoing procedure to verify part gripping with the EOAT isn't it?

Click to expand...

Valving can be internal to the robot, if it was ordered that way. Many are, depending on what it was initially bought to do, as well as internal wiring for sensor inputs from EOAT.
We don't verify part presence with a vacuum set-up, but you can. We mostly use vacuum for part transport (pick & place) we are normally moving mulitple parts. Non-plucked parts are detected at the equipment being unloaded, so there is no need for detection on the robot.
In your application, it would be appropriate to have sensing of some type.
And yes, it IS SOP to verify part gripping with EOAT in some manner.

3t3d said:

Also, how about de-stacking infeed parts?
Can I approach the top of the stack, and check for contact, (vacuum) and then conditionally advance to the next lower position.
Or should I use a microswitch to verify contact with the top of the stack?
and again, advance to lower positions until I find a part blank to grab?
That seems safer than relying on a counter to Assume the height of the stack...
(What about a partial stack? etc. )

Click to expand...

There are some variables here you need to consider, and many ways to do it. It is best and easiest to present the pallet to the robot in a fixed position in the X/Y plane, but it is not required.
If you present the pallet in a fixed X/Y position, then you only need to be concerned with the Z component, which makes programming and operation much more simplified. If you cannot fix the pallet in X/Y, then you need to "find" the pallet with the robot and calculate it's orientation relative to the robots X/Y/Z coordinate system.
Info for a fixed pallet:
You can fix the pallet by having a corner stop and an air cylinder with a V pusher on the end to push the pallet to this stop and keep it clamped via the opposite corner. Pretty simple set-up. I do suggest a gravity roller conveyor to set the pallet on, as it makes it easier to slide if the pallet is heavy. You could also use fixed corner stands with Y guides, if your pallets are all the same X/Y dimensions.
The easiest way to find the rough pallet height is via one of two methods. You can use a probe sensor, where you feed in an XMOVE mode at a specified speed until the sensor makes contact, almost identical to probing on a mill. This is the more expensive, but more accurate set-up.
Note: XMOVE: Move in a linear motion until an input is received.
You can use an retro-reflective optical sensor (BALLUFF BOS-.... type) and step/repeat down the front of the pallet (non-contact, sensor range is up to 400 mm) to determine a position within your step value. This is the method I suggest for your application, since you are using suction cups. You can increment in 3-5 mm steps, program the robot to move enough within the compliance of the cups to always ensure contact with the part. This is a less expensive option. The BOS sensors are about $110-120 vs 300+ for the probing type sensors. I don't recommend a regular micro switch, unless you enjoy replacing them.
You can also set a reference point on a full pallet and assume, but there are several disadvantages to this. You are relying on the pallet bases to be the same height all the time, which is rarely the case.
The programming is simply an array, where you give the X/Y/Z spacing of the parts. You can give the number of layers on the pallet, which will cut down on probing time, since you can roughly assume where the top of the pallet is before you start probing, and the robot will know when to start.
Optionally, you can set a reference at the pallet base, and calculate, based on your probing and it's distance to the reference point, how many layers are on the pallet. - Several different ways to skin a cat -
Non Fixed Pallet:
If the pallet is not fixed in the X/Y plane, then you need to probe for the pallet in 3 dimensions and set up a transformation array. This entails first finding the pallet in the Z axis, then probing 3 corners of the pallet in the X/Y axis in order to set up the transformation. This tells the robot the pallet orientation relative to the robots coordinate system. While it is done often, it is a much more complicated way of doing things, programming and operation wise.

3t3d said:

And on the outfeed stacking, simply keep a counter to track which height to drop the successive parts off at?

Click to expand...

Yes, the programmed array will take care of that, fairly simple stuff.

3t3d said:

Thirdly, the machining center will be using a vacuum chuck.
Current thinking is to remove the finished part, close the door, and using a propellor in the spindle, blow off the fixture to remove small chips.
Open the door and let the robot load the next blank.

Click to expand...

SLOW, SLOW, SLOW.

I do this all the time. What you want to do is have the parts 180° to each other, with the blow-off nozzle on the EOAT at 90°. Pick part up, roll 90, blow off, roll 90 more and load. With the parts at 90 to the blow off, the risk of contamination of the parts is very minimal. If you do have trouble, you can set up a secondary blow-off inside the machine to blow the contact surface of the part off prior to rolling it into position for load. You do not want to exit the machine between unload/load if you can at all avoid it.

Also, keep in mind there are very specific safety requirements for robots. The enclosure must not have 'readily accessible crush zones less than 18" to structure' within the working envelope of the robot. By readily accessible, the meaning is that the human would not have to climb over, under or around a permanent part of the installation to reach the crush zone.
The robot must be physically separated from humans via barrier. This means a fixed cage. It has to be a minimum 1' from the floor, and extend a minimum of 5' from the floor.
The size of the openings in the cage material determine how far away the robot must stay from the cage walls.
Doors of floor accessible robots must have dual-redundant safety devices. This typically means a locking door switch, and a hinge switch. There are other considerations to take into account.

If you need help, send me some pics of the machine and application and I'll offer up some suggestions and things to watch out for. I design, program, build and support this stuff on a daily basis.

Some Sample Programs

3t3d, and anyone else interested in this type of thing,
Warning: This is a long post, hrm, actually it's TOO long to allow posting according to the PM error, so I will have to break it into several posts.
For a follow up, here are some programming examples of doing some of the things you asked about. These are written in AS Language (Advanced Scripting Language) which is used by Kawasaki Robots. This is a very versatile, feature-rich high-level programming language.

Some explanation and background information as to what the some of the commands in the programs mean, as if you don't understand it, posting code means absolutely nothing.
You have a maximum of 256 hard inputs and 256 hard outputs from the robot controller.
The hard inputs will always be seen as 1xxx numbers to the program.
The hard outputs will always be xxx to the program.
The Kawasaki Controller also has 256 internal I/O available. These can be used as keep bits and other uses, but cannot be mapped to external I/O, they are only available within the controller. These are always in the 2xxx range and can be both output and inputs to the program.
In addition, you can map I/O to/from Remote I/O, EtherNet, DeviceNet, etc. going to a secondary controller (PLC).

I/O are read/written in the program via the SIGNAL command, so a SIGNAL 13 would turn on output 13. A SIG(1011) would read input 11 (1011). When writing, a positive value means the signal is turned on and a negative value means the signal is turned off. When reading, a positive value means you are looking for the signal to be ON, and a negative value means you are looking for the signal to be OFF.

The SWAIT command forces the robot to halt all operations until a signal is received.

The BREAK command is very useful, and some CNC's even support this function. This stops pre-processing (read-ahead). This is needed just like it sometimes is in a CNC program where you want to make the controller not read ahead the x# of lines it normally does. This is especially needed in a robotics application where you are looking for certain types of signals. The ACCURACY command sets up a target position sphere. Normally, when the robot reaches this sphere, processing of all the next blocks of information up to and including the next movement command are executed. The BREAK command prevents this from happening. The next blocks of information are not executed until the exact target position of the robot is complete and the robot has ceased all motion.

The DRAW command is an incremental linear move along the three normal cartesian coordinate axis X,Y,Z, delimited by a comma.

A JMOVE is a joint motion command where the path of the robot will be an arcing motion. This is the fastest way to move the robot as the controller calculates the fastest path to the target based on each joint's maximum rotation speed.

A LMOVE is a linear move, and will move the robot end effector in a straight linear path in the normal cartesian coordinate system, maintaining the starting orientation of the end effector along the entire path.

The POINT command allows you to do calculations for positions. If you notice I calculate positions based on fixed reference points. This makes it easy to set the robot back up if something goes wrong. It also allows you to have limited operator corrections for minor day to day variations that can be seen.

The STABLE command similar, but still different from the BREAK command, forces the robot to remain in position for x amount of time after all commanded motion has ceased before executing the next block of the program. This is handy where you are reaching way out at the edge of the robots work envelope with a heavy payload and you get some minor mechanical oscillations. The BREAK command allows continuation immediately after all commanded motion has stopped.

There are two types of positional information a robot uses.

1) Precision Point, noted by a # sign preceding the position name, is a position recorded or calculated using joint angles. It is called precision point because there can only be 1 exact set of joint angles that correspond to a particular position and orientation in 3D space.

2) Transformation Point, noted by a lack of # sign in front of the position name. It is recorded or calculated as a point in 3D space in mm, along the X,Y,Z, coordinate system (joints 1,2 and 3), relative to the coordinate system origin. The three wrists (joints 4,5 and 6) are recorded as relative angles to the coordinate system axis zero angle and denoted by O,A,T.
There can be more than one transformation position that relates to a particular position and end effector orientation in 3D space. Care must be taken when using transformation points, if the orientation of joints 4, 5 and 6 are critical. There are commands available when using transformation points that will force certain joints to take a particular pose to mitigate these issues.
You can convert a precision point to a transformation point and vice versa within the program.

It is much desired to use transformation points if you are doing any calculating of positions, as it is much, much easier to just add 100 mm in Y, vs recalculating all 6 joint angles that would move the robot 100 mm in Y.

See the second post for the first sample programs and an explanation of what they are doing.

First sample programs

Ok, on to the sample programs. Anything after a semi-colon is a comment.
These first two are subs from a much larger system. This is a system I programmed last year and performs the following functions:
Index pallets via conveyor.
Determines how many layers are on the pallets.
Determine the orientation of the trays as they are alternately offset left/right on the pallet.
Determines the fine height of the top tray.
Determines where the pallet is located in the Y axis.
Determines how many rows of the product are on the top tray of the pallet.
Unloads the product to a work cell.
Moves and re-stacks the empty trays to an empty pallet base.
Rinse and Repeat


This first program uses 2 Balluff BOS type sensors, inputs 14 & 15 (1014, 1015) to detect firstly if there is a pallet bottom present at both the load and unload stations, then to incrementally move up the pallet and count the number of trays present on each pallet. The vertical spacing of the trays is a known value input via the Custom User Interface Panel, and has been written to the variable colspc. If the sensor is made, there is a tray in front of it and it is noted via internal I/O. There are a maximum of 6 trays possible in this application.

.PROGRAM trayhgt()
;***************************************************************************
; PALLET TRAY COUNT SEQUENCE
;***************************************************************************
1 IF SIG(1042) THEN ;End Of Cycle Requested From Controller
endofcycle = 1
RETURN ; Jump back to End Of Cycle Sequence
END
SPEED spde ALWAYS ;Set Robot Speed to Empty Speed
ACCEL acce ALWAYS ;Set Robot Accel to Empty Acceleration
DECEL acce ALWAYS ;Set Robot Decel to Empty Deceleration
JMOVE #abovemid;Move Above Middle of Pallets
JMOVE #palletcheck;Move to Pallet Check Position
BREAK ;Wait for Process Stop
;
IF SIG(1014) THEN ;Check for Full Pallet Base Present
SIGNAL 2060 ;Set Full Pallet Present
ELSE
SIGNAL -2060 ;Set Full Pallet Not Present
END
IF SIG(1015) THEN ;Check for Empty Pallet Base
SIGNAL 2070 ;Set Empty Pallet Base Present
ELSE
SIGNAL -2070 ;Set Empty Pallet Base Not Present
END
DRAW 0,0,colspc;Move Up To First Tray
BREAK ;Wait for Process Stop
;
IF SIG(1014) THEN ;Check for Tray 1
SIGNAL 2061 ;Set Tray 1 Present
ELSE
SIGNAL -2061 ;Set Tray 1 Not Present
END
IF SIG(1015) THEN ;Check for Empty Tray 1
SIGNAL 2071 ;Set Empty Tray 1 Present
ELSE
SIGNAL -2071 ;Set Empty Tray 1 Not Present
END
DRAW 0,0,colspc;Move Up One Tray
BREAK ;Wait for Process Stop
;
IF SIG(1014) THEN ;Check for Tray 2
SIGNAL 2062 ;Set Tray 2 Present
ELSE
SIGNAL -2062 ;Set Tray 2 Not Present
END
IF SIG(1015) THEN ;Check for Empty Tray 2
SIGNAL 2072 ;Set Empty Tray 2 Present
ELSE
SIGNAL -2072 ;Set Empty Tray 2 Not Present
END
DRAW 0,0,colspc;Move Up One Tray
BREAK ;Wait for Process Stop
;
IF SIG(1014) THEN ;Check for Tray 3
SIGNAL 2063 ;Set Tray 3 Present
ELSE
SIGNAL -2063 ;Set Tray 3 Not Present
END
IF SIG(1015) THEN ;Check for Empty Tray 3
SIGNAL 2073 ;Set Empty Tray 3 Present
ELSE
SIGNAL -2073 ;Set Empty Tray 3 Not Present
END
DRAW 0,0,colspc;Move Up One Tray
BREAK ;Wait for Process Stop
;
IF SIG(1014) THEN ;Check for Tray 4
SIGNAL 2064 ;Set Tray 4 Present
ELSE
SIGNAL -2064 ;Set Tray 4 Not Present
END
IF SIG(1015) THEN ;Check for Empty Tray 4
SIGNAL 2074 ;Set Empty Tray 4 Present
ELSE
SIGNAL -2074 ;Set Empty Tray 4 Not Present
END
DRAW 0,0,colspc;Move Up One Tray
BREAK ;Wait for Process Stop
;
IF SIG(1014) THEN ;Check for Tray 5
SIGNAL 2065 ;Set Tray 5 Present
ELSE
SIGNAL -2065 ;Set Tray 5 Not Present
END
IF SIG(1015) THEN ;Check for Empty Tray 5
SIGNAL 2075 ;Set Empty Tray 5 Present
ELSE
SIGNAL -2075 ;Set Empty Tray 5 Not Present
END
DRAW 0,0,colspc;Move Up One Tray
BREAK ;Wait for Process Stop
;
IF SIG(1014) THEN ;Check for Tray 6
SIGNAL 2066 ;Set Tray 6 Present
ELSE
SIGNAL -2066 ;Set Tray 6 Not Present
END
IF SIG(1015) THEN ;Check for Empty Tray 6
SIGNAL 2076 ;Set Empty Tray 6 Present
ELSE
SIGNAL -2076 ;Set Empty Tray 6 Not Present
END
JMOVE #abovemid;Move Above Middle of Pallets
;
RETURN
.END

In this next program, we are going to use the info above to determine the fine height of the tray. We will approach the pallet at a known positions (precision point), then we will use the signal bits set above to move to the first tray down that actually exists, again, a known value in Z. Then we will increment down 2 mm, check for the tray edge, if not present, loop back and move 2 more, rinse and repeat until either we find the tray edge, or we exceed 50 mm of travel. If we find the edge, the distance traveled is recorded via the variable dptchk. We can later use this as an offset when we approach to do actual work. If 50 mm travel is exceeded, then we throw out an error message to the user panel, back away from the pallet and go to the end of cycle sequence, which parks the robot and stops the system.

.PROGRAM fineheight()
;***************************************************************************
; DETECT FINE HEIGHT OF TOP TRAY
;***************************************************************************
SIG -9,10 ; Open Gripper
SWAIT 1013 ; Verify Gripper Open
IF SIG(1042) THEN ;End Of Cycle Requested From Controller
endofcycle = 1
RETURN ; Jump back to End Of Cycle Sequence
END
IF SIG(2061) THEN ;If At Least One Tray Exists
IF (SIG(2060) AND SIG(2061)) THEN ;If At Least 1 Tray Is At The Station
ACCURACY 100 ALWAYS
SPEED 100,100 ALWAYS
JMOVE #dptapp;Approach Pallet
JMOVE #dpt;Move To Check Start
SPEED chkspd ALWAYS
IF SIG(2066) THEN ;Tray 6 Present
GOTO 20
END
IF (SIG(2065) AND SIG(-2066)) THEN ;Tray 5 Present
DRAW 0,0,(-colspc);Adjust Z Position
GOTO 20
END
IF (SIG(2064) AND SIG(-2065)) THEN ;Tray 4 Present
DRAW 0,0,(-2*colspc);Adjust Z Position
GOTO 20
END
IF (SIG(2063) AND SIG(-2064)) THEN ;Tray 3 Present
DRAW 0,0,(-3*colspc);Adjust Z Position
GOTO 20
END
IF (SIG(2062) AND SIG(-2063)) THEN ;Tray 2 Present
DRAW 0,0,(-4*colspc);Adjust Z Position
GOTO 20
END
IF (SIG(2061) AND SIG(-2062)) THEN ;Tray 1 Present
DRAW 0,0,(-5*colspc);Adjust Z Position
END
20 IF SIG(-1016) THEN ;Detection Sensor Error
SIGNAL 42 ;Set Robot End Of Cycle Request
robotmess = 7 ;Set Robot Error Messages Variable
SPEED 10 ALWAYS ;Set Speed To Slow
JMOVE #dpt;Move To Pallet Check Start
JMOVE #dptapp;Approach Pallet Position
endofcycle = 1 ; Set end of cycle flag
RETURN ; Jump back for End Of Cycle Sequence
END
ACCURACY 1 ALWAYS
dptchk = 0 ;Reset Check Increment Variable
25 DRAW 0,0,2;Move To Find Tray Height
dptchk = dptchk-2 ;Increment Height Check Variable
BREAK ;Wait for Process Stop
IF SIG(1015) THEN ;Tray Height Found
GOTO 30
END
IF dptchk>=50 THEN
SIGNAL 42 ;Set Robot End Of Cycle Request
robotmess = 7 ;Set Robot Error Messages Variable
SPEED 10 ALWAYS ;Set Speed To Slow
JMOVE #dpt;Move To Pallet Check Start
JMOVE #dptapp;Approach Pallet Position
endofcycle = 1 ; Set end of cycle flag
RETURN ; Jump back for End Of Cycle Sequence
END
GOTO 25
END
30 SPEED 100,100 ALWAYS
JMOVE #dpt;Move To Pallet Check Start
JMOVE #dptapp;Approach Pallet Position
HOME 1 ; Move to home position
END
RETURN
.END

Second sample programs

Apparently I am going to have to make 4 posts, this portion is still a little too long for PM's limit.

These next two programs are part of the programs for a machining cell I programmed earlier this year that does something very similar to what you want to do. This uses a fixed set of trays where operators place parts, they are picked up and loaded into a 5-axis VMC, the finished parts are then output to a small gravity roller conveyor and pushed out of the robot cell area via a rodless pneumatic cylinder with a plastic pusher attached. The length of the output conveyor is set to ensure inspection every x number of parts, as when the conveyor reaches "full" status, the system stops and waits. You can never run more than x+2 bad parts (one in machine, one in robot gripper ready to drop on the conveyor).
There are 3 trays vertically, with 2 rows of parts per tray, 7 parts per row. This gives up to 42 parts total available to run. The actual number of parts available is input by the operator on the Custom User Interface Panel prior to robot start. In this application with these particular parts, 42 parts equates to 12 hours of uninterrupted operation.

.PROGRAM vmc_main()
;******************************************************************************
; Main Program - VMC Cell
;******************************************************************************
; Secton Label Listing
; 1 = Loopback Point
; 100 = Get part from Tray
; 200 = Load / Unload Machine
; 900 = Unload to Push-out conveyor
; 950 = End of Cycle from Tray 1
; 960 = End of Cycle from Tray 2
; 970 = End of Cycle from Tray 3
; 980 = End of Cycle from Unload Area
; 990 = End of Cycle from Machine
; 999 = End of Cycle from Start-up Fault
;***************************************************************************
; We may need to call a sub or two & convert our prec points to trans points
;***************************************************************************
; Need to check to see if we are restarting from a pause, or are we restarting
; with a new set of parts
IF (numkeep <> numparts) THEN ; If number of parts available does not match
CALL calc ; Call calculation program
END
POINT trayref = #trayref
POINT conveyor = #conveyref
POINT machref = #machref
POINT machrefu = #machrefu
;***************************************************************************
; Better set some default params - the old programmer can be forgetful
;***************************************************************************
ACCURACY 75 ALWAYS ; Set Accuracy to 75mm Unless Called Otherwise
SPEED 100,100 ALWAYS
ACCEL 100 ALWAYS ; Set Acceleration to 100% Unless Called Otherwise
DECEL 100 ALWAYS ; Set Deceleration to 100% Unless Called Otherwise
machspeed = 30
slowfeed = 20
trayspeed = 40
unldspeed = 40
autospeed = 100
;***************************************************************************
; We better check to make sure the robot is in a good config to start up with.
; It would not be good to have a crash first thing because of something simple.
;***************************************************************************
IF (SIG(9) AND SIG(11)) THEN
SIGNAL 2030 ; Both grippers closed fault
PRINT "FAULT: BOTH GRIPPERS CLOSED"
GOTO 999
END
IF (SIG(-18) AND SIG(-17)) THEN
SIGNAL 2031 ; Not at home 1 or 2 fault
PRINT "FAULT: ROBOT NOT AT HOME 1 OR 2"
GOTO 999
END
IF SIG(-1040) THEN
SIGNAL 2032 ; Automation not at home fault.
PRINT "FAULT: AUTOMATION NOT AT BASIC POSITION"
GOTO 999
END
IF SIG(-1021) THEN
PRINT "Machine not in Automatic"
GOTO 999
END
IF SIG(2010) THEN
SIGNAL 2034; End of cycle stop requested
PRINT "END OF CYCLE STOP REQUESTED"
GOTO 999
END
;***************************************************************************
; Now we need to determine what to do at start up & move to Home 1
;***************************************************************************
IF SIG(18) THEN ; If at HOME 2
SPEED slowfeed
JMOVE #inthome2
HOME 1 ; Move to HOME 1
END

1 IF (SIG(9) AND SIG(-11)) THEN ; If gripper 1 is closed & Gripper 2 is open
GOTO 200 ; Jump to machine sequence
END
IF (SIG(-9) AND SIG(11)) THEN ; If gripper 1 is open & gripper 2 is closed
GOTO 900 ; Jump to unload sequence
END
IF (SIG(-9) AND SIG(-11)) THEN ; If both grippers are open
GOTO 100 ; Jump to tray pick up sequence
END
GOTO 999 ; Sanity Check
;****************************************************************************
; Ok, lets go get a part from one of the trays
;****************************************************************************
100 HOME 1
; check to see if this is the first cycle - reset variables if so and skip
; waiting on the pre-fetch signal from the machine
IF (firstcycle == 1) THEN ; If this is the first cycle on a new set of parts
f = 0 ; reset x position var to 0
g = 0 ; reset y position var to 0
h = 0 ; reset z position var to 0
firstcycle = 0
GOTO 106
END
; We need to wait on the pre-fetch signal from the machine before we get a part
104 IF SIG(-1010) THEN ; If pre-fetch isn't active then
IF SIG(2010) THEN ; if end of cycle is seen
GOTO 999 ; Jump to end of cycle
END
GOTO 104 ; jump back to start of loop
END
SWAIT 1010 ; Sanitiy check for pre-fetch
; Check to see if all parts have been ran
106 IF (f > numparts) THEN
PRINT "All Done - Load Me Up Again"
SIGNAL 8 ; Cycle Completed
GOTO 999
END
CALL occalc
; Calculate our positions
POINT pickup = SHIFT(trayref BY (xshift[f]+octrx),(yshift[g]+octry),(zshift[h]+octrz))
IF (yshift[g] < 400) THEN
POINT pickupappr = SHIFT(pickup BY 0,-120,10)
POINT pickupdpt = SHIFT(pickup BY 0,-120,50)
ELSE
POINT pickupappr = SHIFT(pickup BY 0,-(120+yspace),10)
POINT pickupdpt = SHIFT(pickup BY 0,-(120+yspace),50)
END
IF (h == 0) THEN
POINT trayappr = SHIFT(trayref BY -620,0,0)
END
IF (h == 1) THEN
POINT trayappr = SHIFT(trayref by -620,0,-zspace)
END
IF (h == 2) THEN
POINT trayappr = SHIFT(trayref by -620,0,-(zspace*2))
END
SPEED autospeed
ACCURACY 100
JMOVE trayappr ; approach trays centrally
ACCURACY 50
JMOVE pickupappr ; move to pre-pick position
SPEED trayspeed ; set our speed to tray speed
ACCURACY 1
LMOVE pickup ; move to pick up position
SIGNAL -9,10 ; Close gripper 1
SWAIT 1013,-1014 ; verify gripper closed
;*****************************************************
; now we have to do the math for the next position in the array
;*****************************************************
f = f+1 ; add 1 to our x axis position
numparts = numparts-1 ; subtract 1 from our parts available count
remain = numparts ; remaining parts for I/F counter
IF (f <= 6) THEN ; if x position is less than 7
g = 0 ; set our y position to be row 1
i = f ; set x position to f value
PRINT "Tray 1 - Row 1"
GOTO 110 ; jump out to Z position calcs
END
IF ((f >= 7) AND (f <= 13)) THEN ; If x position is 8 thru 14
g = 1 ; set our y position to row 2
i = f - 7
PRINT "Tray 1 - Row 2"
GOTO 110 ; jump out to z position calcs
END
IF ((f >= 14) AND (f <= 20)) THEN ; if x position is 15 thru 21
g = 0 ; set our y position to row 1
i = f - 14
PRINT "Tray 2 - Row 1"
GOTO 110 ; jump out to z position calcs
END
IF ((f >= 21) AND (f <= 27)) THEN ; if x position is 22 thru 28
g = 1 ; set our y postion to row 2
i = f - 21
PRINT "Tray 2 - Row 2"
GOTO 110 ; jump out to z position calcs
END
IF ((f >= 28) AND (f <= 34)) THEN ; if x position is 29 thru 35
g = 0 ; Set our y position to row 1
i = f - 28
PRINT "Tray 3 - Row 1"
GOTO 110 ; jump out to z position calcs
END
IF ((f >= 35) AND (f <= 41)) THEN ; if x position is 36 thru 42
g = 1 ; Set our y position to row 2
i = f - 35
PRINT "Tray 3 - Row 2"
GOTO 110 ; jump out to z position calcs
END
110 IF (f <= 13) THEN ; If x position is less than 14
h = 0 ; Set z to tray 1
PRINT "Tray 1"
GOTO 120 ; Jump out of calcs
END
IF ((f >= 14) AND (f <= 27)) THEN ; If x position is 15 thru 28
h = 1 ; set our z to tray 2
PRINT "Tray 2"
GOTO 120 ; jump out of calcs
END
IF (f >= 28) THEN ; If x position is more than 28
h = 2 ; ste our z to tray 3
PRINT "Tray 3"
GOTO 120 ; jump out of calcs
END
GOTO 999 ; oops on error
120 DRAW ,,50 ; move the part up out of tray
LMOVE pickupdpt ; move out away from tray
SPEED autospeed ; set speed to autospeed
ACCURACY 100
JMOVE trayappr ; move back to our tray approach position
HOME 1 ; move back to home
GOTO 200 ; Jump to machine sequence
GOTO 999 ; oops on error
;****************************************************************************
; Machine loading sequence
;****************************************************************************


Please see the next post for the rest of the program, still to many characters.

Rest of main program + calc sub

;****************************************************************************
; Machine loading sequence
;****************************************************************************
200 IF SIG(2010) THEN ; if end of cycle is issued
GOTO 999
END
SPEED autospeed
ACCURACY 150
JMOVE #rotate1
JMOVE #rotate2
JMOVE #unloadappr ; move toward machine
; calculate machine positions
POINT machunload = SHIFT(machrefu BY mux,muy,muz)
POINT unloadappr = SHIFT(machunload BY 150,0,50)
POINT unloaddprt = SHIFT(machunload BY 0,0,50)
POINT machload = SHIFT(machref BY mlx,mly,mlz)
POINT loadappr = SHIFT(machload BY 0,0,50)
POINT loaddeprt = SHIFT(machload BY 150,0,50)
SPEED autospeed
ACCURACY 50
JMOVE #todooru ; move to just in front of the machine door
205 IF SIG(-1009) THEN ; If machine not ready
IF SIG(2010) THEN ; if end of cycle is seen
GOTO 990 ; end of cycle from machine
END
GOTO 205 ; loop back and wait on machine
END
SWAIT 1009 ; sanity check
SIGNAL -16 ; robot in machine area
SIGNAL -3,4 ; open door
SWAIT -1001,1002 ; verify door is opened
SPEED autospeed
ACCURACY 50
LMOVE unloadappr
SPEED machspeed
ACCURACY 1
LMOVE machunload
SIGNAL 11,-12 ; close gripper 2
SWAIT 1015,-1016 ; verify gripper closed
SIGNAL 15 ; Open fixture
SWAIT -1004,1003 ; verify chuck opened
ACCURACY 15
LMOVE unloaddprt ; move part above fixture
SPEED autospeed
ACCURACY 50
LMOVE unloadappr
DRIVE 6,-90,100 ; rotate wrist 90 degrees
SIGNAL 28 ; Turn blow off on
SPEED autospeed
ACCURACY 15
LMOVE #blow1
LMOVE #blow2
LMOVE #blow3
LMOVE unloadappr
SIGNAL -28 ; disable blow off
DRIVE 6,-90,100 ; rotate wrist 90 degrees
LMOVE loadappr ; move to above fixture
SPEED machspeed
ACCURACY 1
LMOVE machload ; move above fixture
DRAW ,,-jdpth ; draw down into fixture
STABLE 0.05 ; make robot stable for 0.05 sec
SIGNAL -9,10 ;Open gripper 1
SWAIT -1013,1014 ; verify gripper open
SIGNAL -15 ; request fixture closed
SPEED autospeed
ACCURACY 100
LMOVE loaddeprt ; move away from fixture
SPEED autospeed
ACCURACY 100
LMOVE #todooru ; move outside door
SWAIT 1004,-1003 ; wait on fixture close confirm
SIGNAL -4,3 ; close door, robot not in machine area, start cycle
SWAIT 1001,-1002; Make sure door is closed
SIGNAL 16,14,13 ; Release cycle start
SPEED autospeed
JMOVE #unloadappr
GOTO 900 ; go to unload sequence
GOTO 999 ; sanity check
;****************************************************************************
; Unload sequence
;****************************************************************************
900 JMOVE #unloadappr ; move to unload general vicinity
IF SIG(1007) THEN ; If Unload area isn't clear/ready
IF SIG(2010) THEN ; If end of cycle requested
GOTO 980 ; Jump to end of cycle
END
GOTO 900
END
; Calculate Unload Positions
POINT unload = SHIFT(conveyor BY cux, cuy, cuz)
POINT unldappr = SHIFT(unload BY 0,0,100)
SWAIT -1007 ; Wait on unload area clear (secondary safe check)
ACCURACY 50
SPEED autospeed
JMOVE unldappr ; move to above unload conveyor
SPEED unldspeed
ACCURACY 2
LMOVE unload ; place part on conveyor
SIG -11,12 ; Open Gripper 2
SWAIT -1015,1016 ; verify gripper is open
SPEED autospeed
ACCURACY 10
LMOVE unldappr ; Move back above gripper
JMOVE #unloadappr ; back away from unload area
SIGNAL 5 ; Extend pusher
JMOVE #rotate2
JMOVE #rotate1
HOME 1 ; Move to home position
GOTO 1 ; restart loop
;****************************************************************************
; End of Cycle from Tray 1
;****************************************************************************

Removed for character count.

GOTO 999
;****************************************************************************
; End of cycle
;****************************************************************************
999 numkeep = numparts
.END

Calculation program for the main:
.PROGRAM calc()
;******************************************************************************
; Calculation Subprogram - VMC Automation
;******************************************************************************
; Notes:
;
; 1. 'numparts' is variable for the number of parts on trays originally input by
; the operators at reload of tray system.
; 2. Remember to set variable 'numkeep' in end of cycle section to make sure that
; they have not reset the number of parts on the trays before you run calc again
; 3. Reference height is 35 mm for load and 45 mm for unload from fixture to grip
; at machine.
; 4. Tray ref is a reference fixture attached to tray support. Gripper centered
; and bottom of gripper pad is even with bottom of reference fixture.
;******************************************************************************
; Fixed Parameters
;******************************************************************************
firstcycle = 1
zspace = 300 ; vertical tray spacing
xspace = 170 ; robot x axis part spacing
yspace = 130 ; robot y axis part spacing
rows = 2 ; number of rows per tray
traytotal = 3 ; total number of trays
xrefshift = 156.527 ; distance from ref point to first position, top tray, x axis
yrefshift = 332.176 ; distance from ref point to first position, top tray, y axis
zrefshift = -31.934 ; distance from ref point to first position, top tray, z axis
tangle = 0.0000 ; Coordinate system to tray X axis correction (tangent of angle)
;******************************************************************************
; Calculations
;******************************************************************************
FOR a = 0 TO 6 ; set 'a' for xshift variable, FOR..TO loop to derive values
xshift[a] = ((xspace*a)+xrefshift)*-1 ; set up array for x spacing
END
FOR b = 0 TO 1 ; set 'b' for yshift variable, FOR..TO loop to derive values
yshift = (yspace*b)+yrefshift ; set up array for y spacing
END
FOR c = 0 TO 2 ; Set 'c' for zshift variable, FOR..TO loop to derive values
zshift[c] = ((zspace*c)*-1)+zrefshift ; set up array for z spacing set to neg value
END
mlx = ocmlx
mly = ocmly
mlz = ocmlz
mux = ocmux
muy = ocmuy
muz = ocmuz
cux = occux
cuy = occuy
cuz = occuz
.END