Motor Paso a Paso con PIC

El motor paso a paso son un tipo especial de motor que permiten el movimiento de su eje en ángulos muy precisos denominados pasos, tanto a la izquierda como a la derecha. Este movimiento se logra a través de una secuencia de pulsos provenientes de un sistema de control. En esta entrada vas a aprender como programar un motor paso a paso por PIC utilizando el lenguaje C y el PIC C Compiler.

Antes de comenzar, puedes suscribirte al canal de YouTube, si deseas seguir aprendiendo sobre programación de sistemas microcontrolados, como por ejemplo el microcontrolador PIC de Microchip.

1. ⚠️ Primero puedes darle un vistazo a nuestro CURSO DE PIC GRATIS
2. ⚠️ Mira como implementar un Motor Paso a Paso con ARDUINO

Motor paso a paso – Funciones y Tipos

Los motores paso a paso son utilizados para generar movimientos precisos, por ejemplo en robots, en equipos con movimientos X-Y, entre otros. Ver mas información de motores paso a paso.

 Existen dos tipos de motor paso a paso:

Motores Unipolares: este tipo de motor tiene dos bobinas en cada uno de los estatores y cada par de bobinas tienen un punto común, es decir, tiene 5 ó 6 terminales.

Motores Bipolares: este tipo de motor tiene dos bobinas y no poseen puntos comunes, es decir tiene cuatro terminales. Para controlar este tipo de motor paso a paso bipolar es necesaria usar 8 transistores o circuitos integrados especiales.

A continuación te dejo algunos motores paso a paso para que hagas tus proyectos. Estos los puedes adquirir de una forma MUY económica por medio del portal chino aliexpress.

También es posible comprar motores directamente en Amazon, bien sea que estemos ubicados en latinoamerica o en españa, estos son los motores más vendidos de esta tienda a un excelente precio:

Control de Motor Paso a Paso PIC C Compiler

Para controlar el motor paso a paso unipolar o bipolar se debe conocer su secuencia y sus terminales, de tal manera que el circuito o el microcontrolador generen la secuencia lógica de cuatro bits que energizan las bobinas del motor en el orden correcto.

Si no sabes cuales son las bobinas del motor paso a paso unipolar, te dejo un video que te enseña a identificar cada bobina y de esta manera poder generar la secuencia que nos permita hacer girar el motor bien sea para la derecha o para la izquierda. La misma secuencia puede ser usada para identificar el motor paso a paso bipolar.

Una vez conseguimos identificar cada bobina del motor, vamos a proceder a darle movimiento con nuestro microcontrolador. Para eso vamos a ver como programar un motor paso a paso en lenguaje c usando el microcontrolador PIC.

Movimiento del Motor Paso a Paso PIC (o cualquier microcontrolador)

Nos encontramos con el primer inconveniente, y es, que el microcontrolador que vayamos a utilizar (en este caso usaremos un PIC) no maneja mucha corriente en sus terminales de salida, por eso, para poder proporcionarle movimiento a nuestro Motor Paso a Paso, vamos a necesitar ayuda de algún circuito externo, que nos proporcione la potencia necesaria para mover el motor.

En el mercado existen drivers que permiten manejar este tipo de motores paso a paso, en nuestro caso, vamos a realizar el movimiento de nuestro motor paso a paso (PaP) con el accionamiento de cuatro transistores los cuales nombraremos (Q1,Q2,Q3,Q4), y su conexión se muestra en el ejemplo.

Para proporcionar el giro en cualquiera de los dos sentidos, debemos respetar una secuencia de activación de los transistores.

Las secuencias más populares son la secuencia a un paso, a dos pasos y a medio paso. A continuación se describen las tres secuencias de la cual puedes seleccionar la que desees:

Secuencia a un paso

Se envían 4 pasos, en cada paso se activa solo una bobina.

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

byte const HORARIO[4] = {  0b1000,
                           0b0100,
                           0b0001,
                           0b1000};
                           
byte const ANTIH[4] ={     0b1000,
                           0b0001,
                           0b0010,
                           0b0100};

Secuencia a dos pasos

Se envían 4 pasos, en cada paso se activa dos bobinas.

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

byte const HORARIO[4] = {  0b1100,
                           0b0110,
                           0b0011,
                           0b1001};
                           
byte const ANTIH[4] ={     0b1001,
                           0b0011,
                           0b0110,
                           0b1100};

Secuencia a medio paso

Se envían 8 pasos, en cada paso se va alternando la activación de una bobina o dos bobinas.

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

byte const HORARIO[8] = { 0b1000,
                          0b1100,
                          0b0100,
                          0b0110,
                          0b0010,
                          0b0011,
                          0b0001,
                          0b1001};
                           
byte const ANTIH[8] ={     0b1001,
                           0b0001,
                           0b0011,
                           0b0010,
                           0b0110,
                           0b0100,
                           0b1100,
                           0b1000};

Como controlar motor paso a paso con PIC

Las señales de los pasos que habilita cada transistor pueden venir desde un circuito integrado o desde el microcontrolador PIC. Un vez el transistor se activa, este hará con que la bobina del motor vaya hacia negativo, permitiendo la circulación de corriente por dicha bobina.

La velocidad del motor paso a paso va depender de la frecuencia con que se envíen los pulsos a cada transistor. Es decir que entre menos tiempo esperamos entre pulso y pulso más rápido será el movimiento del motor. Sin embargo es importante destacar que el motor debe tener la capacidad de girar sin presentar muchas vibraciones, caso esto no suceda, se debe disminuir la velocidad del motor paso a paso.

Por últomo, la secuencia de pasos que hemos visto aquí puede ser programada de una segunda forma usando las instrucciones de rotación que vimos en la entrada de secuencia rítmica de leds. Si no has visto esa entrada, es una excelente oportunidad para que aprendas una instrucción básica pero muy poderosa: Ver 👉  Secuencia de Leds con PIC

Motor Paso a Paso Unipolar por PIC

Se pide controlar un motor paso a paso conectado a los cuatro bits menos significativos del puerto B, de tal manera que si el suiche conectado a RC0 está activo, entonces el motor PaP va a girar a la derecha y si el suiche esta en inactivo, el motor gira a la izquierda.

Realizaremos la simulación del motor paso a paso en proteus y posteriormente realizaremos la implementación práctica.

Este ejemplo puede implementarse por medio de transistores así como vemos en el siguiente circuito:

O también si lo deseamos, podemos usar un integrado puente H, como por ejemplo um L298, utilizando el siguiente circuito:

Para la simulación del motor a pasos en proteus se deben buscar los siguientes componentes: MOTOR-STEPPER (motor unipolar paso a paso), Resistencia de 1k, SWITCH, L298, PIC16F887.

En el siguiente video el circuito implementado:

Codigo de Implementacion en PIC C Compiler:

A continuación se presenta el código para que lo copies y lo pegues en tu compilador y puedas reproducirlo. Recuerda compartir el contenido de este sitio web para que más personas se beneficien de esta información.

#INCLUDE <16f887.h>
#fuses XT,NOPROTECT,NOWDT,NOBROWNOUT,PUT,NOLVP
#use delay(clock=4000000,crystal)//Crystal Externo 4MHz
#byte PORTB=6
#byte PORTC=7
#define SW PORTC,0

INT CONT;
byte const HORARIO[4] = {  0b1100,
                           0b0110,
                           0b0011,
                           0b1001};
                           
byte const ANTIH[4] ={     0b1001,
                           0b0011,
                           0b0110,
                           0b1100};
                           
void main()
{
   SET_TRIS_C(0B11111111);                //Configura el puerto C
   SET_TRIS_B(0B00000000);                //Configura el puerto B
   WHILE(TRUE)
   {
      IF(BIT_TEST(SW))                    // Pregunta si SW esta encendido
      {
         CONT=0;                          //Se pone Cont en cero
         WHILE((CONT&lt;4)&amp;&amp;(BIT_TEST(SW)))  //Mientras que cont sea menor a 4 
                                          //y SW=1(encendido)
         {
            PORTB=(HORARIO[CONT]);        //Envíe al puerto B la información //de
                                          //la tabla de horario
            DELAY_MS(100);                //Retardo de 100 milisegundos
            CONT++;                       //Incremente la variable cont
         }
      }
      ELSE                                //de lo contrario
      {
         CONT=0;                          // la variable cont =0
         WHILE((CONT&lt;4)&amp;&amp;(!BIT_TEST(SW))) //Mientras que cont sea menor a 4 
                                          //y SW=0(apagado)
         {
            PORTB=(ANTIH[CONT]);          //Envíe al puerto B la información de
                                          //la tabla de antihorario
            DELAY_MS(100);                //Retardo de 100 milisegundos
            CONT++;                       //Incremente la variable cont
         }
      }
   }
}

En el ejemplo se uso la lógica a un solo paso:

byte const HORARIO[4] = {  0b1000,
                           0b0100,
                           0b0010,
                           0b0001};
                           
byte const ANTIH[4] ={     0b0001,
                           0b0010,
                           0b0100,
                           0b1000};

Motor Paso a Paso Bipolar por PIC

Este mismo ejemplo, podemos aplicarlo a un MOTOR PASO A PASO BIPOLAR, teniendo en consideración que este tipo de motores poseen dos bobinas y por lo tanto la dirección del giro del motor estará regido por la dirección de flujo de corriente que circule por cada bobina.

Es decir que no se puede energizar una a una cada bobina como lo haciamos en el Unipolar.

En otras palabras, se puede usar el mismo ejemplo visto para el motor unipolar, solo que el circuito para el motor bipolar cambia.

Aquí tenemos dos opciones.

1. Conectar el motor bipolar a dos puente H (Necesitaremos entonces de 8 transistores)
2. Conectar el motor bipolar a un driver o circuito integrado que internamente tiene la configuración de los dos puente H internamente. Como por ejemplo, el integrado L293D ó L298 de la implementación del ejemplo del unipolar.

• Nota 1: Puedes usar una tarjeta controladora de Motor Paso a Paso para controlar la potencia de tus motores

A continuación les mostraré como sería el circuito hecho en proteus, para utilizar EXACTAMENTE el mismo ejemplo, pero en un motor paso a paso BIPOLAR. Considerando que la simulación de este circuito te la dejé para que la descargues arriba donde está el código de implementación.

El componente del motor paso a paso bipolar en proteus se encuentra como MOTOR-BISTEPPER:

Eso es todo por la entrada del dia de hoy, espero les haya gustado y hayan aprendido algo nuevo. Si te ha servido el contenido de esta entrada, de los videos y los códigos de implementación y deseas apoyar mi trabajo invitandome a un café super barato, puedes hacerlo en el siguiente link:

👉 Invitar a Sergio a un Café ☕️

Que esten muy bien, nos vemos en la siguiente entrada.