AccelStepper en Arduino: run(), aceleración, homing y MultiStepper
Intermedio
- 526componentes en el banco de trabajo
- 46placas funcionando ahora
- 1.00xtiempo real, en todas las placas
AccelStepper es la biblioteca de motores a pasos a la que llegan casi todos los proyectos de Arduino, porque acelera y frena el motor, algo que la biblioteca Stepper simple no hace, y lo hace de un paso por llamada, así que el resto del sketch sigue corriendo. En Mokxi viene integrada, con MultiStepper.h a su lado.
El circuito de arriba es un plato giratorio para fotos: una 28BYJ-48 en su placa ULN2003, un Uno y un botón de inicio. Presiona el botón y el plato da una vuelta completa en ocho paradas de 512 medios pasos, arrancando y frenando suavemente en cada una, mientras el monitor serie cuenta las fotos.
Cada número de esta página lo imprimió un sketch ejecutado en el motor de Mokxi, con una 28BYJ-48 o con una NEMA 17 sobre un A4988.
Crea un motor: DRIVER para un A4988, HALF4WIRE para una 28BYJ-48
El constructor indica cómo está conectado el motor. AccelStepper stepper(AccelStepper::DRIVER, 3, 4); es una placa controladora que recibe STEP y DIR, como un A4988 o un DRV8825, con STEP nombrado primero. AccelStepper stepper(AccelStepper::HALF4WIRE, 8, 10, 9, 11); son cuatro pines directos a una placa ULN2003, en medios pasos, y FULL4WIRE son los mismos cuatro pines en pasos completos.
Cada número después de eso está en la unidad que eligió el constructor. Una 28BYJ-48 da una vuelta en 4096 pasos con HALF4WIRE y en 2048 con FULL4WIRE. Una NEMA 17 de 200 pasos da una vuelta en 200 pulsos de STEP en paso completo y en 3200 a 1/16, porque en modo DRIVER un paso de AccelStepper es un pulso y el controlador decide cuánto avanza cada pulso.
El sketch de abajo mueve una 28BYJ-48 un cuarto de vuelta. Imprimió "at 1024 after 3116 ms" y dejó el eje en 90.0 grados.
#include <AccelStepper.h>
// ULN2003 IN1, IN2, IN3, IN4 on pins 8, 9, 10, 11, given as IN1, IN3, IN2, IN4.
AccelStepper motor(AccelStepper::HALF4WIRE, 8, 10, 9, 11);
bool reported = false;
void setup() {
Serial.begin(115200);
motor.setMaxSpeed(800); // steps a second
motor.setAcceleration(400); // steps a second, every second
motor.moveTo(1024); // a quarter turn in half-steps
}
void loop() {
motor.run();
if (!reported && motor.distanceToGo() == 0) {
reported = true;
Serial.print("at ");
Serial.print(motor.currentPosition());
Serial.print(" after ");
Serial.print(millis());
Serial.println(" ms");
}
}Abrir este sketch en el editorSolo el código: el editor coloca la placa y los componentes que puede leer del sketch.
Por qué los pines de la 28BYJ-48 entran como 8, 10, 9, 11
AccelStepper numera sus cuatro pines para un motor sobre dos puentes H, donde los dos primeros pines son una bobina y los dos últimos la otra. Una placa ULN2003 numera sus cuatro bobinas en orden alrededor del motor. Entregar los pines como IN1, IN3, IN2, IN4 es lo que hace que la secuencia de la biblioteca recorra esas bobinas por turnos.
Give it 8, 9, 10, 11 and the same sketch still printed "at 1024 after 3116 ms", but the shaft never left 0 degrees. In that order the sequence switches on opposite coils together, whose pulls cancel, and the field never walks around in one direction, so the rotor is tugged back and forth on the spot. That is the motor that hums and does not move, and the library cannot tell: currentPosition() counts the steps it sent, not the steps the shaft made.
run(), runSpeed() y runToPosition()
run() da como máximo un paso por llamada, cuando toca, y calcula la velocidad del siguiente paso a partir de la aceleración, así que pertenece en loop() sin nada lento a su lado. runSpeed() avanza a la velocidad constante que dio setSpeed(), sin rampa y sin destino. runToPosition() y runToNewPosition() llaman a run() hasta que el motor llega, y nada más se ejecuta hasta que regresan.
Aquí está run() en una NEMA 17 sobre un A4988 en paso completo, con setMaxSpeed(500), setAcceleration(250) y moveTo(1000), imprimiendo el tiempo, la posición y la velocidad cada medio segundo. Imprimió "500 35 133", "1000 132 257", "1500 291 381" y "2000 512 493", el pico, luego "2500 727 369", "3000 880 245" y "3500 971 121", y "at 1000 after 3893 ms". La aritmética dice cuatro segundos: dos para llegar a 500 pasos por segundo a 250 por segundo al cuadrado, recorriendo 500 pasos, y dos para detenerse.
El mismo movimiento con runToNewPosition(1000) imprimió "there after 3889 ms" y el regreso "back after 7779 ms", sin nada en medio, porque loop() nunca se ejecutó. runSpeed() con setSpeed(200) dio 199 pasos en su primer segundo: una velocidad constante desde el primer paso, y sin rampa.
#include <AccelStepper.h>
AccelStepper stepper(AccelStepper::DRIVER, 3, 4); // STEP, DIR
unsigned long lastPrint = 0;
bool reported = false;
void setup() {
Serial.begin(115200);
stepper.setMaxSpeed(500); // steps a second
stepper.setAcceleration(250); // steps a second, every second
stepper.moveTo(1000);
}
void loop() {
stepper.run();
if (millis() - lastPrint >= 500) {
lastPrint += 500;
Serial.print(millis());
Serial.print(" ");
Serial.print(stepper.currentPosition());
Serial.print(" ");
Serial.println((long)stepper.speed());
}
if (!reported && stepper.distanceToGo() == 0) {
reported = true;
Serial.print("at ");
Serial.print(stepper.currentPosition());
Serial.print(" after ");
Serial.print(millis());
Serial.println(" ms");
}
}Abrir este sketch en el editorSolo el código: el editor coloca la placa y los componentes que puede leer del sketch.
setMaxSpeed() y setAcceleration(): por qué importa la rampa
La hoja de datos de la 28BYJ-48 dice que arranca desde el reposo hasta con 600 pasos por segundo y que ya girando aguanta más de 1000, y el modelo de Mokxi tiene ambas cifras.
Así que le pedimos 900 pasos completos por segundo, FULL4WIRE y moveTo(2048), que es una vuelta. Con setAcceleration(500) imprimió "at 2048 after 4054 ms" y el eje dio toda la vuelta. Con setAcceleration(100000), que es no tener rampa alguna, imprimió "at 2048 after 2304 ms" y el eje terminó a 0.8 grados de donde empezó: perdió casi todos los pasos. La biblioteca reportó la misma posición en ambos casos.
Half-steps move the field half as far, and Mokxi’s 28BYJ-48 follows them from rest up to one a millisecond, so HALF4WIRE at 800 steps a second is safe with any ramp. At 1200 half-steps a second with no ramp, a half turn ended 0.9 degrees from the start.
La NEMA 17 de Mokxi sigue hasta 1000 pasos completos por segundo sin importar la aceleración. Una real pierde par al acelerar, algo que Mokxi no modela, así que en un banco de trabajo la rampa importa más.
Un A4988 o un DRV8825: modo DRIVER y el pin de habilitación
En modo DRIVER la biblioteca mantiene STEP en alto durante setMinPulseWidth() microsegundos, 1 por omisión; un DRV8825 necesita 1.9, así que llama a setMinPulseWidth(2). A 1/16 de paso, cada velocidad que era correcta en paso completo hay que multiplicarla por 16.
El pin EN del A4988 es activo en bajo. Entrégalo con setEnablePin(8) y setPinsInverted(false, false, true), y disableOutputs() deja suelto el eje después de un movimiento, lo que mantiene las cosas frescas a costa del par de retención.
Una rutina de homing con un interruptor de fin de carrera
Al encenderse, AccelStepper cree que el motor está en 0. El homing lo corrige: avanza despacio hacia un interruptor hasta que se cierra, llama a setCurrentPosition(0) y cuenta desde ahí.
Mokxi tiene un mecanismo para probarlo: el gabinete del proyecto de la máquina de garra, cuyo pórtico es una NEMA 17 sobre una banda GT2, 0.2 mm por paso completo, con un interruptor de palanca en el extremo de origen que el carro presiona durante el último quinto de milímetro. Pusimos su eje X sobre un A4988 en paso completo y el interruptor en el pin 2 con la resistencia pull-up del pin, y corrimos el sketch de abajo. Con el carro a 120 mm imprimió "switch closed after 601 steps, 3006 ms", luego "at 500, switch 1": a 100 mm y fuera del interruptor otra vez. Desde 60 mm tomó 301 pasos. Con el cable del interruptor desconectado imprimió "homing failed: no switch within 1200 steps" en lugar de empujar el carro contra el extremo para siempre, que es la línea que toda rutina de homing necesita.
The search uses runSpeed(), so it is steady and stops on the step the switch closes, and setCurrentPosition() also zeroes the speed. A printer then backs off and touches the switch again, slower, as the stepper homing project does. If your axis heads away from its switch, flip the sign of the speed.
#include <AccelStepper.h>
const int HOME_PIN = 2; // the switch: COM to GND, NO to pin 2
AccelStepper axis(AccelStepper::DRIVER, 3, 4); // STEP 3, DIR 4
bool home() {
axis.setSpeed(-200); // toward the switch, 200 steps a second
unsigned long start = millis();
while (digitalRead(HOME_PIN) == HIGH) {
axis.runSpeed();
if (axis.currentPosition() < -1200) {
Serial.println("homing failed: no switch within 1200 steps");
return false;
}
}
Serial.print("switch closed after ");
Serial.print(-axis.currentPosition());
Serial.print(" steps, ");
Serial.print(millis() - start);
Serial.println(" ms");
axis.setCurrentPosition(0); // this is zero now
return true;
}
void setup() {
Serial.begin(115200);
pinMode(HOME_PIN, INPUT_PULLUP);
axis.setMaxSpeed(400);
axis.setAcceleration(800);
if (home()) {
axis.runToNewPosition(500); // 100 mm out, at 0.2 mm a step
Serial.print("at ");
Serial.print(axis.currentPosition());
Serial.print(", switch ");
Serial.println(digitalRead(HOME_PIN));
}
}
void loop() {}Abrir este sketch en el editorSolo el código: el editor coloca la placa y los componentes que puede leer del sketch.
MultiStepper: dos motores que llegan juntos
MultiStepper mueve varios AccelStepper para que terminen al mismo tiempo, como necesita un plotter para trazar una línea recta. Encuentra el movimiento que tarda más a su propia velocidad máxima y frena a los demás para coincidir, sin aceleración.
On two NEMA 17s behind two A4988s, both at setMaxSpeed(400), targets of 800 and 200 arrived together and the sketch printed "800 200 2018 ms": two seconds is 800 steps at 400 a second, so the second motor ran at a quarter of that.
#include <AccelStepper.h>
#include <MultiStepper.h>
AccelStepper x(AccelStepper::DRIVER, 3, 4); // STEP, DIR
AccelStepper y(AccelStepper::DRIVER, 5, 6);
MultiStepper both;
void setup() {
Serial.begin(115200);
x.setMaxSpeed(400);
y.setMaxSpeed(400);
both.addStepper(x);
both.addStepper(y);
long targets[2] = {800, 200};
both.moveTo(targets);
unsigned long start = millis();
both.runSpeedToPosition(); // blocks until both are there
Serial.print(x.currentPosition());
Serial.print(" ");
Serial.print(y.currentPosition());
Serial.print(" ");
Serial.print(millis() - start);
Serial.println(" ms");
}
void loop() {}Abrir este sketch en el editorSolo el código: el editor coloca la placa y los componentes que puede leer del sketch.
AccelStepper en un ESP32
En un ESP32 solo cambian los pines y el nivel lógico: un A4988 cuenta como alto un valor de 0.7 de su VDD, 3.5 V con 5 V, algo que un pin de 3.3 V nunca alcanza. Ejecutamos el sketch de abajo en un ESP32-C3, STEP en GPIO 4 y DIR en GPIO 5. Con el VDD del A4988 a 5 V imprimió "done after 1869 ms" y el eje nunca se movió. Con el VDD en el pin de 3.3 V de la placa dio una vuelta. Un DRV8825 lee 2.2 V como alto, así que no necesita ningún cambio.
#include <AccelStepper.h>
// STEP on GPIO 4, DIR on GPIO 5; the A4988's VDD on the board's 3.3 V.
AccelStepper stepper(AccelStepper::DRIVER, 4, 5);
bool reported = false;
void setup() {
Serial.begin(115200);
stepper.setMaxSpeed(400);
stepper.setAcceleration(200);
stepper.moveTo(200); // one turn of a 200-step motor at full step
}
void loop() {
stepper.run();
if (!reported && stepper.distanceToGo() == 0) {
reported = true;
Serial.print("done after ");
Serial.print(millis());
Serial.println(" ms");
}
}Abrir este sketch en el editorSolo el código: el editor coloca la placa y los componentes que puede leer del sketch.
El error que lo hace tartamudear: delay() en loop()
Como run() hace a lo mucho un paso por llamada, cualquier cosa lenta en loop() pone un tope a la velocidad. El movimiento de 1000 pasos de arriba tardó 3893 ms. Con un delay(10) añadido a loop() tardó 10802 ms, porque el motor podía hacer como máximo un paso cada 10 milisegundos, 100 por segundo, sin importar lo que dijera setMaxSpeed(). Mantén loop() corto y cronometra los demás trabajos con millis().
Hay un tope incluso sin nada más en loop(). En un Uno en Mokxi, run() hizo unos 3900 pasos por segundo como máximo, por alto que se pusiera setMaxSpeed(), porque después de cada paso calcula el siguiente intervalo en coma flotante, tres divisiones y un puñado de multiplicaciones, cosa que un Uno hace por software. runSpeed(), que no hace aritmética por paso, hizo 9281 pasos en un segundo con setSpeed(10000). La documentación de la biblioteca original da unos 4000 pasos por segundo para un Uno.
Abre este circuito en el editor. Arduino Uno: un plato giratorio con AccelStepper, cableado como corre en la parte superior de esta página. Cambia un componente o un valor y vuelve a ejecutarlo.
Abrir el circuitoPreguntas
¿AccelStepper viene integrado en Mokxi?
Sí. AccelStepper.h y MultiStepper.h están integrados, escritos a partir de las llamadas y del perfil de velocidad documentados de la biblioteca, así que un sketch que los incluya compila tal cual.
¿Cuál es la diferencia entre run() y runSpeed()?
run() acelera hacia el objetivo que fijó moveTo() y frena para detenerse en él. runSpeed() avanza a la velocidad constante que fijó setSpeed(), sin aceleración y sin objetivo. Ambos hacen a lo mucho un paso por llamada, así que llámalos tan seguido como puedas.
¿Por qué cambia currentPosition() si mi motor no se mueve?
AccelStepper cuenta los pasos que envía, no los pasos que da el eje. En un 28BYJ-48 la causa habitual es el orden de los pines: da los pines como IN1, IN3, IN2, IN4. En una placa driver, revisa EN, el puente de RST a SLP y la alimentación del motor.
¿Cuántos pasos son una vuelta de un 28BYJ-48 en AccelStepper?
4096 con HALF4WIRE y 2048 con FULL4WIRE, usando la caja de engranes de 64 a 1 del datasheet.
Sigue así
Ármalo en la vida real
Abre el editor, cambia un valor y mira cómo cambia el número con él. Nada que instalar y sin necesidad de cuenta.