FAB ACADEMY 2026  •  FORMSHOP

Week 12

Mechanical Design & Machine Design

— Group Project —

The Coloured Plotter  ·  a CNC drawing machine with an automatic tool changer

1. Assignment brief

This week is split into two parts that together make up a single group deliverable. In Part 1 — Mechanical Design we had to design a machine and build it, and operate it manually. In Part 2 — Machine Design we had to actuate and automate the same machine so it can run on its own. Both parts require documentation on a shared group page, plus an individual page (this one) describing what my contribution was and how I understood the process.

Official criteria (2026) •      Mechanical Design (Part 1) — Design a machine that includes mechanism + actuation + automation + application. •      Mechanical Design (Part 1) — Build the mechanical parts and operate it manually. •      Mechanical Design (Part 1) — Document the group project. •      Machine Design (Part 2) — Actuate and automate your machine. •      Machine Design (Part 2) — Document the group project. Reference: fabacademy.org/2026/nueval/mechanical_design,_machine_design

2. Brainstorming — how we picked the machine

Before touching a single motor we spent a couple of evenings just talking. Our group is not in a single lab: teammates work from different cities, so we met online almost every day and met in person when we could. That constraint shaped the conversation — whatever we built had to be simple enough that a single person in the lab could move forward while the others designed or sourced parts remotely.

We listed a handful of ideas — a small pick-and-place, a marble sorter, a fibre-winding rig, a coffee-art machine — and rated them on four axes: mechanism complexity, motor & driver count, material/BOM cost, and "is the final demo actually fun to watch?". The winner was a drawing machine — a plotter. A plotter gives us every sub-system Fab Academy wants us to touch (a mechanism, actuation, automation, and a clear application) while still being cheap, safe, and visual.

Why a plotter? •      Clear mechanism — two orthogonal axes plus a pen-lift. Each sub-system is easy to reason about in isolation. •      Affordable BOM — we could source most parts in-lab: recycled steppers, GT2 belts, 3D-printed brackets. •      Fun application — drawings on paper are immediate feedback; a good machine produces a poster-worthy demo. •      Split-able work — CAD, firmware, electronics, and artwork are mostly independent, so remote teammates aren't blocked on each other.

3. Warm-up — the Mini CNC Plotter

To get a working baseline as fast as possible, I built a small 2-axis CNC plotter driven by an Arduino Nano and a CNC shield. The idea was not to produce our final machine, but to run through the full toolchain — CAD → G-code → firmware → motion — once, end-to-end, so that every person on the team would understand where each piece slots in.

I took the 3D-printed mechanical design from Thingiverse and the 28BYJ-48 GRBL port from a public GitHub repo as my two references:

•      3D-printed mechanical parts — thingiverse.com/thing:4579436

•      GRBL port for 28BYJ-48 steppers — github.com/TGit-Tech/GRBL-28byj-48

3.1. Bill of materials

Part / Component	Qty	Notes
Arduino Nano (clone or original)	1	Main controller
CNC Shield v3 (or hand-wired driver board)	1	Breakout for stepper drivers
A4988 stepper drivers	2	Micro-stepping set to 1/16
28BYJ-48 stepper motors (5 V)	2	Re-wired to bipolar mode
SG90 micro servo	1	Pen lift (Z axis)
3D-printed frame parts (Thingiverse #4579436)	1 set	PLA, 0.2 mm layer
M3 screws & nuts, linear rods, bearings	as needed	Hardware
Ballpoint / fineliner pen	1	Drawing tool

3.2. Flashing GRBL onto the Arduino

I used the mainline GRBL 1.1h firmware from github.com/gnea/grbl. The flow was: download the repo as a ZIP, open the Arduino IDE, go to Sketch → Include Library → Add .ZIP Library, and point it at the grbl/ sub-folder (not the repository root — that's the single most common mistake with GRBL).

From there, File → Examples → grbl → grblUpload opens a sketch that looks suspiciously short (basically two lines). That's fine — all of GRBL's logic lives in the library itself, the sketch is just the entry point. I selected the board (Arduino Nano, ATmega328P Old Bootloader depending on the clone), selected the COM port, and hit Upload.

3.3. GRBL configuration ($$ settings)

After flashing, I opened the Serial Monitor at 115200 baud and typed $$ to dump the current settings. GRBL's defaults are for a much bigger machine, so several values need tuning for a 28BYJ-48 + A4988 setup.

Which settings matter the most •      $100 and $101 — steps per mm on X and Y. These are the first thing to calibrate (we measure a commanded move vs. actual travel and correct the ratio). •      $110 and $111 — max travel rate. 28BYJ-48 motors skip above ~600 mm/min, so keep these conservative. •      $120 and $121 — acceleration. Again, conservative or the pen drags. •      $30 — max spindle / Z servo PWM. Needed once we swap to the servo-GRBL branch.

3.4. Universal G-code Sender (UGS) + JSCUT

For sending G-code I used Universal G-code Sender (UGS). It's a Java app that lets you connect to a GRBL board, jog the machine, home it, and stream a .gcode file while watching progress in real time.

To generate the G-code itself I used JSCut — a browser-based CAM that takes an SVG and spits out a G-code file. For line-art I kept it simple: import SVG, pick "engrave", set the pen-up / pen-down Z heights, export.

3.5. First drawings and what I learned

The orange warm-up plotter drawing its first butterfly — a drop of WD-40 on the rods was the difference between jittery lines and clean ones.

  [PLACEHOLDER — Photo / scan of the finished warm-up drawing (clean shot of the paper)] 

  [PLACEHOLDER — Short video / GIF of the orange mini plotter drawing] 

Takeaway: the mini plotter works, but it is honestly painful to watch. 28BYJ-48 motors are geared-down by design, so max feed rate is tiny. The print area is only a few centimetres wide. And it only knows one pen. That is exactly why we decided to build a second, much better plotter as our actual group deliverable.

Maintenance tip that bit us Always lubricate linear rods before the first real print. Our first "completed" drawing on the warm-up had visible jitter because the Y rod was dry and stuttering on the printed bearings. A shot of WD-40 fixed it (see photo above).

4. The Automatic tool changer Plotter — the real group project

After the warm-up, we upgraded the ambition. The group goal became: a belt-driven XY pen plotter with an automatic tool changer that can swap between multiple pens mid-drawing. That gives us colour — and the automation step (Part 2) becomes genuinely non-trivial, since the machine has to release one pen, park it, pick up another, and carry on.

Reference design we based ours on: HowToMechatronics — DIY Pen Plotter with Automatic Tool Changer. We did not clone it one-to-one — we re-drew the brackets in Fusion 360 to fit our stock, and we trimmed the working area so all parts fit our printers' build plates.

  [PLACEHOLDER — Reference render of the original HowToMechatronics pen-plotter (from the article)] 

5. Mechanical design (Part 1)

Breaking the Part 1 criteria into its four sub-goals (mechanism + actuation + automation + application), here is what the Coloured Plotter does on each axis.

5.1. Mechanism

•      XY gantry: core-XY-style layout with GT2 belts on 2GT pulleys. X moves the whole carriage, Y moves the pen assembly along the carriage.

•      Linear guides: 8 mm smooth rods with LM8UU linear bearings on both axes, held in place with 3D-printed bearing blocks.

•      Pen lift (Z): SG90 micro servo pushing the pen holder down against a sprung lever. Pen-up / pen-down positions are two PWM values in firmware.

•      Tool changer: fixed dock on the side of the work area with four printed slots. Each pen has a magnetic collar; the carriage drops into a slot to release, slides over to the next slot to pick up.

5.2. Actuation

•      2 × NEMA 17 stepper motors (17HS4401 or equivalent) — one per axis.

•      2 × A4988 drivers on a CNC shield v3, micro-stepping 1/16. VREF tuned to roughly 0.8 V to stay under the motors' thermal limit.

•      1 × SG90 servo for pen lift, driven from a free PWM pin via the grbl-servo patch.

•      24 V PSU for the steppers; the Arduino itself is powered via USB during tuning, via a DC-DC buck for standalone runs.

5.3. Automation

•      Firmware: GRBL 1.1h with the servo branch from cprezzi — this exposes a spindle-PWM pin we can hijack for the pen-lift servo.

•      Host software: GRBL Plotter on the PC — it handles multi-colour jobs by inserting M-commands between layers to trigger the tool change routine.

•      Workflow: SVG with one layer per colour → GRBL Plotter → streamed to the machine → at each colour boundary, a tool-change macro drops one pen in the dock and picks up the next.

5.4. Application

The demo application is artistic multi-colour plotting — line-art, mandalas, simple diagrams — but the same mechanism can also be used for educational visualisation (drawing graphs from data), lightweight PCB-stencil outlining on paper, and quick print-preview sketches for larger projects. Crucially, because pens are cheap and swappable, we are not locked to one medium: we can load in fine-liners, markers, gel pens, and even thin brushes with minimal firmware changes.

6. Fabrication — 3D printing the parts

The full set of 3D-printed parts came out to roughly 28 pieces — brackets, bearing blocks, motor mounts, idler pulleys, the pen holder, and the tool-changer dock. We split printing across three printers to parallelise. Total print time was approximately two days of combined wall-clock time.

Part / Component	Qty	Notes
X/Y motor mounts	2	PLA, 100% infill
Bearing blocks (LM8UU)	6	PLA, 100% infill
Belt tensioners / idlers	4	PLA, 100% infill
Pen carriage with servo mount	1	PLA, 100% infill
Tool-changer dock with 4 slots	1	PLA, 100% infill
Pen collars (magnetic)	4	PLA, 100% infill
Frame corners and brackets	8	PLA, 100% infill

  [PLACEHOLDER — Photo of the Coloured Plotter's printed parts laid out after printing — green and yellow PLA pieces] 

Belt tension and endstop being fitted — ruler used to check that the carriage travel matches the expected work area.

7. Assembly (James + Yaroslav)

James and I did the mechanical assembly together in the lab. We split the work so one person held and aligned while the other drove screws, then swapped — this alone saved us a lot of re-alignment time compared to doing it solo.

1.     Built the two side frames first, squared them against a reference plate.

2.     Fitted the 8 mm X-axis rods through the bearing blocks, added the GT2 belt loop with idler + motor pulley.

3.     Repeated for the Y-axis carriage, then seated the carriage on the X rods.

4.     Mounted the pen holder and SG90 servo on the carriage.

5.     Installed the tool-changer dock and checked the four pen slots are co-planar with the pen-down Z height.

6.     Routed cables through printed cable guides so nothing snags on the belts.

 

 

8. Electronics

For electronics we kept it boring-on-purpose: Arduino UNO + CNC Shield v3 + A4988 drivers + SG90 servo. The only deviation from the default CNC-shield wiring is that we route the servo signal to the SpnEn (D11) pin, which is what grbl-servo re-purposes for the pen lift. Steppers get 24 V from an external PSU; the UNO is USB-powered during tuning.

  [PLACEHOLDER — Photo of the green + yellow frame fully squared together on the bench] 

  [PLACEHOLDER — Photo of the pen carriage sliding freely on the Coloured Plotter's rails] 

  [PLACEHOLDER — Close-up of the tool-changer dock with all four pens parked] 

 

 

 

 

Wiring diagram of the Coloured Plotter electronics (Arduino UNO + CNC Shield + servo).

  [PLACEHOLDER — Photo of the real wiring on the green/yellow Coloured Plotter — Arduino UNO, CNC shield with heatsinks, servo cable, endstops tidied up] 

VREF tuning For the A4988 drivers we measured VREF on the trim-pot with a multimeter and set it to about 0.8 V. Rule-of-thumb: Imax = VREF × 2.5 (for the standard A4988 module). Our NEMA 17 motors are rated at 1.7 A, but we aim for ~1.0–1.2 A to keep them cool on a long plot — steppers heat up surprisingly fast on continuous XY motion.

9. Firmware — GRBL with servo support (Part 2)

Plain GRBL only knows a spindle, not a servo. To get a pen lift we used the community-maintained fork cprezzi/grbl-servo, which re-uses GRBL's spindle-PWM output as a servo-PWM output. The flashing procedure is identical to mainline GRBL: delete the old library, add the grbl-servo ZIP, open File → Examples → grbl → grblUpload, upload.

9.1. config.h modifications

Before flashing, there are a few constants in config.h that need editing so the firmware knows we are running a plotter, not a mill.

•      VARIABLE_SPINDLE must be enabled (it is by default).

•      SPINDLE_PWM_MIN_VALUE / SPINDLE_PWM_MAX_VALUE set the servo pulse range — tune these once the pen holder is mounted so pen-up actually lifts the tip clear of the paper.

•      HOMING_CYCLE_0 / HOMING_CYCLE_1 define homing order. For a plotter we home X first, then Y — the opposite of some mills.

9.2. Speed parameters

Because NEMA 17s are much more capable than 28BYJ-48s, our speeds can be an order of magnitude higher than the warm-up plotter.

Part / Component	Qty	Notes
$100 / $101 (steps/mm)	80 / 80	16 × micro-stepping, GT2 × 20-tooth pulley
$110 / $111 (max rate, mm/min)	6000 / 6000	Plenty of headroom; we usually plot at 3000–4000
$120 / $121 (accel, mm/s²)	500 / 500	Smooth enough that pens do not skip
$30 (max spindle / servo PWM)	1000	Full range for pen-up/pen-down

10. Calibration and first manual test (fulfils Part 1, criterion 2)

Before any G-code file ran, we operated the machine manually through UGS — jogging each axis, firing the servo by hand, and measuring actual travel vs. commanded travel. The first pass had X off by about 4 % because I had the wrong number of teeth in my step calculation; one change to $100 fixed it. The Y axis was already correct.

7.     Homing — run $H, watch each axis approach its endstop, pull-off, and re-approach slowly.

8.     Jog a known distance — command G91 G0 X100 F2000, measure actual travel, adjust $100 by ratio.

9.     Servo tune — issue M3 S500 / M5 and watch the pen lift. Adjust SPINDLE_PWM_MIN/MAX until travel is clean.

10.  Square test — draw a 50 × 50 mm square, measure with calipers. Ours came out 49.8 × 50.1 mm — acceptable.

11.  Circle test — draws a 40 mm circle. Look for corners or flats — they indicate an axis is skipping.

 

 

 

 

  [PLACEHOLDER — Photo of the square + circle calibration sheet drawn by the Coloured Plotter] 

GRBL Plotter showing the calibration job loaded and ready to send.

11. Automation — how the tool changer (work in progress)

The tool-change routine is what makes the Coloured Plotter count as a "machine" for Part 2 rather than just a manually-operated pen plotter. The G-code flow for a four-colour drawing looks like this:

12.  Pen 1 is already docked at slot A. Machine homes, then drives to slot A, descends slightly, engages magnetic collar — pen is picked up.

13.  All layer-1 (colour 1) paths are streamed — normal XY motion with M3/M5 for pen-down/pen-up.

14.  When layer 1 finishes, the host software inserts a tool-change macro: drive to slot A, release pen (Z down, release collar), drive to slot B, pick up pen 2.

15.  Layer-2 (colour 2) paths are streamed.

16.  Repeat for slots C and D. Final step returns the last pen to its dock and parks the carriage.

  [PLACEHOLDER — Close-up photo / GIF of the carriage picking up and releasing a pen] 

What can go wrong here: if the magnetic collar isn't perfectly aligned with the pen holder, you get either a failed pick-up (pen stays docked) or a dropped pen (pen leaves a streak across the page). We spent an afternoon re-printing the collar at 0.1 mm tighter tolerance before it worked reliably.

12. Results & demo

The final Coloured Plotter runs a four-pen multi-layer SVG end-to-end without operator intervention. The mini warm-up plotter still sits on the shelf as a teaching piece — it is slow, tiny, and loud, but it was the best way to understand the whole pipeline before committing to the bigger build.

  [PLACEHOLDER — Two or three photos of finished drawings side-by-side (gallery)] 

  [PLACEHOLDER — Short video / GIF of the full automated run, including at least one tool change] 

 

 

 

 

 

13. My individual contribution

Because this is a group project, this page is complemented by the shared group page. Here is specifically what I did, so it is unambiguous for the evaluator.

•      Mini CNC warm-up (100% solo): sourced / printed the Thingiverse parts, assembled the mechanics, wired the Arduino Nano + CNC shield, flashed mainline GRBL, configured $$ settings, set up UGS, tested JSCut, produced the first working drawings.

•      Coloured Plotter electronics: chose the A4988 + CNC-shield topology, measured VREF, wired the servo to the SpnEn pin, flashed grbl-servo, tuned the pen-up/pen-down PWM.

•      Coloured Plotter mechanical assembly (with James): frame squaring, rod + bearing installation, belt routing, pen carriage mounting, tool-dock alignment.

•      Calibration: steps/mm tuning, square + circle tests, first multi-colour test drawing.

•      Documentation: this page, plus photographs and raw notes shared into the group page.

14. Challenges and lessons learned

•      GRBL library import trap: the Arduino IDE wants the grbl/ sub-folder, not the repository root. If you get no $$ output on the Serial Monitor, you almost certainly imported the wrong folder.

•      Stepper choice matters: 28BYJ-48 steppers are fine for a teaching demo, but they make a real plotter painfully slow. On the Coloured Plotter we jumped straight to NEMA 17s and feed rates 10× higher.

•      Servo-branch vs. mainline: we initially flashed mainline GRBL on the Coloured Plotter and wondered why the pen wouldn't lift. grbl-servo is mandatory for any pen-plotter build.

•      Tool changer tolerances: the magnetic pen collar is the trickiest single part. Print it at high resolution and be prepared to re-tune the Z pick-up height.

•      Lubrication: the warm-up plotter taught us to lubricate rods on day one. The Coloured Plotter got a light oil film on rods and bearings before the first power-on.

15. Files & downloads

Downloads — link these to your repo once uploaded •      STL pack (Coloured Plotter) — [LINK: ZIP of all printed parts] •      Fusion 360 source (.f3d) — [LINK: CAD source] •      BOM spreadsheet — [LINK: full parts list with vendors] •      Firmware — GRBL-Servo build (.hex) — [LINK] •      Sample multi-colour SVG and G-code — [LINK] •      Warm-up mini plotter — STL pack and G-code — [LINK]

16. Assignment criteria check

Quick mapping from each of the five Fab Academy bullets to where it is covered on this page.

#	Criterion	Covered in
1	Design a machine that includes mechanism + actuation + automation + application	§4, §5
2	Build the mechanical parts and operate it manually	§6, §7
3	Document the group project (Part 1 — Mechanical Design)	§9 & group page
4	Actuate and automate your machine	§8, §10, §11
5	Document the group project (Part 2 — Machine Design)	§12 & group page

17. References

•      Mini CNC plotter 3D-printed parts — thingiverse.com/thing:4579436

•      GRBL for 28BYJ-48 steppers — github.com/TGit-Tech/GRBL-28byj-48

•      Mainline GRBL — github.com/gnea/grbl

•      grbl-servo branch — github.com/cprezzi/grbl-servo

•      Coloured Plotter reference — HowToMechatronics — DIY Pen Plotter with Automatic Tool Changer

•      Warm-up simple Arduino Mini CNC Plotter — PCBWay article

•      Universal G-code Sender — winder.github.io/ugs_website

•      JSCut — jscut.org

•      Assignment brief — fabacademy.org/2026/nueval/mechanical_design,_machine_design

— end of Week 12 documentation —