Im lifting flat sheets into a machine that forms them into a dome. I need to stack them in 4 stacks of 100. I am working with the R-j3iB controller and as far as im aware it does not have the palletizing function on it. So ill have to do it manually I think I can use position registers from what iv read. Im new to fanuc programming so could someone explain in simple terms how to do this or show me some example programs.
Thanks 
What you'll definitely need are Position Reigsters (PR) and numeric Registers (R).
You'll need R's as counters and possibly for calculating offset values, which you'll later use to shift PR's in given directions.
You'll also need to edit only certain coordinates of PR's - use PR[i,j] for that, where i = PR's number, j = coordinate.
Depending on the PR's data type, values of j are: 1 = x or J1, 2 = y or J2, 3 = z or J3, 4= w or J4, 5 = p or J5, 6 = r or J6. Depending on number of additional axes in your system, there may be further components of PR's. At the end of a PR, there is also a CONF string, which determines the arm's configuration, but that won't be needed in most cases - just use LPOS at some point of your program, to get a correctly "formatted" position and then play with it.
Also, User Frames and Tool Frames will be useful.
Assuming Z is positive... PR[i,3]=PR[i,3]+2
PR[21,3:Offset P1]=(R[19:Height count P1]*R[28:Part height])
Make P1 your bottom point that you teach then use PR21 as an offset to P1 by multiplying the amount of sheets you set by the thickness of each sheet.
When you place a sheet just add 1 to R[19]..... R[19]=R[19]+1.
You can do this for all 4 stacks just whenever R[19]=100 change to the second stack and so on.
The following is a quick little for loop that could create a number of stacks in a square pattern. It can be done more efficiently but this is easy to understand.
P[1] = LOCATION OF THE FIRST PART.
P[2] = LOCATION OF THE FIRST PART APPROACH HIGH ENOUGH TO CLEAR STACK
R[1] = X COUNT MAX
R[2] = Y COUNT MAX
R[3] = Z COUNT MAX
R[4] = CURRENT X COUNT
R[5] = CURRENT Y COUNT
R[6] = CURRENT Z COUNT
R[7] = CURRENT X OFFSET
R[8] = CURRENT Y OFFSET
R[9] = CURRENT Z OFFSET
R[10]= X OFFSET AMOUNT
R[11]= Y OFFSET AMOUNT
R[12]= Z OFFSET AMOUNT
//P[1]
//P[2]
FOR R[4] = 0 TO R[1]
FOR R[5] = 0 TO R[2]
FOR R[6] = 0 TO R[3]
! PICK UP PART HERE
R[7] = R[4] * R[10]
R[8] = R[5] * R[11]
R[9] = R[6] * R[12]
PR[1] = P[1]
PR[1,1] = R[7] + PR[1,1]
PR[1,2] = R[8] + PR[1,2]
PR[1,3] = R[9] + PR[1,3]
PR[2] = P[2]
PR[2,1] = R[7] +PR[2,1]
PR[2,1] = R[8] +PR[2,2]
J PR[2] 100% FINE
L PR[1] XXXXX MM/S FINE
CALL LET_GO_PROGRAM
L PR[2] XXXXX MS/2 FINE
ENDFOR
ENDFOR
ENDFOR*edited to fix the copy and paste typos.
I like your program example. It is very similar to how I would do it, except I would typically use offsets, but that is just a personal preference.
You have a couple typo's in this section:
PR[1,1] = R[7] + PR[1,1]
PR[1,2] = R[7] + PR[1,2] -> should be R[8]
PR[1,3] = R[7] + PR[1,3] -> should be R[9]
Quote
FOR...ENDFOR Statement
Purpose: Looping construct based on an INTEGER counter
For each run of the loop, the R[4/5/6] value will get + 1. Last execution will be when R[4] = R[1], R[5] = R[2] and so on.
Useful if you want to repeat a movement with a certain pattern/spacing.
In the example from I3ooI3oo, R[4] represents the column of the grid (X-axis), R[5] the row (Y-axis) and R[6] the current height (Z-axis).
TLDR; R[4/5/6] are basically counters.
Is below another typo or is that supposed to be like that
PR[2,1] = R[7] +PR[2,1]
PR[2,1] = R[8] +PR[2,2] -> PR[2,2]=R[8]+PR[2,2]
Yes that is also a typo. Your correction is right.
I think it would be best if you entered all of these instructions into the teach pendant manually. That will help you learn how to use the teach pendant menu's. I'm sure you have learned how to insert a point, right? Well if you hit 'next' on the teach pendant while inside your program, then you will see and 'inst' button. Pressing "inst" will show all the logical instructions that you can enter into your program.
//P[1]
//P[2]
Are remarked points.
FOR R[4] = 0 TO R[1]
FOR R[5] = 0 TO R[2]
FOR R[6] = 0 TO R[3]
The FOR/ENDFOR instruction is a function that repeats a loop within FOR and ENDFOR instructions
a specified number of times.
Here´s a "palletizer" I´ve made.
Registers 1-11 are used. I´d recommend you to set register 9/10/11 to a value of 1.
Point register 1 is used.
1. Grab a part with the robot and jog to the first position in the pallet. Record/touch up this point. This will be the origin for the palletizer.
2. Adjust the variables in the program.
3. In the main program, grab the part from the machine, position yourself at some safe distance above pallet.
4. Make a CALL to the program below.
Keep in mind:
1: !################################ ;
2: !##### Palletizer ############### ;
3: !################################ ;
4: UFRAME_NUM=1 ;
5: UTOOL_NUM=1 ;
6: ;
7: !Number of rows ;
8: R[1]=4 ;
9: !Items per row ;
10: R[2]=1 ;
11: !Stack height ;
12: R[3]=100 ;
13: ;
14: !X step ;
15: R[4]=100 ;
16: !Y step ;
17: R[5]=(-100) ;
18: !Part Height ;
19: R[6]=3 ;
20: ;
21: !Drop offset ;
22: R[7]=10 ;
23: !Safe Z ;
24: R[8]=500 ;
25: ;
26: !R[9] X counter ;
27: !R[10] Y counter ;
28: !R[11] Z counter ;
29: ;
30: PR[1,1]=((R[9]-1)*R[4]) ;
31: PR[1,2]=((R[10]-1)*R[5]) ;
32: PR[1,3]=R[8] ;
33: ;
34:L P[1] 300mm/sec FINE Offset,PR[1] ;
35: PR[1,3]=(((R[11]-1)*R[6])+R[7]) ;
36:L P[1] 100mm/sec FINE Offset,PR[1] ;
37: PR[1,3]=(((R[11]-1)*R[6])) ;
38:L P[1] 10mm/sec FINE Offset,PR[1] ;
39: PR[1,3]=R[8] ;
40:L P[1] 300mm/sec FINE Offset,PR[1] ;
41: R[11]=(R[11]+1) ;
42: ;
43: IF (R[11]>R[3]),R[9]=(R[9]+1) ;
44: IF (R[11]>R[3]),R[11]=(1) ;
45: IF (R[9]>R[1]),R[10]=(R[10]+1) ;
46: IF (R[9]>R[1]),R[9]=(1) ;
47: IF (R[10]>R[2]),R[10]=(1) ;You will find the FOR/ENDFOR-instructions here.
Programs on Fanuc robots can only do one operation at a time. So you would need a temp register unless R[10] can change.
R[9]= R[10] - 1
R[9]= R[9] * R[5]
Now R[9] = ((R[10]-1)*R[5])
I´m on a R30iB-controller, so I can use several parethenses.
If this isn´t available in your controller, you will have to break each line down to several lines.
This.
PR[1,1]=((R[9]-1)*R[4])
Becomes this.
PR[1,1]=R[9]-1
PR[1,1]=PR[1,1]*R[4]
Im lifting flat sheets into a machine that forms them into a dome. I need to stack them in 4 stacks of 100. I am working with the R-j3iB controller and as far as im aware it does not have the palletizing function on it. So ill have to do it manually I think I can use position registers from what iv read. Im new to fanuc programming so could someone explain in simple terms how to do this or show me some example programs.
Thanks
Here's a good example:
[glow=grey,2,300]R{3:Count} = 0
LBL{1}
R{11:Row} = ((R{3:Count} DIV 3) MOD 3)
R{12:Column} = R{3:Count} MOD 5
R{13:Layer} = R{3:Count} DIV 15
R{21:Ofs_X} = R{11:Row} * 150
R{22:Ofs_Y} = R{12:Column} * 150
R{23:Ofs_Z} = R{13:Layer} * 300
PR{10:Move} = PR{99:Ref_Origin}
PR{10,1:Move} = PR{10,1:Move} + R{21:Ofs_X}
PR{10,2:Move} = PR{10,2:Move} + R{22:Ofs_Y}
PR{10,3:Move} = PR{10,3:Move} + R{23:Ofs_Z}
L PR{10:Move} 1500mm/s CNT30, Offset PR{93:Z_300mm}
L PR{10:Move} 800mm/s CNT5, Offset PR{91:Z_50mm}
L PR{10:Move} 500mm/s FINE
CALL GRIP_OPEN
R{3:Count} = R{3:Count} + 1
L PR{10:Move} 800mm/s CNT5, Offset PR{91:Z_50mm}
L PR{10:Move} 1500mm/s CNT30, Offset PR{93:Z_300mm}
JMP LBL{1}[/glow]
FOR loops are only available in newer software versions. Maybe your software is too old.
