Aprender

AccelStepper no Arduino: run(), aceleração, homing e MultiStepper

Intermediário

Ou veja todas as aulas.

  • 526componentes na bancada
  • 46placas rodando agora
  • 1.00xtempo real, em todas as placas
Arduino Uno: um turntable com AccelStepperao vivo0.000 s 0.00x
Aperte o botão
Aperte o botão. O AccelStepper gira o 28BYJ-48 um oitavo de volta por vez, 512 meio-passos por parada, com uma rampa em cada extremo.

O AccelStepper é a biblioteca de motores de passo na qual a maioria dos projetos de Arduino acaba, porque ele acelera o motor e o desacelera, algo que a biblioteca Stepper comum não faz, e faz isso um passo por chamada, então o resto do sketch continua rodando. No Mokxi ela já vem incluída, com MultiStepper.h ao lado.

O circuito acima é um turntable de fotos: um 28BYJ-48 na sua placa ULN2003, um Uno e um botão de partida. Aperte o botão e o prato dá uma volta completa em oito paradas de 512 meio-passos, acelerando e desacelerando em cada uma, enquanto o monitor serial conta as fotos.

Todos os números desta página foram impressos por um sketch rodado no motor do Mokxi, num 28BYJ-48 ou num NEMA 17 atrás de um A4988.

Crie um motor: DRIVER para um A4988, HALF4WIRE para um 28BYJ-48

O construtor diz como o motor está ligado. AccelStepper stepper(AccelStepper::DRIVER, 3, 4); é uma placa driver que recebe STEP e DIR, como um A4988 ou um DRV8825, com STEP em primeiro. AccelStepper stepper(AccelStepper::HALF4WIRE, 8, 10, 9, 11); são quatro pinos direto numa placa ULN2003, em meio-passos, e FULL4WIRE são os mesmos quatro pinos em passos completos.

Todos os números depois disso ficam na unidade que o construtor escolheu. Um 28BYJ-48 dá uma volta em 4096 passos com HALF4WIRE e em 2048 com FULL4WIRE. Um NEMA 17 de 200 passos dá uma volta em 200 pulsos de STEP em passo completo e em 3200 em 1/16, porque no modo DRIVER um passo do AccelStepper é um pulso e o driver decide quão longe cada pulso vai.

O sketch abaixo move um 28BYJ-48 um quarto de volta. Ele imprimiu "at 1024 after 3116 ms" e deixou o eixo a 90.0 graus.

Um 28BYJ-48 em HALF4WIRE, um quarto de volta
#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 no editorSó o código: o editor posiciona a placa e os componentes que ele consegue ler do sketch.

Por que os pinos do 28BYJ-48 entram como 8, 10, 9, 11

O AccelStepper numera seus quatro pinos para um motor em duas pontes H, onde os dois primeiros pinos são uma bobina e os dois últimos a outra. Uma placa ULN2003 numera suas quatro bobinas em ordem ao redor do motor. Passar os pinos como IN1, IN3, IN2, IN4 é o que faz a sequência da biblioteca percorrer essas bobinas em ordem.

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() e runToPosition()

run() dá no máximo um passo por chamada, quando um passo é devido, e calcula a velocidade do próximo passo a partir da aceleração, então ele pertence ao loop() sem nada lento ao lado. runSpeed() avança na velocidade constante que setSpeed() definiu, sem rampa e sem alvo. runToPosition() e runToNewPosition() chamam run() até o motor chegar, e nada mais roda até eles retornarem.

Aqui está run() num NEMA 17 atrás de um A4988 em passo completo, com setMaxSpeed(500), setAcceleration(250) e moveTo(1000), imprimindo o tempo, a posição e a velocidade a cada meio segundo. Ele imprimiu "500 35 133", "1000 132 257", "1500 291 381" e "2000 512 493", o pico, depois "2500 727 369", "3000 880 245" e "3500 971 121", e "at 1000 after 3893 ms". A aritmética diz quatro segundos: dois para chegar a 500 passos por segundo a 250 por segundo ao quadrado, cobrindo 500 passos, e dois para parar.

O mesmo movimento com runToNewPosition(1000) imprimiu "there after 3889 ms" e a volta "back after 7779 ms", sem nada no meio, porque o loop() nunca rodou. runSpeed() com setSpeed(200) fez 199 passos no primeiro segundo: velocidade constante desde o primeiro passo, sem rampa.

run() num A4988, imprimindo a 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 no editorSó o código: o editor posiciona a placa e os componentes que ele consegue ler do sketch.

setMaxSpeed() e setAcceleration(): por que a rampa importa

O datasheet do 28BYJ-48 diz que ele parte do repouso com até 600 passos por segundo e acompanha mais de 1000 quando já está girando, e o modelo do Mokxi tem os dois valores.

Então pedimos a ele 900 passos completos por segundo, FULL4WIRE e moveTo(2048), o que é uma volta. Com setAcceleration(500) ele imprimiu "at 2048 after 4054 ms" e o eixo deu a volta completa. Com setAcceleration(100000), que é nenhuma rampa, ele imprimiu "at 2048 after 2304 ms" e o eixo terminou a 0.8 graus de onde começou: perdeu quase todos os passos. A biblioteca informou a mesma posição nas duas vezes.

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.

O NEMA 17 do Mokxi acompanha até 1000 passos completos por segundo, seja qual for a aceleração. Um real perde torque conforme acelera, o que o Mokxi não modela, então numa bancada a rampa importa mais.

Um A4988 ou um DRV8825: modo DRIVER e o pino de enable

No modo DRIVER a biblioteca mantém STEP em alto por setMinPulseWidth() microssegundos, 1 por padrão; um DRV8825 precisa de 1.9, então chame setMinPulseWidth(2). Em 1/16 de passo, toda velocidade que estava certa em passo completo precisa ser multiplicada por 16.

O pino EN do A4988 é ativo em nível baixo. Passe-o com setEnablePin(8) e setPinsInverted(false, false, true), e disableOutputs() solta o eixo depois de um movimento, o que mantém tudo mais fresco ao custo do torque de manutenção.

Uma rotina de homing com um chapeamento de fim de curso

Na ligação, o AccelStepper acredita que o motor está em 0. O homing resolve isso: avance devagar até um interruptor fechar, chame setCurrentPosition(0) e conte a partir daí.

O Mokxi tem um mecanismo para experimentar: o gabinete do projeto da garra de fliperama, cujo pórtico é um NEMA 17 numa correia GT2, 0.2 mm por passo completo, com um interruptor de alavanca na ponta de origem que o carrinho aperta no último quinto de milímetro. Colocamos o eixo X dele num A4988 em passo completo e o interruptor no pino 2 com o pull-up do pino, e rodamos o sketch abaixo. Com o carrinho a 120 mm ele imprimiu "switch closed after 601 steps, 3006 ms", depois "at 500, switch 1": a 100 mm e fora do interruptor de novo. De 60 mm levou 301 passos. Com o fio do interruptor removido ele imprimiu "homing failed: no switch within 1200 steps" em vez de empurrar o carrinho contra o fim para sempre, que é a linha que toda rotina de homing precisa.

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.

Fazendo o homing de um eixo contra uma chave
#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 no editorSó o código: o editor posiciona a placa e os componentes que ele consegue ler do sketch.

MultiStepper: dois motores que chegam juntos

O MultiStepper move vários AccelSteppers para que terminem no mesmo momento, como um plotter precisa para uma linha reta. Ele encontra o movimento que leva mais tempo na sua própria velocidade máxima e desacelera os outros para igualar, sem aceleração.

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.

MultiStepper with two A4988s
#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 no editorSó o código: o editor posiciona a placa e os componentes que ele consegue ler do sketch.

AccelStepper em um ESP32

Em um ESP32 só mudam os pinos e o nível lógico: um A4988 considera alto a partir de 0,7 do seu VDD, 3,5 V em 5 V, o que um pino de 3,3 V nunca alcança. Rodamos o sketch abaixo em um ESP32-C3, STEP no GPIO 4 e DIR no GPIO 5. Com o VDD do A4988 em 5 V ele imprimiu "done after 1869 ms" e o eixo não se moveu. Com o VDD no pino de 3,3 V da placa ele girou uma vez. Um DRV8825 interpreta 2,2 V como alto, então não precisa de mudança.

AccelStepper em um ESP32-C3 e um A4988
#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 no editorSó o código: o editor posiciona a placa e os componentes que ele consegue ler do sketch.

O erro que faz ele engasgar: delay() no loop()

Como run() dá no máximo um passo por chamada, qualquer coisa lenta em loop() limita a velocidade. O movimento de 1000 passos acima levou 3893 ms. Com um delay(10) adicionado ao loop() levou 10802 ms, porque o motor podia dar no máximo um passo a cada 10 milissegundos, 100 por segundo, não importando o que setMaxSpeed() dissesse. Mantenha o loop() curto e marque o tempo dos outros trabalhos com millis().

Há um limite mesmo sem mais nada no loop(). Em um Uno no Mokxi, run() fez cerca de 3900 passos por segundo no máximo, por mais alto que setMaxSpeed() estivesse definido, porque depois de cada passo ele calcula o próximo intervalo em ponto flutuante, três divisões e um punhado de multiplicações, o que um Uno faz por software. O runSpeed(), que não faz aritmética por passo, fez 9281 passos em um segundo com setSpeed(10000). A documentação da biblioteca original indica cerca de 4000 passos por segundo para um Uno.

Abra este circuito no editor. Arduino Uno: uma mesa giratória com AccelStepper, ligada como roda no topo desta página. Mude um componente ou um valor e rode de novo.

Abrir o circuito

Perguntas

O AccelStepper vem incluído no Mokxi?

Sim. AccelStepper.h e MultiStepper.h são incluídos, escritos a partir das chamadas e do perfil de velocidade documentados da biblioteca, então um sketch que os inclui compila como está.

Qual é a diferença entre run() e runSpeed()?

run() acelera em direção ao alvo definido por moveTo() e desacelera para parar nele. runSpeed() avança na velocidade constante definida por setSpeed(), sem aceleração e sem alvo. Ambos dão no máximo um passo por chamada, então chame-os o mais rápido que puder.

Por que currentPosition() muda quando o meu motor não se move?

O AccelStepper conta os passos que ele envia, não os passos que o eixo dá. Em um 28BYJ-48 a causa mais comum é a ordem dos pinos: passe os pinos como IN1, IN3, IN2, IN4. Em uma placa driver, verifique o EN, a ligação de RST a SLP e a alimentação do motor.

Quantos passos é uma volta de um 28BYJ-48 no AccelStepper?

4096 com HALF4WIRE e 2048 com FULL4WIRE, usando o redutor de 64 para 1 do datasheet.

Monte isto de verdade

Abra o editor, mude um valor e veja o número mudar junto. Nada para instalar, e não precisa de conta.