4WD Differential Steering?

Using Arduino Project Guidance
1

Hello!

I am planning on making an simple RC car with an Arduino. It will have four wheels and two motors. Instead of using servos to steer, I want to use differential steering. The two left wheels are linked together with gears, and the two right wheels are linked together with gears. One motor drives the left wheels, one motor drives the right wheels. Is it possible to rotate the car by turning one motor counterclockwise and one motor clockwise? What would the spacing of the wheels have to be?

Thanks!

2

Is it possible to rotate the car by turning one motor counterclockwise and one motor clockwise?

Yes... and No 8)

You actually need to think of the turning as forwards and backwards. If you want to turn left, and look at the left wheel from the left, that wheel will turn backwards or clockwise. Looking at the right wheel from the right, that wheel will turn forwards, which is also clockwise....

You'll need to experiment with the spacing and the relative speeds- if you can use something like Erector (aka Meccano) you can experiment easily. What is your chassis going to be made of?

3

Yes, works really well actually, will turn on a dime. You can also command all motors to run in the same direction but have one side run faster than the other to turn right or left. (i.e. left wheels moving faster than right wheels will make robot turn right)

4

You're describing a skid steer system, which is quite common. It works best on vehicles with a relatively short wheelbase - the longer the wheelbase, the more scrubbing occurs when the vehicle turns.

5

dkl65:
The two left wheels are linked together with gears, and the two right wheels are linked together with gears.

You don't mention it, and I think this is what JimboZA is getting at - but this "gear train" you are talking about needs to be such that wheels on one side of the vehicle turn in the same direction; so make sure that your gear train has an odd number of idler gears (or uses some other configuration) between the drive gears attached to the wheels.

I fact, the best way to achieve such a drive system is to not use gears, but rather chains or toothed belts; it's also a more forgiving design, since you can simply provide tensioning mechanisms on one end of the vehicle to tension the drive properly (whereas with a geared system, you would need to design to a certain tolerance so that your gear train runs smoothly and doesn't bind or otherwise have problems - which isn't a simple task).

dkl65:
Is it possible to rotate the car by turning one motor counterclockwise and one motor clockwise?

Yes - this is called "skid steering" - for instance:

It has this name for a very good reason - when you drive your wheels in this manner to make a turn (and this occurs whether it is a gradual turn, or the "turn-on-a-dime" method you mention), some of the wheels will "skid" on the surface you are driving on. This ultimately leads to a bunch of issues - the least of which is that the surface being driven on may get torn up (which of course depends on the size of the vehicle, it's mass, tire contact patch, etc).

Depending on the grip of the wheels, you may have issues like "bouncing" where the tire will skid and "jump" or "vibrate" on the surface (this would more likely occur with rubber tires on a hard surface like concrete or asphalt); you also need to be aware that while skidding (regardless of surface) you will be applying lateral loads to the wheels, tires, bearing, hubs, etc - of the vehicle; these need to be engineered and designed properly to take this strain - otherwise you end up with broken parts (or at least parts that wear out quicker than they should).

Rarely do you see differential or "skid-steer" machines driven in such a manner (that is, "turn-on-a-dime") because of such issues; especially when it comes to tracked vehicles, such skid-steering may actually cause a "thrown-track", in which the track comes off (or breaks off!) the driver wheels and idlers - necessitating an expensive repair (at best - you obviously don't want this to happen in a war zone in a tank, because that could lead to much worse consequences!).

Instead, such machines in general use gradual turning, which are done by driving one side slower than the other at speed. In the case of skid-steer machines like loaders and such (which have four wheels), they'll likely only be driven on a compliant surface (sand, dirt, grass, etc), or their drive tires will have little or no tread on them (in the cases where they are driven on hard surfaces, gradual turning will generally be used).

dkl65:
What would the spacing of the wheels have to be?

Well - if you want the best performance in "turn-on-a-dime" mode (regardless of the strain on the system or other issues) - then the best positioning would be at the vertices of a square - which would roughly have a turning capability that corresponds to that of a circle whose diameter is the line between opposite corners of that square.

Now - in the case of "turn-on-a-dime" - if you wanted this capability, but less strain on the system (at the expense of a much more complicated mechanical arrangement) - you could allow each wheel to pivot on a vertical axis. Provided that the center of this axis through the wheel positions it right on the vertex of the square/circle, you could tilt the wheels to follow the line of the circle (basically "toe-ing in" each wheel at the corners), and any skidding would be very minor, if any.

This was actually the system used on the various recent Mars Rover vehicles - as well as talked about in this paper:

http://www.ri.cmu.edu/publication_view.html?pub_id=524

I bet you never thought that such a seemingly-simple system could have such complexities!

Finally - I also want to mention that, back in the 1960s and 1970s (and actually into the 1980s) there were a variety of manufacturers (and kits) of 6-wheel skid-steer ATV machines; they were basically the quad-cycles and "Polaris" machines of their day - here's an article on such a machine from Popular Science magazine, December 1961:

A good patent on a similar vehicle (with interesting suspension systems described) is USPTO #3506079:

http://www.google.com/patents/US3506079

Good luck with your project, and I hope this helps. :smiley:

6

If the car is to be small, skid steer setups can be fairly simple. Four inexpensive servos can be modified for continuous rotation and used to drive the wheels. Below is a typical four motor skid steer bot platform.

http://www.lynxmotion.com/c-30-a4wd1-rovers.aspx

7

The chassis will be made of bass wood. Other materials I have are wooden dowels and metal eyepins. Since the motors are regular DC motors controled by a transistor H-Bridge, the only speed control I have are PWM. I will be using 5 gears on each side of the car. This is the basic design of the car (the black circles are gears.) Thanks for all the help! BTW, steering accuracy is not important; it just has to rotate the entire car. Also: is wheelbase to track ration 1:1 better for steering, or 1.5:1?

Arduino RC Car.png
Arduino RC Car.png960×540 122 KB

8

The longer the wheelbase (relative to the track) the harder it will be to turn.

9

This is how I did it.

/*
Andrew Mascolo 
Seminar project with Bluetooth control
 */
#include<string.h>
int DRV1,DRV2,STRR,STRL;
int x = 0;
int y = 0;
int z = 0;
int s = 0;
void move(int z = 0,int y = 0,int s = 0);
String val,X,Y,Z,state = "";
int currentCommand = 0;

byte ledpin = 13;
byte Mopen = 4;
byte Mclosed = 2;
byte M1L = 3;// PWM
byte M2L = 5;// PWM
byte M1R = 9;// PWM
byte M2R = 6;// PWM


void setup()
{
  pinMode(ledpin, OUTPUT);  // pin 13 (on-board LED) as OUTPUT
  pinMode(Mopen, OUTPUT);                                
  pinMode(Mclosed, OUTPUT);
  pinMode(M1L, OUTPUT);                                
  pinMode(M1R, OUTPUT);
  pinMode(M2L, OUTPUT);                                
  pinMode(M2R, OUTPUT);
  Serial.begin(9600);       // start serial communication at 115200bps
}

void loop() {
  if( Serial.available())       // if data is available to read
  { 
    digitalWrite(ledpin, HIGH);
    char c= Serial.read();
    if (c == ','){
      currentCommand++; 
    }
    else { 
      val += c;
      //Serial.println(val);
      switch (currentCommand) {
      case 0:
        X += val;
        val = "";
        break; 
      case 1:
        Y += val;
        val = "";
        break;
      case 2:
        Z += val;
        val = "";
        break;
      case 3:    
        state = val;
        currentCommand = 0;
        val = "";
        x=X.toInt(); //Convert string to a usable integer
        y=Y.toInt(); //Convert string to a usable integer
        z=Z.toInt(); //Convert string to a usable integer
        s=state.toInt(); //Convert string to a usable integer
        X=""; Y=""; Z=""; state=""; //Clear string 
        move(z, y, s); // send to motors
        break;
      }
    } 
  }
} 
    
  void move(int z, int y, int s)
  {  
  //Movement varibles
  int DRV2 = map(z, -15, 0, 255, 0);
  int DRV1 = map(z, 0, 15, 0, 255);
  int STRL = map(y, -10, 0, 255, 0);
  int STRR = map(y, 0, 10, 0, 255);
  //constrain((DRV1,DRV2,STRL,STRR),0,255);

  if(z > 0)//forwards with left/ right skew turning            
  {
    //Serial.println("Driving"); 
    analogWrite(M1L, constrain(abs(DRV1 - STRL),0,255)); analogWrite(M1R, constrain(abs(DRV1 - STRR),0,255));   
    digitalWrite(M2L, LOW);                              digitalWrite(M2R, LOW);   
  }
  else if(z < 0)//backwards with left/ right skew turning                 
  {
    //Serial.println("Driving"); 
    digitalWrite(M1L, LOW);                              digitalWrite(M1R, LOW);   
    analogWrite(M2L, constrain(abs(DRV2 - STRL),0,255)); analogWrite(M2R, constrain(abs(DRV2 - STRR),0,255));   
  }
   else if(z < 4 && z > -4 && y > 0)//zero point turn Right  +-4 is the dead zone, it makes it drive more smoothly             
  {
    //Serial.println("Driving"); 
    digitalWrite(M2L, LOW); analogWrite(M2R, STRR);   
    analogWrite(M1L, STRR); digitalWrite(M1R, LOW);
  }
  else if(z < 4 && z > -4 && y < 0)//zero point turn Left   +-4 is the dead zone, it makes it drive more smoothly               
  {
     //Serial.println("Driving"); 
    analogWrite(M2L, STRL); digitalWrite(M2R, LOW);   
    digitalWrite(M1L, LOW); analogWrite(M1R, STRL);   
  }

  else //full stop
  { 
    digitalWrite(M1L, LOW); digitalWrite(M1R, LOW);        
    digitalWrite(M2L, LOW); digitalWrite(M2R, LOW);    
  }

// Claw controls
   if(s == 1)
    {
      Serial.println("Claw Opening");
      digitalWrite(Mopen, HIGH); digitalWrite(Mclosed, LOW);
    }
    if(s == 2)
    {
      Serial.println("Claw Closing");
      digitalWrite(Mopen, LOW); digitalWrite(Mclosed, HIGH);
    }
    if(s == 0)
    { 
      digitalWrite(Mopen, LOW);  digitalWrite(Mclosed, LOW);
    } 
   else
   {
    digitalWrite(ledpin, LOW);
    x=0; y=0; z=0; s=0;
   } 
 val,X,Y,Z,state = "";  //Clear string
}

This is it in action

10

And another one -

Duane B

rcarduino.blogspot.com

11

Due to the lack of gears, I might have to use an elastic band pulley to connect the wheels instead. I will reply when I have built the car. Thanks for all the help! Much appreciated!

12

That seems like a simpler and more robust solution anyway.

13