TUTORIAL MOTOR PASO-PASO Y PUENTE H CON ARDUINO

Por: MSC. Ing. Raúl Gómez S.

1. INTRODUCCIÓN

Los motores paso a paso son ideales para la construcción de mecanismos en donde
se requieren movimientos muy precisos.
La característica principal de estos motores es el hecho de poder moverlos un paso a
la vez por cada pulso que se le aplique. Este paso puede variar desde 90° hasta
pequeños movimientos de tan solo 1.8°, es decir, que se necesitarán 4 pasos en el
primer caso (90°) y 200 para el segundo caso (1.8°), para completar un giro
completo de 360°.
Estos motores poseen la habilidad de poder quedar enclavados en una posición o
bien totalmente libres. Si una o más de sus bobinas están energizadas, el motor
estará enclavado en la posición correspondiente y por el contrario quedará
completamente libre si no circula corriente por ninguna de sus bobinas.
En este capítulo trataremos solamente los motores P-P del tipo de imán permanente,
ya que estos son los más usados en robótica.

1.1 PRINCIPIO DE FUNCIONAMIENTO.

Básicamente estos motores están constituidos normalmente por un rotor sobre el que
van aplicados distintos imanes permanentes y por un cierto número de bobinas
excitadoras bobinadas en su estator.

1
 TUTORIAL MOTOR PASO-PASO Y PUENTE H CON ARDUINO

Las bobinas son parte del estator y el rotor es un imán permanente. Toda la
conmutación (o excitación de las bobinas) deber ser externamente manejada por
un controlador.

Existen dos tipos de motores paso a paso de imán permanente:

2
 TUTORIAL MOTOR PASO-PASO Y PUENTE H CON ARDUINO

 Bipolar: Estos tiene generalmente cuatro cables de salida (ver figura 1).
Necesitan ciertos trucos para ser controlados, debido a que requieren del
cambio de dirección del flujo de corriente a través de las bobinas en la
secuencia apropiada para realizar un movimiento. En figura 3 podemos
apreciar un ejemplo de control de estos motores mediante el uso de un
puente en H (H-Bridge). Como se aprecia, será necesario un H-Bridge por
cada bobina del motor, es decir que para controlar un motor Paso a Paso de 4
cables (dos bobinas), necesitaremos usar dos H-Bridges iguales al de la
figura 3 . El circuito de la figura 3 es a modo ilustrativo y no corresponde
con exactitud a un H-Bridge. En general es recomendable el uso de H-
Bridge integrados como son los casos del L293 (ver figura 3 bis).

3
 TUTORIAL MOTOR PASO-PASO Y PUENTE H CON ARDUINO

 Unipolar: Estos motores suelen tener 6 o 5 cables de salida, dependiendo de su

conexionado interno (ver figura 2). Este tipo se caracteriza por ser más simple de
controlar. En la figura 4 podemos apreciar un ejemplo de conexionado para controlar un
motor paso a paso unipolar mediante el uso de un ULN2803, el cual es una array de 8
transistores tipo Darlington capaces de manejar cargas de hasta 500mA. Las entradas de
activación (Activa A, B , C y D) pueden ser directamente activadas por un
microcontrolador.

1.2.SECUENCIAS PARA MANEJAR MOTORES PASO A PASO BIPOLARES

Como se dijo anteriormente, estos motores necesitan la inversión de la corriente que

circula en sus bobinas en una secuencia determinada. Cada inversión de la polaridad
provoca el movimiento del eje en un paso, cuyo sentido de giro está determinado por la
secuencia seguida.
A continuación, se puede ver la tabla con la secuencia necesaria para controlar motores
paso a paso del tipo Bipolares:

4
 TUTORIAL MOTOR PASO-PASO Y PUENTE H CON ARDUINO

1.3 SECUENCIAS PARA MANEJAR MOTORES PASO A PASO UNIPOLARES

Existen tres secuencias posibles para este tipo de motores, las cuales se detallan a
continuación. Todas las secuencias comienzan nuevamente por el paso 1 una vez
alcanzado el paso final (4 u 8). Para revertir el sentido de giro, simplemente se
deben ejecutar las secuencias en modo inverso.

Secuencia Normal: Esta es la secuencia más usada y la que generalmente

recomienda el fabricante. Con esta secuencia el motor avanza un paso por vez y
debido a que siempre hay al menos dos bobinas activadas, se obtiene un alto torque
de paso y de retención.

A continuación se puede apreciar la secuencia animada en modo normal:

5
 TUTORIAL MOTOR PASO-PASO Y PUENTE H CON ARDUINO

Secuencia del tipo wave drive: En esta secuencia se activa solo una bobina a la
vez. En algunos motores esto brinda un funcionamiento más suave. La contrapartida
es que, al estar solo una bobina activada, el torque de paso y retención es menor.

A continuación se puede apreciar la secuencia animada en modo wave drive:

Secuencia del tipo medio paso: En esta secuencia se activan las bobinas de tal
forma de brindar un movimiento igual a la mitad del paso real. Para ello se activan
primero 2 bobinas y luego solo 1 y así sucesivamente. Como vemos en la tabla la
secuencia completa consta de 8 movimientos en lugar de 4.

6
 TUTORIAL MOTOR PASO-PASO Y PUENTE H CON ARDUINO

A continuación se puede apreciar la secuencia animada en modo medio paso:

7
 TUTORIAL MOTOR PASO-PASO Y PUENTE H CON ARDUINO

Como comentario final, cabe destacar que debido a que los motores paso a paso son
dispositivos mecánicos y como tal deben vencer ciertas inercias, el tiempo de duración y la
frecuencia de los pulsos aplicados es un punto muy importante a tener en cuenta. En tal
sentido el motor debe alcanzar el paso antes que la próxima secuencia de pulsos comience.
Si la frecuencia de pulsos es muy elevada, el motor puede reaccionar en alguna de las
siguientes formas:
 Puede que no realice ningún movimiento en absoluto.
 Puede comenzar a vibrar pero sin llegar a girar.
 Puede girar erráticamente.
 puede llegar a girar en sentido opuesto.

Para obtener un arranque suave y preciso, es recomendable comenzar con una frecuencia de
pulso baja y gradualmente ir aumentándola hasta la velocidad deseada sin superar la
máxima tolerada. El giro en reversa debería también ser realizado previamente bajando la
velocidad de giro y luego cambiar el sentido de rotación.

Cuando se trabaja con motores P-P usados o bien nuevos, pero de los cuales no tenemos
hojas de datos. Es posible averiguar la distribución de los cables a los bobinados y el cable
común en un motor de paso unipolar de 5 o 6 cables siguiendo las instrucciones que se
detallan a continuación:

a) Aislando el cable(s) común que va a la fuente de alimentación: Como se aprecia en

las figuras anteriores, en el caso de motores con 6 cables, estos poseen dos cables
comunes, pero generalmente poseen el mismo color, por lo que lo mejor es unirlos antes
de comenzar las pruebas.
Usando un tester para chequear la resistencia entre pares de cables, el cable común será
el único que tenga la mitad del valor de la resistencia entre ella y el resto de los cables.

8
 TUTORIAL MOTOR PASO-PASO Y PUENTE H CON ARDUINO

Esto es debido a que el cable común tiene una bobina entre ella y cualquier otro cable,
mientras que cada uno de los otros cables tienen dos bobinas entre ellos. De ahí la mitad
de la resistencia medida en el cable común.
b) Identificando los cables de las bobinas (A, B, C y D): aplicar un voltaje al cable
común (generalmente 12 volts, pero puede ser más o menos) y manteniendo uno de los
otros cables a masa (GND) mientras vamos poniendo a masa cada uno de los demás
cables de forma alternada y observando los resultados.

El proceso se puede apreciar en el siguiente cuadro:

Identificando los cables en Motores P-P Bipolares:

Para el caso de motores paso a paso bipolares (generalmente de 4 cables de salida), la
identificación es más sencilla. Simplemente tomando un tester en modo ohmetro (para
medir resistencias), podemos hallar los pares de cables que corresponden a cada bobina,
debido a que entre ellos deberá haber continuidad (en realidad una resistencia muy baja).
Luego solo deberemos averiguar la polaridad de la misma, la cual se obtiene fácilmente
probando. Es decir, si conectado de una manera no funciona, simplemente damos vuelta los
9
 TUTORIAL MOTOR PASO-PASO Y PUENTE H CON ARDUINO

cables de una de las bobinas y entonces ya debería funcionar correctamente. Si el sentido de

giro es inverso a lo esperado, simplemente se deben invertir las conexiones de ambas
bobinas y el H-Bridge.

Para recordar
 Un motor de paso con 5 cables es casi seguro de 4 fases y unipolar.
 Un motor de paso con 6 cables también puede ser de 4 fases y unipolar, pero con 2
cables comunes para alimentación. pueden ser del mismo color.
 Un motor de pasos con solo 4 cables es comúnmente bipolar.

1.4 APLICACIONES CON ARDUINO

Arduino con Motores P-P Unipolares (ULN2803C):

Nota: El pin 9 del ULN2803C debe estar conectado a la tierra de la tarjeta de Arduino.
Arduino con Motores P-P Bipolares (módulo L298N):

10
 TUTORIAL MOTOR PASO-PASO Y PUENTE H CON ARDUINO

Arduino con Motores P-P Bipolares (módulo L293C):

Arduino con Motores DC – puente H (módulo L293C):

Arduino con Motores DC – puente H (módulo L298N):

11
 TUTORIAL MOTOR PASO-PASO Y PUENTE H CON ARDUINO

Tabla de verdad válida para los módulos (L298N, L293C), en puente H:

A3 A2 A1 A0 Sentido de giro del motor
0 0 0 1 Giro a la horario motor A
0 0 1 0 Giro a la anti-horario motor A
1 0 0 0 Giro a la horario motor B
0 1 0 0 Giro a la anti-horario motor B
0 0 0 0 Motores A y B apagados

Código en C para Arduino que funcionan con los circuitos anteriores (Usando
arquitectura):

Código en lenguaje C
//---------------------------------------------------------------------
//Definicion de variables
uint8_t m_aux, var;
//---------------------------------------------------------------------

void setup() {

void loop() {

//Configurando los puertos

DDRD=0b000011000;
DDRB=0b000001111;
DDRC=0b000001111;

while(1)
{
//---------Algoritmo de control puente H (Trasistorizado)---------------
/*
PORTD=0b00010000;//apago motor
PORTD=0b00011000;// Enciendo motor y Giro a la izq

delay(1000);
PORTD=0b00000000;//apago motor
delay(1000);

PORTD=0b00000000;//apago motor
PORTD=0b00001000;// Enciendo motor y Giro a la der

delay(1000);
PORTD=0b00000000;//apago motor
delay(1000);
*/
//---------Algoritmo de control puente H (L293C / L298N)-----------------
/*
PORTC=0b00001001; //Giro a la horario motores A y B

delay(1000);
PORTC=0b00000000; // Apago motores
delay(1000);

PORTC=0b00000110; //Giro a la anti-horario motores A y B

delay(1000);
PORTC=0b00000000; // Apago motores
delay(1000);
*/

12
TUTORIAL MOTOR PASO-PASO Y PUENTE H CON ARDUINO

//---------Algoritmo de control PASO-PASO-Unipolar (ULN2803)------------

//Giro anti-horario
/*
PORTB=0b00000000;
delay(10);
PORTB=0b00000001;
delay(10);
PORTB=0b00000010;
delay(10);
PORTB=0b00000100;
delay(10);
PORTB=0b00001000;
delay(10);
*/
//Giro horario
/*
PORTB=0b00000000;
delay(10);
PORTB=0b00001000;
delay(10);
PORTB=0b00000100;
delay(10);
PORTB=0b00000010;
delay(10);
PORTB=0b00000001;
delay(10);
*/

//---------Algoritmo de control PASO-PASO-Bipolar (L293C / L298N)------------

//Giro anti-horario
PORTC=0b00000000;
delay(10);
PORTC=0b00000110;
delay(10);
PORTC=0b00000101;
delay(10);
PORTC=0b00001001;
delay(10);
PORTC=0b00001010;
delay(10);
//Giro horario
/*
PORTC=0b00000000;
delay(10);
PORTC=0b00001010;
delay(10);
PORTC=0b00001001;
delay(10);
PORTC=0b00000101;
delay(10);
PORTC=0b00000110;
delay(10);
*/
//-----------------------------------------------------------------------------------------------------
}
}

13
 TUTORIAL MOTOR PASO-PASO Y PUENTE H CON ARDUINO

Código en C con solo funciones de Arduino:

Código en lenguaje C
//---------------------------------------------------------------------
//Definición de variables
uint8_t m_aux, var;
//---------------------------------------------------------------------

void setup() {
pinMode(4, OUTPUT);//def el pin4 como salida digital
pinMode(3, OUTPUT);//def el pin3 como salida digital
digitalWrite(3, LOW); //Apago motor
}

void loop() {

while(1)
{

//---------Algoritmo de control puente H (Transistorizado)---------------

/*
digitalWrite(4, HIGH); // Giro a la izq
digitalWrite(3, HIGH); // Enciendo motor

delay(1000);
digitalWrite(3, LOW); // Apago motor
delay(1000);

digitalWrite(4, LOW); // Giro a la der

digitalWrite(3, HIGH); // Enciendo motor

delay(1000);
digitalWrite(3, LOW); // Apago motor
delay(1000); */
*/
//-----------------------------------------------------------------------------------------------------
}
}

14