Close
0%
0%

MonkeyBot V2 - 3 servo climbing robot

This is a 3 servo, Arduino Nano controlled robot that climbs pegs on a board.

Similar projects worth following
This is version 2 of MonkeyBot and it carries it's own power packs. It climbs pegs and descends. Will now let this project sit awhile and work on something else. Do have plans to make the hands rotate a bit.
The first version was microservos, hotglued to sections of fishing pole and paperclips for hands and was tethered. The new version uses standard size 15kg capacity robot servos and aluminum brackets.

Version 2:

Using robotic servos and brackets - just a simple bolt together affair. Took about half hour though I know I will have to readjust angles. Can still use the custom wiring harness from version 1 to connect Arduino Nano. Problem is how to attach batteries to robot so that they do not interfere with servos as they are moving. May just let batteries and Nano dangle below middle servo and act as a swinging counterweight.

Pegs on climbing board are equidistant apart now so programming will be a cinch. Also longer pegs rather than shorter screws should make grasping them more reliable.

Rather than order new servos for this version I decided to dismantle my 7 servo robot that will just have to live on in videos. Heartbreaking.

Version 1:

3 micro servos

fishing pole sections for the arms

big paper clips (not standard size) for the "hands" or grippers

Arduino Nano

zip ties, epoxy, and hot glue

6 volt AA battery pack for the servos

5 long screws for the climbing pegs and a board (in my case a bamboo cutting board)

I used AAA batteries at first but they drained too quickly because the servos have to do a lot of work lifting the robot and also at times pushing against each other and the pegs. AA batteries worked pretty well.

Kind of an interesting project that has no obvious use except to find out if it can be done.

Programming was rather tedious. The video shows two programming efforts: the first I programmed each servo to move separately and this resulted in a rather jerky moving robot. The second effort I used an interpolated routine to basically move all the servos at the same time and this was decidedly less jerky though the movements could be made much smoother.

If the pegs are at different positions like in my project, you have to program for each movement to each peg. If the pegs were equi-distance and regular then the programming would be much simpler.

  • 1 × Arduino Nano
  • 3 × micro servos
  • 1 × fishing pole sections
  • 1 × zip ties, hot glue, epoxy
  • 1 × large paper clips for grippers

View all 6 components

  • MonkeyBot V2 Untethered

    jimrd03/02/2017 at 08:52 0 comments

    MonkeyBot now carries own powerpacks and is untethered. It is a wire mess and really needs a servo shield to get rid of them. But will stop working on this robot now and do something else. May continue working in the future and make the hands rotating so can climb ladder type structure too. No plans to give it any sensors or make it smart. Just wanted to see what kind of problems I would encounter in doing it. Pretty trivial project really. I have an idea for the rotating hands that would be pretty neat though. We will see.

  • MonkeyBot V2 Tethered

    jimrd02/28/2017 at 09:18 0 comments

    Version 2 MonkeyBot with standard size robot servos and aluminum brackets. Left arm shorter than right so used spacer. Left arm programming different than right arm. Left arm riskier of slipping off peg but smoother. Right arm more stop action but securely grasps peg by pulling in and then down.

    Next will attach battery packs to robot. Should have plenty of beef to carry 3000 mAh battery and 9volt for Nano.

    Need to replace wooden spacer on left hand with something flexible to keep torquing of servos when pull/pushing on pegs to a minimum.

    Onward and upward.

  • MonkeyBot Version 2

    jimrd02/25/2017 at 01:50 0 comments

    Have built version 2, just need to wire it up and program. Drilled some holes and am using chopsticks for pegs for climbing board.

    Update Feb 26: got it wired up but tethered. Programmed it in about 3 hours to climb left and right arms. Since pegs are equidistant apart the programming was pretty trivial. Noticed though that the arms are not the same, left arm is a centimeter shorter than the right arm which causes a problem as the left arm slips off the peg a bit. Will lengthen the left arm and reprogram. Then if that is ok will suspend battery packs and Nano below the middle servo with wires and zip ties. Then if that is ok, will build climbing peg board on a piece of two meter board. Then if that is ok, will take a break and work on my Serenity motor project.


  • MonkeyBot Traversing Horizontally

    jimrd02/10/2017 at 06:27 0 comments

    Here is first version MonkeyBot climbing horizontally across 4 pegs.

  • Plans for Version 2 of MonkeyBot

    jimrd02/05/2017 at 08:35 0 comments

    Have decided to work on version 2 of MonkeyBot which will use robotic standard sized servos (15kg capacity) using mechanical brackets (no hotglued servos for this version) so as to be able to carry its own power supplies. Also I will be using this version to experiment in the future with variable direction claws or hands which will make this robot more versatile in it's ability to climb different peg orientations.

    Goals:

    1. Make robot untethered and able to carry own power supply.

    1. Try orienting both hands in the same direction ( perpendicular to servos) so the robot should be able to climb a standard ladder structure.

    2. Engineer a rotating cuff between the hand and the arm so as to be able to change the direction of the hand so that the robot should be able to orient to different climbing structures on the fly.

    Servos have been ordered and am impatiently waiting to get started on Version 2.

  • MonkeyBot Video

    jimrd01/30/2017 at 07:40 0 comments

View all 6 project logs

  • 1
    Step 1

    Arduino sketch:

    #include <Servo.h>

    Servo myservoLeft,myservoRight, myservoCenter,myservoWeight; // create servo object to control a servo

    int servoRead(int servoNumber) {

    int servoCurrent;

    if (servoNumber== 3) { servoCurrent = myservoLeft.read(); }

    if (servoNumber== 4) { servoCurrent = myservoCenter.read(); }

    if (servoNumber== 5) { servoCurrent = myservoRight.read(); }

    return servoCurrent;

    }

    void servoWrite(int servoNumber, int offset) {

    if (servoNumber==3) { myservoLeft.write(offset); }

    if (servoNumber==4) { myservoCenter.write(offset); }

    if (servoNumber==5) { myservoRight.write(offset); }

    }

    void myServo(int newAngle,int angleInc,int incDelay,int servoNum) {

    int curAngle;

    if (servoNum== 1) { curAngle = myservoLeft.read(); }

    if (servoNum== 2) { curAngle = myservoCenter.read(); }

    if (servoNum== 3) { curAngle = myservoRight.read(); }

    if (servoNum== 4) { curAngle = myservoWeight.read(); }

    if (curAngle < newAngle) {

    for(int angle=curAngle;angle < newAngle;angle += angleInc) {

    if (servoNum == 1) myservoLeft.write(angle);

    if (servoNum == 2) myservoCenter.write(angle);

    if (servoNum == 3) myservoRight.write(angle);

    if (servoNum == 4) myservoWeight.write(angle);

    delay(incDelay); }

    }

    else if (curAngle > newAngle) {

    for(int angle=curAngle;angle > newAngle;angle -= angleInc) {

    if (servoNum == 1) myservoLeft.write(angle);

    if (servoNum == 2) myservoCenter.write(angle);

    if (servoNum == 3) myservoRight.write(angle);

    if (servoNum == 4) myservoWeight.write(angle);

    delay(incDelay); }

    }

    }

    void interpolate3Servos( int servo3,int servo3Position,

    int servo4,int servo4Position,

    int servo5,int servo5Position,

    int numberSteps,int timeDelay){

    int servo3Current,servo4Current,servo5Current;

    servo3Current = servoRead(servo3);

    servo4Current = servoRead(servo4);

    servo5Current = servoRead(servo5);

    Serial.print("Servo3Pos and Current "); Serial.print(servo3Position); Serial.print(" "); Serial.println(servo3Current);

    Serial.print("Servo4Pos and Current "); Serial.print(servo4Position); Serial.print(" "); Serial.println(servo4Current);

    Serial.print("Servo5Pos and Current "); Serial.print(servo5Position); Serial.print(" "); Serial.println(servo5Current);

    Serial.println(" ");

    int cOffset = (servo3Position - servo3Current); cOffset = abs(cOffset)/numberSteps;

    int dOffset = (servo4Position - servo4Current); dOffset = abs(dOffset)/numberSteps;

    int eOffset = (servo5Position - servo5Current); eOffset = abs(eOffset)/numberSteps;

    int cOffsetTotal=0,dOffsetTotal=0,eOffsetTotal=0;

    cOffsetTotal = servo3Current;

    dOffsetTotal = servo4Current;

    eOffsetTotal = servo5Current;

    for (int x=0; x<numberSteps;x++) {

    if (servo3Position > servo3Current) { cOffsetTotal = cOffsetTotal + cOffset; }

    else { cOffsetTotal = cOffsetTotal - cOffset; }

    if (servo4Position > servo4Current) { dOffsetTotal = dOffsetTotal + dOffset; }

    else { dOffsetTotal = dOffsetTotal - dOffset; }

    if (servo5Position > servo5Current) { eOffsetTotal = eOffsetTotal + eOffset; }

    else { eOffsetTotal = eOffsetTotal - eOffset; }

    if (servo3Position != servo3Current) servoWrite(servo3,cOffsetTotal);

    if (servo4Position != servo4Current) servoWrite(servo4,dOffsetTotal);

    if (servo5Position != servo5Current) servoWrite(servo5,eOffsetTotal);

    // Serial.print(" a and b Offset "); Serial.print(aOffsetTotal); Serial.print(" ");Serial.println( bOffsetTotal); delay(10);

    delay(timeDelay);

    }// end for

    //////////////////////////////////////

    // take care of modulo remainders //

    /////////////////////////////////////

    if (servo3Position != servo3Current) servoWrite(servo3,servo3Position);

    if (servo4Position != servo4Current) servoWrite(servo4,servo4Position);

    if (servo5Position != servo5Current) servoWrite(servo5,servo5Position);

    }

    void leftArm() {

    interpolate3Servos( 3,170,4,140,5,150,20,50); //

    delay(500);

    interpolate3Servos( 3,90,4,120,5,150,20,50); // shift monkey right

    delay(500);

    myServo(90,1,1,2); // let go of left hook

    delay(500);

    interpolate3Servos( 3,40,4,100,5,70,20,50); //

    delay(500);

    interpolate3Servos( 3,20,4,90,5,20,20,50); //

    delay(1000);

    interpolate3Servos( 3,20,4,90,5,10,20,50); // extend left arm up

    delay(1000);

    myServo(120,1,1,2); // grab left hook

    delay(1000);

    interpolate3Servos( 3,20,4,110,5,70,20,50); // shift monkey left

    delay(500);

    interpolate3Servos( 3,30,4,90,5,50,20,50); // let loose right arm

    delay(500);

    interpolate3Servos( 3,30,4,80,5,55,20,50); // let loose right arm

    delay(1000);

    interpolate3Servos( 3,130,4,85,5,150,10,50); // pull right arm up to left peg

    delay(1000);

    interpolate3Servos( 3,150,4,160,5,150,20,50); // reach right arm up to right peg

    delay(500);

    interpolate3Servos( 3,130,4,140,5,140,20,50); // reach right arm up to right peg

    delay(500);

    interpolate3Servos( 3,120,4,130,5,140,20,50); // reach right arm up to right peg

    delay(500);

    interpolate3Servos( 3,110,4,110,5,150,20,50); // reach right arm up to right peg

    delay(500);

    interpolate3Servos( 3,110,4,90,5,150,20,50); // reach right arm up to right peg

    // last arm movement

    interpolate3Servos( 3,80,4,100,5,70,20,50); // reach right arm up to right peg

    delay(500);

    interpolate3Servos( 3,70,4,90,5,10,20,50); // reach right arm up to right peg

    delay(500);

    interpolate3Servos( 3,40,4,140,5,0,20,50); // reach right arm up to right peg

    delay(500);

    interpolate3Servos( 3,40,4,140,5,100,20,50); // reach right arm up to right peg

    delay(500);

    delay(15000);

    exit(0);

    }

    void setup()

    {

    Serial.begin(9600);

    delay(100);

    myservoLeft.attach(3); // attaches the servo on pin 3 to the servo object

    myservoLeft.write(90);

    myservoCenter.attach(4); // attaches the servo on pin 4 to the servo object

    myservoCenter.write(90);

    myservoRight.attach(5); // attaches the servo on pin 5 to the servo object

    myservoRight.write(90);

    delay(1000); // waits for the servo to get there

    interpolate3Servos( 3,90,4,90,5,90,10,50); // neutral

    delay(500);

    }

    void loop() {

    leftArm();

    //}

    // delay(1000);

    exit(0); //pause program - hit reset to continue

    }

View all instructions

Enjoy this project?

Share

Discussions

jimrd wrote 01/30/2017 at 20:22 point

Just had an idea I may pursue later: the climbing robot has pegs for hands and just inserts them in holes drilled in a board. I guess the problem would be how to find a hole and how to know it has been inserted in the hole. Requires some sensors. 

  Are you sure? yes | no

ꝺeshipu wrote 01/30/2017 at 08:58 point

Have you tried feeding the servos with higher PWM frequency than the standard 50Hz? That will make them stronger, as the PWM is also fed to the motor -- though it will also make them heat more, and could result in damage if overdone. But maybe it could compensate the voltage drop.

  Are you sure? yes | no

jimrd wrote 01/30/2017 at 10:48 point

Hi Radomir. Yeah, these cheap analogue servos are already jittery and I'm afraid of frying them. I could just use digital servos. It is really a moot issue at this point because I see the idea works fine. I could have used a regulated power supply while developing the robot and saved myself some headache. Will do that when I try my version 2 which will use standard size servos and carry the battery packs with it. Thanks for your idea as it educated me on how servos work a little more. Afraid I am electronically challenged.

  Are you sure? yes | no

Similar Projects

Does this project spark your interest?

Become a member to follow this project and never miss any updates