DrawMv2.0

DrawMachine

An XY pen plotter driven by a Raspberry Pi Pico and a home-made G-code dialect called FCODE.

Feed it a .dxf drawing, it works out where the pen has to go, and a Pico steps three stepper motors (X, Y and a Z pen lift) to draw it on A4 paper.

The goal: a 100% working, reliable XY plotter that does my homework. Partially based on the Scrabble bot.

How it works

flowchart LR
    A[".dxf drawing"] --> B["FCODEgenerator<br/>Python"]
    B --> C[".FCODE file<br/>absolute positions in mm"]
    C --> D["DataSendToPico<br/>Python, over USB serial"]
    D --> E["Pico firmware<br/>C++, relative steps"]
    E --> F["TMC2209 drivers<br/>X, Y, Z steppers"]

1. FCODEgenerator reads a DXF (or you script the pen by hand), centres it on the paper, reorders the strokes to minimise pen travel, and writes an .FCODE text file. Positions are in millimetres.
2. DataSendToPico reads the FCODE file line by line, converts millimetres to motor steps, range-checks every move and sends one command at a time to the Pico over USB CDC (virtual serial port). It waits for the Pico to confirm each command.
3. StepperDriver-pico is the firmware. It parses each command, coordinates X and Y step pulses so both axes finish a move together, lifts and lowers the pen, and homes against the end switches.

Repository layout

Hardware

• Controller: Raspberry Pi Pico (USB CDC serial to the PC).
• Drivers: three TMC2209 stepper drivers, one each for X, Y and Z. Microstepping is set on the board with switches, and the host software assumes 8x.
• Motion: 200 steps/rev steppers on 2 mm pitch rods, so the host uses 800 steps per mm (200 x 8 microsteps / 2 mm).
• Pen lift: the Z stepper raises and lowers the pen. The default stroke is 6500 steps and can be changed with SZS.
• Limit switches: one each for X, Y and Z, used for calibration. Each limit-switch input has an external 4.7 kΩ pull-up resistor.
• Work area: A4 landscape, 297 x 210 mm (A5 and A3 are also defined in the generator).
• Indicators: an "instruction" LED (lit while commands are arriving) and a "console mode" LED.
• Board extras (v2.0): 6 A fuse and bulk capacitor on the motor supply, status LEDs and a debug header.

Pin map (from motorDriver.cpp)

A full ASCII drawing of the Pico with every pin is in StepperDriver-pico/Pico_pins_map.txt.

The limit switches connect their GPIO inputs to GND when pressed. The firmware also enables the Pico's internal pull-ups; the external 4.7 kΩ pull-ups were added to stabilize the switch signals. Motor enable pins are active low.

Getting started

1. Build and flash the firmware

Requirements: Pico SDK 2.2.0, CMake 3.13+, the ARM GNU toolchain (the CMake file is set up for the VS Code Pico extension).

cd StepperDriver-pico
mkdir build && cd build
cmake ..
make -j

Hold BOOTSEL, plug the Pico in, and copy motorDriver.uf2 onto the drive that appears. On boot the console LED blinks six times.

CMakeLists.txt defaults to PICO_BOARD pico. If you are using a Pico 2 / Pico 2 W, configure with cmake -DPICO_BOARD=pico2_w .. (or pico2).

2. Install the Python dependencies

Python 3.10+ is required (the code uses match and X | Y type hints). Run this command from the repository root:

pip install -r requirements.txt

The GUI also needs tkinter, which ships with most Python installers.

3. Generate an FCODE file

Run from inside FCODEgenerator/ (the modules import each other without a package prefix):

cd FCODEgenerator

from main import FGenerator

gen = FGenerator("dxfexamples/simpleShape.dxf",
                 acc=0.1,          # curve flattening accuracy in mm
                 text=False,       # True = also draw TEXT / MTEXT as outlines
                 optimize=True,    # reorder strokes to cut pen travel
                 join_tol=0.5)     # points closer than this (mm) count as the same point

gen.generate_instructions()
gen.save(show_visualization=True)  # writes .fcodes/simpleShape.FCODE and opens a preview

The preview draws pen-down moves in black, pen-up travel in red and the paper outline in blue, so you can check placement before anything moves.

4. Plot it

Plug the Pico in before starting Python, then:

cd DataSendToPico
python -c "from src.Controller import Controller; Controller('../FCODEgenerator/.fcodes/simpleShape.FCODE').do_file()"

This runs the .FCODE file generated above. The controller initializes the pen head, homes X and Y with CLB, then moves the carriage to the configured paper-origin offset. Make sure the carriage has room to move before you run it.

FCODE

File format

An FCODE file is plain text: a header, then one instruction per line.

header_length 3
name simpleShape
plane_size_mm (297, 210)
MOV 10.0 10.0
PDN
MOV 10.0 200.0
MOV 287.0 200.0
MOV 287.0 10.0
MOV 10.0 10.0
PUP
MOV 76.54 127.03
PDN
MOV 88.93 142.52
...

• header_length is the number of header lines (including itself). The sender skips that many lines.
• MOV x y in a file is an absolute position in mm, measured from the bottom-left corner of the paper. Coordinates are rounded to 0.01 mm.
• The pen starts up, so the first stroke begins with a travel MOV followed by PDN.

Instructions

PDN returns an error if the firmware already considers the pen down. PUP runs the lift and endstop-seek sequence. The generator avoids emitting redundant pen-state instructions.

Automatic recalibration

To fight lost steps on long jobs, the generator inserts HCB every 200 instructions and CLB every 1000 (head_calibration_after_instruction and overall_calibration_after_instruction).

Writing FCODE by hand

FGenerator also works without a DXF. Run this from FCODEgenerator/, pass a name instead of a .dxf path, and drive the pen yourself:

from main import FGenerator
from gen import PAPER_SIZES

w, h = PAPER_SIZES["A4"]
gen = FGenerator("outline_A4", text=False, optimize=True, join_tol=0.5)

gen.draw_to(0, h)
gen.draw_to(w, h)
gen.draw_to(w, 0)
gen.draw_to(0, 0)
gen.home()
gen.save()

Available calls: pen_up, pen_down, move_to, travel_to (pen up, then move), draw_to (pen down, then move), draw_polyline, wait, head_calibrate, calibrate, home, save. See example_manual_instructions.py for a 5000-segment random-walk example.

Supported DXF content

LINE, CIRCLE, ARC, ELLIPSE, LWPOLYLINE, POLYLINE, SPLINE, SOLID / TRACE / 3DFACE, POINT (drawn as a small circle), TEXT / MTEXT / ATTRIB (as outlines, only with text=True). Block references (INSERT) and DIMENSION entities are exploded. Anything else is skipped.

Pico serial protocol

The Pico enumerates as a USB CDC serial device. The sender finds it by USB vendor ID 2E8A.

• The host sends one line per instruction, terminated with \n, at most 127 characters.
• Arguments are separated by whitespace. On the wire MOV takes relative steps, not millimetres (MOV 800 -1600 moves +1 mm in X and -2 mm in Y).
• For every line the Pico replies with two lines:
  1. Receive status, sent immediately: 0 = line understood, 1 = rejected (unknown instruction, wrong argument count, or a bad number). After a 1 there is no second reply.
  2. Finish status, sent when the instruction is done: 0 = OK, 1 = failed (for example a limit switch was never reached during calibration).
• If no instruction arrives for 3 seconds, the instruction LED goes off and the motor drivers are disabled.

Firmware behaviour

• XY motion: the axis with more steps determines the move duration; follow-axis pulses are distributed across that duration so both axes finish together.
• Timing: X/Y and Z pulse timing is configurable with SMS. The firmware defaults to 50 us half-cycles for X/Y and 100 us for Z; the host adjusts motor speed for each move.
• Motor enables: X/Y remain enabled while instructions are being processed and are disabled after 3 seconds without a new instruction. The Z motor is disabled after each pen movement.
• Calibration: CLB drives X and Y towards their switches; HCB moves Z away from its switch, then raises it back until the switch triggers. Every calibration loop has a step limit (400000 for XY, 50000 for Z) so a missing or miswired switch can't make it run forever.
• Pen stroke length: SZS steps sets the Z-axis down stroke and the reference length used for the fixed pen-up move and endstop seek.

Host-side tools (DataSendToPico/)

PCB

The controller board is v2.0, designed in KiCad (about 98 x 67 mm). It carries the Pico, three TMC2209 drivers (U1 to U3, one per axis), per-driver microstepping switches, end-switch inputs with 4.7 kΩ pull-ups, a fused motor supply (6 A fuse and a 330 uF bulk capacitor), status LEDs and a debug header. This is the board the firmware pin map targets.

• KiCad project: pcb/2.0/DrawMv2.0/
• Schematic PDF: pcb2_0_schematic.pdf

The v1 prototype in pcb/test/ is no longer used and is kept only for reference. The *-backups folders are KiCad's automatic backups.

Known issues and to-do

• Standard G-code support, which would be easier than maintaining FCODE.