CSlingsby

Scoutbot V0.1

2012-01-24T18:22:00.002Z

Well everything is finally wired up and ready to rock and roll. 3 Ultrasonic sensors facing forward, left (45deg) and right (45deg) as well as a forward facing Sharp IR sensor and a rear IR sensor.

The first attempt at some collision code (shown below). It has some issues that need to be addressed but its a starting point. The code looks at the forward ultrasonic and if the value is less than 25cm it compares the left and right sensors for the best way to go. If the front ultrasonic sees a distance of 10cm the robot reverses.

The value of 25cm may not be far enough based on the first fun, or I need to look a little into the breaking code for the motors. The robot can also get stuck in corners quite easily so that needs addressing. I also think the timing of values taken from the ultrasonics may need looking into, as the program goes through each one every loop, when there isn't a need.

I've also started posting at http://letsmakerobots.com with a blog and design ideas

//--------------------------------------------------------- //
//                                                                                                         //
//Scoutbot V0.1                                                                                   //
//                                                                                                        //
//Programmed by Chris83 2012                                                         //
//                                                                                                       //
// Featuring code snippets from Arduino PING Tutorial                      //
// IR Code with help from www.luckylarry.co.uk                                //
//
//---------------------------------------------------------//

//---------------------------------------------
// Includes : Include all header files

#include "DualVNH5019MotorShield.h"

//---------------------------------------------
// Constants : Declare all constants

//Ultrasonics Pin Numbers
const int ultra_cen    = 53;
const int ultra_right  = 51;
const int ultra_left   = 49;

//IR Pin Numbers
const int ir_front     = 15;
const int ir_back       = 14;

//Anaolgue Resolution
const float analogue_5v =  0.0048828125; // (5V / 1024)
const float analogue_3v =  0.0032226563; // (3.3V / 1024)

//---------------------------------------------
// Variables : Declare all global variables

// Setup The motor shield with declaration md
DualVNH5019MotorShield md;

//Ultrasonic distance variables
int center_dist, right_dist, left_dist;

//IR distance variables
int IR_front_dist, IR_back_dist;

//---------------------------------------------
// Functions : Declare all Functions

float get_distance_IR(int IR_Pin)
{
  float volts = analogRead(IR_Pin) * analogue_5v;
  
  float distance = 27*pow(volts, -1.10);
  
  return distance -1;
}

long get_distance_ultra(int ultra_Pin)
{

  // Local Variables for get_distance
  long duration, distance; 
  
  // Sensor Pre-set . Set pin LOW first for a clean signal. Then High to activate Ultrasonic senor
  pinMode(ultra_Pin, OUTPUT);
  digitalWrite(ultra_Pin, LOW);
  delayMicroseconds(2);
  digitalWrite(ultra_Pin, HIGH);
  delayMicroseconds(5);
  digitalWrite(ultra_Pin, LOW);

  // Sensor Center Detect
  pinMode(ultra_Pin, INPUT);
  duration = pulseIn(ultra_Pin, HIGH);
  
  //Convert Duration to CM
  distance = microsecondsToCentimeters(duration);

 //Return distance in CM
 return distance; 
}

long microsecondsToCentimeters(long microseconds)
{
   // The speed of sound is 340 m/s or 29 microseconds per centimeter.
  // The ping travels out and back, so to find the distance of the
  // object we take half of the distance travelled.
  return microseconds / 29 / 2;
} 
//---------------------------------------------
// Setup: 

void setup()
{
  Serial.begin(9600);
  
  md.init(); // Init the Motor Shield md
  
}

//---------------------------------------------
// Main:

void loop()
{
  
 center_dist = get_distance_ultra(ultra_cen);
 right_dist  = get_distance_ultra(ultra_right);
 left_dist   = get_distance_ultra(ultra_left);
 
 IR_front_dist = get_distance_IR(ir_front);
 IR_back_dist = get_distance_IR(ir_back);
 

      
 Serial.print("Center: ");
 Serial.println(center_dist);
 
 Serial.print("Left: ");
 Serial.println(left_dist);
 
 Serial.print("Right: ");
 Serial.println(right_dist);
 
 Serial.print("IR Front: ");
 Serial.println(IR_front_dist);
 
 Serial.print("IR Back: ");
 Serial.println(IR_back_dist);
 
 Serial.println("");
 
 if (center_dist >= 25) // If Center Ultrasonic sees a distance greater than 25cm go forward
   {
      md.setSpeeds (90,90); 
   }
    
 if (center_dist < 25 || IR_front_dist < 25) // If Center Ultrasonic sees a distance less than 25cm slow and compare
   {
      md.setBrakes (0,0);
      
      if (left_dist > right_dist) // Compare left and right ultrasonics. If Left is greater than right, GO LEFT
        {
           md.setSpeeds (-200, 200); // Start motors going LEFT
           delay (1000); // Run motors for 1 sec left
           md.setBrakes (0,0); // Stop motors
        }
        
        if (left_dist < right_dist) // Compare left and right ultrasonics. If Left is less than right, GO RIGHT
          {
           md.setSpeeds (200, -200); // Start motors going RIGHT
           delay (1000); // Run motors for 1 sec left
           md.setBrakes (0,0); // Stop motors
          }      
   }
     
 if (center_dist < 10) // If Center Ultrasonic sees a distance less than 10cm STOP!
   {
     md.setBrakes (0,0); // STOP!
     
     if (IR_back_dist > 25) // If Room to reverse ( greater than 25cm )
     {
       md.setSpeeds (-90, -90); // Go backwards
      delay (1000); //Run Motors for 1 second 
      md.setBrakes (0,0);
     }
     
     if (left_dist > right_dist) // Compare left and right ultrasonics. If Left is greater than right, GO LEFT
        {
           md.setSpeeds (-200, 200); // Start motors going LEFT
           delay (1000); // Run motors for 1 sec left
           md.setBrakes(0,0); // Stop motors
        }
        
        if (left_dist < right_dist) // Compare left and right ultrasonics. If Left is less than right, GO RIGHT
          {
           md.setSpeeds (200, -200); // Start motors going RIGHT
           delay (1000); // Run motors for 1 sec left
           md.setBrakes(0,0); // Stop motors
          }
   }
 delay(1000);  
}

Not enough space

2012-01-15T17:28:00.001Z

Sensor wires are small. So small in fact that screw terminals sometimes can't grip them properly and the available pin crimps that I had just wouldn't crimp correctly. I needed some kind of breakout board for them to attach to the Mega screwshield.

In addition to this there wasn't any space left on the Wild Thumper to mount anything without building a 2nd level. A re-design was needed.....

Instead of using an ABS box for a mounting point, I just used spare strip board. This enabled me to build in a separate breakout board for the sensors with screw terminals to wire into the screwshield.

The ultrasonic sensors are wired GND / VCC / SIG which is the centre board with 9 headers for further expansion. The Sharp IR sensor however is wired VCC / GND / ANALOGUE, so a smaller board in the top right of this picture was made. Each board gets a 5V and a GND signal thats common to all header connections. The Signal pins are then all wired upto a screw terminal to allow an easy link across to the screw shield.

Not enough pins! (MEGA Screwshield)

2012-01-13T15:06:00.001Z

After connecting up the ultrasonics and IR sensors to the board I started looking into how many I/O pins I had left on the Arduino Duemilanove board. The VNH 5019 Motor shield requires 8 digitals and 2 analogue pins. This left 6 digital pins and 4 analogues, of which 3 ultrasonics needed 3 digital pins and the IR sensor an analogue, not much room for expansion!

Something bigger and better was needed....the MEGA :) 54 digital pins and 16 analogues should allow plenty of expansion!

While playing about with the motors I realised that just pushing wires into the Arduino headers wasn't a great solution, any slight knock/bump and they'd fall out. While Screw Shields are common for the standard Arduino's I couldn't find one on the market for the Mega.

Setting about designing one I realised a small design issue with all Arduino's. The digital pin headers between Digital 10/9/8 and the next header 7/6/5/.. is a distance thats not a standard strip board pinout. All the other headers line up with a strip board apart from these two.

As I was planning on still using other shields, I just cut a section out. I didn't bother with bringing VCC and RESET pins into screw headers and originally planned to duplicate the 5v / 3V / GND pins on both sides of the shield however couldn't think of a tidy way of doing it. Not all pins are taken to screw terminals but this should give me enough I/O (famous last words!).

As I wanted to bring some analogues out to screw headers I kind of lost the space needed to bring both rows of digitals out.

All mounted, just needing the sensors wiring in then I can finally start programming something useful.

Sensors!

2012-01-03T16:22:00.003Z

While thinking about how to mount my ultrasonic transducer onto the chassis I started thinking about other sensors that I would like to use and an actual purpose for the robot. To start with I wanted the robot just to be able to do basic collision avoidance. As such would a single ultrasonic sensor be enough? Should I mount it to a servo motor so it could pan, or should I buy a number of the sensors? Would I just want ultrasonics or should I investigate IR (Infra red) as well.

I decided as the Seeedstudio sensors were relatively cheap I'd buy a few more along with a Sharp IR sensor. I also needed some kind of mounting bracket. Active Robots had a range of brackets, but as with most things on the internet I had no idea what they would actually be like once I received them. I decided on sampling a few types.

Lynxmotion MPSH-01 Multi-purpose Bracket
Active Robots UB1S3 Bracket (All Sharp IR and Devantech Ultrasonics)
Active Robots SPB1S3 Panning Bracket

The Sharp GP2Y0A21YK IR sensor mounted perfectly on the UB1S3 bracket as advertised, however the Seeedstuido Ultrasonic module was a close fit to the panning bracket but not a perfect fit (Nothing a needle file couldn't handle).

In the end I mashed all the brackets into one to provide a suitable mounting point for 3 x Ultrasonic sensors angled 45 degrees apart and a forward facing IR sensor.

I knocked up a quick breakout board to enable the sensors to easily connect with the Arduino and test them all.

Motor Tests

2011-12-22T21:45:00.004Z

Finally I have power and a robot chassis so time to start work on putting everything together and testing it!

The robot is powered by a 7.2V NiMh 4300mAH battery, this is connected to a Dagu High Power switch. This switch allows a manual on/off or one to be fed from some other electrical source, either a switch mounted elsewhere or from a microprocessor controller. The switch is then wired into the VNH5019 motor shield. This in turn powers the Arduino and gives power to the motors.

The VNH5019 comes with a pre written Arduino library so its pretty easy to get started. I loaded up the example program, downloaded to the Arduino and I had 4 motors powering up and down. One thing quickly became apparent, at full power this robot is too fast, so I edited the code to slow it down. Now I did this after about 10 seconds of first powering up, and it lead me on a 4 hour wild goose chase.

The VNH5019 code allows the motors to be peered from -400 (full power reverse) to +400 (full powered forward). At +/- 400 it was simply too fast so I changed the code to +/- 100. On doing so I began to notice that intermittently 1 or 2 of the motors would fail to power up. It would consistently be the same 2, 1 more than the other. Had I been sent some faulty motors? I stripped out all the powering wiring and re did everything. Still the same fault. I then disconnected each motor and tested it independently. Each seemed fine, it was only when they were all connected. I began testing voltages and the penny dropped. At +/- 100 The VNH5019 was only giving out 1.62V. The motors are rated 2v-7v. There simply wasn't enough power to drive each channel of 2 motors. On modifying the program to +/- 200 the problem disappeared. Voltage readings at this setting are approx. 3.2V.

Below is the code used to test the motors. It starts both sets of motors driving forward at half speed (200) for 2 seconds, then stops them, waits 5 seconds and does the same in the backwards direction. To turn the chassis, motors on the A channel should run one way and the motors on the B channel should run opposite ( e.g.md.setSpeeds (200,-200); ).

#include "DualVNH5019MotorShield.h"
DualVNH5019MotorShield md;
void setup()
{
Serial.begin(115200);
  Serial.println("Dual VNH5019 Motor Shield");
  md.init();
}
void loop()
{
   md.setSpeeds (200,200);
  delay(2000);
  md.setBrakes (0, 0);
  delay(5000);
  md.setSpeeds (-200,-200);
  delay(2000);
  md.setBrakes (0, 0);
  delay(5000);
  }

Batteries

2011-12-21T20:38:00.001Z

Power requirements for this robot are going to be slightly more than a few AA's in a battery holder. The chassis can carry unto 2 sub C packs with are often found in RC cars. The Arduino requires an input between 7v and 12v as it has its own voltage regulation to 5v and 3.3v and the motors in the chassis required around 6v - 7v, so I decided on a 7.2v pack. The VNH5019 can power the Arduino however it features no regulation so the voltage input to it must be suitable for both the motors and Arduino, which 7.2v is.

I naively plunged straight in and ordered some Lipo (Lithium Polymer) batteries as most robot websites seemed to stock them in their various forms. I picked out a 7.2v Sub C sized pack, and Lipo charger. However after placing the order I decided to look into the types of batteries a little more and found to my horror Lipo maybe wasn't the best choice. It seems they require a lot of care and attention with regards charging and discharging. Batteries had to be kept balanced and couldn't be fully discharged.

After looking at various forums it became clear this was something that really should be used outside the home in a garage or workshop rather than a spare bedroom due to "abused batteries" potentially catching fire. Lots of sites recommended charging in flameproof bags or buckets of sand. Now a lot of this info was written when Lipo's first came out and I know things have probably moved on since then, but I really didn't want to risk it.

NiMh an older battery technology again used frequently in the RC arena looked like the better option. The major differences between NiMh and Lipo appeared to be capacity and weight. Lipo is lighter and the density is greater giving a larger Mah (milliamp hour) for the equivalent weight, however NiMh is a little more forgiving with the charging and discharging, and while caution should still be taken while charging (never left unattended) a bucket of sand wasn't a recommendation :).

Battery capacity wise I wasn't sure where to start and what I would need. The motors I was using had a no load current of 420mA X 4 ( approx 1700mA ) and approximating normal running with the chassis maybe double that. The Arduino and a few sensors I didn't think would be mush more than 3-400mA.

Motors approx 3000mA - 3500mA
Arduino approx 400mA
Total around 4000mA.

I therefore chose a 4300mAH battery to hopefully give me an hour or so between charges.

Now to fire it all up and see how it runs :)

Robots! Part 2

2011-12-17T19:51:00.001Z

Well it finally arrived, thanks to Robosavvy and the Royal Mail :). The kit comes with the main chassis already built along with the motors and suspension system. All that I had to do was fit the motor axial mounts and the wheels. I left the 2DOF arm off for now, mainly as the chassis is a little bigger than expected and it may have trouble moving around with the arm on. This kit has the 75:1 motor gear boxes and the specification sheets says it will do upto 3km/h. This chassis also has the option of the 34:1 gearbox that will do 7km/h which is a little fast for indoors! Perfect for an outside robot though.

The motors with the Wild Thumper are also quite beefy. Rated at 6VDC (usable between 2VDC and 7.5VDC) with a stall current around 6amps, the Arduino is not going to be able to drive these directly.

Once I started looking around at the various motor shields for the Arduino, one thing quickly became apparent. Motors upto 2A were fine but anything above this was going to require a special motor driver board. The problem was also compounded by the fact the Wild Thumper's motors where connected together in pairs (Both right side act as one, as do the left side). This meant a potential 12amps should the motors stall, on the plus side I could get by with a single or dual motor board.

Pololu seemed to offer a wide variety of motor control boards and after looking around I found the VNH5019 which would control both motors and was an Arduino shield, BONUS! As it was a dual motor driver it also worked out cheaper than buying 2 separate boards. In addition to this Pololu have also written an Arduino library to use with the shield.

The board comes in kit form, where you have to solder the headers and connection block on, but all the other SMD chips are already attached.

The VNH5019 requires external power between 5v and 24v and there is an option to power the Arduino board through the VNH5019 meaning only 1 power supply is required. This is controlled through the blue jumper in the pictures. Jumper present means the Arduino is powered through the VNH5019. When it is configured this way the Arduino can be programmed via USB however NO OTHER POWER can be connected as it will damage both boards. Without the jumper present he Arduino will need its own power source.

Now off to go and look at how to power it all!

Robots!

2011-12-14T15:24:00.001Z

So after playing about with the Arduino for a few weeks now, doing things like ultrasonic rangefinders, temperature monitors I decided to start looking for robot chassis. Not having access to a workshop, only a desk I knew I was going for a robot kit in some way, shape or form be it one that was pre assembled or one that required some assembly but could be done using only a few simple tools ( no machining required! ).

There are various online stores for robotic parts selling kits, however I found there were basic kits that didn't look like they'd last me long and left little room for customisation to products that were just chassis costing hundreds of pounds to full kits costing thousands!. What I wanted was something that allowed me to customise how I wanted, something that would last both in terms of durability and as the project grows and potentially something that could take a knock or two.

Some of the various models I considered.

DFRobot Tracked kit - with a review from RUG Community. This kit seemed to contain just about everything I'd need however it just didn't look durable enough. It also seemed to lack many expansion options. It may be been able to carry a sensor or to but nothing much. It also contained a customised Arduino board that I already had. On the plus side quite cheap :).
DFRobot 4WD - with a review from RUG Community. This kit seemed a great kit to start with with quite a lot of expansion options should I need them. The only thing that put me off this kit was the fact the motors didn't seem too powerful and could be hard to replace if the need arose.
Dagu Wild Thumper 4WD - with a review from RUG Community. The review from RUG was for the 6WD version but Dagu also do the smaller 4WD. This platform appears to have the power, expandability and the robustness required.

I did look at various models from Lynxmotion however they seemed to be just a little too pricey for what I required. In the end I went for the Dagu 4WD Wild Thumper, with the 2DOF arm pack. All ordered and should be here in a few days (depending on how bad the Christmas post is already :) )

Ultrasonics

2011-12-12T12:56:00.003Z

As the final goal is a robot, collision detection is a must. There are various types of detection from IR (Infra-red) range finding, ultrasonic, laser and actual collision detection through use of a push button of something similar. For the purposes of this post I'll be documenting my findings with ultrasonics, however I do intend to look into IR and maybe even laser at some point.

There are many ultrasonic modules on the market, ranging from £10 - £100+. Interfaces range from TTL, I2C and Serial. However by far the easiest to interface with Arduino is the PING sensor. The PING sensor itself is relatively cheap and accurate enough for a basic collision avoidance robot, however SeeedStudio do an even cheaper model (about 2/3 the price of the PING). This is a simple 3 wire sensor, 5V, GND and SNG (which can be connected to any digital pin on the Arduino).

Using the PING tutorial and the inbuilt LCD library that comes with the Arduino IDE, I created a quick demo. All wiring drawings can be found in the respective tutorials.

The sensor basically works by sending a High pulse on the digital pin for 2ms, then recording the time taken (in microseconds) for the same pin the receive the pulse back. The time taken, divided by 2 can then be used to calculate the distance. The PING documentation states that sound travels at 340 m/s in air or 29 microseconds / cm.

The sensor was pretty accurate, easily to within 1cm using my crude measuring techniques in the video.

Below is the code used in the demo:

/* Ping))) Sensor
  
   This sketch reads a PING))) ultrasonic rangefinder and returns the
   distance to the closest object in range. To do this, it sends a pulse
   to the sensor to initiate a reading, then listens for a pulse 
   to return.  The length of the returning pulse is proportional to 
   the distance of the object from the sensor.
     
   The circuit:
    * +V connection of the PING))) attached to +5V
    * GND connection of the PING))) attached to ground
    * SIG connection of the PING))) attached to digital pin 7

   http://www.arduino.cc/en/Tutorial/Ping
   
   created 3 Nov 2008
   by David A. Mellis
   modified 30 Aug 2011
   by Tom Igoe
 
   This example code is in the public domain.

 */


#include <LiquidCrystal.h>

// initialize the library with the numbers of the interface pins
LiquidCrystal lcd(12, 11, 5, 4, 3, 2);

const int pingPin = 7;

void setup() {
  
  lcd.begin(16, 2);
  Serial.begin(9600);
}

void loop()
{
  // establish variables for duration of the ping, 
  // and the distance result in inches and centimeters:
  long duration, cm;

  // The PING))) is triggered by a HIGH pulse of 2 or more microseconds.
  // Give a short LOW pulse beforehand to ensure a clean HIGH pulse:
  pinMode(pingPin, OUTPUT);
  digitalWrite(pingPin, LOW);
  delayMicroseconds(2);
  digitalWrite(pingPin, HIGH);
  delayMicroseconds(5);
  digitalWrite(pingPin, LOW);

  // The same pin is used to read the signal from the PING))): a HIGH
  // pulse whose duration is the time (in microseconds) from the sending
  // of the ping to the reception of its echo off of an object.
  pinMode(pingPin, INPUT);
  duration = pulseIn(pingPin, HIGH);

  // convert the time into a distance

  cm = microsecondsToCentimeters(duration);
  
  lcd.setCursor(0,0);
  lcd.print("Range in cm:");
  lcd.setCursor(0, 1);
  lcd.print(cm);
  
  
  delay(1000);
  lcd.clear();
}


long microsecondsToCentimeters(long microseconds)
{
  // The speed of sound is 340 m/s or 29 microseconds per centimeter.
  // The ping travels out and back, so to find the distance of the
  // object we take half of the distance travelled.
  return microseconds / 29 / 2;
}

What is Arduino?

2011-12-05T09:25:00.000Z

Its an open source (Cheap!) micro controller, developed to be easy to use and flexible. As its open source anyone can build a board and market it. Popular board makers include official Arduino boards, DFRobot and Seeedstudio. It comes in multiple forms from the Nano with 14 digital and 8 analog pins to the Mega with 54 digital and 16 analog pins. The Arduino can be programmed using open source software provided by Arduino on Windows, Linux and Mac platforms.

Code is written in Sketches, and quite closely resemble the C programming language syntax and keywords.

I've tried other micro controller systems however as I'm developing on a Mac, and Arduino has a huge support community, I think its the better choice than say PICAXE or BASIC Stamp. Most Arduino boards accept a USB connection and can be programmed this way.

The board I'll be using is the Duemilanove which features 14 digital pins and 6 analog pins. This should be enough for most basic projects and perhaps my first robot :)