2-Axis Pick-and-Place Gantry on GRBL with a Python G-code Sender and Colour-Sorting Demo

2-Axis Pick-and-Place Gantry on GRBL is a mechatronics integration project that turns ~₹6,500 of hobby hardware into a working benchtop automation cell: a 300 × 200 mm belt-driven gantry picks small parts from a fixed nest, asks a TCS34725 colour sensor what it is holding, and drops it into the matching bin — while a Python program supervises every step.

The clever scoping decision is the controller. Instead of writing fragile home-grown stepper code, the team flashes GRBL v1.1 — the open-source motion controller that runs most hobby CNC machines — onto an Arduino Uno + CNC shield, then configures it like an industry integrator would: steps/mm derivation, acceleration limits, homing switches. That gives the project industrial-grade trapezoidal motion planning for free, and shifts the student work to where the learning is: a Python G-code sender and job sequencer (pyserial) that speaks GRBL's protocol — status polling, ok/error acks, soft state machine — plus a small Arduino Nano that drives the vacuum pump and reads the colour sensor, and a quantified performance study (positioning repeatability, homing repeatability, cycle-time budget, pick success rate vs part mass).

The demo task mirrors a real Indian SSI line: sorting capped vials or colour-coded fasteners arriving at a station into three bins. By the end, the team can defend every layer — why 80 steps/mm, why open-loop steppers are acceptable here, what the vacuum holding-force margin is, and exactly how many milliseconds each phase of the cycle costs — with measured data instead of assertions.

Benchtop automation for small Indian units is priced out of reach — commercial pick-and-place cells cost lakhs and come locked to vendor software — while student-built alternatives typically lack proper motion planning and, more importantly, never measure what matters: repeatability, cycle time and pick reliability. Mechatronics students therefore graduate able to spin a motor but not to integrate a machine or defend its performance.

There is a need for a buildable, measurable 2-axis pick-and-place gantry that (a) uses a proven open-source motion controller (GRBL) configured from first principles — steps/mm, acceleration, homing, limits, (b) adds a sensor-driven sorting task through a custom Python G-code sender and sequencer that speaks the controller's real protocol, and (c) publishes a quantified performance study — positioning and homing repeatability, cycle-time breakdown and pick success rate — so the machine is demonstrated with evidence, and the department gains a documented, extensible automation cell.

Abstract

Pick-and-place automation is the gateway skill of mechatronics: it forces the integration of mechanics, drives, sensing, real-time control and supervisory software. This project builds a 2-axis gantry robot on the GRBL motion controller, adds a colour-sensing end effector and a Python supervisory program, and demonstrates closed-loop-in-the-large behaviour — sensor-driven task selection on top of open-loop motion — with a measured performance study.

Introduction

Small Indian fabrication and packing units increasingly need benchtop automation: sorting colour-coded parts, kitting fasteners, loading fixtures. A commercial SCARA or delta cell starts at ₹2–4 lakh; a student-built gantry on hobby hardware demonstrates every principle of such machines — kinematics, stepper sizing, motion planning, end-effectors, HMI — for the cost of a textbook bundle.

Existing System

• Commercial pick-and-place trainers (2–4 axis robotic kits) cost ₹80,000–₹4,00,000 and are locked to vendor software; students configure rather than build.
• Home-built stepper projects usually bypass proper motion planning, producing jerky, stalled moves, and almost never quantify repeatability or cycle time.
• Academic 3-D printers and CNC routers use GRBL/Marlin internally but treat the controller as a black box; the layer where industry integration engineers actually work — host software speaking G-code — is rarely taught.
• Limitations: no integration experience, no performance evidence, no ownership of the supervisory layer.

Proposed System

• Mechatronics stack: GT2-belt XY gantry (300 × 200 mm travel) on hardened rods, NEMA 17 steppers with A4988 drivers at 1/16 microstepping, Arduino Uno + CNC shield flashed with GRBL v1.1, homing via micro-switches, and a suction end effector (12 V vacuum pump + cup) raised/lowered by a servo.
• Supervisory layer: a Python G-code sender and job sequencer implementing GRBL's protocol (wake, $ status polling, per-line ack tracking, error recovery) and a task state machine: home → move to nest → query colour → choose bin → place → repeat.
• Sensing layer: TCS34725 on a Nano with a controlled white LED; RGB readings classified to red/green/blue part classes; Nano also drives the vacuum pump MOSFET.
• Performance study: positioning repeatability (dial-indicator nest test), homing repeatability, cycle-time breakdown, pick success vs part mass, and belt-tension sensitivity — all tabulated.

Feasibility Study

• Technical: GRBL is mature and documented; the only genuinely new code is the Python sender (≈500 lines), Nano firmware (≈100 lines) and the study scripts; the mechanical design uses parts any Fab lab or local fabricator can make.
• Economic: BOM ≈ ₹6,000–6,500 (Uno ₹550, CNC shield ₹250, drivers ₹160, steppers ₹900, rods/bushings ₹600, belts/pulleys ₹400, frame ₹1,500, Nano ₹350, TCS34725 ₹350, vacuum pump ₹350, PSU ₹450, switches/misc ₹600); all software free.
• Operational: runs from one 12 V 5 A supply; 40 × 40 × 15 mm demo parts are 3-D printed; safety limits (soft-limit G-code fence, E-stop on the PSU, guarded belt paths) are documented; no mains exposure.

In scope

• Two axes of motion (X/Y) with servo-lifted Z at the end effector; suction pick of rigid, non-porous parts up to ~80 g.
• GRBL-based motion control with homing and soft limits; Nano-based sensing and vacuum control; Python supervisory software.
• Three-colour classification demo with controlled LED illumination; repeatability, cycle-time and pick-success studies.

Out of scope

• Machine vision (camera-based part localisation), force feedback and conveyor synchronisation — future scope.
• Closed-loop steppers/servos, encoders and backlash compensation beyond tensioning practice.
• Industrial safety certification; multi-gantry coordination; payload optimisation beyond the stated 80 g class.

The project follows a V-model-flavoured build-and-verify methodology: each layer is built, then verified against a specific test before the next layer mounts on it — the only sane order for an integration project.

Testing approach: unit tests for the sender against a mock serial device (ok/error/timeout paths); integration tests scripted end-to-end with the nest instrumented; metrology tests — positioning repeatability from 20 placement attempts into a dial-indicator nest, homing repeatability from 20 home cycles; pick success over 30 trials at 3 part masses; every result tabulated with apparatus, procedure and uncertainty notes.

The machine is a classic three-controller mechatronics architecture — motion controller, resource controller and supervisory host — deliberately mirroring how real cells split real-time and non-real-time duties.

1. Motion controller (Arduino Uno + CNC shield, GRBL v1.1): executes G-code with trapezoidal acceleration planning, drives A4988 step/dir signals at 1/16 microstepping, manages homing switches and soft limits, and reports status as <Idle|Run|Alarm...> lines. The team configures it through $ parameters — $100/$101 = 80 steps/mm (200 steps/rev × 16 µstep ÷ 40 mm/rev), $110/$111 feed maxima, $120/$121 acceleration, $22 homing.
2. Resource controller (Arduino Nano): owns everything GRBL cannot do — I2C reads of the TCS34725 with the onboard LED held constant during integration, a nearest-reference RGB classification, and a MOSFET channel for the 12 V vacuum pump. It exposes a tiny line protocol to the host: READ → rgb r,g,b; class red.
3. Supervisory host (Python, pyserial): opens both serial ports, streams G-code with ack tracking, and runs the job state machine home → pick move → vacuum on → lift → READ → select bin → place → vacuum off. All events append to a CSV cycle log used by the analysis scripts.

flowchart TD
  PY["Python supervisor (pyserial)<br/>G-code sender + job sequencer"] -->|"USB serial: G-code, status"| GRBL["Arduino Uno + CNC shield<br/>GRBL v1.1 motion planner"]
  PY -->|"USB serial: READ / PUMP cmd"| NANO["Arduino Nano<br/>resource controller"]
  GRBL -->|"step/dir"| DRV["A4988 drivers @ 1/16 µstep"]
  DRV --> MX["NEMA 17 X-axis"]
  DRV --> MY["NEMA 17 Y-axis"]
  MX --> BELT["GT2 belt gantry 300 x 200 mm"]
  MY --> BELT
  BELT --> EE["Suction cup + servo lift"]
  NANO --> VAC["MOSFET -> 12 V vacuum pump"]
  NANO --> CS["TCS34725 colour sensor<br/>(I2C, LED held on)"]
  PART(["Part in nest"]) --> CS
  SW["Home / limit micro-switches"] --> GRBL
  GRBL -->|"ok / error / status"| PY
  NANO -->|"rgb + class"| PY
  PY --> CSV["cycle_log.csv -> analytics"]

The split is defensible in a viva: GRBL owns anything time-critical (step pulses, acceleration), the Nano owns anything GRBL's firmware cannot be modified to do (I2C sensing, pump), and the Python host owns orchestration — exactly the real-time vs non-real-time boundary found in industrial cells. Failure handling is explicit: an ack timeout or an Alarm state aborts the cycle, records it, and returns the machine to a known homed state.

• Camera vision — a webcam over the nest for part localisation and defect rejection, replacing fixed-nest assumptions.
• Third axis — a proper Z axis with leadscrew for bin walls of different heights and stack placing.
• Conveyor synchronisation — a belt feeder with encoder pickup so parts arrive in motion.
• Closed-loop motion — TMC2209 stallGuard or encoder feedback to quantify and reduce lost-step effects under load.
• HMI and safety upgrade — a Raspberry Pi touchscreen panel, physical E-stop chain and interlocked guarding to approach commercial-cell practice.
• Weighted demo line — integrate with the department's PLC trainer over Modbus so the cell reports into a SCADA-style dashboard.