The information below is provided for information only. Use at your own risk! I will not accept any responsibility for any loss, damage, harm etc that may result from the use of the information on this web page or associated pages!

To the best of my knowledge it is accurate and safe to use but don’t blame me if it isn’t!

I am not sponsored by any of the third party sites, products etc. described below and cannot state whether they are truly reliable/safe etc.

Glossary

A few key terms that may make reading the rest of this page easier.

The descriptions below are not intended to be thorough and complete but rather; a basic overview/introduction.

CNC	Computer Numerical Control. This is a very generic term but typically used for Mechanical machines such as mills, routers, cutters, printers etc.
Arduino UNO	Single board microcontroller using an Atmel ATmega328P and runs on a 16MHz core clock. The Uno has become a standard for plug on accessory boards (called Shields) although many newer versions are based on a smaller form factor
ESP32	The ESP32 is a 32bit processor with integrated Wifi/Bluetooth. The Wemos D1 R32 (that I’m using) is an Arduino Uno compatible form factor board. The ESP32 has a 240MHz core clock, 4MB flash, 512KB SDRAM as well as many other improvements with respect to the Arduino such as real DAC outputs. There are differences in particular the Inputs and Outputs (the IO). The IO pin numbering on the D1 R32 is a bit of a mess! You just need to breath slowly (in through the nose, out through the mouth… an relax) and write out what it is and what you want. I believe that some of the extra peripheral pins I wanted to use as outputs on the CNC Shield v3 are only inputs on the ESP32 – nothing critical and I could work around this.One important note is that the ESP32 IO pins are 3.3V and not 5v tolerant.
CNC Shield V3	Designed by Protoneer.co.nz these shields plug into an Arduino Uno and provide breakout connections for limit switches, spindle control etc etc but most importantly, they provide locations for upto 4 StepStick stepper motor modules. The shield includes jumpers to control the number of microsteps used.3 of the StepStick locations are controlled by the Arduino pins directly and typically used for X, Y and Z control.The 4th StepStick module (labelled A) can be controlled using the direction and step controls of either X, Y or Z (via jumpers). Independent control  of the A controller may also be possible.The main purpose of the A controller is that it allows you to use 2 stepper motors in parallel for one axis but with an individual current source for motors.The CNC Shield V3 also has a separate power input for the stepper motors (typically around 12V) allowing the higher voltage and current to be provided – no you can’t run stepper big stepper motors directly from the power of an Arduino!
StepStick	little PCBs with a row of pins on each side that host the Stepper Motor Controller. The stepper motor controller has a “direction” and a “step” control and from these it creates the necessary voltage sequences for the stepper motor controls. The controllers typically also control the maximum current through the coils with associated over current protection, over temperature etc. The boards are typically delivered with a tiny heatsink with a self-adhesive pad on the back. Take care when fitting these heatsinks to ensure that they do not touch any of the components, pins around the controller chip. There are numerous websites and videos describing how to setup and use these (the small pot meter needs to be adjusted etc.). Please check carefully that you know which way up your modules should be inserted. Some have the pot meter at the top, other at the bottom
Microsteps	Stepper motors have distinct positions for their rotations, typically Nema17 motors move in 1.8 degrees although the ones I choose were 0.9degrees per step. The CNC Shield 3 has three jumpers underneath each StepStick module to select the microstepping. With no jumpers fitted, the controller moves in whole steps. There is nothing wrong with this and it will give strong and direct position changes HOWEVER… it will be jumpy and very noisy! Microstepping interprets between steps meaning that to move from one whole step to another it will go through 2,4,8,16,32,64,128,256 intermediate steps depending on the controller and the settings. I used the DRV8825 which support full, half, quarter, 1/8th, 1/16th and 1/32th microsteps. You need to look up the specifications for your driver. For mine, all three jumpers fitted give 1/32. Making the microsteps smaller can also have a negative effect and you may see differences in motor power, skipping steps etc. It isn’t an exact science – adjust as you need to!
GRBL	GRBL is an open source G-Code interpreter written for the Atmel AT328p. It converts G-Code instructions into the relative controls for stepper motors, servos, spindle on/off flood on/off etc etc.Very very simply (don’t complain that this isn’t accurate please!), the GRBL system knows where your machine is the moment in terms of X,Y,Z and other controls. When it receives a G-Code instruction to move to another location, it looks at the requested movement, speed of movement etc. and works out what motor controls are required to move to this now position/state. That sounds simple but it isn’t!Each system will need different settings for the mechanics, motors etc etc. The user therefore sets up parameters for each motor/axis where the most important ones are “steps per mm” “acceleration” “maximum speed”. The Steps per mm says very simply if I need 6789 steps to move 100mm in the x direction then the steps per mm is 67.89The acceleration is also very important. Your axis will have inertia and the motors etc have finite power. If you try to start at max speed, motors will stall, steps will skip etc. The acceleration factor allows the machine to gently increase and decrease in speed. You can tune this to get an efficient quick movement for your machine but without stalling.The maximum speed allows you to limit the max speed for an axis. For example, you may want to keep your z axis very slow to avoid damaging thingsIf (like my machine described below) you have very different mechanical setups for your X and Y axis, you may be able to support a faster X axis than a Y movement. The maximum speed setting overrules the user runtime setting to protect your hardware.Note that GRBL does not support all G-Code commands. When creating G-Code, ensure the generation/post-processor is configured for GRBL or check the web for GRBL compatible commands.
FluidNC	A port of GRBL for the ESP32 by Barton Dring and released to the world via GitHub. This is fully configurable via ini files removing the need to recompile the code each time. Beautifully packaged with simple installers supporting both WiFi and Bluetooth configurations. The distribution includes debug serial terminal tools and an embedded web page. Awesome work by some highly skilled and generous engineers – thank you!
UGS	Universal G-Code Sender. This software is widely used in the hobby CNC world. It is free and available for multiple OS platforms. It provides a GUI for your machine and connects to GRBL via a serial port (such as USB for the Arduino /ESP32 or Bluetooth)
G Code	G-Code is a text based language with sequential commands to control CNC systems. There are pages and pages of info on the web giving detailed information on commands, settings etc. Interpreters such as Mach3 etc support sub routines etc which (as far as I know) GRBL does not. Common commands are G0 and G1 (rapid / normal movement), F to set the feed rate (speed of movement). When the G-Code interpreter receives the new command to move, it calculates the various movements required to get their interpreting the controls for the various motors/actuators simultaneously. Basic commands do straight line movements but arcs are also possible. The machine can be setup to use either relative or exact positioning. Imagine the machine starts at the real position x=0. If you use relative movement x50 moves x + 50mm (i.e. it moves until x=50), then x20 would move it +20 again in the x direction until x=70. In exact positioning mode, x=50 moves it to x=50, then x=20 moves it -30 in the x direction until x=20. Personally I always use Exact positioning.Here are a few common commands I use:(setup for mm, exact positioning and cutter compensation off) G21 G90 G40 (set the plane to x/y plane – this is the typical plane for interpretation, G18 and G19 set other planes) G17 (Set the feed rate i.e. speed of normal movement to 300mm/min) F300 (rapid move to x=0, y=123. Rapid move is normally used when not doing a real operation i.e. cutter bit is not touching the work piece, a pen is not touching the paper, a laser cutter is off etc.) G0 x0 y123 (normal linear move to location x=0, y=0, z=0 with a feed rate of 500mm/m. G1 is the normal movement used while operating to make a linear movement where the linear movement can be in 3D space) G1 F500.0 x0 y0 z0 (normal linear move to location x=123,.45 z=67.89 at the current feed rate) G1 x123.45 z67.89 (pause for n seconds in this case half a second) G04 P0.5 (M62 to M68 control digital and analogue inputs and outputs directly. I use this to set a PWM value to control a servo on analogue output 0 e.g. set the PWM output to 15%) M67 E0 Q15 (stop the spindle if running a router) M5

In the beginning…

November 2018 and I needed to transfer a parametric design onto a sheet of 244x122cm (8x4ft) plywood before cutting it out with an electric jigsaw.

I found a 2m piece of aluminium profile and set about designing a drawing machine.

The heart of the system was GRBL running on an Arduino Uno with a CNC Shield v3 fed by UGS running on Linux.

DON’T PANIC if that is confusing – I’ll explain!

All movement is provided by 3 stepper motors that pull themselves backwards/forwards on long lengths of timing belt (ribbed flexible ribbon)

The wobbly aluminium profile is supported by end plates on wheels where each end plate has its own stepper motor but running in opposite directions while controlled in parallel. These end plates run along the entire length of the work-piece in the Y direction.

The x direction is a small carriage that slides across the wobbly aluminium profile. The carriage also has a servo that lifts/lowers a pen onto the work piece.

The good thing about this design is that the working size is only limited by the length of the aluminium profile, the length of your timing belts and most important the length of the cables.

Because the profile was so thin, the cables had to be supported on an even more wobbly gantry. The pen also dragged and twisted the rail so the effective backlash was terrible.

 

2021 and time for V2

My first try for a new revision was based on timing belts but now using a 1m long piece of 30×60 aluminium profile – more expensive but very rigid and easy to use. 8mm threads were easy to tap in the ends and made assembly very simple and robust.

This looks OK and the profile allows the stepper motor to be fed through the middle of the profile. Note the ugly first attempt to clamp the timing belt for the horizontal rail  – I improved this later!

To keep the belt nice and tight, ideally you want the timing belt to be on the ground each side of the gantry but this means the idlers need to be close the ground resulting in very little clearance under the end supports.

Really, this design is fine and the timing belt solution should provide accurate travel with minimal chance of slipping.

If you are wondering why there are so many 3mm holes in the wood – I over complicated things in my CAD drawing imagining lots of ways to assemble it, mount the ESP32 board etc.

Inspiration at DIY shop!

While walking around the local DIY shop, I saw some very cheap plastic wheels intended for “soap box carts” / “go-carts” etc. An hour later, my 3d printer was busy making a cog to mate with this.

Breaking this down into parts: The end plate has a collection of holes for the 30×60 profile and an oversized hole for the stepper motor. The stepper motor itself is mounted on a 3D printed plate with slots to allow it to slide up and down to adjust the pressure of the small cog onto the main wheel.

Looking at the assembly with the end plate shown as being transparent

The supports move on the main wheel from the DIY shop and a recycled roller skate wheel

The 8mm holes in the end plate allow the 30×60 profile to be mounted horizontally or vertically and in low/high positions. The other holes allow the cables and timing belt to be fed through.

Why would you put the rail horizontally??? The idea is you can also use this for other purposes such as a camera gimble rail (3D printed camera gimble using designs from Isaac879 – amazing bit of CAD work with beautiful herring bone gears. Just one note is that the space for the camera is much too narrow for my SLR). This can eaily be changed of course by moving the end supports out and splitting the camera U bracket.
The movement is a bit graunchy but that is down to the quality of 3D printing on my Anet A6. Isaac also improved his version and printed the sprockets with a flexible material to give a nicer/softer mesh between the gears.

Now lets look again at the photo of belt driven end plates…. it actually shows both the timing belt driven end close to the camera and the wheel based end furthest away

The Carriage

The Carriage runs on “wheels” cut from a plastic chopping board using a wood circle cutter. The plastic chopping board is cheap and slippery and about the right thickness (not perfect but OK). I later replaced the center large wheels with 3D printed ones. The carriage rolls on the two smaller ones so the shape of the center wheel is not so important however the thickness determines the amount of wobble in the carriage – too thick and it binds, too thin and it is wobbly.

The plastic rollers are mounted on M6 long bolts

The stepper motor is mounted on a small inner plate so that the spindle aligns nicely with the centre of the rail so that the timing belt runs along the centre of the rail.

The pen is supported by a 3D printed bracket with a micro servo. The servo pushes an M3 bolt up/down and this pushes the pen. The pen has a large metal washer on the top that provides downward pressure on the pen as well as a larger surface for the servo actuator/M3 bolt.

To ensure the timing belt was properly tensioned across the rail, the belt is laid flat in the top groove of the rail and through the end plates. A 3D printed block with matching ribs for the timing belt gently clamps the belt on an M8 bolts mounted to the end of the rail. Nuts on the bolt then allow the tension to be adjusted as needed.

Electronics

The heart of the system is the GRBL software that translates G-Code into the direction/step signals for the drivers for the stepper motors.

GRBL was originally made for the Arduino but has now been ported on to the ESP32 by Barton Dring – amazing work! This is now captured by the FluidNC project which is extremely configurable without needing to recompile. The ESP32 is not only far more powerful than the Arduino but also supports WiFi and Bluetooth.

Please refer to the excellent Github wiki and YouTube video by Barton Dring describing the installation and use of FluidNC.

I have written some more notes on my experience during the FluidNC installation here:

http://www.b-spoke.nl/steppers-servos-g-code-and-fluidnc/

The ESP32 module (Wemos D1 R32) that I’m using is mechanically compatible with the Arduino UNO which means that it is possible to use the CNC Shield 3 (the red PCB below). When I say “mechanically compatible”, they do plug into each other but on my boards the mounting holes are annoyingly just wrong!

The CNC Shield support 3 main stepper driver locations (the yellow headers) for X, Y and Z. In addition, the 4th (red) headers “A” can be linked to either X,Y or Z so that they use the direction and step signals. These are selected on the CNC Shield (on the left side above the blue power connector) where in this photo, Y is linked to A. This means that the stepper driver in position Y and position A receive the same controls such that two motors can be driven simultaneously but with individual current drivers.

In the photo above, X, Y and A have the microstepper selection jumpers set to max whereas Z is shown without the three jumpers. I fitted them later so actually I ran all motors with 1/32 or 1/16 microsteps depending on the driver boards.

To reduce the number of long cables etc, and to provide a nice high current 12V supply to the CNC Shield 3, I decided to run the whole thing on a 12V Li battery. The most convenient and financially interesting solution was a rechargeable battery from Lidl designed for their old series of power tools. Just by chance someone had helpfully already made a base for this and published their designs on Thingiverse so I could import it into Freecad and modify to fit my needs.

The battery base is “Parkside USB powerbank xteam 12v fast charge by exilaus” (https://www.thingiverse.com/thing:3862515).

A tiny buck regulator is used to step down the voltage for the ESP32 board (it might run on 12V but as that is the max, I wanted to lower this). With around 7v via the jack, it boots happily. I used a tiny module labelled HW-613 which can be adjusted via a pot meter or with solder bridges in fixed steps (1.8V, 2.5V, 3.V, 5V, SV!!! probably 8V but the silkscreen clearly says SV and 12V). If you are going to just the solder bridges, you need to cut the track at the end that goes to the pot meter.

To see the state of the battery, I wanted to box the whole setup and include a simple I/V meter.

Thanks to an amazing effort by a community of Fritzing component contributors,,,,

Notes:

1. The blue/green cross in the stepper motor wiring is done in the stepper cable at the JST-PH connector end.
2. The battery I’m using is clearly not a lead-acid battery – it is a Lithium-Ion but you get the idea!
3. The HV-613 buck regulator I used is not isolating and has a common ground pad for the input and output.
4. The stepper motor for the A interface may need reversing but swapping the coils (see separate section for details). With the jumper settings I used, I have A running with the control signals from Y. Using the two steppers at the end of the Y end plates, I wanted to have the motors rotating in opposite directions so the the machine rolled along rather than spinning in circles.

After a bit of drawing, laser engraving (because I could) and 3D printing brackets etc. I decided to add D9 connectors for the Stepper motors, a small cooling fan, USB feedthrough for the ESP32 and some 4mm sockets in case I wanted to run it without the battery.

 

 

adding a small 3D printed dove-tail bracket on the back to allow the box to be attached/removed from the machine with ease

After a bit of adjustment (Dremel + hot-glue!) it started to come together – note in the picture below, the micro-USB cable goes through the corner of the battery holder – Dremel to the rescue!

The contacts on the battery holder were a bit of a puzzle. I eventually made these but cutting 4mm strips from the lid of an old socket set metal box and sanding these back to bare metal. The metal is thin enough to cut (just about) with a Stanley knife and then can just about be bent, drilled and soldered. It isn’t pretty but it works.

The steppers each have their own D connector to allow simple adjustment, changing cables etc (currently I have only used 4 pins but the other pins could be used for end-stops etc).

The wiring for the D connectors was also kept very simple with pins 1-4 matching pins 1-4 on the headers for the CNC shield headers. Note the blue/green cross in the stepper motor wiring is done in the standard commercial stepper cable at the JST-PH connector end. The wiring I have done matches one-to-one with the ribbon cable wiring and the 0.1″ connector normally provided at the non-motor end of the cable.

Of course I wanted to add a plastic cover (D shell) around the sub D9P connector. These are cheap to buy and come with the associated hardware including the strain relief. One small silly observation, D shells typically have a cable clamp for a round cable. If you invert one side, it provides decent strain relief without pinching the cable:

 

With the connections made and lid on, the box is quite a nice, compact controller that can be mounted directly on the mechanics and should allow wireless control etc.

Stepper motor reversal

The two end plates are driven by motors that share the same digital controls from the ESP32 (the Y and A steppers). As the motors are physically facing in opposite directions; if the motors run with the same rotational direction, the machine would just turn in circles instead of moving along. To resolve this, the direction of one motor must be reversed. Fortunately with bi-polar stepper motors, this is as simple as reversing the polarity on one coil. This can be achieved with a simple cable feedthrough with D9P and D9S connectors such as:

Of course you can buy covers for these but I didn’t have one in stock. Fortunately someone on Thiniverse had made a nice D9-D9 housing “D-Sub 9-Pin double-sided connector as crossover-adapter by Anheledir” (https://www.thingiverse.com/thing:3632375/files)

Mapping the ESP32 pins

FluidNC has simple configuration files that allow the software to work with most hardware but the first task is to tell the software which IO pins to use for the various stepper motor controls.

While the Arduino pins are pretty clear and well documented for the CNC Shield 3, the ESP32 pins are all over the place!

The first thing you need to do is identify the mapping between the ESP32 R1 D32 board and the Arduino CNC Shield

I derived the following:

(CNC Shield name) = Arduino Pin = ESP32 R1 D32 pin name

With the board orientated so that the USB connector is at the top and you are looking down in the component side:

CNC Shield Name	Arduino Pin	ESP32 R1 D32
— Right Side:
Spindle Direction	13	IO18
Spindle Enable	12	IO19
Limit Z Axis	11	IO23
Limit Y Axis	10	IO5
Limit X Axis	9	IO13
Stepper Enable/Disable	8	IO12
Direction Z	7	IO14
Direction Y	6	IO27
Direction X	5	IO16
Step Z	4	IO17
Step Y	3	IO25
Step X	2	IO26
— Left Side
Reset/Abort*	A0	IO2
Feed Hold*	A1	IO4
Cycle Start/Resume*	A2	IO35 (Input only for ESP32)
Coolant Enable	A3	IO34 (input only for ESP32)
Not used/Reserved	A4	IO36 (input only for ESP32)
Not User/Reserved	A5	IO39 (input only for ESP32)

 

 

immediately, you can see some problems! IO34,35,36,39 are (I believe) inputs only for the ESP32

Can I use a servo on this?

Yes – it works!

I defined IO2 as an Analog pin in the FluidNC configuration file. This means that the pin on the CNC Shield labelled “Abort” will be used as an Analog(PWM) output which Fluid NC lets you control through regular G-Code. Cool.

I connected a cheap micro server with the red (+) to the 5V pin on the CNC Shield, black to GND and orange to “Abort”.

(Test Servo – my servo is controlled with PWM between 10 and 50%)
(set the PWM to 10%)
M67 E0 Q10
(wait 0.1 seconds)
G04 P0.1
(set the PWM to 10.5%)
M67 E0 Q10.5
G04 P0.1
(set the PWM to 50%)
M67 E0 Q50

etc

Integrating this into the box and completing the wiring (note the photos below are from two setups hence slight changes to wire colours and with/without heatshrink)

 

NOTE: in the close-up above showing the driver modules, you can see one through hole resistor lifted up. Without disconnecting the resistor, the ESP32 will not boot when the CNC Shield is fitted! I could have removed the resistor but I thought I might want to use it in the future so I just disconnected one end and lifted it up.

 

The drawing machine is complete – time to test – slippery times ahead!

I put the finished machine down on the ground (a short pile carpet should be perfect and give a bit of traction for the plastic wheels. Tape a piece of A4 paper to a flat board under the machine and away we go!

I tuned the steps/cm to give give movements which were pretty close, gentle acceleration and adjusted the height of the pen.

Ummm, something simple – a square and then drawing diagonals.
Very simple, 100mm square from the origin.
0,0 => 100,0 : looks ok
100,0 => 100,100 : probably ok
100,100 => 0,100 : yes also looks good
0,100 => 0,0 : yikes… it looks as though it only went to 0,3

then the diagonals:
0,0 -> 100,100 : sad face… it looks as though it goes to about 100, 106
back along base
100,100 => 0,100 : it looks like it goes to 0,106
0,100 => etc.

so it seems to be drifting only in a positive Y direction, This isn’t just back lash it is really creeping in one direction.
Make it draw again, again the same drift, and again and again!

Check everything, Google a lot, try all of the suggestions, slow down the acceleration and reduce max speeds…. the drift is identical.
Check mechanics – things seem to be tight.
Reduce microsteps -> no improvement just more grungy
Try with and without hold off set to 255 to keep motors powered when not in use.
Try changing pulse widths, hold delay for direction change etc.
I even changed the driver end to use completely different hardware, different types etc etc etc.
How is it possible?

One suggestion on the web is that you should check the position of the motors to see how much they are slipping.
I set the y stepper to start with the locking screw straight up, moved to y100 then back to y0 (yup – clearly walked around 3mm) but huh!!!! the Stepper motor screw is still straight up. If one side was slipping then I could understand it but both side in an identical slip in one direction only?

I disbelief and to prove that it was the machine, I turned the whole machine around 180 degrees and ran it again.
AND… What the… it is still walking in the same direction IN THE ROOM not relative to the machine!!!!
Now rotate the machine 90 degrees in the room…. and the drift goes away.
OK so are you ready for this?
The source of the slipping problem is… the direction of the pile in the carpet!!!
Move the whole system to another room with a wooden floor and the machine perfectly returns to the origin each time.
So three evenings of scratching my head and it turns out to be the carpet!

(setup for mm, exact positioning and cutter compensation off)
G21 G90 G40
G0 Z0.0
G17
(setup for exact stop)
G61
(Go to zero)
G1 F500.0 x0 y0 z0
(Pen Down)
M67 E0 Q30
(Wait 1s)
G04 P1
(now move around)
(make a square)
G1 x100
G1 y100
G1 x0
G1 y0
(make diagonals)
G1 x100 y100
G1 x100 y0
G1 x0 y100
G1 x0 y0 z0
(Test Servo)
(Pen Up)
M67 E0 Q15
G04 P0.5
M5

More complex designs?

To draw the www.b-spoke.nl logo, I used Cambam with the post processor set to GRBL Laser. Then I could use Notepad++ to search/replace for the G-Code for the “Laser On” ” Laser Off”  and change this into the commands to lower/raise the pen. I know I can make a custom post processor for Cambam but this is good enough to start with.

Move to a nice solid wooden floor and – it works!

One small note, my first attempt was mirrored. Fortunately FluidNC includes the option to invert the polarity of pins so I inverted the direction control for the Y axis, saved, rebooted and then it worked.

I’m using UGS (Universal G-Code Sender) to send to my drawing machine via the USB serial port as I currently have FluidNC configured for WiFi mode. In theory, I can configure the ESP32 to use  Bluetooth and UGS should see it as a COM port – not tried yet. Alternatively, I could upload the G-Code with the webpage to the box and run it from their but the memory is very limited as I havent added a uSD card (which also should in theory be possible).

 

Same controller – different use

The same controller box can be used to control a 3 axis system such as the camera rail/gimble.

To do this, I open the box and move the Stepstick DRV8825 module from position “A” to position Z on the CNC Shield. Put the lid back on and move the stepper motor from the A to the Z D connector.

IMPORTANT NOTE: with the drawing machine, because the two end plates are mirror copy, the Y and A motors must move in opposite directions (otherwise the machine would just turn in circles!). As the Y and A controllers are linked on the CNC Shield via the jumpers, the Y and A drivers will move in the same direction. To fix this, the wiring between the A sub-D and the stepper motor is reversed. If you then use the same motors/cables for another application e.g. the camera rail, you can correct for this with the FluidNC pin control

e.g.

stepstick:
direction_pin: gpio.14

becomes

stepstick:
direction_pin: gpio.14:low

 

An example FluidNC configuration file

No I am not in any way an expert on this but these are typical settings I used to get things working for my setup. The steps per, acceleration and max speed are something you really need to tune specifically for each mechanical setup and of course depend on the Stepstick module type and selected microsteps.

Please also note that I have not (yet?) used any end stops / homing.

The settings below are provided for information only. Use at your own risk! I will not accept any responsibility for any loss, damage, harm etc that may result from the use of these settings or the information on this web page!

name: “ESP32 Dev Controller V4”
board: “ESP32 Dev Controller V4”

stepping:
engine: RMT
idle_ms: 250
dir_delay_us: 2
pulse_us: 4
disable_delay_us: 0

axes:
shared_stepper_disable_pin: gpio.12

x:
steps_per_mm: 200
max_rate_mm_per_min:1000
acceleration_mm_per_sec2: 10
max_travel_mm: 1000
homing:
cycle: 2
mpos_mm: 10
positive_direction: false

motor0:
limit_all_pin: gpio.13:low:pu
stepstick:
direction_pin: gpio.16
step_pin: gpio.26
motor1:
null_motor:

y:
steps_per_mm: 61
max_rate_mm_per_min: 1000
acceleration_mm_per_sec2: 8
max_travel_mm: 1000
homing:
cycle: 2
mpos_mm: 10
positive_direction: false

motor0:
limit_all_pin: gpio.5:low:pu
stepstick:
direction_pin: gpio.27:low
step_pin: gpio.25
motor1:
null_motor:

z:
steps_per_mm: 600
max_rate_mm_per_min: 5000
acceleration_mm_per_sec2: 40
max_travel_mm: 1000
homing:
cycle: 1
mpos_mm: 10
positive_direction: true

motor0:
limit_all_pin: gpio.23:low:pu
stepstick:
direction_pin: gpio.14
step_pin: gpio.17
motor1:
null_motor:

user_outputs:
analog0_pin: gpio.2
analog0_hz: 200