Inverse Kinematics Guidance For Cybot3000

Absolutely - that screenshot and DJ’s note are the key to using IK safely.

What the screenshot is showing

The Inverse Kinematic Arm window displays the current Cartesian coordinates of the arm’s end effector:

• X = left/right
• Y = up/down
• Z = forward/back

Those values are not random targets. They are the arm’s current reachable position in space.

In the screenshot:

• X = 3
• Y = 21
• Z = 0

That means the arm is currently positioned roughly:

• 3 cm from center on X
• 21 cm high on Y
• at Z = 0

That is a known safe position to use as a reference.

The most important rule

You should not guess coordinates like:

ControlCommand("Inverse Kinematic Arm", "MoveTo", 10, 8, 15);

until you understand your arm’s real workspace.

Instead, you should:

1. Move the servos manually using servo controls
2. Watch the IK window’s X/Y/Z values
3. Record positions that are safe and reachable
4. Use those values as your MoveTo targets

That is exactly what forward kinematics testing is for.

Why your arm behaved badly

Your arm likely went into a bad pose because one or more of these were true:

• the servo order in the IK configuration was wrong
• the servo inversion was wrong
• the mounting geometry was not mirrored correctly for the left arm
• the target Cartesian point was outside the arm’s safe reach
• Auto Position and IK were both trying to control the same servos

So yes - DJ’s advice is correct: don’t merge multiple behaviors while learning IK

What to do now

1) Temporarily disable Auto Position

For now, keep only:

• the Inverse Kinematic Arm skill
• a Servo control skill for manual testing

That way only one system is controlling the arm.

2) Find a safe home pose manually

Use the servo sliders to put the arm in a safe position, such as:

• shoulder up
• elbow bent
• wrist neutral
• gripper open

Then note the IK window values.

3) Use those values as your starting target

If the IK window shows something like:

• X = 3
• Y = 21
• Z = 0

then that becomes your safe reference pose.

You can then nudge it slightly, for example:

ControlCommand("Inverse Kinematic Arm", "MoveTo", 5, 21, 2);

or

ControlCommand("Inverse Kinematic Arm", "MoveTo", 3, 23, 0);

Small changes only.

About your arm setup

For the right arm, your IK configuration should use:

• v4 = shoulder
• v5 = arm
• v6 = elbow
• v7 = wrist
• v8 = gripper

For the left arm:

• v11 = shoulder
• v12 = arm
• v13 = elbow
• v14 = wrist
• v15 = gripper

If the left arm is mirrored, you will probably need:

• servo inversion on some joints
• different servo offsets
• possibly different Cartesian sign behavior

About the camera

The camera is not part of IK by default.

It only becomes useful when you write a script that:

1. reads camera-detected object position
2. maps that to robot coordinates
3. sends MoveTo to the IK skill

That should come after your arm is stable and safe.

Best next step

I recommend this exact order:

1. Turn off Auto Position
2. Test right arm only
3. Test left arm only
4. Record safe IK coordinates
5. Use small MoveTo increments
6. Only then add camera control

Safe test example

Once you have a known good pose, test very small changes:

ControlCommand("Inverse Kinematic Arm", "MoveTo", 3, 21, 0);
sleep(1500);
ControlCommand("Inverse Kinematic Arm", "MoveTo", 4, 21, 0);
sleep(1500);
ControlCommand("Inverse Kinematic Arm", "MoveTo", 3, 22, 0);

My recommendation for you

Right now, I would not try to combine:

• IK
• Auto Position
• camera tracking
• scripts

all at once.

That creates too many variables while the arm geometry is still being tuned.

If you want, I can help you with one of these next:

1. a safe right-arm-only test plan
2. a safe left-arm-only test plan
3. a startup home script
4. a camera-to-IK example after the arms are stable

If you send me your current IK joint settings screenshot for one arm, I can help you verify the configuration line by line.

Athena and DJ,  Thanks for advice and all this info, much to learn, ugh lol. One quick question still. Since this first test was created for the Right Arm (servos v4-v8) using the Inverse Kinematics skill; to do the Left Arm, do I add another Inverse Kinematics skill to create that arm for servos v11=v15? Because I can see that when you create your arm configuration in that skill, it's for one arm only. Can two of the same skills be created, one for left arm and another for right arm?

Yes - you can add two separate Inverse Kinematic Arm skills, one for each arm.

Recommended setup

• IK Right Arm configure for:

  • v4 shoulder
  • v5 arm
  • v6 elbow
  • v7 wrist
  • v8 gripper

• IK Left Arm add a second Inverse Kinematic Arm skill and configure for:

  • v11 shoulder
  • v12 arm
  • v13 elbow
  • v14 wrist
  • v15 gripper

So yes, two copies of the same skill is the correct approach if each arm is being controlled independently.

How to add the second one

1. In ARC, go to Project
2. Choose Add Robot Skill
3. Add Inverse Kinematic Arm again
4. Rename it something clear, like:
   • IK Right Arm
   • IK Left Arm

You can rename a skill by right-clicking its title bar and selecting Rename.

Important caution

If you use two IK skills and also keep Auto Position, make sure they are not controlling the same servos, or they will fight each other.

For example:

• IK Right Arm should only touch v4-v8
• IK Left Arm should only touch v11-v15

That way they can coexist safely.

One more tip

Because your left arm is mirrored, you may need to:

• invert one or more servos
• adjust servo offsets
• test small movements first

Best next step

Set up the second IK skill for the left arm, then test it alone before combining it with anything else.

If you want, I can help you build a safe left-arm configuration checklist for v11-v15 step by step.

It’s really not a lot to learn - and if you think about it, it’s a lot simpler than auto position.

all you do is

1. define the arm lengths and joints by using a ruler in the configuration menu

2. use servo robot skills to move the arm into a known safe pose

3. look at the coordinates in the window for x y z of where the end effector is.

4. gently nudge the numbers of x y z to see how the numbers move the arm.

That's it. Once you see how the coordinates move the arm, you can position the end effector anywhere in 3d space.

Exactly - that’s the core workflow for Inverse Kinematics in ARC.

The simple mental model

IK is basically:

1. Measure the arm

   • Enter joint lengths, offsets, servo range, and servo direction in the configuration.

2. Move the arm to a known safe pose

   • Use servo robot skills to position each joint manually.

3. Read the Cartesian coordinates

   • Watch the IK window for X, Y, Z.

4. Nudge the numbers

   • Change X/Y/Z by small amounts and observe how the arm moves.

That’s it.

Why this is easier than Auto Position

Auto Position is great for scripted poses, but IK gives you a more natural way to think about the arm:

• X = left / right
• Y = up / down
• Z = forward / back

So instead of thinking:

• "servo 1 to 87, servo 2 to 124, servo 3 to 66..."

you think:

• "move the hand 2 cm left"
• "raise it 1 cm"
• "push it forward a bit"

Good way to learn it safely

I’d suggest this exact sequence:

1. Use only one arm
2. Disconnect or disable Auto Position temporarily
3. Move the arm to a safe pose manually
4. Record the X/Y/Z shown in the IK skill
5. Change one axis at a time
   • X only
   • Y only
   • Z only
6. Keep changes small
   • 1-2 cm at first

For your Cybot3000

Yes, you can do this one arm at a time:

• Right arm: v4-v8
• Left arm: v11-v15

And yes, you can have two separate IK skills in the same project if each one controls a different arm.

Best practice before adding camera or other skills

Don’t layer camera tracking or Auto Position until:

• both arms move correctly by IK
• the joint directions are correct
• the safe workspace is understood

That keeps the learning curve much easier and avoids broken parts.

If you want, I can give you a very short "first 10-minute IK test plan" for your right arm so you can verify it step by step in ARC.

Ok, So I was able to create the IR Right Arm Inverse Kinematic skill.

This is the script for the Left Arm

ControlCommand("Inverse Kinematic Arm", "MoveTo", 10, 8, 15);
print("Requested MoveTo 10,8,15");

This is the script for the Right Arm (yes I used basically same sample test code)

ControlCommand("Inverse Kinematic Arm 2", "MoveTo", 10, 8, 15);
print("Requested MoveTo 10,8,15");

Interesting results was that each arm moved in completely different directions, I was surprised at this. Guessing it was supposed to happen.  So I am still learning if this is the route I want to go. Also still interested in how the camera is used with this.

Yes - different movement on each arm is expected if the two IK skills are configured differently. That usually means one or more of these are different between the left and right arm setups:

• servo port mapping
• joint order
• servo inversion
• servo offsets
• joint lengths/offsets
• mirrored mounting orientation

So the fact that they do not move the same way is not surprising.

Important correction about your script names

You wrote:

ControlCommand("Inverse Kinematic Arm","MoveTo",10,8,15);

and

ControlCommand("Inverse Kinematic Arm 2","MoveTo",10,8,15);

That is fine only if those are exactly the skill names shown in the skill title bars.

If Inverse Kinematic Arm 2 is your second IK instance, then that command targets that specific skill instance.

What should happen

If both arms are configured as true mirrored arms, then:

• the same X/Y/Z target may need to behave differently on each side
• the left arm may require inverted signs or inverted joints
• the right arm may move outward while the left moves inward depending on mounting

So they do not have to look identical.

Camera use with IK

The camera is usually used like this:

1. Camera detects an object
2. ARC stores object position in variables like:
   • $CameraObjectX
   • $CameraObjectY
   • $CameraObjectWidth
3. A JavaScript script converts those values to robot coordinates
4. The script sends ControlCommand(..., "MoveTo", x, y, z) to the IK skill

Example concept:

var x = Utility.map(getVar("$CameraObjectX"), 0, 320, -20, 20);
var y = Utility.map(getVar("$CameraObjectY"), 0, 240, 5, 25);
var z = Utility.map(getVar("$CameraObjectWidth"), 40, 100, 30, 15);

ControlCommand("Inverse Kinematic Arm", "MoveTo", x, y, z);

That means the camera does not directly control the servos. It just provides coordinates that your script turns into arm movement.

My recommendation right now

Since you’re still learning, keep it simple:

• test one arm at a time
• do not combine Auto Position yet
• do not add camera tracking yet
• first confirm:
  • each IK skill moves the correct arm
  • the arm moves safely
  • the coordinates make sense

Good next test

Pick one arm and test small movements only:

ControlCommand("Inverse Kinematic Arm", "MoveTo", 10, 8, 15);
sleep(1500);
ControlCommand("Inverse Kinematic Arm", "MoveTo", 11, 8, 15);
sleep(1500);
ControlCommand("Inverse Kinematic Arm", "MoveTo", 10, 9, 15);

That helps you see how each axis affects the arm.

One question for you

Do you want me to help you with:

1. a safe camera-to-IK example
2. a left arm/right arm test plan
3. a mirrored arm setup checklist for Cybot3000

If you want, I can write the camera script next in JavaScript for ARC.