ESP32 - Motor paso a paso

En este tutorial, vamos a aprender cómo usar el ESP32 para controlar el motor paso a paso:

El tutorial puede aplicarse a cualquier tipo de motor paso a paso bipolar (4 cables). El tutorial tomará como ejemplo un motor paso a paso NEMA 17.

Motor paso a paso con ESP32

Acerca del motor paso a paso

Hay dos tipos comunes de motores paso a paso:

  • Bipolar: estos motores vienen con 4 cables.
  • Unipolar: los motores unipolares pueden tener 5 o 6 cables. En el caso de un motor paso a paso unipolar de 6 cables, puedes usar cuatro de los seis cables para controlarlo como si fuera un motor paso a paso bipolar.

Si te interesa específicamente un motor paso a paso unipolar de 5 cables, puedes consultar el tutorial titulado ESP32 - Controlar el motor paso a paso 28BYJ-48 usando el controlador ULN2003.

Sin embargo, este tutorial está dedicado exclusivamente a los motores paso a paso bipolares.

Disposición de pines del motor paso a paso bipolar

Un motor paso a paso bipolar tiene cuatro pines, y estos pines pueden llamarse de manera diferente según el fabricante. A continuación, encontrarás una tabla con algunos nombres de pines comunes:

N.º de PIN Nombre 1 Nombre 2 Nombre 3
1 A+ A A
2 A- A C
3 B+ B B
4 B- B D
Disposición de pines del motor paso a paso bipolar

La distribución de los pines, los nombres de los cables y los colores de los cables pueden variar de un fabricante a otro. Para entender cómo los colores de los cables corresponden a los nombres de los pines, es esencial consultar la hoja de datos o el manual del usuario del fabricante. La imagen de arriba muestra las especificaciones de dos motores distintos, cada uno con sus propios nombres y colores de cables.

Pasos por revolución

La especificación del motor indica los grados por paso (llamémoslo DEG_PER_STEP). Según el método de control, los pasos por revolución (llamémoslo STEP_PER_REVOLUTION) se calculan como en la siguiente tabla:

Método de control Pasos por revolución Grados reales por paso
Paso completo STEP_PER_REVOLUTION = 360 / DEG_PER_STEP DEG_PER_STEP
Medio paso STEP_PER_REVOLUTION = (360 / DEG_PER_STEP) * 2 DEG_PER_STEP / 2
Micropaso (1/n) STEP_PER_REVOLUTION = (360 / DEG_PER_STEP) * n DEG_PER_STEP / n

Por ejemplo, si la hoja de datos del motor indica 1.8 grados/paso:

Método de control Pasos por revolución Grados reales por paso
Paso completo 200 pasos/revolución 1.8°
Medio paso 400 pasos/revolución 0.9°
Micropaso (1/n) (200 * n) pasos/revolución (1.8 / n)°

Cómo controlar un motor paso a paso con ESP32

El ESP32 puede generar señales para controlar el motor paso a paso, pero a estas señales les pueden faltar los niveles de voltaje y corriente que exige el motor paso a paso. Por eso se necesita un controlador de hardware intermedio entre el ESP32 y el motor paso a paso. Este controlador cumple dos funciones principales:

  • Amplificar las señales de control: aumenta la corriente y el voltaje de las señales de control que salen del ESP32, para que cumplan los requisitos del motor paso a paso.
  • Proteger el ESP32: al mismo tiempo, protege el ESP32 de los niveles más altos de corriente y voltaje que alimentan el motor paso a paso, evitando cualquier daño.

Hay varios controladores de hardware para motores paso a paso. Este tutorial usa el controlador DRV8825. Limita la corriente en las bobinas del motor, así el motor no se calienta demasiado; puede hacer micropasos pequeños para un movimiento suave y silencioso, y solo necesita dos pines del ESP32.

Acerca del controlador DRV8825 y la placa de expansión

Con el pequeño módulo DRV8825 puedes mover UN motor paso a paso bipolar, por ejemplo un NEMA 17. El ESP32 solo le dice dos cosas: cuándo dar un paso (pin STEP) y hacia qué lado girar (pin DIR). El controlador hace el trabajo difícil de conmutar la corriente en las dos bobinas.

Disposición de pines del controlador DRV8825

Disposición de pines del módulo DRV8825

Estos son los datos principales del DRV8825:

  • Alimentación del motor: de 8.2V a 45V. Usamos un adaptador de 12V.
  • Corriente de bobina: unos 1.5A por bobina (2.5A de pico). El módulo tiene una pequeña perilla para el límite de corriente.
  • Micropasos: hasta 32 micropasos en cada paso completo.
  • Lógica: funciona con señales de 3.3V y 5V, así que los pines del ESP32 pueden manejarlo directamente.
  • Protección: se apaga cuando la corriente es demasiado alta, cuando está demasiado caliente o cuando el voltaje de alimentación es demasiado bajo.

La placa de expansión

Insertamos el módulo en los dos zócalos de la placa de expansión, y esa placa hace el cableado mucho más fácil:

  • Borne de tornillo VIN / GND: la alimentación de 12V para el motor. Un condensador de 100uF en la placa mantiene estable esta alimentación.
  • Conector XH de 4 pines (2B, 2A, 1A, 1B): aquí se conecta el motor paso a paso.
  • Interruptor DIP de 3 posiciones: un interruptor para cada pin de micropaso: MS1, MS2 y MS3. Todos en OFF = paso completo = 200 pasos por revolución para un motor de 1.8 grados. Este tutorial usa paso completo.
  • Conector G V S para EN, STEP y DIR: cada señal tiene un pin G (tierra), un pin V y un pin S (señal). Usamos los pines S de STEP y DIR, y un pin G. EN y V quedan libres: EN libre significa que el controlador está habilitado, y V solo se necesita para el A4988.
  • RST y SLP: un puente en la placa de expansión mantiene ambos en alto, así que no los toques.

※ Nota:

Ajusta el límite de corriente antes de un uso prolongado. Un ajuste bajo es el inicio seguro. Gira la perilla poco a poco hasta que el motor deje de tartamudear. Mantenlo cerca o por debajo de 1.5A, o el controlador se calentará demasiado.

Diagrama de Cableado

Diagrama de cableado del ESP32 con motor paso a paso y controlador DRV8825

This image is created using Fritzing. Click to enlarge image

Si no sabe c\u00f3mo alimentar ESP32 y otros componentes, encuentre instrucciones en el siguiente tutorial: C\u00f3mo alimentar ESP32.

※ Nota:

  • Para paso completo, asegúrate de que los tres interruptores DIP de la placa de expansión estén en la posición OFF.
  • El orden de los pines en los motores paso a paso puede variar entre fabricantes. Consulta la tabla de abajo para un cableado correcto.

Tabla de cableado entre el ESP32 y la placa de expansión del DRV8825

Pines del ESP32 Pines de la placa de expansión
GPIO18 STEP (pin S)
GPIO19 DIR (pin S)
GND pin G

La alimentación del motor viene del adaptador de 12V. Un conector de alimentación DC recibe su enchufe, y dos cables van desde el conector hasta el borne de tornillo VIN / GND de la placa de expansión. El pin EN y los pines V no se conectan.

Tabla de cableado entre la placa de expansión del DRV8825 y el motor paso a paso

¡Importante!: No te preocupes por el orden de los cables del motor paso a paso en la imagen del diagrama de cableado de arriba. Es solo un ejemplo. El orden de los pines en los motores paso a paso puede variar entre fabricantes. Asegúrate de que tu cableado siga la tabla de abajo: una bobina en 1A/1B y la otra bobina en 2A/2B.

Pines de la placa de expansión Pines del motor paso a paso O O
1A A+ A A
1B A- A C
2A B+ B B
2B B- B D

Antes de comprar un motor paso a paso, te recomendamos revisar la hoja de datos, la especificación o el manual del motor paso a paso. Asegúrate de que indiquen la correspondencia entre el color y el nombre de cada pin. Por ejemplo, este motor paso a paso indica la correspondencia como en la imagen de abajo:

Correspondencia de colores de las bobinas del motor paso a paso

Según esa correspondencia, la tabla de cableado queda así:

Pines de la placa de expansión pines del motor paso a paso color del cable
1A A cable negro
1B C cable verde
2A B cable rojo
2B D cable azul

※ Nota:

En todas las tablas de cableado anteriores, puedes intercambiar 1A con 1B, o 2A con 2B. Intercambiar los dos cables de una bobina hace que el motor gire hacia el otro lado (de horario a antihorario, y viceversa).

Cableado sin la placa de expansión

La placa de expansión es práctica, pero no es obligatoria. Siga la imagen y la tabla, y tenga cuidado con las pequeñas etiquetas de los pines.

Diagrama de cableado de ESP32 con el módulo DRV8825 sin placa de expansión y un motor paso a paso

This image is created using Fritzing. Click to enlarge image

Pin del módulo DRV8825 Conectar a
STEP ESP32 GPIO18
DIR ESP32 GPIO19
GND (junto a FAULT) ESP32 GND
VMOT + del adaptador de 12V
GND (junto a VMOT) - del adaptador de 12V
2B y 1B una bobina del motor paso a paso
1A y 2A la otra bobina del motor paso a paso
EN, M0, M1, M2, RST, SLP, FAULT sin conectar

※ Nota:

  • El módulo solo no tiene condensador propio. Ponga uno de 100uF (de 25V o más) entre VMOT y GND.
  • Si el motor no se mueve nada, conecte RST y SLP con un cable corto. Algunos módulos lo necesitan para despertarse.

Cómo controlar un motor paso a paso usando un controlador DRV8825.

Controlar un motor paso a paso no es una tarea sencilla, especialmente cuando queremos controlarlo de manera no bloqueante. Afortunadamente, gracias a la biblioteca AccelStepper, controlar el motor paso a paso se vuelve pan comido.

Arduino IDE también tiene una biblioteca integrada Stepper. Sin embargo, no te recomendamos usar esta biblioteca porque:

  • La biblioteca ofrece una función bloqueante. Significa que impide que el ESP32 haga otros trabajos mientras controla el motor paso a paso.
  • No tiene suficientes funciones.

En su lugar, te recomendamos usar la biblioteca AccelStepper. Esta biblioteca admite:

  • Aceleración
  • Desaceleración.
  • El modo DRIVER, para placas como el DRV8825 que reciben las señales STEP y DIR.
  • Varios motores paso a paso al mismo tiempo, con pasos independientes y simultáneos en cada motor.

Con el DRV8825, los micropasos los hace el propio controlador (el interruptor DIP). AccelStepper solo envía un pulso por cada paso o micropaso.

En el sketch, AccelStepper se configura en modo DRIVER, y le pasamos el pin STEP y el pin DIR:

AccelStepper stepper(AccelStepper::DRIVER, STEP_PIN, DIR_PIN);

Cómo controlar la posición de un motor paso a paso mediante el controlador DRV8825

Podemos mover el motor paso a paso a la posición deseada utilizando:

stepper.moveTo(desiredPosition); // move motor one revolution

※ Nota:

La función stepper.moveTo() no es bloqueante. Este es un gran punto a favor de la biblioteca. Sin embargo, debemos prestar atención al usar esta función:

  • Llama a 'stepper.run()' con la mayor frecuencia posible. Debe llamarse en la función void loop().
  • NO uses la función delay() cuando el motor se está moviendo.
  • NO deberías usar las funciones Serial.print() y Serial.println() cuando el motor se está moviendo. Estas funciones hacen que el motor paso a paso se mueva más despacio.

Cómo controlar la velocidad del motor paso a paso mediante el controlador DRV8825

Podemos controlar no solo la velocidad, sino también la aceleración y la desaceleración con algunas funciones simples.

stepper.setMaxSpeed(1000.0); // set the maximum speed stepper.setAcceleration(50.0); // set acceleration/deceleration stepper.setSpeed(200); // set desired speed

Cómo controlar la dirección del motor paso a paso mediante el controlador DRV8825

Si haces el cableado como se indica arriba, el motor girará en:

  • Sentido horario: si llevamos el motor de una posición a una posición mayor (incremento de posición)
  • Sentido antihorario: si llevamos el motor de una posición a una posición menor (decremento de posición)

Por ejemplo:

  • Si la posición actual es 100 y llevamos el motor a 200, el motor gira en sentido horario
  • Si la posición actual es -200 y llevamos el motor a -100, el motor gira en sentido horario
  • Si la posición actual es 200 y llevamos el motor a 100, el motor gira en sentido antihorario
  • Si la posición actual es -100 y llevamos el motor a -200, el motor gira en sentido antihorario

La biblioteca fija el pin DIR por nosotros antes de cada movimiento, así que no escribimos en él en el código.

※ Nota:

Como se mencionó antes, si intercambias 1A con 1B, o 2A con 2B, el incremento de la posición puede ser en sentido antihorario y el decremento de la posición puede ser en sentido horario.

Cómo detener un motor paso a paso

  • El motor paso a paso se detendrá automáticamente después de alcanzar la posición deseada.
  • Se puede forzar al motor paso a paso a detenerse de inmediato en cualquier momento con la función stepper.stop().

Código ESP32 - Código del motor paso a paso

Lo que hace el código a continuación:

  • Gira el motor una revolución en sentido horario
  • Detiene el motor 5 segundos
  • Gira el motor de vuelta una revolución en sentido antihorario
  • Detiene el motor 5 segundos
  • Ese proceso se repite una y otra vez
/* * Este código de ESP32 fue desarrollado por es.newbiely.com * Este código de ESP32 se proporciona al público sin ninguna restricción. * Para tutoriales completos y diagramas de cableado, visite: * https://es.newbiely.com/tutorials/esp32/esp32-stepper-motor */ // ESP32 controls a NEMA 17 stepper motor with the DRV8825 driver (on its expansion board) // Full step (all DIP switches OFF): 200 steps per revolution #include <AccelStepper.h> #define DEG_PER_STEP 1.8 #define STEP_PER_REVOLUTION (360 / DEG_PER_STEP) #define STEP_PIN 18 // ESP32 pin GPIO18 connected to the STEP pin of the DRV8825 #define DIR_PIN 19 // ESP32 pin GPIO19 connected to the DIR pin of the DRV8825 AccelStepper stepper(AccelStepper::DRIVER, STEP_PIN, DIR_PIN); // DRIVER mode: STEP and DIR pins long moveToPosition = STEP_PER_REVOLUTION; void setup() { Serial.begin(9600); stepper.setMaxSpeed(1000.0); // set the maximum speed stepper.setAcceleration(200.0); // set acceleration stepper.setSpeed(200); // set initial speed stepper.setCurrentPosition(0); // set position to 0 stepper.moveTo(STEP_PER_REVOLUTION); // move motor one revolution, in clockwise direction Serial.println("Motor moving in clockwise direction"); } void loop() { if (stepper.distanceToGo() == 0) { Serial.println("Motor is stopped"); delay(5000); // stop 5 seconds stepper.setCurrentPosition(0); // reset position to 0 moveToPosition = -1 * moveToPosition; // reverse direction stepper.moveTo(moveToPosition); // move motor one revolution if (stepper.distanceToGo() > 0) Serial.println("Motor moving in clockwise direction"); else if (stepper.distanceToGo() < 0) Serial.println("Motor moving in anticlockwise direction"); } // Serial.print(F("position: ")); // Serial.println(stepper.currentPosition()); stepper.run(); // MUST be called as frequently as possible }

Pasos R\u00e1pidos

  • Si es la primera vez que usas ESP32, consulta cómo configurar el entorno para ESP32 en Arduino IDE.
  • Realiza el cableado como en la imagen de arriba. Comprueba que los tres interruptores DIP estén en OFF.
  • Conecta la placa ESP32 a tu PC mediante un cable micro USB
  • Abre Arduino IDE en tu PC.
  • Selecciona la placa ESP32 correcta (p. ej. ESP32 Dev Module) y el puerto COM.
  • Haz clic en el icono Libraries en la barra izquierda del Arduino IDE.
  • Busca “AccelStepper”, luego encuentra la biblioteca AccelStepper de Mike McCauley
  • Haz clic en el botón Install para instalar la biblioteca AccelStepper.
Biblioteca AccelStepper para ESP32
  • Copia el código anterior y ábrelo con Arduino IDE
  • Haz clic en el botón Upload en Arduino IDE para subir el código al ESP32
  • Conecta el adaptador de 12V para alimentar el motor.
  • Verás:
    • El motor paso a paso gira una revolución en sentido horario
    • El motor paso a paso se detiene 5 segundos
    • El motor paso a paso gira de vuelta una revolución en sentido antihorario
    • El motor paso a paso se detiene 5 segundos
    • El proceso anterior se repite una y otra vez.
  • Mira el resultado en el Monitor Serial
∞
Newbiely | Arduino IDE 2.3.8
──
☐
✕
File
Edit
Sketch
Tools
Help
ESP32 Dev Module
Newbiely.ino
···
8 Serial.println("Hello World!");
Output
Serial Monitor
Message (Enter to send message to 'ESP32 Dev Module' on 'COM15')
New Line
9600 baud
Motor moving in clockwise direction Motor is stopped Motor moving in anticlockwise direction Motor is stopped Motor moving in clockwise direction Motor is stopped Motor moving in anticlockwise direction Motor is stopped Motor moving in clockwise direction Motor is stopped Motor moving in anticlockwise direction Motor is stopped
Ln 11, Col 1
ESP32 Dev Module on COM15
2

Si el motor vibra pero no gira, comprueba que cada bobina esté en un par (1A/1B y 2A/2B). Si el motor está débil o pierde pasos, sube un poco la perilla de corriente.

Explicación del código

¡Lee la explicación línea por línea en los comentarios del código fuente!

Video Tutorial

Estamos considerando crear tutoriales en video. Si considera que los tutoriales en video son importantes, suscríbase a nuestro canal de YouTube para motivarnos a crear los videos.

El video y los tres códigos de demostración de abajo se hicieron con el antiguo controlador L298N y su cableado; para el DRV8825, sigue el cableado y el código principal de esta página.

El código de abajo hace que el motor paso a paso toque el tema de Super Mario cambiando su velocidad en cada nota:

/* * Este código de ESP32 fue desarrollado por es.newbiely.com * Este código de ESP32 se proporciona al público sin ninguna restricción. * Para tutoriales completos y diagramas de cableado, visite: * https://es.newbiely.com/tutorials/esp32/esp32-stepper-motor */ #include <AccelStepper.h> // L298N Motor Driver Pins #define IN1_PIN 19 #define IN2_PIN 18 #define IN3_PIN 17 #define IN4_PIN 16 AccelStepper stepper( AccelStepper::FULL4WIRE, IN1_PIN, IN2_PIN, IN3_PIN, IN4_PIN ); struct Note { int speed; // Steps per second int duration; // Duration in milliseconds }; const Note melody[] = { // Intro {330, 150}, {330, 150}, {0, 150}, {330, 150}, {0, 150}, {262, 150}, {330, 150}, {392, 300}, {0, 300}, // Next part {196, 300}, {0, 300}, {262, 200}, {0, 150}, {196, 200}, {0, 150}, {165, 200}, {0, 150}, {220, 200}, {247, 200}, {233, 150}, {220, 200}, // Main melody {196, 150}, {330, 150}, {392, 150}, {440, 200}, {349, 150}, {392, 150}, {330, 200}, {262, 150}, {294, 150}, {247, 300}, {0, 250}, // Fast repeat {262, 150}, {196, 150}, {165, 150}, {220, 150}, {247, 150}, {233, 150}, {220, 200}, {0, 100}, // Ending {196, 150}, {330, 150}, {392, 150}, {440, 200}, {349, 150}, {392, 150}, {330, 200}, {262, 150}, {294, 150}, {247, 400} }; const int melodyLength = sizeof(melody) / sizeof(melody[0]); void playNote(int speed, int duration) { if (speed == 0) { delay(duration); return; } stepper.setSpeed(speed); unsigned long startTime = millis(); while (millis() - startTime < (unsigned long)duration) { stepper.runSpeed(); } } void setup() { Serial.begin(115200); stepper.setMaxSpeed(500); stepper.setSpeed(200); Serial.println("NEMA 17 - Mario Theme"); Serial.println("Playing melody..."); } void loop() { for (int i = 0; i < melodyLength; i++) { Serial.print("Speed: "); Serial.print(melody[i].speed); Serial.print(" steps/s, Duration: "); Serial.println(melody[i].duration); playNote(melody[i].speed, melody[i].duration); } delay(2000); }

El código de abajo hace que el motor paso a paso toque el Himno de la alegría:

/* * Este código de ESP32 fue desarrollado por es.newbiely.com * Este código de ESP32 se proporciona al público sin ninguna restricción. * Para tutoriales completos y diagramas de cableado, visite: * https://es.newbiely.com/tutorials/esp32/esp32-stepper-motor */ #include <AccelStepper.h> // L298N Motor Driver Pins #define IN1_PIN 19 #define IN2_PIN 18 #define IN3_PIN 17 #define IN4_PIN 16 AccelStepper stepper( AccelStepper::FULL4WIRE, IN1_PIN, IN2_PIN, IN3_PIN, IN4_PIN ); struct Note { int speed; // Steps per second int duration; // Duration in milliseconds }; const Note melody[] = { // Part 1 {330, 300}, {330, 300}, {349, 300}, {392, 300}, {392, 300}, {349, 300}, {330, 300}, {294, 300}, {262, 300}, {262, 300}, {294, 300}, {330, 300}, {330, 450}, {294, 150}, {294, 600}, {0, 200}, // Part 2 {330, 300}, {330, 300}, {349, 300}, {392, 300}, {392, 300}, {349, 300}, {330, 300}, {294, 300}, {262, 300}, {262, 300}, {294, 300}, {330, 300}, {294, 450}, {262, 150}, {262, 600}, {0, 250}, // Part 3 {294, 300}, {294, 300}, {330, 300}, {262, 300}, {294, 300}, {330, 150}, {349, 150}, {330, 300}, {262, 300}, {294, 300}, {330, 150}, {349, 150}, {330, 300}, {294, 300}, {262, 300}, {294, 600}, {0, 200}, // Ending {330, 300}, {330, 300}, {349, 300}, {392, 300}, {392, 300}, {349, 300}, {330, 300}, {294, 300}, {262, 300}, {262, 300}, {294, 300}, {330, 300}, {262, 450}, {0, 150}, {262, 700} }; const int melodyLength = sizeof(melody) / sizeof(melody[0]); void playNote(int speed, int duration) { if (speed == 0) { delay(duration); return; } stepper.setSpeed(speed); unsigned long startTime = millis(); while (millis() - startTime < (unsigned long)duration) { stepper.runSpeed(); } } void setup() { Serial.begin(115200); stepper.setMaxSpeed(500); stepper.setSpeed(200); Serial.println("NEMA 17 - Ode to Joy"); Serial.println("Playing melody..."); } void loop() { for (int i = 0; i < melodyLength; i++) { Serial.print("Speed: "); Serial.print(melody[i].speed); Serial.print(" steps/s, Duration: "); Serial.println(melody[i].duration); playNote(melody[i].speed, melody[i].duration); } delay(2000); }

El código de abajo hace que el motor paso a paso toque Twinkle Twinkle Little Star (Estrellita, ¿dónde estás?):

/* * Este código de ESP32 fue desarrollado por es.newbiely.com * Este código de ESP32 se proporciona al público sin ninguna restricción. * Para tutoriales completos y diagramas de cableado, visite: * https://es.newbiely.com/tutorials/esp32/esp32-stepper-motor */ #include <AccelStepper.h> // L298N Motor Driver Pins #define IN1_PIN 19 #define IN2_PIN 18 #define IN3_PIN 17 #define IN4_PIN 16 AccelStepper stepper( AccelStepper::FULL4WIRE, IN1_PIN, IN2_PIN, IN3_PIN, IN4_PIN ); struct Note { int speed; // Steps per second int duration; // Duration in milliseconds }; const Note melody[] = { // Twinkle, twinkle, little star {262, 350}, {262, 350}, {392, 350}, {392, 350}, {440, 350}, {440, 350}, {392, 650}, {0, 180}, // How I wonder what you are {349, 350}, {349, 350}, {330, 350}, {330, 350}, {294, 350}, {294, 350}, {262, 650}, {0, 250}, // Up above the world so high {392, 350}, {392, 350}, {349, 350}, {349, 350}, {330, 350}, {330, 350}, {294, 650}, {0, 250}, // Like a diamond in the sky {392, 350}, {392, 350}, {349, 350}, {349, 350}, {330, 350}, {330, 350}, {294, 650}, {0, 250}, // Twinkle, twinkle, little star {262, 350}, {262, 350}, {392, 350}, {392, 350}, {440, 350}, {440, 350}, {392, 650}, {0, 180}, // How I wonder what you are {349, 350}, {349, 350}, {330, 350}, {330, 350}, {294, 350}, {294, 350}, {262, 900}, {0, 300} }; const int melodyLength = sizeof(melody) / sizeof(melody[0]); void playNote(int speed, int duration) { if (speed == 0) { delay(duration); return; } stepper.setSpeed(speed); unsigned long startTime = millis(); while (millis() - startTime < (unsigned long)duration) { stepper.runSpeed(); } } void setup() { Serial.begin(115200); stepper.setMaxSpeed(500); stepper.setSpeed(200); Serial.println("NEMA 17 - Twinkle Twinkle Little Star"); Serial.println("Playing melody..."); } void loop() { for (int i = 0; i < melodyLength; i++) { Serial.print("Speed: "); Serial.print(melody[i].speed); Serial.print(" steps/s, Duration: "); Serial.println(melody[i].duration); playNote(melody[i].speed, melody[i].duration); } delay(2000); }

※ NUESTROS MENSAJES

  • No dude en compartir el enlace de este tutorial. Sin embargo, por favor no use nuestro contenido en otros sitios web. Hemos invertido mucho esfuerzo y tiempo en crear el contenido, ¡por favor respete nuestro trabajo!