Overview
In the world of 3D printing and robots, the NEMA17 motor is loved for its small size and big power. To make it work at its best, we need to know how to control it. This piece is about controlling NEMA17 with the DRV8825 driver and ESP8266.
The DRV8825 driver is a handy tool that helps the NEMA17 motor work in different ways. It’s more powerful than the A4988 driver and is good for bigger projects. The ESP8266 is a WiFi module that lets you control the motor from far away. Together, they make controlling the NEMA17 motor easy and flexible.
This guide will show you how to connect these parts with the NEMA17 motor. It includes basic info, wiring, and coding. By following this guide, you’ll be ready to use these parts in various projects, like robots, 3D printing, and anything else that needs precise motor control.
Bill of Materials
You need the following components to follow along with this tutorial. You can easily purchase all of these components from Amazon. We’ve also provided the purchase links for your convenience.
| S.N. | Components Name | Quantity | Purchase Links |
|---|---|---|---|
| 1 | NodeMCU ESP8266 Board | 1 | Amazon | AliExpress |
| 2 | DRV8825 Stepper Motor Driver | 1 | Amazon | AliExpress |
| 3. | NEMA17 Stepper Motor | 1 | Amazon | AliExpress |
| 4 | Capacitor 100uF | 2 | Amazon | AliExpress |
| 5 | 7805 Voltage Regulator IC | 1 | Amazon | AliExpress |
| 6 | 12V, 2A Power Supply | 1 | Amazon | AliExpress |
| 7 | Connecting Wires | 20 | Amazon | AliExpress |
| 8 | Breadboard | 1 | Amazon | AliExpress |
DRV8825 Stepper Motor Driver Module
The DRV8825 is a complete Microstepping Motor Driver with a built-in translator for easy operation. The breakout board from Texas Instruments features adjustable current limiting, over-current and over-temperature protection, and six different microstep resolutions.
It operates from 8.2 V to 45 V and can deliver up to approximately 1.5 A Current per phase without a heat sink or forced airflow. It is rated for 2.2 A Current per coil with sufficient additional cooling.
Additionally, the DRV8825 is compatible with many popular microcontrollers, such as the Arduino, ESP8266, ESP32, making it easy to integrate into your existing projects. With its robust features and powerful performance, the DRV8825 stepper motor driver is an excellent tool for controlling your NEMA17 or other bipolar stepper motors.
Features
- Max. Operating Voltage: 45V
- Min. Operating Voltage: 8.2V
- Max. Current Per Phase: 2.5A
- Microstep resolution: Full step, 1/2 step, 1/4 step, 1/8 step, 1/16 step 1/32 step
- Over temperature shutdown circuit
- Under-voltage lock out
- Over current shutdown
- Dimensions: 20.5 x 15.5 mm (0.8″ × 0.6″)
- Short-to-ground and shorted-load protection
- Low RDS(ON) outputs
DRV8825 Motor Driver Pinout
The DRV8825 driver has total of 16 pins which are as follows:
1. Power Supply Pins: The pin includes VMOT, GND MOT & GND Logic. The DRV8825 module does not have any logic supply pin as it gets its power from the internal 3V3 voltage regulator. The VMOT supplies power for the motor which may be 8.2V to 45 V.
2. Microstep Selection Pins: The DRV8825 driver has three-step resolution selector inputs, i.e., M0, M1 & M2. By setting appropriate logic levels to those pins we will set the motors to at least one of the six-step resolutions.
3. Control Input Pins: STEP & DIR are the 2 control input pins. STEP input controls the micro-steps of the motor. The faster the pulses, the faster the motor will rotate. The DIR input controls the spinning direction of the motor. Pulling it HIGH drives the motor clockwise and pulling it LOW drives the motor anti-clockwise
4. Power States Control Pin: The DRV8825 has three different inputs for controlling its power states, i.e EN, RST, and SLP. The EN pin is always active low input by default which enables the driver. SLP Pin is active low input. Pulling this pin LOW puts the driver in sleep mode, minimizing the facility consumption. The RST is a lively low input which when pulled LOW, all STEP inputs are ignored. It also resets the driver by setting the internal translator to a motor initial stage.
5. Output Pins: There are 4 output pins as B2, B1, A2, A1. We can connect any bipolar stepper motor having voltages between 8.2V to 45 V to those pins. Each output pin on the module can deliver up to 2.2A to the motor
6. Fault Detection Pin: The DRV8825 features a FAULT output that drives LOW whenever the H-bridge FETs are disabled due to over-current protection or thermal shutdown. The Fault pin is shorted to the SLEEP pin & when it is driven LOW, the whole chip is disabled.
Heat Sink Requirement
It is safe to use the DRV8825 Driver without a heat sink if the current rating is up to 1.5A. For achieving more than 1.5A per coil, i.e. 2.2A, a heat sink or other cooling method is required.
Because of the excessive power dissipation of the DRV8825 driver, there is a rise in temperature that can go beyond the capacity of IC, probably damaging it.
Setting Up Current Limit
Before we connect the motor we should adjust the current limiting of the driver so that the current is within the limit of the motor. We can do that by adjusting the reference voltage using the potentiometer on the board and considering this equation below.
|
1 |
Current Limit = VRef x 2 |
For example, if the Stepper Motor is rated for 350mA, we need to adjust the reference voltage to 0.17V. Take a small screwdriver and adjust the current limit with a potentiometer until you reach the rated current.
NEMA17 Stepper Motor
NEMA 17 is a hybrid stepping motor with a 1.8° step angle (200 steps/revolution). The term “NEMA 17” refers to the National Electrical Manufacturers Association’s specification for stepper motors. Specifically, the ’17’ refers to the faceplate dimensions of the motor, which in this case is approximately 1.7 inches by 1.7 inches. Check out Stepper Motor Calculator to calculate various stepper motor parameters.
NEMA 17 stepper motors are widely used in devices like 3D printers, CNC machines, and small robotic applications due to their compact size, good torque, and precise control. Note that to properly control a stepper motor, you’ll usually need a stepper motor driver, which can precisely control the current in the motor windings to move the rotor in precise “steps.”
NEMA 17 stepper motors typically have four wires, each connected to one end of two separate coils inside the motor. These four wires are often color-coded to help identify them. The color coding is not standardized across all manufacturers, but a common scheme is:
- Black and Green wires: often correspond to one coil, which can be referred to as Coil A or Phase 1.
- Red and Blue wires: often correspond to the other coil, which can be referred to as Coil B or Phase 2.
Interfacing NEMA17 Stepper Motor with ESP8266 using DRV8825
To control a NEMA17 stepper motor using the DRV8825 stepper motor driver and the NodeMCU ESP8266 board, the connections are very simple. We can use the D3 and D4 pins on the NodeMCU ESP8266 Board to control the motor direction and stepping. The complete wiring diagram is provided below.
For power, connect the VMOT pin on the DRV8825 driver to a 12V power supply, and the SLP & RES pin to a 5V supply. It’s important to install a 100µF decoupling electrolytic capacitor across the motor power supply pins near the board to stabilize the power supply and reduce noise. Additionally, a 10µF electrolytic capacitor should be installed at the 5V supply pin for further stabilization.
The NEMA17 stepper motor is then connected to the DRV8825 driver using the four available motor pins as shown in circuit above.
Basic Stepper Motor Control Code
Now that you’ve connected the wires to the DRV8825 Stepper Motor driver and adjusted the current limit, it’s time to link the NodeMCU ESP8266 Board to your computer and load some code. The code we’re going to use will control the motor to move in one direction.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 |
const int dirPin = 0; const int stepPin = 2; const int stepsPerRevolution = 200; void setup() { // Declare pins as Outputs pinMode(stepPin, OUTPUT); pinMode(dirPin, OUTPUT); } void loop() { // Set motor direction clockwise digitalWrite(dirPin, HIGH); // Spin motor slowly for(int x = 0; x < stepsPerRevolution; x++) { digitalWrite(stepPin, HIGH); delayMicroseconds(2000); digitalWrite(stepPin, LOW); delayMicroseconds(2000); } delay(1000); // Wait a second // Set motor direction counterclockwise digitalWrite(dirPin, LOW); // Spin motor quickly for(int x = 0; x < stepsPerRevolution; x++) { digitalWrite(stepPin, HIGH); delayMicroseconds(1000); digitalWrite(stepPin, LOW); delayMicroseconds(1000); } delay(1000); // Wait a second } |
How does this code works
This code is for controlling a NEMA17 stepper motor using an ESP8266 microcontroller and the DRV8825 stepper motor driver. Here’s a breakdown of what each line of the code does:
|
1 2 3 |
const int dirPin = 0; const int stepPin = 4; const int stepsPerRevolution = 200; |
These three lines define the constants to be used in the program. dirPin is the pin number where the direction pin of the DRV8815 driver is connected. stepPin is the pin number where the step pin of the DRV8825 driver is connected. stepsPerRevolution is the number of steps the motor needs to take to complete one full revolution. For a NEMA17 stepper motor, this is typically 200 steps per revolution.
|
1 2 3 4 5 |
void setup() { pinMode(stepPin, OUTPUT); pinMode(dirPin, OUTPUT); } |
The setup() function is called once when the program starts. It’s used to initialize the digital pins as output.
|
1 2 3 |
void loop() { digitalWrite(dirPin, HIGH); |
The loop() function is called over and over again by the Arduino framework. It first sets the direction of the motor by writing HIGH (or 1) to dirPin. The direction depends on your motor and how it’s connected. In this case, HIGH might represent clockwise.
|
1 2 3 4 5 6 7 |
for(int x = 0; x < stepsPerRevolution; x++) { digitalWrite(stepPin, HIGH); delayMicroseconds(2000); digitalWrite(stepPin, LOW); delayMicroseconds(2000); } |
This for loop will execute stepsPerRevolution times, or 200 times, which will make the motor rotate one full revolution. Each iteration of the loop represents one step of the motor. The digitalWrite(stepPin, HIGH) and digitalWrite(stepPin, LOW) commands, combined with the delays, generate a pulse that causes the stepper motor to move one step.
|
1 2 |
delay(1000); digitalWrite(dirPin, LOW); |
This line causes the program to pause for 1000 milliseconds, or one second. If HIGH was clockwise, LOW would be counterclockwise.
|
1 2 3 4 5 6 7 |
for(int x = 0; x < stepsPerRevolution; x++) { digitalWrite(stepPin, HIGH); delayMicroseconds(1000); digitalWrite(stepPin, LOW); delayMicroseconds(1000); } |
This is another for loop like the one before, but the delay between steps is shorter (1000 microseconds instead of 2000), so the motor will rotate at a higher speed.
Finally, the program pauses again for one second before the loop() function ends. At this point, the function starts over from the beginning, causing the motor to spin first in one direction and then the other over and over again.
Controlling Stepper Motor Spinning Direction
This code lets you control the direction of the NEMA17 stepper motor with ESP8266 & DRV8825. You can make the motor spin either clockwise or counterclockwise. The code not only manages the speed and the number of turns but also the direction in which the stepper motor spins.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 |
const int dirPin = 0; const int stepPin = 2; const int stepsPerRevolution = 200; void setup() { // Declare pins as Outputs pinMode(stepPin, OUTPUT); pinMode(dirPin, OUTPUT); } void loop() { // Set motor direction clockwise digitalWrite(dirPin, HIGH); // Spin motor slowly for(int x = 0; x < stepsPerRevolution; x++) { digitalWrite(stepPin, HIGH); delayMicroseconds(2000); digitalWrite(stepPin, LOW); delayMicroseconds(2000); } delay(1000); // Wait a second // Set motor direction counterclockwise digitalWrite(dirPin, LOW); // Spin motor quickly for(int x = 0; x < stepsPerRevolution; x++) { digitalWrite(stepPin, HIGH); delayMicroseconds(1000); digitalWrite(stepPin, LOW); delayMicroseconds(1000); } delay(1000); // Wait a second } |
Controlling Stepper Motor with AccelStepper Library
The AccelStepper library allows for control of the Stepper Motor. It offers an organized, object-oriented interface for stepper motors with 2, 3, or 4 pins, as well as motor drivers.
AccelStepper enhances the standard Stepper library in many ways. It includes features like acceleration and deceleration support. It’s also capable of managing multiple steppers at once, each with independent, concurrent steps. Plus, it supports even very slow speeds.
The code below demonstrates all these features.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 |
#include <AccelStepper.h> // Define stepper motor connections and motor interface type. Motor interface type must be set to 1 when using a driver: #define dirPin 0 #define stepPin 2 #define motorInterfaceType 1 // Create a new instance of the AccelStepper class: AccelStepper stepper = AccelStepper(motorInterfaceType, stepPin, dirPin); void setup() { // Set the maximum speed in steps per second: stepper.setMaxSpeed(1000); } void loop() { // Set the current position to 0: stepper.setCurrentPosition(0); // Run the motor forward at 200 steps/second until the motor reaches 400 steps (2 revolutions): while(stepper.currentPosition() != 400) { stepper.setSpeed(200); stepper.runSpeed(); } delay(1000); // Reset the position to 0: stepper.setCurrentPosition(0); // Run the motor backwards at 600 steps/second until the motor reaches -200 steps (1 revolution): while(stepper.currentPosition() != -200) { stepper.setSpeed(-600); stepper.runSpeed(); } delay(1000); // Reset the position to 0: stepper.setCurrentPosition(0); // Run the motor forward at 400 steps/second until the motor reaches 600 steps (3 revolutions): while(stepper.currentPosition() != 600) { stepper.setSpeed(400); stepper.runSpeed(); } delay(3000); } |
Stepper Motor Acceleration & Deceleration Code
The following code will include acceleration and deceleration in the stepper motor’s movements. The motor will oscillate back and forth at a speed of 200 steps per second and an acceleration rate of 30 steps per second.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 |
#include <AccelStepper.h> #define dirPin 0 #define stepPin 2 #define motorInterfaceType 1 // Create a new instance of the AccelStepper class: AccelStepper stepper = AccelStepper(motorInterfaceType, stepPin, dirPin); void setup() { // Set the maximum speed and acceleration: stepper.setMaxSpeed(200); stepper.setAcceleration(30); } void loop() { // Set the target position: stepper.moveTo(600); // Run to target position with set speed and acceleration/deceleration: stepper.runToPosition(); delay(1000); // Move back to zero: stepper.moveTo(0); stepper.runToPosition(); delay(1000); } |
Control NEMA17 Stepper Motor with DRV8825 & Potentiometer
You can also control the stepper motor using a Potentiometer. In my case, I used a 10K Potentiometer and linked it to the A0, the analog pin, on the ESP8266 board. The voltage sent to the ESP8266’s analog pin can serve as a reference point to manage the speed of the Stepper Motor. You can see how to connect everything in the diagram below.
Copy the code from below and upload it to the NodeMCU ESP8266 Board.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 |
/ Defines pins numbers const int stepPin = 2; const int dirPin = 0; int customDelay,customDelayMapped; // Defines variables void setup() { // Sets the two pins as Outputs pinMode(stepPin,OUTPUT); pinMode(dirPin,OUTPUT); digitalWrite(dirPin,HIGH); //Enables the motor to move in a particular direction } void loop() { customDelayMapped = speedUp(); // Gets custom delay values from the custom speedUp function // Makes pules with custom delay, depending on the Potentiometer, from which the speed of the motor depends digitalWrite(stepPin, HIGH); delayMicroseconds(customDelayMapped); digitalWrite(stepPin, LOW); delayMicroseconds(customDelayMapped); } // Function for reading the Potentiometer int speedUp() { int customDelay = analogRead(A0); // Reads the potentiometer int newCustom = map(customDelay, 0, 1023, 300,4000); // Convrests the read values of the potentiometer from 0 to 1023 into desireded delay values (300 to 4000) return newCustom; } |
Conclusion
In conclusion, mastering the control of the compact yet powerful NEMA17 motor greatly optimizes its potential, particularly in applications like 3D printing and robotics. The DRV8825 driver plays a pivotal role in this, offering more power than the A4988 driver and facilitating diverse motor functions.
Coupled with the ESP8266 WiFi module, it enables not just efficient and flexible control of the NEMA17 motor but also remote management. This guide has aimed to equip you with the basic knowledge, wiring techniques, and coding skills required to integrate these components with the NEMA17 motor.
By following this guide, you’re now prepared to venture into various projects requiring precise motor control, be it in robotics, 3D printing, or other exciting fields. Harnessing the power of the NEMA17, the DRV8825 Stepper Motor driver, and the ESP8266 will open up a plethora of opportunities for innovation and exploration in your future endeavors.
