understanding how a motor is controlled with an L293D and raspberry pi

Question

See update, picture of robot below.

So today I hooked up a motor and made it spin with my raspberry pi and an L293D by reading this tutorial.

This is what the circuit looks like (larger pictures):

It work's and I'm pretty happy. My end goal is to understand this and build something that can control two motors and I'm set to build a small bot :)

My issues:

If I'm not mistaken in this circuit, the enable pin on the L293D is getting a PWM signal for the speed of the motor it drives.

1. From the software page I can follow what the python is doing but I don't see where it says that pin 18 on the raspberry GPIO should be enabled as PWM? The docs say that Pin 12 supports PWM ? How does this work?

2. What if I didn't care about speed? Can I just use an regular GPIO pin for output a high on the enable of the L293D? With the Pi I'm assume that would out a 3.3v? And if I'm looking at the datasheet correct the enable pin can take upto 7v as a high? (What speed would it run on?)

3. Also again, if I didn't care about speed control, I could hook another GPIO to the second enable and control another motor also right. And I can then control each of they're directions?

---

Update:

Thanks @Passerby and @JImDearden I got it to work. No PWM, but just two motors. Like @Passerby says, I need three GPIO's for each motor. One for enable/disable and two for direction.

Here is what I made :) And it's wifi network controlled (with a wifi dongle attached) The cable is just a USB power cable :)

Answer 1

From the software page I can follow what the python is doing but I don't see where it says that pin 18 on the raspberry GPIO should be enabled as PWM? The docs say that Pin 12 supports PWM ? How does this work?

Not knowing the specifics of the RPI GPIO Library that Adafruit uses, but looking at the page you link to, it enables it with set("mode", "pwm"). As it says, The Python program first sets-up the two GPIO pins to be outputs. It then defines the same convenience function (“set”) that we used in Lesson 8, to write to the PWM Kernel Module. This is then used to set the parameters for PWM. The RPI hardware PWM is enabled through that library.

What if I didn't care about speed? Can I just use an regular GPIO pin for output a high on the enable of the L293D? With the Pi I'm assume that would out a 3.3v? And if I'm looking at the datasheet correct the enable pin can take upto 7v as a high? (What speed would it run on?)

Yes, you can do that. It would run at 100%, because you simply toggled the pin on. The voltage at the pin is not what sets the speed, but simply how fast you turn the pin off or on in a given time period that does. Like flipping a light switch on and off fast enough that it seems like the lights are only half on.

Also again, if I didn't care about speed control, I could hook another GPIO to the second enable and control another motor also right. And I can then control each of they directions?

Yes, but you would actual need three gpio to control both directions of one motor. 1 for the motor enable (on/off), and 2 for the motor 2 direction. Exactly as it is now, except without pwm.

Answer 2

1. Any general purpose I/O pin can be made to output a PWM signal, It is simply a matter of turning it ON for a given time and then OFF for the remainder of the period.

2. A continuous HIGH is just like a PWM with no OFF period so yes, the motor will run at full speed. The speed of the motor is a function of SUPPLY VOLTAGE and not the size of the enable signal. The motor supply is taken from the battery pack (6V)

3. With the right software (see answer 1) you could operate a second motor and control both speed and direction

Answer 3

While you can produce a PWM signal from any of the GPIO pins, the fact that the Raspberry Pi is not running a real time operating system means that using anything other than the hardware PWM outputs will be low performance and/or unpredictable, and the higher performance you try for the more unpredictable it will be. For stable robotic control you want it to be as predictable as is possible.

The WiringPi library appears to support both hardware PWM output on one GPIO pin and software PWM on any of the other GPIO pins. Which of these is suitable for your applications depends on how many PWM outputs you need and what performance you want out of those outputs.

If you application is tolerant of low timing resolution and high jitter then you could use a software timing loop. If you want higher precision / lower jitter PWM then you will need hardware assistance.

When might Software PWM be suitable?

If you want to flash a bunch of LEDs with different human visible cadences (10's of hertz) with soft real-time response requirements then the software loop could handle as many PWM's as you have GPIO pins (more with multiplexes).

When might Hardware PWM be suitable?

If you want to control a servo motor with hard real-time response requirements then you will need to use the Hardware PWM. Even then you may have problems ensuring a real-time response for the servo loop which ties encoder input to PWM output.

A stable servo loop needs to read encoders at a regular rate (low jitter), write out revised PWM output values at a regular rate and the latency between these should be fixed (low jitter overall) or you will have to under tune your motor to prevent it becoming unstable under load. This is hard to do with a multi-tasking operating system without low level support.

What if I need multiple hardware PWM outputs?

If you need to run multiple servo loops, then you are probably going to need to offload them to another device to ensure hard real-time performance, relegating your Raspberry Pi to being a soft real-time supervisor.

One option, would be something like the Adafruit 16-Channel 12-bit PWM/Servo Driver - I2C interface - PCA9685 which would allow you to control 16 pwm outputs with just a few pins of GPIO for the I2C bus. For an example of it's use, check out the I2C 16 Channel PWM/Servo Breakout - Working post on the Raspberry Pi forums.

_{Based on my answer over on Raspberry Pi with thanks to Alex Chamberlain for his answer}