Paralleling the Rugged Motor Driver

Introduction

Our Rugged Motor Driver is rated for 2.8A peak per-phase current (two phases) and realistically can sustain about half of that in steady operation (here’s why). A common question is whether the two output phases can be put in parallel to get twice the current when driving a DC motor. The answer is “yes”, but requires a little bit of care.

Hardware

The two outputs of the Rugged Motor Driver are available at two screw-terminal connectors. The silkscreen on the board identifies one terminal as “+” and the other as “-”. These are fairly arbitrary since a terminal can be at a higher or lower voltage relative to the other, depending on which way the motor is turning.

The important part in paralleling the two drivers is to connect “+” to “+” and “-” to “-” as shown in this diagram.

The MOTOR+ and MOTOR- wires above go to your DC motor. Again, the “+” and “-” aren’t important and will switch polarity when the motor reverses direction.

Software

The important part in paralleling the two drivers is to make sure you never have one on in the “forward” direction while the other is on in the “reverse” direction. Here are some helper functions you can include in your sketches to make sure this never happens.

First, let’s define our pins:

#define EN1 3            // Pin 3 is Enable for Driver #1
#define EN2 11           // Pin 11 is Enable for Driver #2
#define DIR1 12          // Pin 12 is Direction for Driver #1
#define DIR2 13          // Pin 13 is Direction for Driver #2

                                                    

Now this function will set the power level (PWM) to the motors, ensuring that both motors turn on and off at the same time. NOTE: This code is for the Uno/Duemilanove/Ruggeduino only, and only for the pin assignments shown above! It is not for the Mega1280/2560, and will not work if you have rewired the control inputs.

uint8_t savedPWM = 0;
void pAnalogWrite(uint8_t pwm) { // Parallel analogWrite()
  if (pwm==0) {
    digitalWrite(EN1, LOW); digitalWrite(EN2, LOW);
  } else if (pwm==255) {
    digitalWrite(EN1, HIGH); digitalWrite(EN2, HIGH);
  } else {
    TCCR2A |= _BV(COM2A1) | _BV(COM2B1);
    OCR2A = OCR2B = pwm;
  }
  savedPWM = pwm;
}

Finally, this function is used to set the direction of the motor, and makes sure that the two drivers never try to “fight” each other and go in opposite directions.

void pSetDirection(uint8_t forward) { // 1==forward, 0==reverse
  pAnalogWrite(0); // Turn drivers off while switching direction
  if (forward) {
    digitalWrite(DIR1, HIGH); digitalWrite(DIR2, HIGH);
  } else {
    digitalWrite(DIR1, LOW); digitalWrite(DIR2, LOW);
  }
  pAnalogWrite(savedPWM);   // Restore driver power level
}

Example

Here is an example that shows this code in action. The sketch is simple, it just spins the motor forwards for 1 second, pauses, then spins it in reverse for 1 second, pauses, then repeats.

void setup() {
  pAnalogWrite(0); // Both motors off for now
  pinMode(EN1, OUTPUT); pinMode(EN2, OUTPUT);
  pinMode(DIR1, OUTPUT); pinMode(DIR2, OUTPUT);
}
void loop() {
  pSetDirection(1); // Forward
  pAnalogWrite(128); // 50% power
  delay(1000);
  pAnalogWrite(0); // Pause rotation
  delay(1000);
  pSetDirection(0); // Reverse
  pAnalogWrite(128); // 50% power
  delay(1000);
  pAnalogWrite(0); // Pause rotation
  delay(1000);
}

Conclusion

The Rugged Motor Driver can have its two phase outputs paralleled to double the current drive to a single DC motor. However, you must be careful to connect the two terminal outputs together in the right way, and your code must make sure that the two phase outputs are always driving current in the same direction.

Since the Rugged Motor Driver is fully protected against shorted motor leads, making a mistake in the hardware or software is not catastrophic. The motor driver will simply shut down and you will not deliver any electrical power to your motor.