Del campo magnético al movimiento: motores paso a paso

¿Qué es un motor eléctrico y qué es un motor paso a paso?

Un motor eléctrico es un dispositivo que convierte energía eléctrica en movimiento mecánico. Internamente, están compuestos por un rotor, la parte que se encarga de girar, y un estator, la parte fija que se encarga de hacer girar el rotor. 

Un motor paso a paso es un tipo de motor eléctrico que convierte impulsos eléctricos en movimientos rotacionales muy precisos. A diferencia de los motores comunes, no gira libremente al encenderse, sino que avanza en pequeños pasos angulares, como si fuera siguiendo una cuadrícula.

Esto permite un control fino del movimiento sin necesidad de sensores de posición, ideal para aplicaciones donde la precisión lo es todo.

¿Cómo funciona internamente un motor paso a paso?

Antes de poder responder la pregunta “¿cómo funciona un motor paso a paso?”, primero debemos preguntarnos “¿cómo funciona una bobina?”. ¿Por qué? Porque un motor paso a paso está compuesto por un conjunto de bobinas dispuestas de forma tal que, al ser energizadas en un cierto orden, producen un movimiento rotacional controlado del rotor.

Entonces, ¿qué es una bobina? Una bobina o inductor es un componente eléctrico pasivo que almacena energía en forma de campo magnético cuando es atravesada por una corriente eléctrica. Una bobina está compuesta por un alambre conductor enrollado en forma de espiral aislado para evitar cortocircuitos entre las vueltas. Cuando la corriente fluye a través del conductor, se genera un campo magnético alrededor. Este fenómeno se conoce como principio de inducción electromagnética, descubierto por Micheal Faraday, que establece que un campo magnético variable puede crear una fuerza electromotriz.

Entonces, ¿cómo se relacionan las bobinas con los motores paso a paso? Como ya se mencionó anteriormente, el motor paso a paso está compuesto por bobinas y un rotor. Imaginemos que hay varias bobinas dispuestas alrededor de un rotor dentado o con imanes. Si se energizan las bobinas en un orden específico, el campo magnético se va “desplazando”, y el rotor va siguiendo ese campo, girando en pequeños pasos.

Cada vez que energizamos una bobina distinta, el rotor se mueve una cierta cantidad de grados. ¡Así logramos el movimiento controlado!

Existen tres tipos de motores paso a paso, se clasifican según su tipo de rotor:

• de Imán permanente: El rotor es un imán permanente, son muy comunes y precisos.
• de reluctancia variable: El rotor es de hierro dentado, sin imanes, que se alinea con los campos magnéticos generados por las bobinas. Es más simple y barato, pero menos preciso.
• híbrido: Combina imanes permanentes y un rotor dentado, es muy preciso y tiene mucha fuerza y es muy usado en impresoras 3D

A su vez, los motores de imán permanente se dividen en unipolares y bipolares. 

Motores Unipolares

El motor unipolar está compuesto por cuatro bobinas o dos bobinas con derivación central (es decir, que cada bobina se divide en dos mitades). Los unipolares utilizan un cable común para cada bobina, permitiendo que la corriente fluya en una sola dirección a través de cada bobina. Se caracterizan por ser más simples de controlar.

Secuencias de control para motores unipolares

Para que el motor gire, debemos energizar las bobinas en cierto orden. Existen dos modos principales:

• Paso completo: activa una bobina a la vez (menos torque, menos precisión). Generalmente, un paso del motor equivale a 1.8 grados de rotación, es decir, para dar una vuelta completa, el motor debe hacer 200 pasos.
• Medio paso: activa una y luego dos bobinas al mismo tiempo, alternadamente (más suave, mejor resolución).

También existe el microstepping, donde se modula la corriente para lograr movimientos aún más finos (ideal para servocontroladores modernos).

Secuencia de paso completo

Secuencia de medio paso

Motores bipolares

Tiene dos bobinas polarizadas que no están conectadas entre sí. Para invertir la dirección de giro del motor hay que invertir el sentido de la corriente por las bobinas.

Secuencias de control para motores Bipolares

Secuencia de paso completo

Secuencia de medio paso

¿Cómo controlar un motor paso a paso con Arduino?

En este ejemplo usaremos un motor 28BYJ-48 unipolar junto al driver ULN2003. Este driver tiene 7 transistores Darlington que permiten controlar las bobinas del motor desde las salidas del Arduino. Además, tiene 4 leds para indicar qué bobina se está activando, una entrada de alimentación y una bornera para conectar el motor.

Conexiones

• IN1 → Pin 8 de Arduino
• IN2 → Pin 9
• IN3 → Pin 10
• IN4 → Pin 11
• VCC y GND → alimentación (5V y masa)

Código sin librería “Stepper”

Para hacer que un motor paso a paso gire, simplemente hay que seguir alguna de las secuencias (de paso o medio paso) y energizar las bobinas en el orden específico. 

int delayTime = 15; // Variable que almacena el tiempo de espera entre pasos. Cambia el valor de esta variable para aumentar o disminuir la velocidad del motor
void setup() { // Código de inicialización, se ejecuta una sola vez
    // Declara los pines 8, 9, 10 y 11 como salidas
    pinMode(8, OUTPUT);
    pinMode(9, OUTPUT);
    pinMode(10, OUTPUT);
    pinMode(11, OUTPUT);
}

void loop() { // Código en bucle, se ejecuta todo el tiempo
    // Primer paso: se energiza la primera bobina y se apagan las demás bobinas
    digitalWrite(8, HIGH);
    digitalWrite(9, LOW);
    digitalWrite(10, LOW);
    digitalWrite(11, LOW);
    delay(delayTime);
    // Segundo paso: se energiza la segunda bobina y se apagan las demás bobinas
    digitalWrite(8, LOW);
    digitalWrite(9, HIGH);
    digitalWrite(10, LOW);
    digitalWrite(11, LOW);
    delay(delayTime);
    // Tercer paso: se energiza la tercera bobina y se apagan las demás bobinas
    digitalWrite(8, LOW);
    digitalWrite(9, LOW);
    digitalWrite(10, HIGH);
    digitalWrite(11, LOW);
    delay(delayTime);
    // Cuarto paso: se energiza la cuarta bobina y se apagan las demás bobinas
    digitalWrite(8, LOW);
    digitalWrite(9, LOW);
    digitalWrite(10, LOW);
    digitalWrite(11, HIGH);
    delay(delayTime);
}

Código con librería “Stepper”

#include 

const int stepsPerRevolution = 200;
Stepper myStepper(stepsPerRevolution, 8, 9, 10, 11);
int delayTime = 15;
void setup() {
}

void loop() {
  myStepper.step(1);
  delay(delayTime);
}