Week 12 Group Assignment – Machine Design and Building

📌 Case study

We call moverXYZmm(10, 5, 2), which converts millimeters to steps and passes them to moverXYZ(). With 800 steps/mm, the resulting call is:

moverXYZ(8000, 4000, 1600)
// X = 8000 steps
// Y = 4000 steps
// Z = 1600 steps
// Total steps: 8000

The axis with the most steps (X = 8000) sets the total, and the other axes are distributed proportionally using error accumulation.

🔁 Step-by-step iterations

Each iteration, our algorithm accumulates error per axis. When the error exceeds the threshold, a step pulse is generated. This keeps all axes synchronized throughout the movement:

X moves every iteration · Y every 2 · Z every 5
Ratio: 1 : 0.5 : 0.2 → Perfect linear 3D movement ✔️

🎯 Final result: X = 10 mm · Y = 5 mm · Z = 2 mm

📌 Case study negative movement

We test what happens when we command a movement that would take the machine outside its safe working area:

moverXYZmm(-20, -10, 2)
// newX = -20 → X_MIN=0 ❌
// newY = -10 → Y_MIN=0 ❌
// Result: machine does not move

❌ Our limit validation function dentroLimites() detects the violation immediately and cancels the motion before any pulses are sent to the drivers.

⚙️ Behavior without limits (analysis)

To understand the underlying logic, we analyzed what moverXYZ() would do if limits did not exist. The system would correctly compute magnitudes and directions:

moverXYZ(-16000, -8000, 1600)
// dx=16000, dy=8000, dz=1600
// X → LOW (negative)
// Y → LOW (negative)
// Z → HIGH (positive)

✔️ Our system correctly separates magnitude (abs()) from direction (DIR pin), so negative movements are fully supported at the hardware level.

Conclusion: the algorithm handles negative movements correctly, but our soft limits protect the machine from leaving its safe boundaries. Once we verified the desk test, we proceeded to run the code on the actual machine with our teammates.

CAM software interface we can convert from DXF to G-code and from SVG to G-code. From this program we can send the generated G-code directly to the microcontroller, as well as save the G-code file.

To run this program, we open it from the Windows CMD (terminal). The application starts by initializing the GUI and waits for user interaction.

CAM software demo video showing the full conversion and sending workflow from file selection to G-code transmission.

Default Configuration Parameters these predefined values control machining behavior. z_seguro keeps the tool lifted when not cutting, z_grabado sets the cutting depth, feed_rapido and feed_grabado control travel and cutting speeds, and arco_pasos sets the resolution of curves.

DEFAULTS = {
  "z_seguro":     3.0,
  "z_grabado":   -0.3,
  "feed_rapido": 1200,
  "feed_grabado": 600,
  "escala":       1.0,
  "offset_x":     0.0,
  "offset_y":     0.0,
  "arco_pasos":    20,
  "baudrate":  115200,
}

G-code Generation GcodeWriter class manages tool position, tool state, and generated G-code lines. At startup, the CNC is configured with standard commands and the tool is moved to a safe height. G0 is used for rapid travel and G1 for cutting moves.

G28   ; go to home position
G21   ; set units to millimeters
G0 Z3 ; move to safe height

// Movements:
G0 X10 Y10      ; rapid (no cutting)
G1 X20 Y20 F600 ; cutting move

Supported entities and serial communication the converter handles all common DXF and SVG geometry. Curves are approximated as small line segments since our firmware does not support G2/G3. Each G-code line is sent one at a time and the program waits for an ok response before continuing. If an error is detected, the tool is lifted automatically to prevent damage.

// DXF: LINE, POLYLINE,
//      CIRCLE, ARC, SPLINE
// SVG: lines and curves
//      (approximated as segments)

// Serial communication:
ser.write((linea + "\n").encode())
respuesta = ser.readline().decode()
// waits "ok" before next line

// On error → tool lift:
G0 Z5

Libraries used the application is built entirely in Python. ezdxf handles DXF parsing, svgpathtools reads SVG paths, and tkinter provides the graphical interface. threading keeps the UI responsive during long conversions or transmissions.

import ezdxf
from svgpathtools import svg2paths
from tkinter import ttk, filedialog,
  messagebox, scrolledtext
import threading
import os, sys, math, time

Download the full CAM software source file:

Pin Configuration Dual X Motor the X axis is driven by two synchronized motors (X1 and X2) that always step together. Y and Z each use a single motor.

// X Axis (Dual Motor)
#define X1_STEP 16  #define X1_DIR 17
#define X1_EN   18
#define X2_STEP  7  #define X2_DIR  8
#define X2_EN    6

// Y Axis
#define Y_STEP 1  #define Y_DIR 2
#define Y_EN   0

// Z Axis
#define Z_STEP 4  #define Z_DIR 5
#define Z_EN   3

Manual Control (Buttons) jog moves the selected axis while the button is held. The origin buttons set the current position as (0,0,0) for XY and Z independently, replacing the need for endstop switches.

#define PIN_ORIGEN_XY 19
#define PIN_ORIGEN_Z  13
#define PIN_X_PLUS    28
#define PIN_X_MINUS   27
#define PIN_Y_PLUS    26
#define PIN_Y_MINUS   22
#define PIN_Z_PLUS    21
#define PIN_Z_MINUS   20

Motion Parameters & Soft Limits 800 steps/mm gives our system high precision. Velocity is defined by a min/max range in microseconds to create smooth acceleration and deceleration. Soft limits define the safe working area and stop motion if exceeded.

#define PASOS_MM     800.0
#define VEL_MIN_US   2000
#define VEL_MAX_US    400
#define JOG_DELAY_US  600

// Safe working area:
X: 0.0 – 220.0 mm
Y: 0.0 – 200.0 mm
Z: -10.0 – 5.0 mm

Buffer System (G-code) incoming G-code commands are stored in a circular queue before execution. This allows smooth and continuous motion without pausing to wait for the next serial command.

struct Movimiento {
  float x, y, z;
  float servoAng;
};
// bufHead / bufTail pointers

Step Pulse Both X motors fire simultaneously to keep the gantry square, both X drivers always receive their pulse at exactly the same time in a single function call.

inline void stepPulseX() {
  digitalWrite(X1_STEP, HIGH);
  digitalWrite(X2_STEP, HIGH);
  delayMicroseconds(2);
  digitalWrite(X1_STEP, LOW);
  digitalWrite(X2_STEP, LOW);
}

Servo Control adjusts tool orientation based on movement direction. The angle is calculated with atan2() and updated gradually to avoid abrupt rotations. It is only active during G1 cutting moves; during G0 rapid travel the servo remains inactive.

float calcularAnguloServo(
    float dx_mm, float dy_mm)

// G0 → servo inactive
// G1 → servo active

G-code Interpreter our firmware accepts a standard subset of G-code. Every valid command responds with ok so the CAM software knows when to send the next line.

G0  → fast movement (no cutting)
G1  → cutting (activates servo)
G21 → set units to millimeters
G28 → reset position (home)
G92 → define current position
M114 → report position
M280 → control servo manually

Main Loop each iteration of loop() checks buttons for manual jog, reads incoming G-code from the serial port, executes the next buffered movement, and updates the servo angle smoothly.

void loop() {
  leerBotones();      // manual jog
  leerGcodeSerial();  // from PC
  ejecutarBuffer();   // queued moves
  actualizarServo();  // smooth angle
}

CNC code running

Download the final firmware source file: