Controlador de motor paso a paso con Arduino
Un motor paso a paso es un tipo de motor que, en lugar de girar de forma continua en una dirección, permite realizar giros muy pequeños y parar y cambiar de dirección muy rápidamente, sin problemas de inercia. Esto hace muy apropiados a estos motores para montajes en los que se requieran realizar movimientos de precisión. En este artículo voy a mostrar cómo construir un sencillo controlador para manejar uno de estos motores a través de la placa Arduino, junto con un programa de ejemplo escrito en CSharp que permite mover el motor desde el ordenador dónde conectemos la placa.
En este enlace podéis descargar el código fuente y el ejecutable del proyecto StepByStepMotorArduino, escrito con Visual Studio 2013.
El modelo de placa Arduino que he usado es el Arduino MEGA, que proporciona gran cantidad de entradas y salidas, aunque podéis utilizar cualquier otro modelo de placa conectada al ordenador con una conexión USB.
Existen gran cantidad de tipos de motores paso a paso, el que voy a utilizar en este artículo es del tipo unipolar, que es el más fácil de controlar, ya que solo es necesario activar en un orden determinado las diferentes bobinas para que el motor se desplace en la dirección deseada.
El motor que he utilizado es reciclado. Lo he sacado de un disco duro antiguo, de un PC de los que llevaban el procesador 8086 nada menos, pero es similar a otros que se pueden encontrar en las tiendas sin problemas.
El problema en este caso es averiguar cuáles son los cables que polarizan las bobinas y cuál es el cable común. Esto es bastante sencillo, solo es necesario un polímetro para medir la resistencia entre cada par de cables. La resistencia será la misma entre dos terminales de bobinas, pero será la mitad entre uno de estos terminales y el terminal común.
En este caso, tengo un terminal común y cuatro cables que conectan con cada bobina. Para averiguar cuál es el orden en que debemos polarizar estos cables, basta con conectar el terminal común a masa e ir probando a hacer pasar un pulso de corriente por el resto de cables hasta que consigamos cuatro movimientos en la misma dirección seguidos. En el caso de este motor, he utilizado 12V, que es lo más normal en este tipo de motores.
Como el trabajo de control y temporización se realizará todo mediante software, bien en la placa Arduino, bien en el programa del PC, lo único que necesitamos es una serie de interruptores que nos permitan controlar los 12 voltios que necesita el motor con los 5 voltios de las salidas de Arduino. Esta es la placa que he montado:
Cada interruptor está compuesto de un transistor 2N 2222, un diodo BA 158 y una resistencia de 1K, tan sencillo como eso. Este es el esquema de la placa:
En la placa se pueden ver 5 transistores. En este ejemplo solo necesitamos 4, por lo que solo muestro el esquema para esta cantidad, la placa permite también mover motores de 5 terminales, lo único que hay que hacer es añadir otro interruptor al esquema.
Las entradas S1 a S4 las conectaremos a 4 pines de salida de la placa Arduino. Yo he utilizado los pines 22, 24, 26 y 28 de la mía, pero esto es indiferente.
El programa para la placa Arduino es el siguiente:
int pin1 = 22;
int pdir = LOW;
void setup() {
// Initialize pins
for (int ix = 22; ix <=28; ix+=2) {
pinMode(ix, OUTPUT);
digitalWrite(ix, LOW);
}
Serial.begin(9600);
}
void loop() {
if(Serial.available() > 1) {
int val = Serial.read();
int vt = Serial.read();
if (val & 1) { // move in one direction
for (int ip = 0; ip < vt; ip++) {
digitalWrite(pin1, HIGH);
delay(100);
digitalWrite(pin1, LOW);
pin1 += 2;
if (pin1 > 28) {
pin1 = 22;
}
}
}
if (val & 2) { // move in the other direction
for (int ip = 0; ip < vt; ip++) {
digitalWrite(pin1, HIGH);
delay(100);
digitalWrite(pin1, LOW);
pin1 -= 2;
if (pin1 < 22) {
pin1 = 28;
}
}
}
}
}
En el puerto serie escribiremos dos bytes, el primero será para indicar la dirección del movimiento, con el bit 0 a 1 para mover en una dirección y el bit 1 a 1 para mover en la contraria. Los dos bits se pueden pasar a 1, con lo que el motor haría un barrido en una dirección y volvería al punto de partida.
El segundo byte contiene el número de pasos que queremos que avance el motor. Para dar un paso, enviamos un pulso de 100 milisegundos al pin actual y avanzamos al siguiente pin. Tan sencillo como esto.
El programa en que a su vez controla la placa Arduino desde el ordenador también es muy sencillo, tiene un cuadro de texto para indicar el puerto al que está conectada la placa, otro para indicar el número de pasos que queremos avanzar y un botón para cada dirección:
Como el número de pasos solo puede valer entre 1 y 255, pues se trata de un byte, utilizo una función para obtener el valor o utilizar en su defecto el valor 1 en caso de que se escriba un valor incorrecto:
private byte GetSteps()
{
int steps;
if (int.TryParse(txtSteps.Text, out steps))
{
if (steps > 255)
{
steps = 255;
}
if (steps < 1)
{
steps = 1;
}
}
else
{
steps = 1;
}
txtSteps.Text = steps.ToString();
return (byte)steps;
}
En el controlador del evento Click de los botones, se escriben los datos en el puerto serie para pasárselos a la placa Arduino:
SerialPort p = new SerialPort(txtCOM.Text);
p.BaudRate = 9600;
p.Open();
byte[] val = new byte[2] { 1, GetSteps() };
p.Write(val, 0, 2);
p.Close();
Fijaos que la propiedad BaudRate del puerto se establece en 9600 tanto en el programa de la placa Arduino como en el programa del PC.
Si queréis ver el montaje completo donde he utilizado este circuito, podéis seguir este enlace donde explico cómo construir una torreta airsoft robotizada.
