CNC Expansion Shield V3 for A4988 and DRV8825 Stepper Motor Drivers Us

📋 Overview

The CNC Expansion Shield V3 transforms your Arduino UNO or MEGA2560 into a powerful 4-axis stepper motor controller. Originally designed by Protoneer, this shield is the industry-standard solution for DIY CNC routers, laser engravers, 3D printers, and multi-axis robotics projects.

The shield provides dedicated sockets for up to four stepper motor driver modules (A4988 or DRV8825), along with connectors for limit switches, a spindle/laser, coolant control, and GRBL control signals — all without any soldering or complex wiring.

Key highlights:

4 independent stepper motor channels (X, Y, Z, and A/clone axis)
Plug-and-play sockets for A4988 or DRV8825 driver modules
GRBL firmware compatible — converts G-code into precise stepping signals
Limit switch headers for all axes (6 total: 2 per axis for X, Y, Z)
Spindle enable and direction control pins
Coolant enable output pin
Abort, Hold, and Resume control pins
Onboard microstepping jumpers for each axis
Powered by 12–36V DC via screw terminals

Note: The kit from Envistia includes four A4988 stepper motor driver modules with heatsinks. For detailed information about the A4988 drivers themselves (pinout, current limiting, VREF setup), please refer to our dedicated A4988 Stepper Motor Driver User Guide.

📐 Specifications

Parameter	Value
Shield Version	V3.0 / V3.10 / V3.51
Compatible Boards	Arduino UNO-Compatible, Arduino MEGA2560-Compatible
Compatible Drivers	A4988, DRV8825 (Pololu-compatible pinout)
Stepper Channels	4 (X, Y, Z, A)
Motor Supply Voltage	12V – 36V DC
Logic Supply	5V (derived from Arduino USB or VIN)
Firmware Compatibility	GRBL 0.8, 0.9, 1.1
Limit Switch Inputs	6 (X+, X-, Y+, Y-, Z+, Z-)
Control Outputs	Spindle Enable, Spindle Direction, Coolant Enable
Control Inputs	Abort, Feed Hold, Resume
Microstepping	Configurable per axis via jumpers
Board Dimensions	~68mm × 53mm (matches Arduino UNO footprint)

🔌 Shield Layout and Connectors

The CNC Shield V3 plugs directly onto the Arduino UNO's header pins. Here is a breakdown of all the connectors and headers on the board:

Stepper Driver Sockets

The shield has four sets of driver sockets labeled X, Y, Z, and A. Each socket accepts one A4988 or DRV8825 driver module.

⚠️ Critical: Driver orientation matters! When inserting the driver modules, the potentiometer (small brass adjustment screw) must face toward the power screw terminals (away from the Arduino USB port). Inserting a driver backwards will destroy it instantly when power is applied.

Motor Output Headers

Each axis has a 4-pin header for connecting the stepper motor's coil wires. These are typically labeled with color codes on the board:

Header Color	Axis
Yellow	X-axis
Red	Y-axis
Blue	Z-axis
Green/White	A-axis (4th axis)

Power Input

Terminal	Description
12–36V	Motor power supply positive (+) via screw terminal
GND	Motor power supply negative (−) via screw terminal

End Stop / Limit Switch Headers

Six 2-pin headers for limit switches, arranged in pairs for each axis:

Header	Arduino Pin	Description
X-	D9	X-axis minimum limit switch
X+	D9	X-axis maximum limit switch (shared pin)
Y-	D10	Y-axis minimum limit switch
Y+	D10	Y-axis maximum limit switch (shared pin)
Z-	D11	Z-axis minimum limit switch
Z+	D11	Z-axis maximum limit switch (shared pin)

Note: By default, the + and − limit switches for each axis share the same Arduino pin. GRBL can be configured to use them as a combined home/limit signal. Each end stop header has two pins: Signal and GND. The switches are "normally open" — they connect the signal pin to GND when triggered.

Control Pin Headers

Header	Arduino Pin	Function
Abort	A0	Emergency stop — immediately halts all motion
Hold	A1	Feed hold — pauses motion (can be resumed)
Resume	A2	Resumes motion after a feed hold
Coolant Enable	A3	Turns on/off a coolant pump or mist system
Spindle Enable	D12	Enables/disables the spindle motor or laser
Spindle Direction	D13	Controls spindle rotation direction (CW/CCW)

⚙️ Arduino Pin Mapping

The CNC Shield V3 maps specific Arduino UNO pins to each function. This is important whether you're using GRBL firmware or writing your own Arduino sketches.

Stepper Motor Pins

Function	Arduino Pin
X-axis STEP	D2
X-axis DIR	D5
Y-axis STEP	D3
Y-axis DIR	D6
Z-axis STEP	D4
Z-axis DIR	D7
Stepper Enable (all axes)	D8

A-Axis (4th Axis) — See Jumper Configuration

The 4th axis (A) does not have its own dedicated Arduino pins. Instead, it clones (mirrors) one of the other axes using jumper settings. See the 4th Axis Jumper Configuration section below.

Limit Switch Pins

Function	Arduino Pin
X Limit	D9
Y Limit	D10
Z Limit	D11

Control Pins

Function	Arduino Pin
Abort	A0
Feed Hold	A1
Resume	A2
Coolant Enable	A3
Spindle Enable	D12
Spindle Direction	D13
Stepper Enable	D8 (active LOW — LOW = motors enabled)

🔧 Assembly and Setup

Step 1: Attach the Shield to the Arduino

Align the CNC Shield's header pins with the Arduino UNO's female headers.
Press the shield firmly and evenly onto the Arduino until fully seated.
Ensure all pins are properly aligned — no pins should be bent or hanging off the edge.

Step 2: Install the Heatsinks on the A4988 Drivers

Peel the adhesive backing from each heatsink.
Place each heatsink on the A4988 chip (the largest IC on the driver board).
Press firmly to adhere.

Step 3: Set the Current Limit on Each A4988

Before inserting the drivers into the shield, set the current limit (VREF) on each A4988 module to match your stepper motors. Refer to our A4988 Stepper Motor Driver User Guide for the complete VREF adjustment procedure.

Step 4: Insert the Stepper Drivers

Identify the correct orientation — the potentiometer (brass screw) faces toward the power screw terminals.
Carefully align the driver pins with the socket.
Press the driver straight down into the socket until fully seated.
Install drivers for each axis you plan to use (X, Y, Z, and optionally A).

⚠️ Never insert or remove driver modules while the shield is powered. This will destroy the driver and may damage the Arduino.

Step 5: Configure Microstepping Jumpers

See the Microstepping Jumper Configuration section below.

Step 6: Connect the Power Supply

Connect your 12–36V DC power supply to the screw terminals on the shield.
Observe correct polarity: + to the positive terminal, − to GND.
Use a power supply rated for the total current draw of all your stepper motors combined.

Tip: A 12V 5A power supply is a good starting point for most setups with 2–4 NEMA 17 motors.

Step 7: Connect the Stepper Motors

Connect each stepper motor's 4 wires to the corresponding axis motor header (X, Y, Z, or A).
Identify the coil pairs using a multimeter (see the A4988 User Guide for wire identification instructions).
If a motor spins in the wrong direction, swap the two wires of one coil at the header.

⚙️ Microstepping Jumper Configuration

Below each driver socket on the shield, there are three jumper positions labeled M0, M1, and M2 (corresponding to MS1, MS2, MS3 on the driver). Installing a jumper cap bridges the pins to HIGH.

For A4988 Drivers

M0	M1	M2	Resolution	Steps/Rev (1.8° motor)
○	○	○	Full step	200
●	○	○	Half step	400
○	●	○	Quarter step	800
●	●	○	Eighth step	1,600
●	●	●	Sixteenth step	3,200

(● = jumper installed, ○ = no jumper)

For DRV8825 Drivers

M0	M1	M2	Resolution	Steps/Rev (1.8° motor)
○	○	○	Full step	200
●	○	○	Half step	400
○	●	○	Quarter step	800
●	●	○	Eighth step	1,600
○	○	●	Sixteenth step	3,200
●	●	●	1/32 step	6,400

Tip: For CNC applications, eighth step (1/8) is a popular choice — it provides a good balance between resolution and speed. For 3D printing, sixteenth step (1/16) is common.

🔀 4th Axis Jumper Configuration

The CNC Shield V3 has a set of two jumpers near the A-axis socket that determine how the 4th axis behaves. The 4th axis can be configured to clone (mirror) any of the three main axes:

Jumper Position	4th Axis Clones
Both jumpers on bottom position	X-axis (mirrors X step/dir signals)
Both jumpers on middle position	Y-axis (mirrors Y step/dir signals)
Both jumpers on top position	Z-axis (mirrors Z step/dir signals)

When to Use the 4th Axis

Dual-motor axes: If your CNC machine uses two stepper motors on the same axis (e.g., two motors driving the Y-axis gantry), clone that axis to the A-axis and connect the second motor to the A-axis header.
Independent 4th axis: For true independent 4th-axis control, you'll need custom firmware or a modified GRBL build that supports 4 axes (standard GRBL supports 3 axes).

🔗 Connecting End Stops / Limit Switches

Limit switches (also called end stops) tell the controller when an axis has reached its physical travel limit. They are essential for homing and for preventing the machine from crashing into its frame.

Wiring

Each end stop header has two pins: Signal and GND.

Connect one terminal of your limit switch to the Signal pin.
Connect the other terminal to the GND pin.
The switches should be normally open (NO) — they close the circuit when triggered.

Configuration in GRBL

By default, GRBL treats the limit switches as active-low with internal pull-up resistors. When a switch is triggered (closed), the signal pin is pulled to GND, and GRBL detects the limit.

To enable limit switches and homing in GRBL, use these configuration commands via the serial terminal:

  
$20=1    (Enable soft limits)
$21=1    (Enable hard limits)
$22=1    (Enable homing cycle)
$23=0    (Homing direction invert mask — adjust as needed)
$24=25   (Homing feed rate, mm/min)
$25=500  (Homing seek rate, mm/min)                                        

🖥️ Using with GRBL Firmware

The CNC Shield V3 is designed to work seamlessly with GRBL, the open-source G-code interpreter that runs on Arduino. GRBL converts G-code commands into precisely timed stepper motor pulses.

Installing GRBL on Arduino UNO

Download the latest GRBL release from github.com/grbl/grbl.
Open the Arduino IDE.
Go to Sketch → Include Library → Add .ZIP Library and select the downloaded GRBL .zip file.
Go to File → Examples → grbl → grblUpload.
Select your Arduino board (Tools → Board → Arduino UNO) and the correct COM port.
Click Upload.

Connecting to GRBL

Once GRBL is uploaded, you can communicate with it via any serial terminal at 115200 baud:

Arduino IDE Serial Monitor (set to 115200 baud, "Newline" line ending)
Universal G-code Sender (UGS) — a popular free GUI
bCNC — another popular open-source CNC controller
Easel (by Inventables) — web-based, beginner-friendly
CNCjs — web-based CNC controller

Essential GRBL Configuration Commands

Type these commands in the serial terminal to configure GRBL for your machine:

Command	Description	Example
`$$`	View all current settings	`$$`
`$0`	Step pulse time (µs)	`$0=10`
`$1`	Step idle delay (ms)	`$1=25`
`$100`	X steps/mm	`$100=250`
`$101`	Y steps/mm	`$101=250`
`$102`	Z steps/mm	`$102=250`
`$110`	X max rate (mm/min)	`$110=500`
`$111`	Y max rate (mm/min)	`$111=500`
`$112`	Z max rate (mm/min)	`$112=500`
`$120`	X acceleration (mm/sec²)	`$120=10`
`$121`	Y acceleration (mm/sec²)	`$121=10`
`$122`	Z acceleration (mm/sec²)	`$122=10`

Calculating Steps Per Millimeter

Use this formula to determine the correct $100, $101, $102 values:

Steps/mm = (Motor steps per rev × Microstepping) / (Belt pitch × Pulley teeth)

Example: A 1.8° motor (200 steps/rev) with 1/8 microstepping, a GT2 belt (2mm pitch), and a 20-tooth pulley:

Steps/mm = (200 × 8) / (2 × 20) = 1600 / 40 = 40 steps/mm

For lead screw drives:

Steps/mm = (Motor steps per rev × Microstepping) / Lead screw pitch (mm)

💻 Using with Arduino IDE (Without GRBL)

You can also control the CNC Shield directly from Arduino sketches without GRBL. This is useful for simple automation, testing, or custom motion control projects.

Basic Example: Move X and Y Axes


// CNC Shield V3 - Direct Arduino Control
// Envistia Mall - envistiamall.com

// Pin definitions (CNC Shield V3 mapping)
#define X_STEP  2
#define X_DIR   5
#define Y_STEP  3
#define Y_DIR   6
#define Z_STEP  4
#define Z_DIR   7
#define EN_PIN  8   // Stepper enable (active LOW)

void setup() {
  // Set all pins as outputs
  pinMode(X_STEP, OUTPUT);
  pinMode(X_DIR, OUTPUT);
  pinMode(Y_STEP, OUTPUT);
  pinMode(Y_DIR, OUTPUT);
  pinMode(Z_STEP, OUTPUT);
  pinMode(Z_DIR, OUTPUT);
  pinMode(EN_PIN, OUTPUT);

  // Enable stepper drivers (active LOW)
  digitalWrite(EN_PIN, LOW);
}

void loop() {
  // Move X-axis 200 steps forward
  digitalWrite(X_DIR, HIGH);
  for (int i = 0; i < 200; i++) {
    digitalWrite(X_STEP, HIGH);
    delayMicroseconds(800);
    digitalWrite(X_STEP, LOW);
    delayMicroseconds(800);
  }

  delay(500);

  // Move Y-axis 200 steps forward
  digitalWrite(Y_DIR, HIGH);
  for (int i = 0; i < 200; i++) {
    digitalWrite(Y_STEP, HIGH);
    delayMicroseconds(800);
    digitalWrite(Y_STEP, LOW);
    delayMicroseconds(800);
  }

  delay(500);

  // Move both axes back
  digitalWrite(X_DIR, LOW);
  digitalWrite(Y_DIR, LOW);
  for (int i = 0; i < 200; i++) {
    digitalWrite(X_STEP, HIGH);
    digitalWrite(Y_STEP, HIGH);
    delayMicroseconds(800);
    digitalWrite(X_STEP, LOW);
    digitalWrite(Y_STEP, LOW);
    delayMicroseconds(800);
  }

  delay(1000);
}

Example: Using AccelStepper Library with CNC Shield

For smoother motion with acceleration, use the AccelStepper library (install via Arduino IDE Library Manager):


// CNC Shield V3 with AccelStepper Library
// Envistia Mall - envistiamall.com

#include 

// Define steppers using CNC Shield pin mapping
AccelStepper stepperX(AccelStepper::DRIVER, 2, 5);  // STEP=D2, DIR=D5
AccelStepper stepperY(AccelStepper::DRIVER, 3, 6);  // STEP=D3, DIR=D6
AccelStepper stepperZ(AccelStepper::DRIVER, 4, 7);  // STEP=D4, DIR=D7

#define EN_PIN 8

void setup() {
  // Enable drivers
  pinMode(EN_PIN, OUTPUT);
  digitalWrite(EN_PIN, LOW);

  // Configure X-axis
  stepperX.setMaxSpeed(1000);
  stepperX.setAcceleration(500);

  // Configure Y-axis
  stepperY.setMaxSpeed(1000);
  stepperY.setAcceleration(500);

  // Configure Z-axis
  stepperZ.setMaxSpeed(800);
  stepperZ.setAcceleration(300);
}

void loop() {
  // Move X to position 1600, Y to 800, Z to 400
  stepperX.moveTo(1600);
  stepperY.moveTo(800);
  stepperZ.moveTo(400);

  // Run all steppers simultaneously until they reach targets
  while (stepperX.isRunning() || stepperY.isRunning() || stepperZ.isRunning()) {
    stepperX.run();
    stepperY.run();
    stepperZ.run();
  }

  delay(1000);

  // Return all axes to home
  stepperX.moveTo(0);
  stepperY.moveTo(0);
  stepperZ.moveTo(0);

  while (stepperX.isRunning() || stepperY.isRunning() || stepperZ.isRunning()) {
    stepperX.run();
    stepperY.run();
    stepperZ.run();
  }

  delay(1000);
}

⚡ Power Supply Requirements

Supply	Source	Voltage	Purpose
Logic Power	Arduino USB or VIN	5V	Powers the Arduino and shield logic
Motor Power	Screw terminals on shield	12–36V DC	Powers all stepper motors via the drivers

Important Power Notes

Use an adequate power supply. Each NEMA 17 motor can draw 0.5–2A. With four motors, you may need a supply rated for 5A or more at 12V.
Do NOT power the motors from the Arduino's 5V rail. The screw terminals on the shield provide a separate motor power path.
A 12V 5A–10A power supply is recommended for most 3-axis CNC setups with NEMA 17 motors.
ATX computer power supplies work well — use the 12V rail and connect the GND.
The shield does not have a built-in voltage regulator for the motor supply — the voltage goes directly to the driver modules.

⚠️ Never exceed 35V when using A4988 drivers, or 45V when using DRV8825 drivers.

🌡️ Thermal Considerations

Always install the included heatsinks on the A4988 driver chips before use.
For sustained operation at higher currents (above 1A per phase), add a small cooling fan directed at the driver modules.
If drivers are overheating, reduce the current limit (VREF) on the A4988 potentiometer.
Ensure adequate ventilation around the shield in any enclosure.

❓ Troubleshooting

No motors move

Verify the 12–36V motor power supply is connected and turned on.
Check that the Enable pin (D8) is LOW. In GRBL, motors are enabled automatically. In custom Arduino code, add digitalWrite(8, LOW);.
Confirm the A4988 drivers are inserted in the correct orientation (potentiometer toward power terminals).
Ensure GRBL firmware is properly uploaded to the Arduino.

Only some axes move

Check that a driver module is installed in the socket for the non-working axis.
Verify the motor is properly connected to the correct axis header.
Test the driver by swapping it with a known working driver from another axis.

Motors vibrate but don't rotate

The coil wires are swapped. Try swapping the two wires of one coil at the motor header.
The current limit (VREF) may be too low — increase it slightly on the A4988 potentiometer.

Motors are very hot

The current limit is set too high. Reduce the VREF on the A4988 driver. Stepper motors do get warm during normal operation, but they should not be too hot to touch.

GRBL doesn't respond

Verify the correct COM port is selected in your serial terminal software.
Set the baud rate to 115200.
Try pressing the Reset button on the Arduino.
Re-upload the GRBL firmware.

Limit switches don't work

Verify wiring: one switch terminal to Signal, the other to GND.
Enable hard limits in GRBL: $21=1.
Enable homing: $22=1.
Test the switch by manually triggering it and checking the signal with ? status report in GRBL.

A4988 driver burns out

The driver was likely inserted backwards — always verify the potentiometer faces the power terminals.
The motor was connected or disconnected while powered — always power off before changing motor connections.
The motor supply voltage exceeded 35V (including voltage spikes).
No decoupling capacitor — while the shield has some onboard capacitance, adding a 100µF electrolytic capacitor across the motor power terminals is recommended for additional protection.

⚠️ Important Safety Warnings

Verify driver orientation before powering on. Inserting an A4988 or DRV8825 backwards will destroy it immediately.
Never connect or disconnect stepper motors while the shield is powered. Always turn off the power supply first.
Do not exceed the voltage rating of your driver modules (35V for A4988, 45V for DRV8825).
Set the current limit (VREF) before running motors to prevent overheating.
Use an appropriately rated power supply for the total current draw of all motors.
Keep hands and loose clothing away from moving CNC components during operation.
Wear safety glasses when operating CNC routers or laser engravers.

🛒 Where to Buy the CNC Expansion Shield

A4988 CNC Expansion Shield →

📚 References and Additional Resources

Envistia Mall Guides

A4988 Stepper Motor Driver User Guide — Complete guide for the included A4988 driver modules

Firmware and Software

GRBL Firmware (GitHub) — Open-source G-code interpreter for Arduino
GRBL Configuration Wiki — Detailed GRBL settings reference
Universal G-code Sender (UGS) — Free G-code sender application
bCNC — Open-source CNC controller with CAM features
CNCjs — Web-based CNC controller interface

Hardware References

Protoneer CNC Shield V3 Assembly Guide — Original designer's assembly guide
Allegro A4988 Datasheet (PDF) — Full technical datasheet
AccelStepper Library Documentation — Arduino library for smooth stepper control

Community and Learning

GRBL Wiki — Comprehensive GRBL documentation

This guide is provided by Envistia Mall for educational and technical reference purposes. The manufacturer and Envistia LLC (dba Envistia Mall) are not responsible for any damages or losses resulting from the use of this product. Always follow proper electrical safety practices when working with electronic components. Specifications are based on manufacturer data and are subject to change without notice.

Country/region

Language