Overview
In the world of 3D printing and robotics, the NEMA17 stepper motor is very popular because of its small size and strong performance. To use it to its full potential, it’s important to understand how to control it. This article will show you how to control the NEMA17 using the A4988 driver and ESP8266, two important parts that help the motor work well.
The A4988 driver is a versatile tool that lets the NEMA17 work in different ways, which makes it a key part in controlling the stepper motor. The ESP8266, on the other hand, is a WiFi module that allows you to control the motor remotely. Using these two together makes controlling the NEMA17 easy and flexible.
This guide will explain in simple terms how to connect these parts with the NEMA17, including the basic theory, wiring, and coding steps. By following this guide, you’ll be able to confidently use these parts in various projects, whether in robotics, 3D printing, or any other area that needs precise motor control. An alternative to A4988 is DRV8825 Driver, which is more powerful.
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 | A4988 Stepper Motor Driver | 1 | Amazon | AliExpress |
| 3. | NEMA17 Stepper Motor | 1 | Amazon | AliExpress |
| 4 | Electrolytic Capacitor 10uF | 1 | Amazon | AliExpress |
| 5 | Electrolytic Capacitor 100uF | 1 | Amazon | AliExpress |
| 6 | 7805 Voltage Regulator IC | 1 | Amazon | AliExpress |
| 7 | 12V DC Adapter | 1 | Amazon | AliExpress |
| 8 | Connecting Jumper Wires | 20 | Amazon | AliExpress |
| 9 | Breadboard | 1 | Amazon | AliExpress |
A4988 Stepper Motor Driver Module
The A4988 is a complete Microstepping Motor Driver with a built-in translator for easy operation. The breakout board from Allegro features adjustable current limiting, over-current and over-temperature protection and five different microstep resolutions. It operates from 8 V to 35 V and can deliver up to approximately 1 A per phase without a heat sink or forced airflow. It is rated for 2 A per coil with sufficient additional cooling.
Features
- Max. Operating Voltage: 35V
- Min. Operating Voltage: 8V
- Max. Current Per Phase: 2A
- Microstep resolution: Full step, ½ step, ¼ step, 1/8 and 1/16 step
- Reverse voltage protection: No
- Dimensions: 15.5 × 20.5 mm (0.6″ × 0.8″)
- Short-to-ground and shorted-load protection
- Low RDS(ON) outputs
- Thermal shutdown circuitry
A4988 Motor Driver Pinout
The A4988 driver has total of 16 pins which are as follows:
1. Power Supply Pins: The pin include VDD & VMOT & Pair of GND pins. VDD is employed for driving the interior logic circuitry which may be 3V to 5V whereas VMOT supplies power for the motor which may be 8V to 35 V.
2. Microstep Selection Pins: The A4988 driver has three-step resolution selector inputs, i.e., MS1, MS2 & MS3. By setting appropriate logic levels to those pins we will set the motors to at least one of the five-step resolutions.
3. Control Input Pins: STEP & DIR are the 2 control input pins. STEP input controls the micro-steps of the motor whereas DIR input controls the spinning direction of the motor.
4. Power States Control Pin: The A4988 has three different inputs for controlling its power states, i.e EN, RST, and SLP. The EN pin is active low input, when pulled LOW the A4988 driver is enabled. 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 2B, 2A, 1B, 1A. We can connect any bipolar stepper motor having voltages between 8V to 35 V to those pins.
Heat Sink Requirement
It is safe to use the A4988 Driver without a heat sink if the current rating is up to 1A. For achieving more than 1A per coil, a heat sink or other cooling method is required.
Because of the excessive power dissipation of the A4988 driver, there is a rise of 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.5 |
For example, if the Stepper Motor is rated for 350mA, we need to adjust the reference voltage to 0.14V. 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.
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.” Check out Stepper Motor Calculator to calculate various stepper motor parameters.
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 A4988 Driver
To control a NEMA17 stepper motor using the A4988 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 A4988 driver to a 12V power supply, and the VDD 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 A4988 driver using the four available motor pins as shown in circuit above.
Basic Stepper Motor Control Code
Now that you have wired up the A4988 driver and set the current limit, it is time to connect the NodeMCU ESP8266 Board to the computer and upload some code. This sketch controls motor in a single 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 A4988 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 A4988 driver is connected. stepPin is the pin number where the step pin of the A4988 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
Using this code, the stepper motor direction can be controlled. You can rotate the motor in either clockwise direction or in anticlockwise direction. This sketch controls both the speed, the number of revolutions, and the spinning direction of the stepper motor.
|
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
Stepper Motor can be controlled using the AccelStepper library. It provides an object-oriented interface for 2, 3, or 4 pin stepper motors and motor drivers.
AccelStepper significantly improves on the standard Stepper library in several ways like it supports acceleration and deceleration. It also supports multiple simultaneous steppers, with independent concurrent stepping on each stepper. Even very slow speeds are also supported
The following code shows all the above-mentioned 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 sketch will add acceleration and deceleration to the movements of the stepper motor. The motor will run back and forth with a speed of 200 steps per second and an acceleration 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 A4988 & Potentiometer
The stepper motor can be controlled using Potentiometer as well. I used a 10K Potentiometer and connected it to the A0, analog pin of the ESP8266 board. The voltage fed to the Analog pin of ESP8266 can be used as a reference voltage to control the speed of the Stepper Motor. The connection diagram is given 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, the NEMA17 stepper motor, combined with the A4988 driver and the ESP8266 WiFi module, offers a powerful and flexible solution for precise motor control in applications such as 3D printing and robotics. The A4988 driver allows for versatile operation of the motor, while the ESP8266 enables remote control over WiFi.
This guide has walked you through the essentials of interfacing these components, from understanding the basic theory to the practical steps of wiring and programming. With this knowledge, you can confidently implement these components in your projects, harnessing the capabilities of the NEMA17 stepper motor to its full potential.
