At the start of this project, I decided to build a robot arm with a “classic”, articulated design: a rotating base, with “shoulder”, “elbow” and “wrist” joints. I wanted to make something that’s suitable for picking apples, but not specific to this task, something that could maybe even used or developed further in the future for other applications.

To be able to reach any point in any orientation of the end effector (or gripper), we need seven degrees of freedom: this means seven servos for joints + one more for operating the gripper. We don’t necessarily need that to be useful though. If we’re happy with limited orientations, we can get away with less.

One design I considered is another popular, and clever one, that uses parallelogram linkages to keep the gripper always horizontal, and also to move the heavy servos to the bottom – this is also what MeArm uses.

The drawback is the complicated mechanism with many links, which could also introduce slop and reduce accuracy.

I decided to go with a straightforward chain, but with only five joints: the end effector has one less joint, so it can be kept horizontal and can turn in limited ways up or down. This should be good for picking apples.

By reattaching the gripper at 90 degrees, facing downwards (this needs a bit of disassembly though), we could even have another configuration that’s good for picking up things from the floor.

This seemed like a reasonable design, and I went ahead to figure out how to attach servos and joints, and designed and built the first prototype, with the first four joints, without the final piece with the gripper. It started to look quite impressive:

Weight Problems

Much later, when I finally got to designing the gripper and also started doing some tests to see how much the arm could lift (thinking of even using it to pick up sheep!) I ran into a problem I should have anticipated: with the extra weight of the last joint and the gripper – and the extended length, the arm was really struggling to even lift itself from a lower, extended position.

This meant very erratic movement as the shoulder joint servo with the highest load was struggling to lift the arm, continuously overshooting, stopping and starting again. Here is a plot to show current consumption in the worst case, when the current protection actually kicked in, stopping the servo (the scale is wrong because of an obscure bug, but the relative change looks scary):

So what’s happening? Is the arm too heavy and can’t possibly work? Are these servos simply too weak? Maybe there is a reason not many people are building big robot arms with many joints using these servos...?

As I started thinking, many potential solutions came to mind immediately:

• Use stronger servo for the first joint – but the next similar model is twice as expensive, needs higher voltage, and is much heavier.

• Gear down: extra complexity, possibly losing precision due to backlash, but more importantly losing position control: we’d need a new position sensor and somehow modify the driver to use that instead of the one built into the servo, etc.

• Move the servo from the second joint down to the bottom of the first link, and drive the second joint via a timing belt or similar (to shift weight): extra mechanical complexity, would probably not be enough weight shifted.

• Add counterweight to first joint: requires reducing angle (can’t "flip" any more), would make the arm look awkward and less “cool”, would add extra weight for Flig to carry.

• Reduce length of arm sections: this reduces how far we can reach so we might not get the top apples and this may not be enough to fix the issue.

• Reduce number of servos: remove one DOF at the end: might be good enough to grab apples (as they are spherical, can be grabbed from any angle), but harder for picking up sheep (can’t rotate and align the gripper with the sheep “blocks”) - also makes inverse kinamatics calculations tricky: it really needs enough degrees of freedom.

• Move the gripper servo down to the base and drive the gripper with cables (like tendons): this might not reduce weight enough in itself and leading the cables from the tip all the way to the bottom isn’t trivial.

None of these sounded great really!

Then suddenly, when thinking about counterweights, the solution popped into my head:

No need for counterweights, as our problem is not weight, but force: we just need something that pulls the arm back as it stretches! And if it’s not enough, just add more:

After some experimenting and tweaking I managed to find a configuration where the arm is almost balanced in a fairly large range of poses (the drawback is that for a “compact”, folded position, the rubber bands pull a little too much – but the overall strain on the servos was greatly reduced. Going from an initial, higher position to a lower, extended one and back looked like this on the current chart:

And here is the arm with the highly advanced counter-gravity devices attached (with one spare included):

All that remains is to find a place for our driver, Dinky the gnome, who prefers gardening riding a robot dog, and is already sitting in his cockpit with his controls: