Jo Fairfax Studio – Motor controller
I’ve been working with light artist, maker and NESTA fellow Jo Fairfax, (of Jo Fairfax Studio) on an interactive wall prototype.
He needed to have control over loads of motors which all move circular disks a set distance.
I designed a stepper motor controller unit to control up to 12 motors. These can be repeated to produce very large arrays of stepper motors.
The final effect is amazing, as shown in the videos here.
The final results look great and the unit in these videos has 6 of the motor controllers to control 72 small stepper motors.
Design brief
The design brief was to create a unit to control the rotation of a number of circular disks. The unit needed to be easily reprogrammable (so that different effects could be easily created), daisy-chainable (so that many motors could be controlled), detect movement (to activate different motion patterns) and relatively low-cost (as this was a prototype).
Design overview
There were a number of design decisions made through a number of prototype steps. Jo was actively engaged in the design process (as he knew the final effect he was wanting) and he also wanted to be able to reprogram the units easily, to speed up the development time.
We eventually settled upon:
- Arduino compatible Nano based controller unit
- Controls up to 12 small stepper motors, which can be configured into two banks of 6.
- Stepper motors all have individual controllers.
- Ultrasconic distance sensors detect movement.
- This meant we could program specific distances for the unit to react to and we found much more reliable than a PIR sensor.
- DC-DC converter power supply.
- For input voltages up to 12V DC.
We also implemented a reset to known position on start up so that the pattern stays true, even with a power loss. This was done by monitoring the input voltage (using a potential divider) and storing the position of the motors into EEPROM just before it powers down. This worked very well compared to our other options of mechanical reset switches.
The PCB for the motor controller.
The populated PCB.
The unit is based on the Nano (Arduino Clone).
A DC-DC converter is used for powering the unit.
This means we can power the boards at 12V, but the motors run at 5V.
The prototype on the test bench.
Lots of motors (72 in total) controlled by the boards (6 boards in total). This prototype version is a bit of a mess.
Ultrasonic sensors control the unit.
Arduino Code
We wrote some Arduino code to control the motors, which is based upon AccelStepper stepper motor controller code.
/*
Stepper Motor Controller
This runs a stepper motor (or motors) from an Arduino Pro
5V ATMEGA328 16MHz (12MHz?)
I'm using the 28BYJ-48 stepper motor with driver
This Motor has a Gear ratio of 64 , and Stride Angle 5.625°
so this motor has a 4096 Steps .
Lots more info here:
http://42bots.com/tutorials/28byj-48-stepper-motor-with-uln2003-driver-and-arduino-uno/
Gear ratio is: 64 approx :1
Actual gear ratio: 63.68395 : 1
The PCB has the following wiring:
Stepper Motor Set 1 (6 x motors) is on:
D5,D6,D7,D8
Stepper Motor Set 2 (6 x motors) is on:
D9,D10,D11,D12
Connectors K1/K2/K3/K4 decide if all 12 Motors do the same thing or
if there are two sets of 6 motors which can do different things.
INPUTS:
RESET D2
SW1 D3
SW2 D4
DETECT_IN1
A0
A1 TrigPin
A2 EchoPin
A3 This is the input voltage with a 100k/10k divider.
This code has the following functions:
STEPPED:
Each time the PIR is triggered then the motors will move one position forwards.
When all positions are complete then the motor will be back to position 0
There are 4096 (approx) steps 1 rotation (360degrees).
There are four positions we can move to.
The end position wil always be zero.
The input voltage is monitored all the time.
This is used to record the last position of the motor before shutting down.
This means the unit can reset when powered up.
This example code is in the public domain.
*/
#include <EEPROM.h> // For writing values to the EEPROM
#include <avr/eeprom.h>
#include <AccelStepper.h>
#define HALFSTEP 8
// Motor pin definitions
#define motorPin1 5 // IN1 on the ULN2003 driver 1
#define motorPin2 6 // IN2 on the ULN2003 driver 1
#define motorPin3 7 // IN3 on the ULN2003 driver 1
#define motorPin4 8 // IN4 on the ULN2003 driver 1
#define trigPin A2 // The connections for the ultrasonic distance sensor
#define echoPin A1
#define voltageMonitor A3 // This is the pin to measure the voltage on the input
// ****************USER VARIABLES****************************************
// **********************************************************************
// ************** MODE ************************
// STEPPED = stepps through 4 different locations
String mode = "STEPPED";
// ************** STEPPED INPUT ********************
// These are the three positions the unit will move into before returning to 0 in the fourth
// The positions are steps where 4096 = 360 degrees (approx)
int step1 = 1024;
int step2 = 2048;
int step3 = -1024;
int previousStep = 0; // A holder for the position the unit was left in.
// This means we can reset to zero when powered up.
// Ultrasonic distance sensor variables
int minDistance = 10; // Minimum distance (cm) for the Ultrasonic Sensor
int maxDistance = 100; // Maximum distance (cm) for the Ultrasonic Sensor
// Stepper motor variables
int maxSpeed = 800; // The maximum speed for the motor (typical values 200-800)
int acceleration = 100; // Acceleration of the motor (typical values (50 - 400)
// ********************* END OF USER VARIABLES***************************
// **********************************************************************
int RESET = 2;
int SW1 = 3;
int SW2 = 4;
int led = 13; // LED on pin 13 - flash to make it obvious
boolean pirTriggered = LOW; // This is a flag to stop things repeating
boolean stepTrigger = LOW; // This is to set off the step trigger
int stepCase = 0; // This is the next step movement to do.
int modeCase = 0; // This is the main mode to do.
// Varibales for writing to EEPROM
int hiByte; // These are used to store longer variables into EEPROM
int loByte;
int sensorValue = 0; // For the distance sensor
long duration, distance;// For the distance sensor
// Initialize with pin sequence IN1-IN3-IN2-IN4 for using the AccelStepper with 28BYJ-48
AccelStepper stepper1(HALFSTEP, motorPin1, motorPin3, motorPin2, motorPin4);
void setup() {
// Initialise the PIR as a input with a pull up resistor
pinMode(RESET, INPUT_PULLUP);
pinMode(SW1, INPUT_PULLUP);
pinMode(SW2, INPUT_PULLUP);
pinMode(voltageMonitor, INPUT);
pinMode(led,OUTPUT); // Have the LED display an output
pinMode(trigPin, OUTPUT);
pinMode(echoPin, INPUT);
Serial.begin(115200);
stepper1.setMaxSpeed(maxSpeed); // usual value = 500
stepper1.setSpeed(maxSpeed); // usual value = 200
stepper1.setAcceleration(acceleration); // usual value = 100
// Retrieve the setpoints from EEPROM
hiByte = EEPROM.read(0);
loByte = EEPROM.read(1);
previousStep = (hiByte << 8)+loByte; // Get the previous step value
Serial.print("Previous Step was:");
Serial.println(previousStep);
// We want to move to zero again to start once more.
stepper1.setCurrentPosition(previousStep);
stepper1.moveTo(0);
while(stepper1.run())
{
}
// Switch off the motors
digitalWrite(motorPin1,LOW);
digitalWrite(motorPin2,LOW);
digitalWrite(motorPin3,LOW);
digitalWrite(motorPin4,LOW);
if(mode=="STEPPED")
{
modeCase = 0;
}
}//--(end setup )---
void loop() {
switch(modeCase) {
case 0:
if(stepTrigger==HIGH)
{
Serial.println("Button PRESSED!");
Serial.println(stepper1.currentPosition());
// do something different depending on the case:
switch (stepCase) {
case 0:
// ******* STEPPED MODE ******************
stepper1.moveTo(step1);
while(stepper1.run())
{
// We want to read the voltage during every step
// If the voltage drops below a certain amount
// We want to store the voltage and stop the movement of the motor
if(analogRead(voltageMonitor)<=200)
{
// This means the voltage is around 10V on the input
previousStep = stepper1.currentPosition(); // Store the value to EEPROM
// Save this value before all the power fails
EEPROM.write(0, previousStep >> 8); // Do this seperately
EEPROM.write(1, previousStep & 0xff);
// Write it to serial for DEBUG
Serial.println("LOW VOLTAGE");
Serial.println(previousStep);
break;
}
}
Serial.print("Moved to:");
Serial.println(step1);
break;
case 1:
stepper1.moveTo(step2);
while(stepper1.run())
{
Serial.println(stepper1.currentPosition());
// This displays the current position all the time
// We want to read the voltage during every step
// If the voltage drops below a certain amount
// We want to store the voltage and stop the movement of the motor
if(analogRead(voltageMonitor)<=200)
{
// This means the voltage is around 10V on the input
previousStep = stepper1.currentPosition(); // Store the value to EEPROM
// Save this value before all the power fails
EEPROM.write(0, previousStep >> 8); // Do this seperately
EEPROM.write(1, previousStep & 0xff);
// Write it to serial for DEBUG
Serial.println("LOW VOLTAGE");
Serial.println(previousStep);
break;
}
}
Serial.print("Moved to:");
Serial.println(step2);
break;
case 2:
stepper1.moveTo(step3);
while(stepper1.run())
{
Serial.println(stepper1.currentPosition());
// This displays the current position all the time
// We want to read the voltage during every step
// If the voltage drops below a certain amount
// We want to store the voltage and stop the movement of the motor
if(analogRead(voltageMonitor)<=200)
{
// This means the voltage is around 10V on the input
previousStep = stepper1.currentPosition(); // Store the value to EEPROM
// Save this value before all the power fails
EEPROM.write(0, previousStep >> 8); // Do this seperately
EEPROM.write(1, previousStep & 0xff);
// Write it to serial for DEBUG
Serial.println("LOW VOLTAGE");
Serial.println(previousStep);
break;
}
}
Serial.print("Moved to:");
Serial.println(step3);
break;
case 3:
stepper1.moveTo(0);
while(stepper1.run())
{
Serial.println(stepper1.currentPosition());
// This displays the current position all the time
// We want to read the voltage during every step
// If the voltage drops below a certain amount
// We want to store the voltage and stop the movement of the motor
if(analogRead(voltageMonitor)<=200)
{
// This means the voltage is around 10V on the input
previousStep = stepper1.currentPosition(); // Store the value to EEPROM
// Save this value before all the power fails
EEPROM.write(0, previousStep >> 8); // Do this seperately
EEPROM.write(1, previousStep & 0xff);
// Write it to serial for DEBUG
Serial.println("LOW VOLTAGE");
Serial.println(previousStep);
break;
}
}
Serial.print("Moved to:");
Serial.println("0");
break;
}
// Switch off the motors
digitalWrite(motorPin1,LOW);
digitalWrite(motorPin2,LOW);
digitalWrite(motorPin3,LOW);
digitalWrite(motorPin4,LOW);
// Move to the next step
stepCase++;
if(stepCase>=4)
{
stepCase=0; // return to zero
}
}
break;
// ******** END OF STEEPED MODE *********************
}
// ********** SENSOR READS ************************************ //
// This is always within the loop
//***** UltraSonic Distance Sensor **********//
// This sction of code reads the ultrasonic distance sensor delay
for(int i = 0; i<=5; i++)
{
digitalWrite(trigPin, LOW); // Added this line
delayMicroseconds(2); // Added this line
digitalWrite(trigPin, HIGH);
delayMicroseconds(1000); // Added this line
digitalWrite(trigPin, LOW);
duration = pulseIn(echoPin, HIGH);
distance += (duration/2) / 29.1;
delay(2);
}
distance = distance/5; // Averaging
if((distance<=maxDistance&&distance>=minDistance)||digitalRead(SW1)==LOW)
{
stepTrigger = HIGH;
}
else
{
stepTrigger = LOW;
}
Serial.print("Ultrasonic:");
Serial.print(distance);
Serial.println(" cm");
// We want to read the voltage during every step
// If the voltage drops below a certain amount
// We want to store the voltage and stop the movement of the motor
if(analogRead(voltageMonitor)<=200)
{
// This means the voltage is around 10V on the input
previousStep = stepper1.currentPosition(); // Store the value to EEPROM
// Save this value before all the power fails
EEPROM.write(0, previousStep >> 8); // Do this seperately
EEPROM.write(1, previousStep & 0xff);
// Write it to serial for DEBUG
Serial.println("LOW VOLTAGE");
Serial.println(previousStep);
}
}
The prototype has already been shown at an exhibition in Wakefield.