Amazon.in
Grafito CANStepper on Amazon India (ASIN B0HP1B8G36), for buyers who prefer marketplace checkout and delivery.
View on Amazon.inPrices in INR · India
Included in the box
- TMC2209 heat sink
- Ready-made cables, crimped based on customer requirement
- 4 × M3 40.0 mm socket head screws
- Encoder magnet
- 4 × 3 mm spacers
Is CANStepper right for you?
- Robot arms and other multi-axis robots
- Camera sliders, turntables and kinetic builds
- Lab and liquid-handling automation
- Python, Raspberry Pi and custom motion projects
- PLCs and other CANopen (CiA 402) masters
- Drop-in use in Klipper or Marlin 3D printers
- GRBL, Mach3 or other STEP/DIR CNC controllers
CANStepper takes motion commands over CAN or USB and has no STEP/DIR input, so it does not replace a printer or CNC driver. For a Klipper printer toolhead, a Klipper CAN toolboard is the better fit.
CANSTEPPER · CLOSED-LOOP CAN NODEDownload datasheet
CANStepper: closed-loop NEMA 17 control over CAN, programmable in Python
₹3,769₹2,89930% OFF
You save ₹870
Bolt it on the back of a NEMA 17, pip install grafito-canstepper, and command position from Python over USB or CAN. Missed steps are detected and corrected on the board, and up to 31 axes share one two-wire CAN bus. Designed and supported by Grafito Innovations in Kerala, India.
On-board closed loop · 14-bit encoderUp to 31 axes on one CAN busPython API · pre-flashed firmwareGitHub
Choose your option
Selected: Board Only — ₹2,899
Available on backorder
One component is currently out of stock. Order and pay now, and your order ships as soon as it arrives. Estimated lead time: 1–2 weeks.
Ships across India · 30-day returns
- Ships worldwide from Kerala, India (currently on backorder, est. 1–2 weeks)
- 30-day returns on unused units in original packaging
- Defective units replaced (email hello@grafito.in with photos)
- Bulk and college lab quotations with GST
- Engineering support from the team that wrote the firmware
- Never lose position: a 200 Hz on-board position loop with a 14-bit MT6701 encoder; median settling error 0.11° in our published tests
- Wire a multi-axis robot with one cable: CAN daisy-chain, a DIP switch for termination, and one board acts as the USB bridge
- Code, not config files: a Python API for moves, homing, telemetry and coordinated motion (pip install grafito-canstepper)
- Fully CANopen compatible: firmware 2.1 speaks CiA 301 and CiA 402 (profile position, profile velocity, and homing) and ships an EDS for PLC masters
- TMC2209 driver, ESP32-C3 with Wi-Fi and Bluetooth, USB-C, 5–24 V input and a limit-switch port on one board
Applications
Robot armsMulti-axis robotsLab automationCamera sliders & turntablesConveyorsCustom motion rigs
A networked closed-loop axis for every NEMA 17.
CANStepper mounts on the back of a standard NEMA 17 motor and combines a TMC2209 driver, a 14-bit MT6701 magnetic encoder, an ESP32-C3 and a CAN transceiver on one board. The position loop runs on the board itself, so each motor becomes an independent node you command over CAN or USB.
We developed it for motion axes in our own robotics work at Grafito Innovations, then opened it up for other builders who write their own motion code: robot arms, lab automation, camera rigs and multi-axis research setups.
What type of closed-loop stepper solution is CANStepper? CANStepper is a retrofit integrated-controller solution. It mounts onto a standard NEMA 17 motor and combines the motor driver, encoder feedback, control processor and communication interface on one board. Unlike a complete integrated closed-loop motor, CANStepper lets you retain or select your own compatible NEMA 17 motor. Unlike a conventional external closed-loop driver, the controller and encoder are mounted directly at the motor and communicate over CAN Bus.
| Solution Type | Driver Location | Encoder | Motor | Communication | Common Models | NEMA Sizes |
|---|---|---|---|---|---|---|
| External closed-loop driver | Separate enclosure | External (wired to driver) | Standard NEMA 17/23/34 | Step/direction | Leadshine CL57T, CL86T · JMC HSD57, HSD86 | NEMA 17 / 23 / 34 |
| Integrated closed-loop motor | Inside motor housing | Built into motor | Proprietary motor | Step/direction or bus | JMC iHSS57 · MKS SERVO42C | NEMA 17 (frame-specific) |
| Retrofit controller (CANStepper) | Motor-mounted board | Onboard magnetic encoder | Standard NEMA 17 (user-retained) | CAN Bus (GCSP or CANopen) + WiFi + BLE | Grafito CANStepper | NEMA 17 only |
For NEMA 23 or NEMA 34 applications, see our guides page for external driver options.
Full documentation, including GCSP v1, the CANopen / CiA 402 firmware, the Python library, closed-loop speed tuning, the hardware guide and measured open-loop vs closed-loop speed limits, is published at https://docs.grafito.in. Install the host library with: pip install grafito-canstepper. CANopen guide: https://docs.grafito.in/docs/canopen
Measured Performance
Characterization motor: PR42HS40-1204AF-02 NEMA 17 (1.2 A rated, 3.2 mH, 4.2 kg·cm holding, D-shaft Ø4.5×19 mm, frame 42×42×40 mm, rotor inertia 54 g·cm²). All tests at 24 V, firmware ≥1.2, SpreadCycle, 8 µsteps, unless noted.
| Test condition | Result |
|---|---|
| Motor model and length | PR42HS40-1204AF-02, NEMA 17 40 mm |
| Supply voltage | 24 V DC |
| Motor current setting (RMS) | 70% run_current (~0.84 A RMS on 1.2 A rated motor) |
| No-load maximum speed (open-loop) | ~7200 deg/s (~1200 RPM) |
| Loaded maximum speed (closed-loop cruise proven) | ~6000 deg/s (~1000 RPM) max proven; 4800 deg/s (800 RPM) production default |
| Position-loop update rate | 200 Hz (5 ms control interval) |
| Stall detection response | StallGuard4 via TMC2209 DIAG pin; firmware ≥1.4 reports driver faults over CAN |
| Position settling error | Median 0.11°, max 0.46° (pid_tolerance 0.35° window) |
| Continuous operating duration tested | 10-minute soak: 239 full cycles, 478/478 settles, 100% success, 0 faults/timeouts/USB errors |
| Driver temperature (MCU, during soak) | MCU 41.4→61.4 °C; TMC2209 OTPW frequent without heatsink at high duty |
| Test load/inertia | No external load; rotor inertia 54 g·cm² + encoder magnet |
Full test matrix, soak logs, and tuning procedure: docs.grafito.in/docs/closed-loop-tuning. Graphs and videos for commanded vs measured position, open-loop vs closed-loop error, stall recovery, RPM vs load, driver temperature over time, multi-axis CAN latency, and repeatability are available on the tuning page and the Grafito CANStepper YouTube channel.
Compatibility Requirements
CANStepper is fully CANopen compatible. Firmware 2.1 implements CiA 301 and CiA 402 (profile position, profile velocity, and homing). Import GrafitoCANStepper.eds into the PLC and enable the drive with controlword 0x6040 = 6, then 7, then 15. The same board also runs GCSP v1 for the Python library. Keep one protocol on a CAN bus. Guide: docs.grafito.in/docs/canopen.
| Requirement | Specification |
|---|---|
| Supported NEMA 17 motor lengths | Any standard NEMA 17 frame (42×42 mm). Tested with 40 mm body length; board mounts on rear face |
| Maximum motor current | 2.0 A RMS / 2.8 A peak (TMC2209 limit) |
| Required rear-shaft / magnet arrangement | Rear shaft with diametric magnet centered over MT6701 at 1–2 mm air gap |
| Compatible shaft diameter | D-shaft Ø4.5–5 mm typical for NEMA 17 |
| Magnet placement tolerance | Centered within ~0.5 mm over encoder IC; 1–2 mm gap |
| Maximum recommended supply voltage | 24 V DC (board input range: 5–24 V) |
| CAN-to-USB adapter included? | No — USB-C on the board provides direct serial access; a single board acts as the CAN–USB bridge |
| Firmware pre-installed? | Yes — pre-flashed with latest firmware; update over USB-C if needed |
| STEP/DIR input supported? | No — the board drives its own STEP/DIR pulses internally via TMC2209; motion is commanded over CAN or USB |
| CANopen supported? | Yes — fully compatible. Firmware 2.1 is CiA 301 / CiA 402 (profile position, profile velocity, homing), node IDs 1–127, EDS/DCF included. GCSP v1 remains the Python path (up to 31 nodes). One protocol per bus |
| Supported operating systems | Linux, macOS, Windows (any platform with Python 3.8+ and USB CDC serial) |
| Host languages | Python (grafito-canstepper on PyPI) over GCSP; any CANopen master (TwinCAT, CODESYS, and others) with firmware 2.1 |
| Control loop runs onboard? | Yes — trapezoidal planning, velocity feedforward, and tracking PID run on the ESP32-C3 |
| Internet / Wi-Fi required? | No (optional: Wi-Fi test portal for configuration; Bluetooth for wireless monitoring) |
| Casing suitable for industrial? | 3D-printed casing included; user-replaceable with custom enclosure for harsh environments |
| Operating temperature range | Ambient: 0–50 °C (estimated); TMC2209 OTPW at ~120 °C die, OT shutdown at ~150 °C die |
| Reverse polarity protection? | Not confirmed — use a regulated DC supply and verify polarity before connecting |
| Overcurrent protection? | Yes — TMC2209 internal current regulation and short-to-ground detection; fault=5 (DRIVER_SHORT) reported on fw ≥1.4 |
| Overheating protection? | Yes — TMC2209 OTPW pre-warning + OT shutdown (fault=4); reported over CAN on fw ≥1.4 |
CANStepper puts the driver, encoder and controller on the back of each NEMA 17, so a multi-axis machine needs one CAN cable instead of a driver and cable bundle per axis.
A 200 Hz position loop on the ESP32-C3 reads the 14-bit MT6701 encoder and corrects missed steps on the board. Published tests: median settling error 0.11°, 478/478 settles in a 10-minute soak.
Measured Performance
Characterization motor: PR42HS40-1204AF-02 NEMA 17 (1.2 A rated, 3.2 mH, 4.2 kg·cm holding, D-shaft Ø4.5×19 mm, frame 42×42×40 mm, rotor inertia 54 g·cm²). All tests at 24 V, firmware ≥1.2, SpreadCycle, 8 µsteps, unless noted.
| Test condition | Result |
|---|---|
| Motor model and length | PR42HS40-1204AF-02, NEMA 17 40 mm |
| Supply voltage | 24 V DC |
| Motor current setting (RMS) | 70% run_current (~0.84 A RMS on 1.2 A rated motor) |
| No-load maximum speed (open-loop) | ~7200 deg/s (~1200 RPM) |
| Loaded maximum speed (closed-loop cruise proven) | ~6000 deg/s (~1000 RPM) max proven; 4800 deg/s (800 RPM) production default |
| Position-loop update rate | 200 Hz (5 ms control interval) |
| Stall detection response | StallGuard4 via TMC2209 DIAG pin; firmware ≥1.4 reports driver faults over CAN |
| Position settling error | Median 0.11°, max 0.46° (pid_tolerance 0.35° window) |
| Continuous operating duration tested | 10-minute soak: 239 full cycles, 478/478 settles, 100% success, 0 faults/timeouts/USB errors |
| Driver temperature (MCU, during soak) | MCU 41.4→61.4 °C; TMC2209 OTPW frequent without heatsink at high duty |
| Test load/inertia | No external load; rotor inertia 54 g·cm² + encoder magnet |
Full test matrix, soak logs, and tuning procedure: docs.grafito.in/docs/closed-loop-tuning. Graphs and videos for commanded vs measured position, open-loop vs closed-loop error, stall recovery, RPM vs load, driver temperature over time, multi-axis CAN latency, and repeatability are available on the tuning page and the Grafito CANStepper YouTube channel.
CANStepper ships pre-flashed. Mount it, power it, run pip install grafito-canstepper and most builders have closed-loop motion in about 15 minutes (quickstart: docs.grafito.in).
Node 1 acts as the USB-to-CAN bridge. Chain up to 31 nodes with 4-pin JST PH 2.0 cables (+24V, CANL, CANH, GND) and switch termination on only at the two ends.
Complete specifications:
Technical Specifications Table
| Specification | Value |
|---|---|
| Product Type | Closed-loop NEMA 17 controller with CAN Bus (motor-mounted) |
| Command Input | CAN Bus (GCSP v1 or CANopen CiA 402) or USB; no STEP/DIR input |
| Supported Motor Type | NEMA 17 stepper motor |
| Control Mode | Closed-loop with magnetic encoder feedback |
| Motor Driver | TMC2209 |
| Encoder | Up to 14-bit magnetic rotary (MT6701) |
| Angle Resolution | ~0.022° per step |
| Input Voltage | 5-24V |
| Motor Current | 2.0A RMS / 2.8A peak |
| MCU | ESP32-C3 (WiFi + Bluetooth) |
| Communication | CAN Bus daisy-chain (GCSP v1 or CANopen CiA 402), USB-C, WiFi, Bluetooth |
| Limit Switches | 3-position JST PH 2.0 (micro / proximity / inductive) |
Built for projects where your own software plans the motion. CANStepper has no STEP/DIR input and is commanded over CAN or USB.
Included: TMC2209 heatsink, 4 M3 40 mm screws, encoder magnet, 4 3 mm spacers, 6 4-way JST PH 2.0 connectors, 2 3-way JST PH 2.0 connectors, and motor connector.
Choose Board only if you already have a NEMA 17 with a rear shaft rated within 2.0 A RMS / 2.8 A peak; choose Board + motor for a complete axis. Buy from grafito.in or Amazon.in (ASIN B0HP1B8G36).
Compatibility Requirements
CANStepper is fully CANopen compatible. Firmware 2.1 implements CiA 301 and CiA 402 (profile position, profile velocity, and homing). Import GrafitoCANStepper.eds into the PLC and enable the drive with controlword 0x6040 = 6, then 7, then 15. The same board also runs GCSP v1 for the Python library. Keep one protocol on a CAN bus. Guide: docs.grafito.in/docs/canopen.
| Requirement | Specification |
|---|---|
| Supported NEMA 17 motor lengths | Any standard NEMA 17 frame (42×42 mm). Tested with 40 mm body length; board mounts on rear face |
| Maximum motor current | 2.0 A RMS / 2.8 A peak (TMC2209 limit) |
| Required rear-shaft / magnet arrangement | Rear shaft with diametric magnet centered over MT6701 at 1–2 mm air gap |
| Compatible shaft diameter | D-shaft Ø4.5–5 mm typical for NEMA 17 |
| Magnet placement tolerance | Centered within ~0.5 mm over encoder IC; 1–2 mm gap |
| Maximum recommended supply voltage | 24 V DC (board input range: 5–24 V) |
| CAN-to-USB adapter included? | No — USB-C on the board provides direct serial access; a single board acts as the CAN–USB bridge |
| Firmware pre-installed? | Yes — pre-flashed with latest firmware; update over USB-C if needed |
| STEP/DIR input supported? | No — the board drives its own STEP/DIR pulses internally via TMC2209; motion is commanded over CAN or USB |
| CANopen supported? | Yes — fully compatible. Firmware 2.1 is CiA 301 / CiA 402 (profile position, profile velocity, homing), node IDs 1–127, EDS/DCF included. GCSP v1 remains the Python path (up to 31 nodes). One protocol per bus |
| Supported operating systems | Linux, macOS, Windows (any platform with Python 3.8+ and USB CDC serial) |
| Host languages | Python (grafito-canstepper on PyPI) over GCSP; any CANopen master (TwinCAT, CODESYS, and others) with firmware 2.1 |
| Control loop runs onboard? | Yes — trapezoidal planning, velocity feedforward, and tracking PID run on the ESP32-C3 |
| Internet / Wi-Fi required? | No (optional: Wi-Fi test portal for configuration; Bluetooth for wireless monitoring) |
| Casing suitable for industrial? | 3D-printed casing included; user-replaceable with custom enclosure for harsh environments |
| Operating temperature range | Ambient: 0–50 °C (estimated); TMC2209 OTPW at ~120 °C die, OT shutdown at ~150 °C die |
| Reverse polarity protection? | Not confirmed — use a regulated DC supply and verify polarity before connecting |
| Overcurrent protection? | Yes — TMC2209 internal current regulation and short-to-ground detection; fault=5 (DRIVER_SHORT) reported on fw ≥1.4 |
| Overheating protection? | Yes — TMC2209 OTPW pre-warning + OT shutdown (fault=4); reported over CAN on fw ≥1.4 |
Where to buy
Order from the official Grafito shop for documentation, firmware guidance and direct support, or buy through Amazon.in if you prefer marketplace delivery. Choose Board + motor if you need a motor; Board only if you already have a NEMA 17.
Official Grafito shop
Order directly from grafito.in. The official shop ships worldwide, with documentation, support from Grafito Innovations, and the latest board firmware guidance.
Buy from the Grafito shopDocumentation, software & project lineage
Complete CANStepper documentation lives at https://docs.grafito.in — quickstart, hardware wiring, GCSP v1 protocol, Python API, coordinated motion, and closed-loop trapezoid + feedforward tuning (firmware ≥1.2). The host library is on PyPI as grafito-canstepper (import canstepper).
This product was inspired by the open community project CANBUS-Stepper by Josh R (https://github.com/joshr120/CANBUS-Stepper). That work helped shape the idea of a NEMA 17–mounted, CAN-connected closed-loop stepper node.
The Grafito CANStepper Adapter Board is not a copy or fork of that design. Board architecture — including component selection, placement, routing, and the full software stack (firmware, GCSP protocol, and host library) — was independently developed by Grafito Innovations for its internal project requirements and commercial products.
Mechanical CAD, assembly & drawings
Download the V2 product brochure, assembled photo, board pinout, daisy-chain diagram, PCB STEP model, casing mount, heat spreader, and TMC2209 heatsink for enclosure design and machine integration. Previews render on this page; the same pack is documented at docs.grafito.in.
Assembly walkthrough
Physical assembly of the CANStepper board on a NEMA 17 (magnet, heatsink, casing as applicable).
Leader / follower (encoder mirroring)
Dual-motor demo: follower mirrors the leader encoder over CAN — same idea as DualMotorAxis / dual-Z sync.
CAN daisy-chain diagram
Download daisy-chain diagram
V2 assembled board
Download assembled photo
PCB mechanical drawing V2 (PDF)
All CAD downloads
Product Brochure (PDF)
PDFCANStepper v2 product brochure — features, specs, applications, and ordering information.
Board pinout
ImageV2 connector and pin map for power, CAN, USB-C, and motor wiring.
CAN daisy-chain diagram
ImageMulti-axis daisy-chain wiring for CANStepper nodes.
System block diagram
ImageArchitecture overview: MCU, driver, encoder, CAN, power, and motor path.
PCB 3D model (STEP)
STEPV2 full-board solid model for CAD clearance and assembly (~24 MB).
Casing mount (STEP)
STEP3D-printed casing / mount geometry for NEMA 17 installation.
Heat spreader (STEP)
STEPThermal heat-spreader geometry for continuous-duty cooling stack.
TMC2209 heatsink (STEP)
STEPDriver heatsink model — recommended for high-speed closed-loop duty.
PCB drawing V2 (PDF)
PDFManufacturing / mechanical drawing for CANStepper V2.
Assembly photo (WebP)
ImageV2 board assembled on a NEMA 17 for documentation and marketing.
CANStepper vs MKS SERVO42C
Spec comparison for builders choosing between a distributed CAN-enabled NEMA 17 closed-loop adapter and the Makerbase MKS SERVO42C closed-loop stepper board.
| Feature | CANStepper | MKS SERVO42C |
|---|---|---|
| Project / open source | grafito.in/shop/products/canstepper-adapter-board | github.com/makerbase-mks/MKS-SERVO42C |
| Supported motor | NEMA 17 stepper motor | 42-series / NEMA 17 class closed-loop stepper setup |
| Input voltage | 5-24V | 7-28V |
| Motor current | 2.0A RMS / 2.8A peak | 0-3000mA adjustable range |
| MCU / controller | ESP32-C3 with WiFi and Bluetooth | Serial-control closed-loop controller |
| Communication | CAN Bus daisy-chain (GCSP v1 or CANopen CiA 402), USB-C, WiFi, Bluetooth | USART / serial control |
| Motor driver approach | TMC2209-based stepper drive with magnetic encoder feedback | 4 half-bridge driver with 8 MOSFETs and FOC |
| Angle resolution | Approximately 0.022 degrees per step | 0.08 degrees |
| Limit switch support | 3-position JST PH 2.0 for micro / proximity / inductive switch input | Not highlighted in official comparison table |
| Best fit | Distributed robotics, automation, CAN networks, wireless configuration | Standalone closed-loop stepper retrofit with serial control |
Frequently Asked Questions
How easy is CANStepper to set up?+
Firmware is pre-flashed, so there is nothing to compile for first motion. Mount the board on a NEMA 17, place the encoder magnet, connect 5–24V and USB-C, then run pip install grafito-canstepper. Most builders have closed-loop position control in about 15 minutes.
Does CANStepper work with Klipper, Marlin or GRBL?+
Not as a drop-in driver today. CANStepper is commanded over CAN or USB with the GCSP protocol and has no STEP/DIR input, so 3D printer and CNC firmware that expects a step/direction driver or a Klipper MCU cannot drive it. It is designed for projects where your own software (for example, the Python library) plans the motion.
How many motors can I control on one CAN Bus?+
Up to 31 CANStepper nodes can daisy-chain on a single 2-wire CAN Bus with GCSP. CANopen firmware uses node IDs 1–127. Assign each motor a unique node ID and keep every node on that bus on the same protocol.
Does it support CANopen or EtherCAT?+
CANopen: yes, fully. Firmware 2.1 implements CiA 301 and CiA 402 — profile position, profile velocity, and homing. Import GrafitoCANStepper.eds into TwinCAT, CODESYS, or another CANopen master, then enable the drive with controlword 0x6040 = 6, then 7, then 15. Units are encoder counts (16384 per revolution). Guide: https://docs.grafito.in/docs/canopen. The Python library still uses GCSP v1 (pip install grafito-canstepper). Run one protocol per CAN bus. EtherCAT is not supported.
Where can I buy CANStepper in India?+
Order directly from grafito.in/shop/products/canstepper-adapter-board (ships worldwide) or through Amazon.in (ASIN B0HP1B8G36). Board only ₹2,899 + shipping. Board + NEMA 17 motor ₹3,699.
Was this project inspired by other open hardware?+
Yes. The product concept was inspired by Josh R's CANBUS-Stepper project (https://github.com/joshr120/CANBUS-Stepper). Grafito's board architecture is different — component selection, placement, routing, and the software stack were independently developed by Grafito Innovations for its internal projects and products, and this is not a copy or fork of that design.
CANStepper Closed-Loop NEMA 17 CAN Bus Controller · Board Only
₹2,899
Backorder · ships in 1–2 weeks