Saltar al contenido

Motor Paso a Paso Arduino

Hola controleros y controleras, bienvenidos a otra entrada del sitio web donde abordaremos como usar un Motor Paso a Paso con Arduino, sea Unipolar o Bipolar, y veremos cómo implementarlo con un ejemplo claro y detallado. En esta entrada tomaremos como ejemplo el motor paso a paso 28BYJ-48 y lo controlaremos a través de un UNL2003, sin embargo, veremos que podremos controlar un motor paso a paso con arduino usando transistores en puente H o 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 motor paso a paso o también conocidos como “stepper motor” es un dispositivo electrónico que permite efectuar un movimiento muy preciso en ángulos pequeños y por pasos en ambas direcciones, por lo tanto este dispositivo es usado en infinidad de procesos de precisión como CNC, 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 bobinas que se organizan en grupos llamados «fases». Al energizar cada fase en secuencia, el motor rotará, un paso a la vez.

Los pasos del motor son controlados por una computadora o un microcontrolador, pudiendo lograr un posicionamiento muy preciso y / o controlar de velocidad del motor paso a paso. Por esta razón, los motores paso a paso son el motor elegido para muchas aplicaciones de control de movimiento de precisión.

Los motores paso a paso vienen en diferentes tamaños y estilos y características eléctricas. Esta guía detalla lo que necesita saber para elegir el motor adecuado para su trabajo.

Nosotros ya habíamos tenido la oportunidad de hablar de los motores paso a paso en nuestro curso 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:

Motores Paso a Paso
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 cuales deben ser energizadas en una secuencia ordenada para poder conseguir el movimiento del motor.

Tipos de Motores Paso a Paso

Pero antes es importante entender que en el mercado existen dos tipos de motores paso a paso los cuales podremos controlar con Arduino.

Bobinas del motor paso 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.

Motores paso a paso

Estos motores de paso pueden ser encontrados en diferentes dispositivos comunes tales como las impresoras y muchas veces puede resultar especialmente utíl poder reconocer cada uno de los terminales del motor, por lo tanto preparé el siguiente video explicándote como reconocer fácilmente las bobinas y los cables de un motor paso a paso para controlarlo posteriormente con un Arduino.

Motor Paso a Paso Unipolar con Arduino

Este es el motor de paso más común, el cual posee dos bobinas en cada uno de los estatores donde cada una de esas bobinas posee un punto común, por lo tanto este motor típicamente posee 5 o 6 cables. Y viendo esta entrada estarás en la capacidad de controlar un motor paso a 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á negativa o positiva según nuestro criterio. La otra punta de la derivación contendrá la polarización contraria. Los motores unipolares se pueden implementar con un simple circuito de transistor. La desventaja es que hay menos torque disponible porque solo la mitad de las bobinas se pueden energizar a la vez.

Motor Paso a Paso Bipolar con Arduino

También posee dos bobinas, con la diferencia que no tienen un punto intermedio común, por lo tanto, es fácil intuir que posee 4 cables. Sin embargo, para conseguir el control de este motor bipolar será necesario efectuar una configuración de 2 puente H usando 8 transistores, o bien usando algú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 flujo de 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 paso 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 vários drivers diseñados para este fin tales como el ULN2003, L298, L296 entre otros, o también podriamos 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és de estos dispositivo mandaremos la secuencia en orden para poder mover el motor paso a paso.

Entonces, para poder controlar un motor paso a paso con Arduino podemos emplear alguna de las siguientes 3 secuencias de pasos descritas a continuación:

Quizas te interese algunos productos de Arduino en Amazon a un mu buen precio.

Secuencia a 1 Fase

Encendemos únicamente una bobina por vez siguiendo la siguiente tabla de verdad.

PasoIn1In2In3In4
1ONOFFOFFOFF
2OFFONOFFOFF
3OFFOFFONOFF
4OFFOFFOFFON
Secuencia a 1 paso

Secuencia a 2 pasos

En esta secuencia encendemos de a 2 bobinas para aumentar el Par del motor

PasoIn1In2In3In4
1ON ON OFFOFF
2OFFONON OFF
3OFFOFFONON
4 ON OFFOFFON
Secuencia a 2 pasos

Secuencia a Medio Paso

Es una combinación de las dos secuencias anteriores donde se enciende 1 bobina intercalada con la activación de 2 bobinas, por lo tanto puede ser aplicado en aplicaciones que requieran de una mayor precisión.

PasoIn1In2In3In4
1ONOFFOFFOFF
2ONONOFFOFF
3OFFONOFFOFF
4 OFFONONOFF
5 OFF OFF ONOFF
6OFFOFFONON
7OFFOFFOFFON
8ONOFFOFFON
Secuencia a medio paso

Invertir giro motor paso a paso

La inversión de giro de un motor paso a paso es sumamente sencilla, para ello solo basta con enviar los pasos mostrados en las tablas anteriores en la dirección contraria, o sea, debemos mirar la tabla de abajo hacia arriba. Si se respeta ese orden en la programación del motor paso a paso con Arduino, conseguiremos invertir el cambio de sentido del motor pap sin ninguna complicación.

Por ejemplo para la secuencia a 1 fase, debemos enviar primero el paso 4, luego el paso 3, luego el 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) con el driver ULN2003 controlado con Arduino. Por lo tanto esta practica consistirá en un motor paso a paso unipolar con Arduino.

El motor 28BYJ-48 es un motor paso a paso Unipolar, por lo tanto no necesita de un complejo sistema de driver para ser controlado por eso haremos uso 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 impulsos por 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 significa que en realidad hay que dar 64 * 63.68395 pasos por 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.

Ejemplo Motor PaP con Arduino UNL2003

Hagamos un ejemplo de un motor paso a paso unipolar arduino.

Crear un programa en arduino usando el driver UNL2003 y el Motor paso a paso 28BYJ-48 que sea capaz de detectar el cambio en 4 pulsadores. Un pulsador servirá para hacer el giro sentido horario, 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.

El esquema es representado a continuación, donde se muestra como conectar un motor paso a paso en Arduino:

Lista de Materiales

  • 1 Arduino
  • 1 Driver UNL2003
  • 1 Motor paso a paso 28BYJ-48
  • 4 Resistencias de 10k
  • 4 Pulsadores

Motor paso 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 comerciales como el L293D y el Driver L298, que internamente poseen configuraciones en Puente H. Por lo que puedes usar exactamente el mismo código, cambiando el 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 Paso a Paso Bipolar con Arduino

El ejemplo anterior también puede ser utilizado con Motores Paso a Paso Bipolares, sin embargo el 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 diferencia del motor paso a paso unipolar, el motor paso a paso bipolar tiene dos conductores por fase, ninguno de los cuales es común.

Sin embargo usando los Drivers que poseen puente H internos como el caso del 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.

Diferencia en la conexión del Motor PaP Unipolar y Bipolar

CONEXION BIPOLAR UNIPOLAR

Motor Paso 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 mencionados o inclusive vamos a conectar un motor paso a paso a Arduino sin usar DRIVER y lo má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:

Motor Paso a Paso UNIPOLAR y BIPOLAR con Arduino

Código Motor Paso a Paso Arduino

Sabes que para bajar el código solo basta con compartir el contenido de este post con cualquiera de los siguientes 3 botones, así ayudas a difundir la información de esta web y que más personas aprendan y conozcan el maravilloso mundo de Arduino.

Si lo deseas Puedes Descargar el Archivo con el Código y con los diagramas de simulación en Proteus 8

//*************************************************************//
//*************************************************************//
//****                                                    *****//
//**** 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, 
                             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);
  }
  //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
    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)
  {
    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;
       }
        delay(vel[Cvel]);                      //Retardo de 100 milisegundos
  
}

Eso es todo por la clase del día de hoy controleros y controleras, espero les haya gustado y hayan aprendido algo nuevo y puedan colocar a rodar sus proyectos con Motores Paso a Paso y Arduino. Si te ha servido esta información podrías invitarme a un café y ayudarme a seguir pagando los servidores. 👉Invitar un Café a SERGIO ☕️

Nos Vemos en una próxima entrada de nuestro curso. Les deseo un excelente día.

Entradas relacionadas

Deja una respuesta

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *

Este sitio usa Akismet para reducir el spam. Aprende cómo se procesan los datos de tus comentarios.

Comentarios (24)

tendra el codigo del motor paso a paso con arduino no supe como descargarlo

Responder

Israel, el código está al final del post, puedes copiarlo y pegarlo en el Arduino IDE, o puedes descargarlo directamente dando click en el botón naranjado que se encuentra justo encima del código. Saludos.

Responder

hola como estas…??? esta genial tu explicación para el paso a paso…!!!
ahora tengo una inquietud si quiero hacer que se mueva a traves de un control IR como tendria que hacer…??? y que el mismo gire a una sola velocidad…???

gracias

Responder

Cómo sería el programa para q con un botón de inicio gire horario después otro botón cambie giro antihorario y otro botón para q se apague

Responder

buenos días,
como se asegura que el motor da el número de pasos programados? no existe un circuito que hace un lazo de control cerrado¿ Tan confiables son los motores de paso en particular este modelo 28BYJ-48? En youtube vi un «control cerrado» sólo con un sensor hall (que me imagino sirve como un paso-por-cero) ¿es eso posible? Saludos y gracias por su canal

Responder

profesor gracias por su enseñanza, a parte de ser muy simple muchos enseñan por youtube solamente, pero la verdad que encima acompañarlo de una pagina web ayuda aun mas…
hice el proyecto y funciona de diez!!

Solo una pregunta, si quisiera que la velocidad cambie luego de presionar el pulsador un tiempo x, y luego vuelva a la primer condicion como se haria??
se lo agradeceria.

Responder

Hola Gabriel, para hacer lo que pretendes que son manejos de tiempo se vuelve un poco más complejo y depende de la experiencia que tengas con Arduino. La forma más simple sería crear una función que vaya realizando el conteo del tiempo pero que a la vez vaya ejecutando el código, porque cuando usamos la función delay es una mala práctica dado que esa función paraliza al arduino. La función que te cuento, puede ser una similar a la vista en la entrada de multiplexación con Arduino. Sin embargo, lo mejor para manejar tiempos con el arduino, es que aprendas a utilizar los timers del mismo, y tenemos una entrada donde explicamos como configurar dichos Timers con Arduino. Saludos y muchos éxitos.

Responder

La programacion del mismo es algo que me tiene limitado, los proyectos que hago siempre suelen ser ensambles de otros proyectos, trabajo con maquinas y me encanta la automatizacion en la industria, como en la casa con la domotica, hice un curso de IOT ( a quien le interesa)
Gracias por sus consejos, estare encarando por donde me dijo.
PD: intentare hasta donde pueda si no lo contratare.
saludos!!!

Responder

hola …gracias a tu website…. tengo peroblema…no puedo hacer programa para 3 motores paso paso ….. puedo conectar los cables y dispositivos ,,,,
intentaba ayudar me con tu website pero no puedo … yo estoy estudiando robotica industrial en spain…. çpodrias ayudar me porfavor…

gracias

Responder

tengo implementado un sistema de dos motores paso a paso 28byj48 con dos drivers ulm2003, todo comandado por un joystick un Ardino «»UNO»», todo funciona correctamente,,,, el tema es que los drivers cuando el joystick esta en la posicion neutral, quedan encendido dos led en cada driver,,y los motores toman algo de temperatura,, me pueden ayudar dado que conozco poco sobre el tema Arduino

Responder

una forma es crear un condicional (IF) dentro de tu código para que cada vez que el jostick este en posición neutra, el Arduino no mande ninguna secuencia por las salidas digitales.

Responder

Mil gracias, por tu ayuda,,,, tratere de ver en algunos programas como puedo crear un if,,,con mis años, esto se me hace dificil,,,, has sido muy amable por tu respuesta

Responder

Hola Sergio, no se si la simulación la has hecho con Tinkercad te lo comento porque no aparece el componente del motor paso a paso junto con el controlador (supongo que lo habrás hecho con otro simulador)

Responder

Hola Miguel Angel, efectivamente, fue simulado con el proteus y el simulino, el tinkercad es muy limitado en sus componentes. En la página principal del curso se muestra como instalar el simulino en proteus, ya debes tratar de buscar en la web el instalador de proteus. Te dejo el link, el video está justo depues de las entradas. https://controlautomaticoeducacion.com/arduino

Responder

gracias a ti pude aprender correctamente el motor paso a paso

Responder

Hola Santiago, me alegra saber eso. Te deseo el mejor de los éxitos!!

Responder

Sergio:
Excelente presentación. Didáctico, concentrado, objetivo e ilustrativo. Felicidades, buen trabajo. Me ha sido de gran utilidad.

Responder

Muchas Gracias Roberto, me alegra que te haya gustado el post y lo más importante, que hayas aprendido. Saludos!!

Responder

muy bueno gracias por compartir todo esto, estoy comenzando en el tema de arduino no me quedó claro las sentencias para los pulsadores , yo quiero hacer solo que gire hacia izquierda o derecha y con el máximo de velocidad de mi motor nema 17. Mi pregunta es cómo modifico el código? para que funcione con 2 pulsadores solamente . gracias

Responder

Hola john, es solo dejar en tu código los IF de los sentidos de GIRO y quitar los otros IF. Colocar el mínimo delay para que vaya a la máxima velocidad. Y debes decidir cual de las 3 secuencias de pasos quieres darle, quizas una de dos pasos de convenga. Saludos.

Responder

el archivo de proteus no lo puedo abrir en proteus 8

Responder

Está hecho en la version Proteus 8.7

Responder

Gracias oo compartir. Excelente información. un favor no tendrás entre tus publicaciones como hacer un menú con submenús en Arduino ??

Responder

Gracias Mario. No tengo eso con Arduino, el curso apenas lo estoy comenzando. Saludos.

Responder