Camera with Geometric

Pickpos = Base_Data[5]:Campos.

This will generate an offset base using the Campos values.
Don't forget afterwards to add activate that base:

$Base = Pickpos

Pickpos is what you want it to be, in my example i used it as a base. you need that variable to store your new base in, and it is most of the time not the smartest idea to write over your old base value. so for clarity:

Frame New_base ;define new frame variable for your new base


New_base = Base_data[5]:Campos ;make an offset of your old base using the camera values
$base = Newbase  ;Activate your new base
LIN Pickpos  ;Move to desired position

That is a difficult one, I have in no way enough knowledge to explain this, but it does matter. Sometimes it looks like just simply adding all values but that is a coincidence.
I must admit i only learned how to use the geometric operator not the math behind it.

The ":" is called the Geometric Operator in KRL. It is a method of "multiplying" two 6DOF (XYZABC) frames by each other. This is done by converting the two frames into 4x4 matrices, performing cross-multiplication on them, and converting the resulting matrix back into XYZABC.

(side note: in KRL, a FRAME variable is XYZABC. A POS or E6POS variable is just a FRAME with more variables -- S, T, E1-E6. The Geometric Operator will work on any of them, but for this math, only the XYZABC values matter)

However, unlike "normal" multiplication, matrix multiplication is not commutative. That is, while 2*3=3*2, MatrixA*MatrixB != MatrixB*MatrixA.

The most basic way of explaining how this works in robotics is this:
1. Set a Base
2. Program a Pos in that Base
3. The numbers in the Pos will be a set of directions, starting from the 0,0,0,0,0,0 of the Base:
4. Move along Base X by the value of Pos X, then along Base Y by the value of Pos Y, then along Base Z by the value of Base Z
(at this point, the TCP is still oriented the same as the Base -- A, B, and C are all 0.
5. Rotate around the Z axis by the value of Pos.A
6. Rotate around the new Y axis by the value of Pos.B (this is where people start to get confused)
7. Rotate around the new X axis by the value of Pos.C

Now, you can daisy-chain these transforms. For instance, if you had Pos programmed in Base1, and you wanted to know what the Pos would be if you converted it to World, you could do this:
PosInWorld = $WORLD : BASE_DATA[1] : Pos
This works because all Bases are simply transforms from World, and all Pos are simply transforms from whatever Base they were programmed in.

Now, as for swapping which Frame is on the left or right of the Geometric Operator, it's basically swapping which Frame acts as the Starting Point. If I use BASE:POS, I get the directions to move from the Base's origin (all zeros) to the location and orientation of the Pos. However, if I do POS:BASE, I get the reverse directions -- that is, if I pretended the Pos was actually a Base, I could find the directions to get back to the Base origin starting from the Pos.

It sounds weird, but it's very valuable when doing Vision Guidance, Palletizing, and oddball operations like translating a Pos from one Tool or Base to another Tool or Base.

For example, I once had a drilling end effector where the drill was parallel to my TCP Z axis. And I had to "land" it on variable surfaces using 6DOF vision. Well, when I was done drilling, I needed to pull the drill straight back out of the hole, but because I was landing on uneven surfaces, I couldn't make any pre-programmed points to do that motion. Instead, I could use one of two methods:
LIN_REL {Z -20} #TOOL ; method 1
LIN $POS_ACT : {X 0,Y 0,Z -20,A 0,B 0,C 0} ; method 2

Now, both those work. But the advantage to the send method is that I could pre-calculate the escape motion, and check if it would move too far, or hit a limit, before I began physically moving. The LIN_REL method, on the other hand, would simply start moving, and fault the robot if it hit something. So doing the Geo-Op math could be valuable for deciding if a move was safe or not.

Usually, with a fixed camera aligned with a robot Base frame, you do want to move the Base, temporarily. That makes it easy to move multiple points (BeforePick, Pick, AfterPick, etc) as a group.

Of course, you want to keep Base5 as a permanent setup, matched to the camera. So your normal action in the program would be $BASE = BASE_DATA[5] : CameraData.

However, if you want to avoid changing the Base, then you can move the point. Exactly how depends on what Base the points are taught in.
If the points are taught in $WORLD (Base 0): LIN BASE_DATA[5] : CameraData : PickPosition
If the points are taught in Base 5, it's simpler: LIN CameraData : PickPosition

Just use another base such as base six ad calculate it using base5 and camera offset