2. Software design

Back to PLOT BOT
1. Hardware design
3. Production
4. BOM and files

Goals

1. Modular Architecture: Organize firmware into abstract, decoupled layers.
2. Kinematics change: Replace Mecanum wheels with omni wheels.
3. Coordinated Motion: Implement linear interpolation to ensure smooth, straight-line multi-axis movements.

Architecture Overview

Firmware Layers

To keep the main orchestration file (.ino) clean and focused, the codebase is split into dedicated hardware abstraction layers using header (.h) and source (.cpp) files.

A. Main Orchestration

PLOTBOT_V02.ino

The main .ino file serves as the system’s Orchestrator. It initializes hardware submodules, manages the top-level application state, and coordinates continuous data flow between serial inputs and the display peripherals.

B. G-code Parsing & Execution

gcode.cpp

The gcode.cpp file acts as the Application Layer. Its primary responsibility is to translate abstract text commands (G-code strings) sent via serial communication into explicit physical movement coordinates and tool actions.

C. Motion Control

motion.cpp

The core of PlotBot’s physical movement is handled within motion.cpp, which translates abstract target coordinates into precise, synchronized stepper motor pulses.

1. Omni-Wheel Kinematics

PlotBot uses a 3-wheel omnidirectional chassis. This requires mapping target Cartesian movements (dx, dy) and rotation (dr) into individual motor step targets.

float steps1 = -dx * 0.866025f * STEPS_PER_MM_X + dy_corr * 0.5f * STEPS_PER_MM_Y - dr * STEPS_PER_DEG_R;
float steps2 =  dx * 0.866025f * STEPS_PER_MM_X + dy_corr * 0.5f * STEPS_PER_MM_Y + dr * STEPS_PER_DEG_R;
float steps3 =  dx * STEPS_PER_MM_X * M3_X_SCALE + dr * -STEPS_PER_DEG_R;

• The Y-Axis Component (sin 30 degrees = 0.5): M1 and M2 are angled relative to the forward direction; only 50 percent of their rotation contributes to forward/backward (Y) motion.
• The X-Axis Component (cos 30 degrees = 0.866025): Because of their mounting angles, 86.6 percent of M1 and M2’s rotation translates into horizontal (X) translation.
• The Passive Axis (M3): Because M3 is mounted perfectly sideways, it is mathematically isolated from Y-axis movements, rolling passively on its sub-rollers during forward/backward motion.

2. Linear Interpolation & Coordinated Motion

Without proper interpolation, multi-axis moves execute unevenly, resulting in jagged, staggered paths.

To achieve true straight-line linear interpolation (G1), motion.cpp dynamically scales the maximum speed and acceleration of each motor. This ensures all motors start and stop exactly at the same time, regardless of how many steps each individual motor needs to take.

1. Identify the dominant axis: Find the maximum step count required by any single motor.

    float maxSteps = max(abs(steps1), max(abs(steps2), abs(steps3)));
   

2. Calculate proportional scaling factors: Determine each motor’s travel distance relative to the dominant axis (scale value between 0 and 1).

    float scale1 = abs(steps1) / maxSteps;
   

3. Scale Speeds and Accelerations: Constrain the AccelStepper parameters dynamically before execution so that slower motors step proportionally to the fastest one.C++

    stepperM1.setMaxSpeed(max(MAX_SPEED * scale1, 1.0f));
    stepperM1.setAcceleration(max(ACCELERATION * scale1, 1.0f));
   

Ref:

• RepRap G-code
• CNC Cookbook G00 and G01 G-Code Mastery

3. Empirical Drift Compensation

Empirical adjustments to eliminate drift based on test results.

1. Motor 3 Scaling (M3_X_SCALE = 1.85f)
   • The Problem: When moving purely in the X direction, the combined drag/force of M1 and M2 does not naturally match the output of M3, causing the machine to rotate unintentionally.
   • The Fix: Scales M3’s contribution during horizontal travel to balance the physical force vector.C++

    float steps3 = dx * STEPS_PER_MM_X * M3_X_SCALE + dr * -STEPS_PER_DEG_R;
   

2. Cross-Talk Compensation (X_Y_DRIFT_COMPENSATION = 0.02f)
   • The Problem: Pure horizontal (X) movements can trigger minor, unintended tracking errors along the Y-axis due to directional traction differences in omni-wheel sub-rollers.
   • The Fix: Dynamically introduces a minor Y-axis correction step proportional to the absolute distance traveled in X.C++

    float abs_dx = (dx >= 0.0f) ? dx : -dx;
    float dy_corr = dy + abs_dx * X_Y_DRIFT_COMPENSATION;
   

D. Telemetry & Peripheral Control

power_monitor.cpp and display.cpp

Power Monitor (power_monitor.cpp)

UI Display (display.cpp)

Placeholder…

E. Hardware Abstraction Layer

A Hardware Abstraction Layer is a software design pattern that separates core application logic from physical hardware definitions (pins.h and config.h).