Este documento describe cómo controlar un motor paso a paso con Arduino. Explica que existen dos tipos de motores paso a paso (unipolar y bipolar) y cómo se pueden controlar ambos tipos usando diferentes circuitos como el ULN2003 o L298. También incluye el código de Arduino para implementar la secuencia de pasos y controlar la velocidad y dirección del motor con pulsadores.

1. Motor Pasó a Paso Arduino
Hola controlarosycontrolaras,bienvenidosaotraentrada del sitiowebdonde abordaremos como
usar un Motor Paso a Paso con Arduino, sea Unipolar o Bipolar, y veremos cómo implementarlo
con un ejemploclaroy detallado.En esta entradatomaremoscomo ejemploel motorpaso a paso
28BYJ-48 y lo controlaremos a través de un UNL2003, sin embargo, veremos que podremos
controlar un motor pasoa paso con arduinousando transistoresenpuente H u otro tipo de driver
como el L298.
Antes que nada te dejo la invitación para que veas nuestro Curso Gratis de Arduino.
Motor Paso a Paso con Arduino
Un motorpasoa pasoo tambiénconocidoscomo“steppermotor”esun dispositivoelectrónicoque
permite efectuar un movimiento muy preciso en ángulos pequeños y por pasos en ambas
direcciones,porlotantoeste dispositivoesusadoeninfinidadde procesosde precisióncomoCNC,
impresoras 3D, robots, fotocopiadoras, cortadoras láser entre otros.
Los motores paso a paso son motores de CC que se mueven en pasos discretos. Tienen múltiples
bobinasque se organizanengruposllamados“fases”.Al energizarcadafase ensecuencia,el motor
rotará, un paso a la vez.
Los pasosdel motorsoncontroladosporuna computadoraoun microcontrolador,pudiendolograr
un posicionamientomuyprecisoy/ocontrolarde velocidaddel motorpasoapaso.Porestarazón,
los motorespasoa paso son el motor elegidoparamuchas aplicacionesde control de movimiento
de precisión.

2. Losmotorespasoapasovienenendiferentestamañosyestilosycaracterísticaseléctricas.Estaguía
detalla lo que necesita saber para elegir el motor adecuado para su trabajo.
Nosotrosyahabíamostenidolaoportunidadde hablarde losmotorespasoapasoennuestrocurso
de PIC donde explicamos en detalle su funcionamiento. Ver motor paso a paso con PIC.
Básicamente un motor paso a paso puede ser representado por la siguiente figura:
5. Motores Paso a Paso
Como puede ser observado en la figura anterior y como ya fue mencionado, el motor paso a paso
posee diferentes cables “fases” y es porque internamente dicho motor posee varias bobinas, las
cualesdebenserenergizadasen una secuenciaordenada para poderconseguirel movimientodel
motor.
Tipos de Motores Paso a Paso
Pero antes es importante entender que en el mercadoexisten dos tipos de motor paso a paso los
cuales podremos controlar con Arduino.
Bobinas del motor pasó a paso
A continuación podemos ver un esquema que muestra la configuración de las diferentes
bobinas dentro de un motor paso a paso unipolar y bipolar.
Estos motoresde paso puedenserencontradosendiferentesdispositivoscomunestalescomolas
impresoras y muchas veces puede resultar especialmente útil poder reconocercada uno de los
terminales del motor, por lo tanto preparé el siguiente video explicándote como reconocer
fácilmentelasbobinasyloscablesde unmotorpasoapasopara controlarloposteriormente conun
Arduino.

3. Motor Pasó a Paso Unipolar con Arduino
Este esel motor de pasomás común,el cual posee dosbobinasencadaunode losestatoresdonde
cada una de esasbobinasposee unpuntocomún, por lotanto este motor típicamente posee 5o 6
cables.Yviendoestaentradaestarásenlacapacidadde controlarunmotorpasoa paso de 6 cables
con Arduino y mucho más.
Los motores unipolares, siempre energizan sus fases de la misma forma. La derivación “común”,
siempre seránegativaopositivasegúnnuestrocriterio.Laotrapunta de la derivacióncontendrála
polarización contraria. Los motores unipolares se pueden implementar con un simple circuito de
transistor. La desventaja es que hay menostorque disponible porque solola mitad de las bobinas
se pueden energizar a la vez.
Motor Pasó a Paso Bipolar con Arduino
También posee dos bobinas, con la diferencia que no tienen un punto intermedio común, por lo
tanto,esfácil intuirque posee4cables. Sinembargo,paraconseguirelcontrol deestemotorbipolar
seránecesarioefectuarunaconfiguraciónde 2puente Husando8transistores,obienusandoalgún
driver o integrado especial para poder mandar la secuencia de pasos.
Los motores bipolares necesitan los circuitos de puente H porque es necesario invertir el flujode
corriente a través de las fases. Al energizar las fases alternando la polaridad, todas las bobinas
pueden ponerse a trabajar girando el motor.
Movimiento del Motor pasó a Paso con Arduino o cualquier Microcontrolador
Para conseguir el movimiento de un motor paso a paso con Arduino o cualquier otro
microcontrolador, necesariamente vamos a tener que recurrir a la ayuda de un circuito externo,
debido a que un sistema microcontrolado no cuenta con la corriente suficiente para mover este
dispositivo con carga.
En el mercado existen varios drivers diseñados para este fin tales como el ULN2003, L298, L296
entre otros, o también podríamos pensar en controlar un motor paso a paso con Arduino sin
Driver a través de 4 transistores (unipolar) para activar cada bobina o 8 transistores (bipolar) para
hacer una configuración de 2 Puente H que direccione la corriente dentro del motor.
A travésde estosdispositivosmandaremoslasecuenciaenordenparapodermoverel motorpaso
a paso.
Entonces,para podercontrolarun motor paso a paso con Arduinopodemosemplearalgunade las
siguientes 3 secuencias de pasos descritas a continuación:
Secuenciaa 1 Fase
Encendemosúnicamente unabobinaporvezsiguiendo lasiguientetablade verdad.

4. Paso In1 In2 In3 In4
1 ON OFF OFF OFF
2 OFF ON OFF OFF
3 OFF OFF ON OFF
4 OFF OFF OFF ON
Secuenciaa 2 pasos
En estasecuenciaencendemosde a2 bobinasparaaumentarel Par del motor
Paso In1 In2 In3 In4
1 ON ON OFF OFF
2 OFF ON ON OFF
3 OFF OFF ON ON
4 ON OFF OFF ON

5. Secuenciaa MedioPaso
Es una combinaciónde lasdossecuenciasanterioresdonde se enciende1bobinaintercaladacon
la activaciónde 2 bobinas,porlo tantopuede seraplicadoen aplicacionesque requierande una
mayor precisión.
Paso In1 In2 In3 In4
1 ON OFF OFF OFF
2 ON ON OFF OFF
3 OFF ON OFF OFF
4 OFF ON ON OFF
5 OFF OFF ON OFF
6 OFF OFF ON ON
7 OFF OFF OFF ON
8 ON OFF OFF ON
Invertir giro motor paso a paso
La inversiónde girode unmotorpasoa pasoessumamente sencilla,paraellosolobastaconenviar
lospasosmostradosenlastablasanterioresenladireccióncontraria,osea,debemosmirarlatabla
de abajohaciaarriba.Si se respetaeseordenenlaprogramacióndelmotorpasoapasoconArduino,
conseguiremos invertir el cambio de sentido del motor pap sin ninguna complicación.
Por ejemploparalasecuenciaa1 fase,debemosenviarprimeroel paso4, luegoel paso3, luegoel
paso 2 y finalmente el paso 1.
Usando un Motor Paso a Paso 28BYJ-48 con ULN2003 y Arduino
Para esta práctica del Motor paso a paso con Arduino vamos a usar el popular motor 28BYJ-48
(datasheet) conel driverULN2003 controladocon Arduino.Porlo tanto esta práctica consistiráen
un motor paso a paso unipolar con Arduino.

6. El motor 28BYJ-48 es un motor paso a paso Unipolar, por lo tanto no necesita de un complejo
sistemade driverpara ser controladopor eso haremosuso del ULN2003 el cual es una agrupación
de 7 darlingtons que sirven para proporcionarle la corriente necesaria al motor para moverse.
Según el datasheet, cuando el motor 28BYJ-48 funciona con una secuencia a medio paso,
cada medio paso corresponde a una rotación de 5.625 °. Eso significa que hay 64 impulsospor
revolución (360 ° / 5.625 ° = 64).
Además, el motor posee una reducción de 1/64. (En realidad es 1 / 63.68395 pero a hacer un
redondeo para 1/64 que es una buena aproximación)
Esto significaque enrealidadhayque dar 64 * 63.68395 pasospor revolución=4,075.7728 ~ 4076
pasos por vuelta.
El motor 28BYJ-48 es más un motor de precisión que de velocidad. La velocidad máxima para un
motor paso a paso 28BYJ-48 es aproximadamente 10-15 rpm a 5 V.
EjemploMotor PaP con ArduinoUNL2003
Hagamos un ejemplo de un motor paso a paso unipolar arduino.
Crear un programa en arduinousando el driver UNL2003 y el Motor paso a paso28BYJ-48 que sea
capaz de detectarel cambioen4 pulsadores.Unpulsadorserviráparahacerel girosentidohorario,
otro pulsador hará el giro anti horario, otro pulsador cambiará la secuencia de pasos para 1, 2 o
medio paso y el ultimo pulsador modificará la velocidad del motor.

7. El esquemaesrepresentadoacontinuación,dondese muestracomoconectarunmotorpasoapaso
en Arduino:
Lista de Materiales
 1 Arduino
 1 Driver UNL2003
 1 Motor paso a paso 28BYJ-48
 4 Resistencias de 10k
 4 Pulsadores
Motor pasó a paso arduino L293D y L298 Unipolar
Note que el ejemplo anterior del Motor Paso a Paso con Arduino Unipolar también puede ser
implementado con drivers comercialescomo el L293D y el Driver L298, que internamente poseen

8. configuracionesenPuente H.Por lo que puedesusar exactamente el mismocódigo,cambiandoel
driver que tengas en tu poder.
También puede implementarse el control del motor paso a paso con arduino sin driver utilizando
para ello un arreglo de 4 transistores que activen cada una de las bobinas del motor UNIPOLAR.
Motor Pasó a Paso Bipolar con Arduino
El ejemploanteriortambiénpuedeserutilizadoconMotoresPasoa Paso Bipolares,sinembargoel
control de este tipo de motor puede resultar un poco más complejo, en el caso que se quiera
implementar con un arreglo de 8 transistores para hacer 2 puente H.
A diferenciadelmotorpasoapasounipolar,elmotorpasoapasobipolartienedosconductorespor
fase, ninguno de los cuales es común.
SinembargousandolosDriversque poseenpuente Hinternoscomoel casodel L293D o el L298, es
sumamente fácil poner a trabajar nuestros motores BIPOLARES, es más, puede
emplearse EXACTAMENTE EL MISMO programa hecho para el motor UNIPOLAR, haciendo las
conexiones correctas.
Diferenciaenla conexióndel Motor PaP Unipolary Bipolar
Motor Pasó a Paso UNIPOLAR y BIPOLAR con Arduino
A continuación se muestra el esquema electrónico del ejemplo, que muestra la conexión para
motores paso a paso unipolares y bipolares usando cualquiera de los drivers anteriormente
mencionadosoinclusivevamosaconectarunmotorpasoapasoa ArduinosinusarDRIVERylomás
importante es que todos los esquemas usan el MISMO CÓDIGO DE PROGRAMACIÓN DEL
ARDUINO.
Inicialmente veamos el esquema del motor paso a paso en proteus:

9. CódigoMotor Paso a Paso Arduino
Sabesque para bajar el códigosolobastacon compartir el contenidode este postconcualquiera
de lossiguientes3botones,asíayudasa difundirlainformaciónde estawebyque máspersonas
aprendany conozcan el maravillosomundode Arduino.
Si lo deseasPuedesDescargarel Archivoconel Códigoyconlos diagramasde simulaciónen
Proteus8

10. //*************************************************************//
//*************************************************************//
//**** *****//
//**** MOTOR PASO A PASO CON ARDUINO *****//
//**** *****//
//**** By: SERGIO ANDRES CASTAÑO GIRALDO *****//
//**** https://controlautomaticoeducacion.com/ *****//
//**** RIO DE JANEIRO - BRASIL - 2018 *****//
//**** *****//
//*************************************************************//
//*************************************************************//
//Declaración de los PULSADORES
byte PHorario = 2; //Pulsador sentido horario
byte PAntiHorario = 3; //Pulsador sentido anti horario
byte PPasos = 4; //Pulsador numero de pasos
byte PVel = 5; //Pulsador velocidad
//Declaración de los PINES del Driver
byte IN1=8; // 28BYJ48 In1
byte IN2=9; // 28BYJ48 In2
byte IN3=10; // 28BYJ48 In3
byte IN4=11; // 28BYJ48 In4
int horario=1;
//*** Crear Matriz con los Pasos del Motor ***//
int paso=4; //Variable que indica el numero de pasos de las matrices
int Cpaso=0; //Contador de pasos
int vel[5]={5,10,30,100,500}; //Vector de velocidad
int Cvel=0; //Contador de Velocidad
int conf=1; //Variable que configura la secuencia de pasos
//secuencia 1 paso
const int UnPaso[4] = { B1000,

11. B0100,
B0010,
B0001 };
//secuencia 2 pasos
const int DosPasos[4] = { B1100,
B0110,
B0011,
B1001 };
// Secuencia a medio paso
byte const MedioPaso[8] = { B1000,
B1100,
B0100,
B0110,
B0010,
B0011,
B0001,
B1001 };
//Función que coloca en el puerto de salida los bits comenzando
// desde el pin ini hasta el pin fin
void puerto(int bits,int ini,int fin){
for(int i=ini;i<=fin;i++)
{
digitalWrite(i,bitRead(bits,i-ini));
}
}
void setup() {
//Configura los 4 Pines de Pulsadores como ENTRADAS
for(int i=2;i<=5;i++){
pinMode(i,INPUT);
}

12. //Configura los 4 Pines digitales como SALIDAS
for(int i=IN1;i<=IN4;i++){
pinMode(i,OUTPUT);
}
}
void loop() {
//***********************************************************************
*******//
//*********** Pregunta por los Pulsadores
*********************************//
//***********************************************************************
*******//
// Giro en Sentido Horario
if(digitalRead(PHorario)) // Pregunta si pulsador horario fue presionado
{
delay(100); //Anti-Rebote
horario=1;
Cpaso=-1;
}
// Giro en Sentido Anti-Horario
if(digitalRead(PAntiHorario)) // Pregunta si pulsador horario fue
presionado
{
delay(100); //Anti-Rebote
horario=0;
Cpaso=paso;
}
// Cambio de la secuencia de pasos
if(digitalRead(PPasos)) // Pregunta si pulsador horario fue presionado
{
delay(100); //Anti-Rebote

13. while(digitalRead(PPasos)); //Espera hasta soltar el boton
delay(100); //Anti-Rebote
conf++;
//Si ya paso por las 3 configuraciones reinicie
if(conf>3)
conf=1;
if(horario==1)
Cpaso=-1;
else
Cpaso=paso;
puerto(B0000,IN1,IN4);
}
// Velocidad del Motor
if(digitalRead(PVel)) // Pregunta si pulsador horario fue presionado
{
delay(100); //Anti-Rebote
while(digitalRead(PVel)); //Espera hasta soltar el boton
delay(100); //Anti-Rebote
Cvel++;
//Si ya paso por las 5 velocidades reinicie
if(Cvel>4)
Cvel=0;
}
//***********************************************************************
*******//
//*********** Logica de los contadores
*********************************//
//***********************************************************************
*******//
if(horario==1)
{

14. Cpaso++; //Incremente la variable cont
if(Cpaso>=paso)
Cpaso=0; //Se pone Contador de pasos en cero
}
else{
Cpaso--; //Decremente la variable cont
if(Cpaso<0)
Cpaso=paso-1; //Se pone Contador igual al paso
}
//***********************************************************************
*******//
//*********** Secuencia de Movimiento del Motor
***************************//
//***********************************************************************
*******//
switch(conf){
case 1:
puerto(UnPaso[Cpaso],IN1,IN4); //Envíe al puerto la información de la
tabla
paso=4;
break;
case 2:
puerto(DosPasos[Cpaso],IN1,IN4); //Envíe al puerto la información de la
tabla
paso=4;
break;
case 3:
puerto(MedioPaso[Cpaso],IN1,IN4); //Envíe al puerto la información de la
tabla
paso=8;
break;
}

15. delay(vel[Cvel]); //Retardo de 100 milisegundos
}