CNC PCB

Project Overview

The goal of this project is to develop a G-code interpreter and CNC mill. The CNC mill can follow straight lines, arcs and cubic bezier curves. It is 3D-printed with PETG, uses stepper motors, which are controlled with an Arduino Mega. The code ran on the laptop sends motor speeds to the Arduino, which moves the motors accordingly. To use the program, connect the Arudino Mega to your laptop with a USB cable. Run the Python file

Getting Started

SolidWorks is used for the CAD

KiCAD is used for the circuit diagram and PCB

Ensure Git is installed and setup to work with he repository

Clone the project repository to your local machine and navigate into the directory:

git clone https://github.com/VedantGithub123/DIY-CNC-Mill
cd DIY-CNC-Mill

Python and the PyGame library are needed

Arduino and the AccelStepper library are needed

Repository Structure

The main branch is the organized working branch. Below is an overview of the folder structure for the main branch of this repository

DIY-CNC-Mill/
├── build/
├── electrical/
├── input/
├── media/
├── src/
│   ├── arduino/
│   ├── assets/
│   └── run.py
└── README.md

Folder Descriptions

build/: Contains files relating to the physical construction of the device

  design/: Contains the CAD files of the design

electrical/: Contains files relating to the electrical wiring of the device

input/: Location of G-code files to run

media/: Contains photos of the mill

src/: Contains all source code and assets

  arduino/: Code to run on the Arduino

  assets/: Photos needed for the GUI

  run.c: Program to run on the laptop

README.md: Project repository documentation

Program Design Process

Before deciding on how the program specifications were, I needed to determine how I wanted to organize the code. I wanted to keep the UI, G-code interpreter, and serial communication sections separate. A constant loop was needed for the UI, then when buttons are pressed, it would tell the CNC how to move or change the data, such as what file is being read. Finally, during the loop, the interpreter should calculate what speeds are needed and use the serial communication to send it to the Arduino.

G-Code Protocol

I decided to follow this marlin G-code protocol (mostly): https://marlinfw.org/meta/gcode/

However, the only commands that can be used are:

• G0: Straight line max speed
• G1: Straight line controlled
• G2: Clockwise Arc
• G3: Counterclockwise Arc
• G4: Stop for time
• G5: Cubic Bezier Curve
• G9: Stop
• M0/M1/M2/M30: Stop the machine and spindle
• M3: Spindle on clockwise
• M4: Spindle on counterclockwise
• M5: Stop the spindle

Speed Calculations

The path-following algorithms in run.py use the same control approach for straight lines, arcs, and cubic Bezier curves. Each path can provide a position and tangent for a given parameter, allowing the main update loop to follow different G-code commands without duplicating the motion-control logic.

During each update, the program determines the point on the active path that is closest to the current spindle position. It calculates the tangent at that point and combines it with a correction vector from the spindle to the path. The correction keeps the tool close to the programmed path, while the tangent continues the motion toward the end of the command. This produces the velocity vector that run.py sends to the Arduino through the serial connection.

The requested velocity is then constrained by the machine's acceleration and deceleration limits. At the beginning of a movement, the speed increases gradually. As the spindle approaches the endpoint, the speed is reduced so the target can be reached without overshooting. If the next movement is compatible with the current direction, the code can transition directly into it instead of stopping between commands; commands such as stops and dwells require the velocity to reach zero.

The update loop repeats these calculations while the machine is running. When the spindle is sufficiently close to the endpoint and its remaining velocity is small enough, run.py completes the current command and advances to the next one. This separates path geometry, speed limiting, and serial output while allowing the same motion loop to control lines, arcs, and Bezier curves.

Serial Communication Protocol

When the computer tries to connect with the Arduino, the Arduino will say CNC Ready. The computer will need to read this before continuing. The Python program opens the Arduino's serial connection, waits for this ready message, and then begins sending movement and spindle commands generated by the G-code interpreter.

The Arduino program reads the commands received over the serial connection, converts them into motor and spindle actions, and uses the stepper-motor controllers to execute them. It continues processing incoming commands while the machine is running and reports status messages back to the computer when necessary. The Python program reads these responses so that it can keep the user interface and machine state synchronized.

If the ready message is not received, the Python program should not send movement commands. The Arduino must be connected over USB and powered before starting the Python program.