Entendiendo su funcionamiento.

Introducción.

Fig. 1 Motor pap bipolar con 4 hilos.

Este tema está muy descrito y casi todas las webs disponen de un artículo o tutorial que lo abordan, entonces ¿por qué motivo hacer este artículo? El motivo es que cuando uno empieza a realizar ejercicios con códigos que encuentra en las distintas publicaciones, al menos las que yo he podido encontrar y estudiar, todas muy interesantes te indican cómo hacer que el motor gire en una u otra dirección y lo hacen bien. Sin embargo, en contadas ocasiones describen qué hace que el motor de, un paso y quien decide cómo lograrlo. No se si me explico.

Con lo dicho en el párrafo anterior no quiero despreciar a nadie en absoluto su árduo trabajo, nada más lejos de eso. Hace unos años (con los medios de los que disponía) ya hice un artículo que trataba del tema de los motores bipolares con el driver L293 que utilicé en aquel momento.

Los motores pap que podemos encontrar bien sean nuevos o viejos rescatados de impresoras industriales, pueden ser unipolares (6 u 8 hilos) y bipolares (de 4 hilos). Los motores pap son económicos, versátiles y para aplicaciones de automatización y CNC. Los motores bipolares son los más adecuados para nuestras pretensiones. También están los servomotores pero estos por su precio y sus drivers los dejaremos por ahora. Las posibles conexiones de estos motores se pueden ver en la siguiente imagen.

Fig. 2 Conexiones de los motores pap.

Ahora, pretendo enfocar el trabajo de las señales desde otra perspectiva. En principio la señal más determinante es la denominada step (literalmente paso), se trata de una señal cuadrada que suele controlarse por chip y luego inyectada a un puente H, con el que se manejan las bobinas del motor.

Desde mi experiencia, un buen día sin más, ‘tropecé’ con el tema de la velocidad en el motor bipolar, cosa que realmente no tiene una gran relevancia, puesto que la velocidad es de traslación y por tanto es relativa o sea, no es determinante. Pero como digo, no se porqué motivo cambie el valor de la velocidad y ese fue mi primer error, por eso cuando lo puse en marcha (ya hace unos años) el primer ejemplo de control del motor paso a paso me encontré con el movimiento errático del motor que giraba en una sola dirección, eso me hizo pensar que algo no estaba funcionando, pensé que podía tratarse del driver utilizado, un A4988 de Pololu, después de cambiarlo mi sorpresa fue en aumento, el motor seguía girando en una única dirección, sospeche que tal vez la señal DIR no estaba funcionando y dopé el código con indicadores para seguir la evolución de las señales y después de unas horas de pruebas y cambios de programas que por otra parte no registraban cambios significativos que mejoraran los resultados.

Llegué a sospechar del Arduino, lo pensé mejor y entonces acudió a mi mente que la velocidad podía tener que ver con el problema. Recuerdo que el motor giraba en una dirección y cuando tenía que cambiar la dirección producía un primer impulso seguido de una serie de vibraciones, debido al lazo del programa volvía a repetirse el bucle de las direcciones. Así pasaron los hechos.

Para llevar a cabo esta práctica se necesitan unos pocos componentes, vamos a usar un Arduino UNO, un driver A4988 y un motor paso a paso, si se dispone de uno bipolar, mejor en el caso de un motor de 6 hilos, no hay mayor problema se tendrá que averiguar los cables de cada bobinado dejando al aire el cable intermedio de cada bobinado como se ha visto en la imagen anterior.

Fig. 3 Motor unipolar y Driver A4988

El siguiente es uno de los códigos de los programas que estuve probando, lo he llamado NEMA 17 pero eso no importa.

Código del boceto_nema17_1

// boceto_nema17_1.ino
//
//
#define dirPin 3
#define stepPin 9
#define stepsPerRevolution 200void setup() {
// Declare pins as output:
pinMode(stepPin, OUTPUT);
pinMode(dirPin, OUTPUT);
Serial.begin(115200); // solo para ver origen
Serial.println(«\n\ 18/07/2020″);
Serial.println(» boceto_nema17″);
delay(1000);
}void loop() {
// Establecer la dirección de giro hacia la derecha:
digitalWrite(dirPin, HIGH);
// Gire el motor 1 revolución lentamente:
for (int i = 0; i < stepsPerRevolution; i++) {
// These four lines result in 1 step:
digitalWrite(stepPin, HIGH);
delayMicroseconds(3000);
digitalWrite(stepPin, LOW);
delayMicroseconds(3000);
}delay(1000);// Establecer la dirección de giro hacia la izquierda:
digitalWrite(dirPin, LOW);
// Gire el motor 1 revolución rápidamente:
for (int i = 0; i < stepsPerRevolution; i++) {
// These four lines result in 1 step:
digitalWrite(stepPin, HIGH);
delayMicroseconds(2000);
digitalWrite(stepPin, LOW);
delayMicroseconds(2000);
}
delay(1000);
}

Hice consultas en foros y mientras esperaba la respuesta seguía con mis pruebas y errores. Quizas por esas cuatro líneas para dar un paso a que hace referencia el código.

Si la señal step es una señal cuadrada, para que se hace un retardo tan largo delayMicroseconds(2000); me dejé llevar por la lógica, ¿para que necesitaba tanta velocidad el motor? pensé en ir por partes, de manera que empecé por bajar la velocidad. Daría una vuelta en una dirección y después de un lapsus de 1 segundo giraría una vuelta en la otra dirección, lo probé y EUREKA, había encontrado el motivo por el que no giraba mi motor en ambas direcciones, era debido a que se saltaba los pasos por exceso de velocidad. A continuación eliminé el retardo de cada bucle for y lo probe. Ahora el código tenía este aspecto:

Código del boceto_nema17_2.

// boceto_nema17_2.ino
//
//
#define dirPin 3
#define stepPin 9
#define stepsPerRevolution 200void setup() {
// Declare pins as output:
pinMode(stepPin, OUTPUT);
pinMode(dirPin, OUTPUT);
Serial.begin(115200); // solo para ver origen
Serial.println(«\n\ 18/07/2020″);
Serial.println(» boceto_nema17″);
delay(1000);
}void loop() {
// Establecer la dirección de giro hacia la derecha:
digitalWrite(dirPin, HIGH);
// Gire el motor paso a paso 1 revolución lentamente:
for (int i = 0; i < stepsPerRevolution; i++) {
digitalWrite(stepPin, HIGH);
delayMicroseconds(10);
digitalWrite(stepPin, LOW);
delayMicroseconds(10);
}
delay(1000);// Establecer la dirección de giro hacia la izquierda:
digitalWrite(dirPin, LOW);
// Gire el motor paso a paso 1 revolución rápidamente:
for (int i = 0; i < stepsPerRevolution; i++) {
digitalWrite(stepPin, HIGH);
delayMicroseconds(10);
digitalWrite(stepPin, LOW);
delayMicroseconds(10);
}
delay(1000);
}

De manera que hice pruebas bajando la velocidad y llegó un momento en que volvía a perder pasos por una velocidad muy baja observé que a baja velocidad el consumo de corriente es mayor llegando a calentarse el driver, por eso es conveniente utilizar un pequeño ventilador para su refrigeración. Según el motor que estaba probando un NEMA 23 de 2’8A, configuré el A4988 a una Vref de 1’56V y llegué a la conclusión de que por debajo de 1000 (la máxima velocidad) el motor deja de girar, incluso en ambos sentidos. Por contra al aumentar la velocidad sobre 3000 (la velocidad es bastante baja) y considero que se aproxima a la velocidad de trabajo normal. En definitiva, cuanto más bajo es el valor más rápido girara el motor, con 1000 no pierde pasos.

Nota.- El parámetro al que estoy mal llamando velocidad, realmente es el retardo entre un paso y el siguiente, es decir, el delay() en cada bucle de sentido de giro.

Ahora, era cuestión de aumentar los pasos que consideraba necesarios para realizar un trayecto imaginario y así probar que iba a producir los pasos previstos en el programa.

Para corroborar esta experiencia realicé este otro código para comprobar que estaba todo correcto:

Código Prueba_con_A4988.

// Prueba_con_A4988.ino
//#define VELOCIDAD 3000 //cuanto mas bajo mas rápido girara, con 1000 no pierde pasos.
int direccion = 3;
int steps = 9;
int pasos = 200; // a 200 pasos por vuelta 360 grados//la rutina de configuración se ejecuta una vez cuando presiona restablecer:
void setup() {
// initializa el pin digital como una salida (output).
pinMode(steps, OUTPUT);
pinMode(direccion, OUTPUT);
digitalWrite(direccion, HIGH); //Fijamos una direciónSerial.begin(115200); // solo para ver origen
Serial.println(«\n\ 24/07/2020″);
Serial.println(» Prueba con A4988″);
delay(1000);
}// la rutina de bucle se ejecuta una y otra vez para siempre:
void loop() {
digitalWrite(direccion, HIGH);
delay(10); // un retardo para estabilizar la dirección.for (int i = 0; i< pasos; i++) {
//Equivale al numero de vueltas o micropasos (200 son 360º grados)
digitalWrite(steps, HIGH); // Este cambio BAJO a ALTO es lo que crea el pulso.
digitalWrite(steps, LOW); // al A4988 para avanzar un paso por cada pulso.
delayMicroseconds(VELOCIDAD); // Regula la velocidad, cuanto mas bajo mas velocidad.
}
delay(1000);digitalWrite(direccion, LOW);
delay(10);for (int i = 0; i< pasos; i++) {
//Equivale al numero de vueltas o micropasos (200 son 360º grados)
digitalWrite(steps, LOW); // LOW a HIGH hace que el motor avance ya que da la orden
digitalWrite(steps, HIGH); // al A4988 de avanzar una vez por cada pulso.
delayMicroseconds(VELOCIDAD); // Regula la velocidad, cuanto mas bajo mas velocidad.
}
delay(1000);
}

Rescatados de una impresora industrial, dispongo de dos motores idénticos de 1’8º y 1’7A de 6 hilos, como el mostrado, me pueden servir para los ejes X e Y. He configurado la Vref para ambos según la formula Vref = 8 * I * Rs * 0’7, lo que en números es: Vref = 8 * 1’7 * 0’1 * 0’7 = 0’952V. Los he probado con el segundo ejemplo, funcionando ambos bien. También dispongo de un tercer motor de 6 hilos de 1’8º, 1’3A y 3’9V que supongo me servirá para el eje Z.

Fig. 3 Motor pap de 1,7A y 6 hilos

El esquema que he utilizado es bastante explicito, se puede ver a continuación.

Fig. 4 Esquemático.

Así que, antes de terminar veamos una muestra uno de los motores funcionando.

La puesta en marcha de estos motores fue el motivo principal que me hizo plantearme la construcción de una CNC que tantos años llevo esperando poder realizar, pero eso por su envergadura mejor lo dejo para otra ocasión.

Esto es todo, por este simple tutorial.