The following example demonstrates the use of an Arduino shield from the Rasperry Pi.
The shield used is a clone of the Adafruit motor shield. See shieldlist.org for details.
For the demonstration DC motors 3 and 4 are being driven forwards and backwards with changing speeds (speeds are controlled via PWM).
Seven connections are made between the Pi and the shield. Four to latch the motor states (latch, enable, data, clock); Two to control motor speed (PWM 3 and 4); and ground.
The code used was ported from the Adafruit Arduino code and converted to use the pigpio library. Only the DC motor code was ported.
A video of the shield in use is available at youtube.com
`
#include <stdio.h>` `
#include <pigpio.h>
/*
This code may be used to drive the Adafruit (or clones) Motor Shield.
The code as written only supports DC motors.
http://shieldlist.org/adafruit/motor
The shield pinouts are
D12 MOTORLATCH
D11 PMW motor 1
D10 Servo 1
D9 Servo 2
D8 MOTORDATA
D7 MOTORENABLE
D6 PWM motor 4
D5 PWM motor 3
D4 MOTORCLK
D3 PWM motor 2
The motor states (forward, backward, brake, release) are encoded using the
MOTOR_ latch pins. This saves four gpios.
*/
typedef unsigned char uint8_t;
#define BIT(bit) (1 << (bit))
/* assign gpios to drive the shield pins */
/* Shield Pi */
#define MOTORLATCH 14
#define MOTORCLK 24
#define MOTORENABLE 25
#define MOTORDATA 15
#define MOTOR_3_PWM 7
#define MOTOR_4_PWM 8
/*
The only other connection needed between the Pi and the shield
is ground to ground. I used Pi P1-6 to shield gnd (next to D13).
*/
/* assignment of motor states to latch */
#define MOTOR1_A 2
#define MOTOR1_B 3
#define MOTOR2_A 1
#define MOTOR2_B 4
#define MOTOR4_A 0
#define MOTOR4_B 6
#define MOTOR3_A 5
#define MOTOR3_B 7
#define FORWARD 1
#define BACKWARD 2
#define BRAKE 3
#define RELEASE 4
static uint8_t latch_state;
void latch_tx(void)
{
unsigned char i;
gpioWrite(MOTORLATCH, PI_LOW);
gpioWrite(MOTORDATA, PI_LOW);
for (i=0; i<8; i++)
{
gpioDelay(10); // 10 micros delay
gpioWrite(MOTORCLK, PI_LOW);
if (latch_state & BIT(7-i)) gpioWrite(MOTORDATA, PI_HIGH);
else gpioWrite(MOTORDATA, PI_LOW);
gpioDelay(10); // 10 micros delay
gpioWrite(MOTORCLK, PI_HIGH);
}
gpioWrite(MOTORLATCH, PI_HIGH);
}
void init(void)
{
latch_state = 0;
latch_tx();
gpioWrite(MOTORENABLE, PI_LOW);
}
void DCMotorInit(uint8_t num)
{
switch (num)
{
case 1: latch_state &= ~BIT(MOTOR1_A) & ~BIT(MOTOR1_B); break;
case 2: latch_state &= ~BIT(MOTOR2_A) & ~BIT(MOTOR2_B); break;
case 3: latch_state &= ~BIT(MOTOR3_A) & ~BIT(MOTOR3_B); break;
case 4: latch_state &= ~BIT(MOTOR4_A) & ~BIT(MOTOR4_B); break;
default: return;
}
latch_tx();
printf("Latch=%08X\ ", latch_state);
}
void DCMotorRun(uint8_t motornum, uint8_t cmd)
{
uint8_t a, b;
switch (motornum)
{
case 1: a = MOTOR1_A; b = MOTOR1_B; break;
case 2: a = MOTOR2_A; b = MOTOR2_B; break;
case 3: a = MOTOR3_A; b = MOTOR3_B; break;
case 4: a = MOTOR4_A; b = MOTOR4_B; break;
default: return;
}
switch (cmd)
{
case FORWARD: latch_state |= BIT(a); latch_state &= ~BIT(b); break;
case BACKWARD: latch_state &= ~BIT(a); latch_state |= BIT(b); break;
case RELEASE: latch_state &= ~BIT(a); latch_state &= ~BIT(b); break;
default: return;
}
latch_tx();
printf("Latch=%08X\ ", latch_state);
}
int main (int argc, char *argv[])
{
int i;
if (gpioInitialise()<0) return 1;
gpioSetMode(MOTORLATCH, PI_OUTPUT);
gpioSetMode(MOTORENABLE, PI_OUTPUT);
gpioSetMode(MOTORDATA, PI_OUTPUT);
gpioSetMode(MOTORCLK, PI_OUTPUT);
gpioSetMode(MOTOR_3_PWM, PI_OUTPUT);
gpioSetMode(MOTOR_4_PWM, PI_OUTPUT);
gpioPWM(MOTOR_3_PWM, 0);
gpioPWM(MOTOR_4_PWM, 0);
init();
for (i=60; i<160; i+=20)
{
gpioPWM(MOTOR_3_PWM, i);
gpioPWM(MOTOR_4_PWM, 220-i);
DCMotorRun(3, FORWARD);
DCMotorRun(4, BACKWARD);
sleep(2);
DCMotorRun(3, RELEASE);
DCMotorRun(4, RELEASE);
sleep(2);
gpioPWM(MOTOR_4_PWM, i);
gpioPWM(MOTOR_3_PWM, 220-i);
DCMotorRun(3, BACKWARD);
DCMotorRun(4, FORWARD);
sleep(2);
DCMotorRun(3, RELEASE);
DCMotorRun(4, RELEASE);
sleep(2);
}
gpioPWM(MOTOR_4_PWM, 0);
gpioPWM(MOTOR_3_PWM, 0);
DCMotorRun(3, RELEASE);
DCMotorRun(4, RELEASE);
gpioTerminate();
}
`