I’ve added the top chassis plate to my hexapod. I glued 16 blue leds to it and then soldered wires to the leds. The wires are connected to 2 74HC595 shift registers. My hexapod needed some sensors so I mounted 3 small servos to it. One in the bottom plate that sweeps a SRF06 ultrasonic sensor. On the top plate I mounted a pan/tilt kit with a SR04 ultrasonic sensor and a Rocket brand studios Wiicamera. I glued another 2 blue leds to the pan tilt kit. These are controlled by 2 PWM pins. All the sensors and leds are controlled by the Seeeduino Mega, so a 16MHz 8 bit micro controller is more then fast enough to control a total of 21 servos and some sensors.
I now need to learn my hexapod some tricks based on the sensor input

Some photos:

Bajdupod 996r top

Bajdupod 996r front

Bajdupod 996r in action

Bajdupod 996r in action

Bajdupod 996R: Arduino hexapod from Bajdi on Vimeo.

I finally finished the design of my hexapod chassis and had it laser cut this week. I had 3 plates laser cut in acrylic. The original chassis was a bit to small to fit everything. So I designed a bigger chassis and went for 3 decks. This gives me enough room for the battery and electronics. Between the bottom and the middle plate are the Lipo battery, UBEC’s and power servo power PCB. Between the middle and the top plate are the Seeeduino Mega and my Bajduino Mega 3A with the ATmega1284 micro controller. I could run all the code on one micro controller but it’s more fun to use 2. The 2 micro controllers communicate with each other over hardware serial. The Bajduino Mega 3A has a header for the nRF24L01 module and at the moment it only handles the wireless communication.

Bajdupod 996R chassis

BTW If you’re wondering what the strange music is in the video, the ice cream van just drove by while I shot the video in the garden

I’ve bought me a HC05 bluetooth module on Ebay. And I also recently got me a Samsung smartphone. When you trow an Arduino robot in the mix you get the above video

The HC05 bluetooth modules seem to be very popular. You can easily find them on Ebay. I bought the module on a small PCB that has a 3.3V voltage regulator. As the HC05 module works at 3.3V. Communicating with the module is very easy. It’s just plain simple serial, so you don’t need any special libraries.

I connected the TX/RX signals of the HC05 bluetooth module to an ATmega1284 through a voltage divider. I used a 10K and a 5K6 resistor to drop the voltage from 5V to 3.2V. I just soldered the resistors and some pins to a piece of perfboard. I used an ATmega1284 as it has 2 serial ports, one for uploading sketches and the serial monitor and the other for the bluetooth module. You can of  course connect it to an Arduino with an ATmega328 using the software serial library. It doesn’t make much difference in the code.

So after connecting the HC05 module to my Bajduino I needed to try it out. I just got myself a new Android smartphone so I started browsing the Android play store for a suitable app. Then I remembered that Rocket Brand Studios sells a small app to control a robot, Rocketbot robot controller. It isn’t a free app but it costs less then 2€. And I have to say it is a great app for a small price.

After successfully trying out the example sketch from Rocket Brand studios I wrote a simple sketch to control a robot with 2 continuous rotation servos. Here is the sketch:

// Bluetooth controlled Arduino robot
// http://www.bajdi.com
// HC05 bluetooth module receicing 2 bytes from Android app
// Android app = Rocket Bot Controller (rocketbrandstudios.com)
// 2 continuous rotation servos
// µController = ATmega1284P-PU


#include <Servo.h> 

Servo leftServo;  // create servo object to control a servo
Servo rightServo;  // create servo object to control a servo
int qualifier;
int dataByte;

void setup()

{
  Serial.begin(57600);   // serial monitor
  Serial1.begin(9600);   // HC05 bluetooth module
  leftServo.attach(21);   
  leftServo.write(90);   // stop servo
  rightServo.attach(22);              
  rightServo.write(90);  // stop servo
}

void loop()
{
  if(Serial1.available()>1)
  {
    qualifier=Serial1.read();
    dataByte=Serial1.read();

    Serial.print("qualifier = ");
    Serial.println(qualifier);
    Serial.print("dataByte = ");
    Serial.println(dataByte);

    if ( qualifier == 68)
    {
      if (dataByte == 1)
      {
        forward();
      }
      if (dataByte == 2)
      { 
        left();
      }
      if (dataByte == 3) 
      {
        right();
      }
      if (dataByte == 4)
      {
        backward();
      }
      if (dataByte == 5)
      {
        stop();
      }
    }
  }
}

void stop(){
  leftServo.write(90);               // stop
  rightServo.write(90);              // stop
}

void forward(){
  leftServo.write(0);              // go straight forward
  rightServo.write(120);         
}

void backward(){
  leftServo.write(180);                // backward
  rightServo.write(60);             
}

void left(){
  leftServo.write(140);                // go left 
  rightServo.write(100);              
}

void right(){
  leftServo.write(40);              // go right 
  rightServo.write(80);           
}

Nano undershield revision 2

Almost a year ago I designed my first PCB. It was a small 50x50mm PCB that acts as an undershield for an Arduino Nano. I designed it because the Arduino Nano has a tiny 5V voltage regulator. To not overheat the regulator you can not draw more then 200-300mA from it depending on the input voltage. Since I use Lipo batteries for most of my projects I also needed a regulator to power a couple of small servos. So I thought why not design a shield with a cheap 3A 5V switch mode regulator (LM2576). 3A is more then enough for a couple of servos and some sensors. The added benefit is that the switch mode regulator is much more efficient then a linear regulator. Which is a good thing when you use battery power.
While my first design worked it had a couple of small mistakes. Some of the holes were not big enough and some of the traces were a bit on the thin side. So I decided to make an improved version. In this version the Nano gets its power through the Vin pin. It is connected to the screw terminal through a schottky diode. Next to the Nano there are 3 rows of pins. The row with pins closest to the Nano are connected to the pins on the Nano. The middle row is the 5V, which comes from the 3A regulator. The outer row of pins are the ground pins. These 3 rows of pins make it very easy to connect servos and sensors to the Arduino Nano without have to worry if they get power enough. I’ve done some testing with the board and even connected 10 little servos to it. The regulator could handle the servos but the 5V line becomes very noisy. It does not effect the Nano though since it doesn’t get power from the regulator. With a small heatsink like the one in the photo below the regulator is good for about 2A without overheating.

Nano undershield rev2

Parts used:

1x PCB made by Seeedstudio
1x Screw terminal with 2 positions 5mm (Tayda Electronics)
1x Capacitor 100µF 50V (Tayda Electronics)
1x LM2576 5V (Tayda Electronics)
1x TO220 heatsink (Tayda Electronics)
1x 100µH 3A inductor (Ebay)
2x Capacitor 1000µF 25V (Ebay)
1x 1N5822 3A diode (Tayda Electronics)
1x 100nF 50V Ceramic capacitor (Tayda Electronics)
1x 1N5818 Schottky diode (Tayda Electronics)
A couple of strips of male and female headers (Tayda Electronics)

I had 10 of these PCB’s made by Seeedstudio, I wont be needing them all. If you would like to have one sent me an email: info|@|bajdi d|0|t com

My goal was to blink 16 leds nightrider style. I used 2 74HC595 shift registers and 16 leds with 220ohm resistors. As I wanted to integrate the code in an other sketch I used the millis function to time the shifting of the leds. This is the result:

This is the code I used:

// http://www.bajdi.com
// Nightrider effect using 16 leds and 2 74HC595 shift registers

//Pin connected to Pin 12 of 74HC595 (Latch)
int latchPin = 8;
//Pin connected to Pin 11 of 74HC595 (Clock)
int clockPin = 12;
//Pin connected to Pin 14 of 74HC595 (Data)
int dataPin = 11;
//data for LED on. Second shift register will be written first.
int ledOn2[]={
  1,2,4,8,16,32,64,128,0,0,0,0, 0, 0, 0,  0, 0, 0, 0,0,0,0,0,128,64,32,16,8,4,2,1};
int ledOn1[]={
  0,0,0,0, 0, 0, 0,  0,1,2,4,8,16,32,64,128,64,32,16,8,4,2,1,  0, 0, 0, 0,0,0,0,0};
byte nextLed;
unsigned long Timer;

void setup() 
{
  pinMode(latchPin, OUTPUT);
  pinMode(clockPin, OUTPUT);
  pinMode(dataPin, OUTPUT);
}

void loop() 
{
  unsigned long ledMillis = millis();

  if (ledMillis >= Timer){
    Timer = Timer+50;
    nextLed = nextLed +1;
    digitalWrite(latchPin, LOW);
    shiftOut(ledOn2[nextLed]);
    shiftOut(ledOn1[nextLed]);
    //set latchPin to high to lock and send data
    digitalWrite(latchPin, HIGH);

    if (nextLed == 30){ 
      nextLed = 0;
    }
  }
}

void shiftOut(byte dataOut) 
{
  // Shift out 8 bits LSB first,
  // on rising edge of clock
  boolean pinState;
  //clear shift register ready for sending data
  digitalWrite(dataPin, LOW);
  digitalWrite(clockPin, LOW);
  // for each bit in dataOut send out a bit
  for (int i=0; i<=7; i++) 
  {
    //set clockPin to LOW prior to sending bit
    digitalWrite(clockPin, LOW);
    // if the value of DataOut and (logical AND) a bitmask
    // are true, set pinState to 1 (HIGH)
    if ( dataOut & (1<<i) ) 
    {
      pinState = HIGH;
    }
    else 
    {
      pinState = LOW;
    }
    //sets dataPin to HIGH or LOW depending on pinState
    digitalWrite(dataPin, pinState);
    //send bit out on rising edge of clock
    digitalWrite(clockPin, HIGH);
  }

  //stop shifting out data
  digitalWrite(clockPin, LOW);
}

I think I have finally solved all the bugs in my hexapod code, well at least the walking gait part of the code. The servos now move in 15 steps from one position to the other. The time between these steps determines how fast the hexapod walks. I can change the speed with my remote control. Every walking gait is divided in 4 parts. During each part the servos are moved in 15 steps. I use the millis timer to keep track of the time. My biggest problem was coding the value that the legs should move. While this is a simple subtract function it was very difficult to calculate it at the right moment and making sure that this value didn’t change when I didn’t want it. It sounds very simple but I have absolutely no coding background and it took me hours to figure out. Since all the code is based on one timer (millis) you can’t have any blocking functions. I found out that the RF24 library sometimes caused a hick up in my code. This resulted in the legs going crazy. After that was solved I can finally say that the basic walking gaits are finished.
There are still some other functions that I want to implement. So the coding is far from finished.

As you can see in the video I have removed the bottom plate of the chassis. I removed it so I could measure it. Then I started designing a new chassis in Autocad. This is the latest version:

Bajdupod 996R chassis rev2

My first plan to power the hexapod was to use 2 UBECs. So I had designed a PCB where I could power 18 servos with 2 separate power supplies. Unfortunately the UBECs were not strong enough for my power hungry MG996R servos. So I had to resort to using 3 8A UBECs. I designed a new PCB so I could easily connect the 3 UBECs to the servos and micro controller. This is it:

Servo power board revision 2

The 3 8A UBECs are connected to the servo PCB. 18 wires with Dupont connectors connect the Seeeduino Mega with the servo power PCB. I chose the Seeeduino Mega as it is a lot smaller then the standard Arduino Mega. It’s about the same size as an Arduino Uno.

Seeeduino Mega 2560

I have also received my metal servo horns. So I will fit these when I have the new chassis made.

Metal servo horns