Utilizaremos nuestra versión económica de Arduino, con un Atmega8 montado en un protoboard, sin otros elementos adiconales, salvo el Array de Darlington y un grupo de 4 LEDs indicadores, con sus resistencias limitadoras de corriente. Estos leds pueden omitirse, aunque resultan muy importantes para visualizar las secuencias de paso. La programación se hará con el entorno de Arduino, quemando el micro luego mediante el programador USBAsp construido en clase.Obviamente todos los programas y conexiones son válidas para las versiones de Arduino y Seeduino compatibles.
El esquema es similar al usado en el ejercicio anterior del Puente H (PuenteH.htm) reemplazando el circuito integrado de aquel por el ULN2803 y modificando las conexiones como se muestra en las imágenes.
Particularmente deben tenerse en cuenta que ahora existirán dos alimentaciones independientes, cuyos polos negativos (masa) deben conectarse en forma común. Una de esas alimentaciones es de 5V, para que funcione la parte lógica y los leds y nosotros la tomaremos del propio programador USBAsp (o del Arduino), es decir, del puerto USB. La otra es la alimentación exclusiva del motor, cuya tensión debe ser adecuada al motor que tengamos (12V en nuestro ejemplo) y se conecta al cable común de las bobinas del motor Paso a Paso y al pin 10 del ULN2803. Más abajo se explica como identificar correctamente los cables del motor usando el Ohmetro.
Este es el esquemático del circuito a realizar:
Y este es el aspecto del circuito montado en un protoboard:
Los motores Paso a Paso de tipo Unipolar pueden presentar 5 o 6 cables. Los motores que tienen 4 cables son de tipo Bipolar y no sirven para este ejemplo.
En nuestro caso, el motor presenta 6 cables. En este caso, los cables centrales de cada bobina se deben conectan juntos, comportándose como si fuera uno de 5. De hecho, el que presenta sólo 5 cables tiene esta conexión ya hecha en forma interna.
Con el uso del Ohmetro resulta fácil identificar qué cables pertenecen a una u otra bobina, siguiendo la siguiente lógica:
Entre dos cables cualesquiera de diferentes bobinas, hay resistencia infinita ya que no están en contacto entre si en modo alguno, si las conexiones centrales no están unidas.
Entre los extremos de una misma bobina hay un cierto valor en Ohms que podemos llamar R
Entre cada uno de esos extremos y la conexión central, la resistencia en ohms será exctamente la mitad de la que hay entre los extremos. Si llamamos r a este valor, tendremos entonces que: r=R/2. Esto sigue siendo válido aún si ambos cables centrales están unidos
El valor de resistencia que hemos medido en el paso anterior entre cada extremo y el centro de cada bobina (r) nos será útil, junto con la tensión nominal (V) indicada por el fabricante, para calcular la corriente (I) que consumirá nuestro motor:
La corriente I será entonces I=V/r
Estando medida la tension en Volts y la resistencia en Ohms, el resultado será directamente la corriente que tomará el motor en cada bobina, medida en amperes. Por ejemplo, si entre cada extremo y el centro hubiera una resistencia de 16 Ohms y la tensión del motor fuera de 12 Volts:
I = 12 V / 16 Ohms = 0,75 amperes = 750 miliamperes
Debe tenerse la precaución de evitar que la corriente resultante supere la máxima corriente que soporta cada rama del integrado ULN2803 (500 o 600 mA). En caso que así sea, tenemos la opción de poner dos o más ramas del integrado en paralelo, o reducir la tensión de alimentación del motor. También depende mucho del régimen de trabajo al que someteremos al conjunto. En régimen contínuo no deberíamos superar los 500 mA.
Arduino ofrece una librería, de nombre Stepper.h, con el propósito de manejar un motor paso a paso. Nosotros la utilizaremos en el segundo ejemplo, por su simplicidad, y para ejemplificar su uso, pero cabe aclarar que muchos alumnos han encontrado problemas en su uso, pricipalmente porque no está adecuadamente documentada, presenta algunos errores y no ofrece la flexibilidad necesaria.
Resulta mucho más didáctico y util manejar por nosotros mismos, directamente desde nuesto programa, las salidas digitales que comandan el motor, obteniendo así el máximo de flexibilidad, sin que esto agregue demasiada complejidad.
La idea al manejar un motor paso a paso Unipolar es ir "encendiendo" y "apagando" las bobinas de a pares, siguiendo una determinada secuencia, como se muestra en la siguiente tabla, extraída de http://www.todorobot.com.ar/informacion/tutorial%20stepper/stepper-tutorial.htm:
| PASO | Bobina A | Bobina B | Bobina C | Bobina D | |
| 1 | ON | ON | OFF | OFF |
 |
| 2 | OFF | ON | ON | OFF |
 |
| 3 | OFF | OFF | ON | ON |
 |
| 4 | ON | OFF | OFF | ON |
 |
Si bien existen otras secuencias posibles, que se pueden consultar en la página citada, la elegida es la sugerida por los fabricantes por ser la que ofrece mayor torque, ya que en todo momento hay dos bobinas activadas, a diferencia de otras secuencias que activan una sola bobina en determinados momentos.
Para Encender o Apagar una bobina, basta con dar valor HIGH o LOW en nuestro programa al pin que se encuentra conectado a la entrada respectiva del ULN2809, siguiendo la tabla. Cuanto más rápida sea velocidad con la que cambiamos las salidas de uno de los estados de la tabla al siguiente, más rápido será el giro del motor.
Si invertimos el orden en que recorremos la tabla (hacia arriba o abajo) invertiremos el sentido del paso y por lo tanto del giro del motor.
En nuestro siguiente ejemplo, en lugar de hacer esto, continuamos con la secuencia de pasos siempre en el mismo orden de la tabla, pero cada vez que queremos invertir el invertir el sentido de giro simplemente intercambiamos la asignación de pines del Arduino en una de las bobinas, lo que es más simple de hacer por software y produce el mismo efecto.
/* Motor_PaP_Secuencia Hace girar un motor PaP unipolar (de 5 o 6 cables) de a un paso por vez, en una secuencia simple, con un delay de temp milisegundos entre cada paso, mediante un array de Darlingtons conectado a los pines digitales 5, 6, 7 y 8 Cada vez que completa una vuelta, se invierte el sentido de giro No se utiliza el potenciómetro conectado
Agosto 2009 - Miguel Grassi Ultima revision: Junio 2010 www.miguelgrassi.com.ar */ int previous = 0; int p1=5; // Declara los 4 pines digitales que usaremos. El orden debe coincidir con la disposición int p2=7; // de los cables en el bobinado de nuestro motor. Las líneas p1 y p3 deben corresponder int p3=6; // a dos extremos de una misma bobina, al igual que p2 y p4. Una vez verificado esto, int p4=8; // si se invierte uno de los pares (1-3 o 2-4)se invertirá el sentido de giro int temp = 100; // Delay entre cada paso int vuelta=200; // Cantidad de pasoa para una vuelta completa int cuenta=0; // Lleva la cuenta de la cantidad de pasos dados void setup() { pinMode(p1,OUTPUT);//Declara como salidas los pines pinMode(p2,OUTPUT); pinMode(p3,OUTPUT); pinMode(p4,OUTPUT); } void loop() { //Posición inicial digitalWrite(p1,HIGH) ; digitalWrite(p2,HIGH) ; digitalWrite(p3,LOW) ; digitalWrite(p4,LOW) ; cuenta++; // incrementa la cuenta de pasos en 1 delay(temp); //primer paso digitalWrite(p1,LOW) ; digitalWrite(p2,HIGH) ; digitalWrite(p3,HIGH) ; digitalWrite(p4,LOW) ; cuenta++; // incrementa la cuenta de pasos en 1 delay(temp); //segundo paso digitalWrite(p1,LOW) ; digitalWrite(p2,LOW) ; digitalWrite(p3,HIGH) ; digitalWrite(p4,HIGH) ; cuenta++; // incrementa la cuenta de pasos en 1 delay(temp); //tercer paso digitalWrite(p1,HIGH) ; digitalWrite(p2,LOW) ; digitalWrite(p3,LOW) ; digitalWrite(p4,HIGH) ; cuenta++; // incrementa la cuenta de pasos en 1 delay(temp); if (cuenta>=vuelta) { // Vuelta completa, invierte el sentido de giro intercambiando p2 y p4 // se podría lograr lo mismo intercambiando p1 con p3 int aux=p2; // variable auxiliar para el intercambio p2=p4; p4=aux; cuenta=0;//vuelve la cuenta de pasos a 0 } }
Este ejemplo hace uso de Stepper.h, adaptado a nuestras conexiones.
/* Motor_PaP_Pote Hace girar un motor PaPC mediante un array de Darlington conectado a los pines digitales 7, 8, 9 y 10 siguiendo la posición de un potenciometro conectado al pin analogico 5 usando la libreria original de Arduino Stepper.h Basado en el ejemplo MotorKnob de Arduino Agosto 2009 - Miguel Grassi Ultima revision: Junio 2010 www.miguelgrassi.com.ar */ #include <Stepper.h> //Número de pasos de nuestro motor #define STEPS 200 // create an instance of the stepper class, specifying // the number of steps of the motor and the pins it's // attached to Stepper stepper(STEPS, 5, 6, 7, 8); // guarda el valor anterior de la lectura analógica (pote) int previous = 0; void setup() { //establece la velocidad de giro del motor en 30 RPMs stepper.setSpeed(30); } void loop() { // lee el valor del pote int val = analogRead(5); // mueve el motor tantos pasos como resulte de dividir por 5 // la diferencia entre la lectura actual y la anterior del pote stepper.step((val - previous)/5); // memoriza la lectura actual como ultima previous = val; }