DEV Community: Eric Park

Step 6: Moving to an Absolute Position — Let the Code Figure Out the Direction

Eric Park — Fri, 10 Apr 2026 01:12:54 +0000

Step 6: Moving to an Absolute Position — Let the Code Figure Out the Direction

Hello everyone. This is Eric Park, 3D Printer Engineer from South Korea.

Quick recap before we dive in:

Step 1: Made the motor spin for the first time. 200 pulses, one full revolution.
Step 2: Controlled speed by adjusting the delay between pulses.
Step 3: Built rotateAngle() — pass in degrees, the function calculates steps automatically.
Step 4: Added direction control and started tracking the current angle as a global variable.
Step 5: Switched from angles to millimeters. Introduced moveX(distance, direction) with currentX tracking.
Step 6 (today): Switch to absolute coordinates. You give a target position, the code decides direction automatically.

The Problem with Step 5

In Step 5, I wrote a function called moveX(). It looked like this:

moveX(5.0, true, 2);   /* move 5mm in the positive direction */
moveX(3.0, false, 2);  /* move 3mm in the negative direction */

Every call required me to specify:

How far to move
Which direction

That is fine for manual jogging — "go 5mm left," "go 3mm right." But it is not how real motion control systems work.

A G-code command looks like this:

G1 X50.0

It does not say "go 50mm to the right." It says "go to position X=50.0." If the current position is X=30, the controller figures out it needs to move 20mm in the positive direction. If the current position is X=70, it moves 20mm in the negative direction.

That is what Step 6 is about — absolute coordinates.

What Changes

The function signature changes from this:

void moveX(float distance, bool positive, int speedDelay);

To this:

void moveToX(float targetX, int speedDelay);

No direction parameter. You give it a destination, it calculates everything.

Inside the function, two things happen automatically:

Calculate the distance: targetX - currentX
Determine direction from the sign of that result

If the result is positive, move in the positive direction. If negative, move in the negative direction.

The Code

/*
 * step6_absolute.c
 *
 * Step 6: Absolute coordinate movement
 *
 * Machine assumptions:
 *   - One full revolution = 10mm of travel
 *   - 200 steps per revolution
 *   - Therefore: 20 steps per mm
 *
 * Compile: gcc -o step6 step6_absolute.c -lwiringPi -lm
 * Run:     sudo ./step6
 */

#include <wiringPi.h>
#include <stdio.h>
#include <stdbool.h>
#include <math.h>     /* fabs() */

/* ── Pin definitions (BCM GPIO numbering) ── */
#define STEP_PIN    4
#define DIR_PIN     3
#define ENABLE_PIN  2

/* ── Machine configuration ── */
#define STEPS_PER_REV  200      /* 360 / 1.8 degrees = 200 steps */
#define MM_PER_REV     10.0f   /* depends on your belt/screw setup */
#define STEPS_PER_MM   (STEPS_PER_REV / MM_PER_REV)  /* 20.0 */

/* ── Current position (global) ── */
/*
 * This variable tracks where the motor is right now.
 * It starts at 0.0 (we assume power-on = origin).
 * Every moveToX() call updates it when the move completes.
 */
float g_current_x = 0.0f;

/* ─────────────────────────────────────────────
 * rotateMotor: send step pulses to the driver
 *
 * steps    : how many pulses to send
 * delay_ms : delay between each pulse (controls speed)
 * ───────────────────────────────────────────── */
void rotateMotor(int steps, int delay_ms) {
    for (int i = 0; i < steps; i++) {
        digitalWrite(STEP_PIN, HIGH);
        delay(delay_ms);
        digitalWrite(STEP_PIN, LOW);
        delay(delay_ms);
    }
}

/* ─────────────────────────────────────────────
 * moveToX: move to an absolute X position
 *
 * targetX   : destination in mm (absolute)
 * delay_ms  : speed control (smaller = faster)
 *
 * Direction is calculated automatically.
 * ───────────────────────────────────────────── */
void moveToX(float targetX, int delay_ms) {

    /* Step 1: calculate how far we need to travel */
    /*
     * distance = targetX - g_current_x
     *
     * Examples:
     *   current=0.0,  target=30.0  → distance = +30.0 (move positive)
     *   current=30.0, target=10.0  → distance = -20.0 (move negative)
     *   current=10.0, target=10.0  → distance =   0.0 (already there)
     */
    float distance = targetX - g_current_x;

    /* Step 2: if distance is near zero, skip the move */
    /*
     * fabs() returns the absolute value of a float.
     * We use 0.01mm as the threshold — anything smaller
     * is less than 1 step at 20 steps/mm, so there is
     * nothing meaningful to do.
     */
    if (fabs(distance) < 0.01f) {
        printf("Already at target position: X = %.2fmm\n\n", g_current_x);
        return;
    }

    /* Step 3: determine direction from the sign of distance */
    /*
     * distance > 0  →  positive direction (DIR pin HIGH)
     * distance < 0  →  negative direction (DIR pin LOW)
     *
     * We also need the absolute value for the step count.
     * fabs() gives us that without an if-else.
     */
    bool positive       = (distance > 0.0f);
    float abs_distance  = fabs(distance);

    printf("X%.2f -> X%.2f: moving %.2fmm in %s direction\n",
           g_current_x, targetX, abs_distance,
           positive ? "+" : "-");

    /* Set the direction pin before sending pulses */
    digitalWrite(DIR_PIN, positive ? HIGH : LOW);

    /* Step 4: convert mm to steps */
    /*
     * steps = abs_distance × STEPS_PER_MM
     *
     * Example: 15.0mm × 20.0 steps/mm = 300 steps
     *
     * (int) cast truncates the decimal.
     * At 20 steps/mm, the minimum resolution is 0.05mm.
     * Any fractional mm below that is lost here.
     * This is the same rounding limitation we saw in Step 3.
     */
    int steps = (int)(abs_distance * STEPS_PER_MM);
    printf("  -> %d steps\n", steps);

    /* Step 5: run the motor */
    rotateMotor(steps, delay_ms);

    /* Step 6: update the position tracker */
    /*
     * We set g_current_x to targetX (not += distance).
     * Using targetX directly avoids floating point
     * accumulation errors from repeated additions.
     */
    g_current_x = targetX;
    printf("  -> current position: X = %.2fmm\n\n", g_current_x);
}

/* ─────────────────────────────────────────────
 * main: test the absolute coordinate system
 * ───────────────────────────────────────────── */
int main(void) {

    if (wiringPiSetupGpio() == -1) {
        printf("wiringPi init failed\n");
        return 1;
    }

    pinMode(STEP_PIN,   OUTPUT);
    pinMode(DIR_PIN,    OUTPUT);
    pinMode(ENABLE_PIN, OUTPUT);

    /* Enable the motor driver (active LOW on most drivers) */
    digitalWrite(ENABLE_PIN, LOW);
    delay(100);

    printf("=== Absolute Coordinate Movement Test ===\n");
    printf("Config: %.1fmm/rev, %.1f steps/mm\n\n",
           MM_PER_REV, STEPS_PER_MM);
    printf("Start: X = %.2fmm\n\n", g_current_x);

    /* Test sequence */
    moveToX(10.0f, 2);   /* X0   -> X10  (positive direction) */
    moveToX(25.0f, 2);   /* X10  -> X25  (positive direction) */
    moveToX(5.0f,  2);   /* X25  -> X5   (negative direction, auto!) */
    moveToX(15.5f, 2);   /* X5   -> X15.5 */
    moveToX(15.5f, 2);   /* X15.5 -> X15.5 (already there) */
    moveToX(0.0f,  2);   /* X15.5 -> X0  (back to origin) */

    printf("=== Final result ===\n");
    printf("Final position: X = %.2fmm\n", g_current_x);

    /* Disable the motor driver */
    digitalWrite(ENABLE_PIN, HIGH);

    return 0;
}

Walking Through the Key Part

The function moveToX() does its most important work in three lines:

float distance = targetX - g_current_x;
bool positive  = (distance > 0.0f);
float abs_distance = fabs(distance);

Let me trace through a concrete example. Suppose g_current_x = 25.0 and we call moveToX(5.0, 2).

distance    = 5.0 - 25.0 = -20.0
positive    = (-20.0 > 0.0) = false   → DIR pin goes LOW
abs_distance = fabs(-20.0) = 20.0
steps       = (int)(20.0 * 20.0) = 400

The direction is set automatically. I never had to think about it — I just said "go to X=5.0."

One Detail Worth Explaining: Why `g_current_x = targetX` Instead of `+= distance`

At the end of the function, I write:

g_current_x = targetX;

An alternative would be:

g_current_x += distance;

Both give the same answer mathematically. But with floating point numbers, repeated additions accumulate small rounding errors. If you add and subtract many times, the result drifts slightly from the true value.

Assigning targetX directly avoids that drift. Each move lands exactly on the intended coordinate.

What the Output Looks Like

=== Absolute Coordinate Movement Test ===
Config: 10.0mm/rev, 20.0 steps/mm

Start: X = 0.00mm

X0.00 -> X10.00: moving 10.00mm in + direction
  -> 200 steps
  -> current position: X = 10.00mm

X10.00 -> X25.00: moving 15.00mm in + direction
  -> 300 steps
  -> current position: X = 25.00mm

X25.00 -> X5.00: moving 20.00mm in - direction
  -> 400 steps
  -> current position: X = 5.00mm

X5.00 -> X15.50: moving 10.50mm in + direction
  -> 210 steps
  -> current position: X = 15.50mm

Already at target position: X = 15.50mm

X15.50 -> X0.00: moving 15.50mm in - direction
  -> 310 steps
  -> current position: X = 0.00mm

=== Final result ===
Final position: X = 0.00mm

The third move (X25 → X5) goes in the negative direction automatically. No direction argument, no manual calculation.

Honest Limitation: The Position Tracker Has No Memory

g_current_x only exists in RAM. If the motor skips a step under load — which stepper motors do occasionally — the tracker has no way to know. It still believes the motor is exactly where the math says it should be.

Real systems solve this with:

An encoder on the motor shaft for feedback
A homing sequence at startup to establish a known reference point
Limit switches to detect the physical endpoints

For now, we are assuming the motor never misses a step. That is fine for learning, but it is worth understanding the assumption.

Practice Ideas

Call moveToX(0.0f, 2) twice in a row. Does the second call print "already at target position"?
Try moveToX(-10.0f, 2). Can the motor go to a negative coordinate? Does g_current_x correctly show -10.0?
Change MM_PER_REV to match your actual hardware (GT2 belt + 20-tooth pulley = 40.0mm). Does the motion scale correctly?
Add a homeX() function that calls moveToX(0.0f, 2). This is the beginning of a real homing function.

What Is Next

Step 7 will add acceleration and deceleration to moveToX(). Right now the motor starts and stops at full speed, which causes vibration and can lose steps at high speeds.

With a proper velocity profile — slow start, ramp up, ramp down before stopping — the motion becomes smoother and more reliable. That is also the foundation for understanding how Klipper and Marlin handle motion planning.

See you next week.

Eric Park, from Daegu, South Korea

Tags: raspberrypi c steppermotor 3dprinting beginners embeddedsystems

Step 5: Moving in Millimeters — Position Tracking with Real Units

Eric Park — Thu, 02 Apr 2026 12:28:58 +0000

Step 5: Moving in Millimeters — Position Tracking with Real Units

Hello everyone. This is Eric Park, 3D Printer Engineer from South Korea.

We are now at Step 5. Here is a quick recap of where we have been:

Step 1: Sent 200 pulses, made the motor complete one full revolution
Step 2: Controlled speed by adjusting the delay between pulses
Step 3: Rotated the motor by a specific angle using a formula
Step 4: Added direction control and started tracking angle as a global variable
Step 5 (today): Forget angles. We move in millimeters.

This step felt like a real turning point for me. For the first time, the motor started speaking the same language as a real machine.

Why Millimeters?

In Steps 3 and 4, I was controlling the motor by angle — 90 degrees, 180 degrees, and so on. That works fine for a rotating shaft.

But a 3D printer or CNC machine does not think in degrees. It thinks in millimeters. When Klipper receives G1 X50, it moves the X axis to 50mm. Not 1000 degrees, not 4000 steps — just 50mm.

So the question is: how do we convert mm to motor steps?

The Key Formula

A stepper motor has a mechanical chain between it and the actual moving part. In my test setup, I am assuming a GT2 timing belt with a 20-tooth pulley. Here is how the math works:

Pulley teeth × belt pitch = distance per revolution
20 teeth × 2mm = 40mm per revolution

Wait — actually in my setup I am using a simpler approximation:

1 revolution = 10mm movement
200 steps = 10mm
1mm = 200 / 10 = 20 steps

So the conversion is:

steps = distance_mm × steps_per_mm
steps = distance_mm × 20

Example:

Move 5mm → 5 × 20 = 100 steps
Move 3mm → 3 × 20 = 60 steps
Move 0.1mm → 0.1 × 20 = 2 steps

This is defined once at the top of the code, and everything else uses it automatically.

What Changed From Step 4

In Step 4, the function looked like this:

rotateAngle(90, clockwise, 2);   // rotate 90 degrees, clockwise, delay=2

In Step 5, it looks like this:

moveX(5.0, true, 2);   // move 5.0mm in positive direction, delay=2

The interface is now talking about physical distance, not motor rotation. That feels much more natural when you are thinking about building a machine.

The Code

/*
 * step5_position_tracking.c
 * Step 5: Coordinate-based position tracking (mm units)
 *
 * Compile: gcc -o step5 step5_position_tracking.c -lwiringPi -lm
 * Run    : sudo ./step5
 */

#include <wiringPi.h>
#include <stdio.h>
#include <stdbool.h>
#include <math.h>

/* ── Pin definitions (BCM GPIO numbers) ── */
#define STEP_PIN    4
#define DIR_PIN     3
#define ENABLE_PIN  2

/* ── Motor and mechanical settings ── */
#define STEPS_PER_REV  200      /* 360 / 1.8 = 200 steps per revolution */
#define MM_PER_REV     10.0f   /* 1 revolution moves 10mm (adjust for your machine) */
#define STEPS_PER_MM   (STEPS_PER_REV / MM_PER_REV)   /* 20 steps/mm */

/* ── Current position tracking ── */
float currentX = 0.0f;   /* unit: mm */

/* Low-level pulse generation */
void rotateMotor(int steps, int delayMs) {
    for (int i = 0; i < steps; i++) {
        digitalWrite(STEP_PIN, HIGH);
        delay(delayMs);
        digitalWrite(STEP_PIN, LOW);
        delay(delayMs);
    }
}

/*
 * moveX: move by a relative distance in mm
 *
 * distance_mm : how far to move (always positive)
 * positive    : true = forward (+X), false = backward (-X)
 * speedDelay  : delay between pulses (ms)
 */
void moveX(float distance_mm, bool positive, int speedDelay) {

    /* Set direction */
    if (positive) {
        digitalWrite(DIR_PIN, HIGH);
        printf("X+ direction: +%.2fmm\n", distance_mm);
    } else {
        digitalWrite(DIR_PIN, LOW);
        printf("X- direction: -%.2fmm\n", distance_mm);
    }

    /* Convert mm to steps */
    int steps = (int)(distance_mm * STEPS_PER_MM);
    printf("  -> %d steps\n", steps);

    /* Execute */
    rotateMotor(steps, speedDelay);

    /* Update position */
    if (positive) {
        currentX += distance_mm;
    } else {
        currentX -= distance_mm;
    }

    printf("  -> current position: X = %.2fmm\n\n", currentX);
}

int main(void) {

    if (wiringPiSetupGpio() == -1) {
        printf("wiringPi init failed\n");
        return 1;
    }

    pinMode(STEP_PIN, OUTPUT);
    pinMode(DIR_PIN, OUTPUT);
    pinMode(ENABLE_PIN, OUTPUT);

    digitalWrite(ENABLE_PIN, LOW);
    printf("Motor enabled\n\n");

    printf("=== Position tracking test (mm units) ===\n");
    printf("Settings: 1 rev = %.1fmm, 1mm = %.0f steps\n\n",
           MM_PER_REV, STEPS_PER_MM);
    printf("Start: X = %.2fmm\n\n", currentX);

    moveX(5.0f,  true,  2);   /* +5mm */
    moveX(3.0f,  true,  2);   /* +3mm */
    moveX(2.0f,  false, 2);   /* -2mm */
    moveX(1.5f,  true,  2);   /* +1.5mm */

    printf("=== Result ===\n");
    printf("Final position: X = %.2fmm\n", currentX);
    printf("Expected      : 5 + 3 - 2 + 1.5 = 7.5mm\n");

    digitalWrite(ENABLE_PIN, HIGH);
    return 0;
}

Walking Through the Code

STEPS_PER_MM macro:

#define STEPS_PER_MM   (STEPS_PER_REV / MM_PER_REV)

This calculates itself from the two values above it. If I change MM_PER_REV to match my actual machine, everything else updates automatically. That is the benefit of defining constants at the top — I only need to change one number.

currentX global variable:

float currentX = 0.0f;

This keeps track of where the motor is right now. Every time moveX() runs, it adds or subtracts from this value. This is the same idea as Step 4's currentAngle, but now in mm.

The conversion inside moveX():

int steps = (int)(distance_mm * STEPS_PER_MM);

This is the only place the formula appears. The rest of the code just calls moveX() with millimeters. Clean separation between "what I want" and "how to achieve it."

What I Discovered During Testing

When I tested moveX(0.1f, true, 2), the motor moved only 2 steps. That is the smallest possible movement. Anything smaller than 1 / STEPS_PER_MM = 0.05mm rounds down to zero and the motor does not move at all.

This is not a bug — it is a real physical limitation. One step equals one minimum increment. With 20 steps/mm, the resolution is 0.05mm per step.

If I need higher resolution, I would switch the driver to microstepping (for example, 1/16 stepping gives 320 steps/mm, or 0.003mm resolution). But for now, 0.05mm is more than enough for learning.

Adjusting for Your Machine

The MM_PER_REV value depends entirely on your mechanical setup. Here are common examples:

Setup	MM_PER_REV
GT2 belt + 20-tooth pulley	40.0
GT2 belt + 16-tooth pulley	32.0
Lead screw, 2mm pitch	2.0
Lead screw, 8mm pitch	8.0

The easiest way to find your actual value: move the motor exactly 200 steps (one revolution) and measure how far the carriage moved with a ruler. That measurement is your MM_PER_REV.

Practice Ideas

Change MM_PER_REV to match your actual machine. Measure 1 revolution and set the correct value.
Try moveX(0.1f, true, 2) — what is the smallest movement you can actually see?
Add a moveY() function for a second axis with different steps_per_mm.
Try calling moveX() with distance_mm = 0. What happens?

What's Next

In Step 5, direction is still manual — I have to type true or false to choose which way to go.

In Step 6, I will change the interface to moveToX(target_mm). You give it a destination, and the code figures out direction automatically. That brings us one step closer to how G-code actually works.

See you next time.

Eric Park, from Daegu, South Korea

Tags: raspberrypi c steppermotor 3dprinting beginners embeddedsystems

Step 2: Controlling the Speed of a Stepper Motor

Eric Park — Thu, 26 Mar 2026 12:01:47 +0000

Step 2: Controlling the Speed of a Stepper Motor

Hello everyone. This is Eric Park, 3D Printer Engineer from South Korea.

Welcome back to the series. Quick recap from Step 1:

We set up the GPIO pins on the Raspberry Pi
We connected the A4988 driver to a NEMA17 motor
We sent 200 pulses to the motor and watched it complete one full revolution for the first time

That first spin felt surprisingly satisfying. But the motor was just running at one fixed speed. Step 2 is about changing that.

What Controls Speed?

In Step 1, the code looked something like this:

for (int i = 0; i < 200; i++) {
    digitalWrite(STEP_PIN, HIGH);
    delay(2);
    digitalWrite(STEP_PIN, LOW);
    delay(2);
}

The delay(2) is a 2 millisecond pause after each pulse. The motor waits for that pause before receiving the next pulse.

So the relationship is simple:

shorter delay  =  less waiting  =  faster motor
longer delay   =  more waiting  =  slower motor

That is the entire idea behind Step 2. We are not changing anything complicated — just the number we pass to delay().

Calculating Speed

Let me put a number to this.

Each full revolution requires 200 steps. If each step takes 2ms (HIGH) + 2ms (LOW) = 4ms total, then one revolution takes:

200 steps × 4ms = 800ms = 0.8 seconds per revolution

If I change the delay to 1ms:

200 steps × 2ms = 400ms = 0.4 seconds per revolution

Twice as fast. If I change the delay to 4ms:

200 steps × 8ms = 1600ms = 1.6 seconds per revolution

Half as fast. The delay value directly controls how long each revolution takes.

A Practical Limit: Too Fast = Missed Steps

I was curious how fast I could push the motor, so I tried very small delays — 0.5ms, then 0.1ms.

The motor started making a grinding noise and vibrating in place instead of rotating. This is called step loss (or missing steps). The motor's internal magnets need a minimum amount of time to physically move between positions. If the pulses arrive faster than the motor can mechanically respond, it misses them.

For a typical NEMA17 at 12V with an A4988 driver, around 1ms delay is usually the practical minimum before step loss starts. The exact limit depends on the motor's current setting and the load it is carrying.

This was an interesting thing to discover just by experimenting. No special equipment needed — the sound alone tells you when the motor is being pushed too hard.

The Code

#include <wiringPi.h>
#include <stdio.h>

#define STEP_PIN    4
#define DIR_PIN     3
#define ENABLE_PIN  2

#define STEPS_PER_REV  200

/*
 * rotateMotor: spin the motor a given number of steps at a given speed
 *
 * steps    : how many steps to execute
 * delay_ms : delay between pulses in milliseconds
 *            smaller = faster, larger = slower
 */
void rotateMotor(int steps, int delay_ms) {
    for (int i = 0; i < steps; i++) {
        digitalWrite(STEP_PIN, HIGH);
        delay(delay_ms);
        digitalWrite(STEP_PIN, LOW);
        delay(delay_ms);
    }
}

int main(void) {

    if (wiringPiSetupGpio() == -1) {
        printf("wiringPi init failed\n");
        return 1;
    }

    pinMode(STEP_PIN,   OUTPUT);
    pinMode(DIR_PIN,    OUTPUT);
    pinMode(ENABLE_PIN, OUTPUT);

    /* Motor ON (ENABLE is active LOW on A4988) */
    digitalWrite(ENABLE_PIN, LOW);
    delay(100);

    printf("--- Step 2: Speed Control ---\n\n");

    /* Slow */
    printf("Slow (delay = 5ms)\n");
    rotateMotor(STEPS_PER_REV, 5);
    delay(1000);

    /* Medium */
    printf("Medium (delay = 2ms)\n");
    rotateMotor(STEPS_PER_REV, 2);
    delay(1000);

    /* Fast */
    printf("Fast (delay = 1ms)\n");
    rotateMotor(STEPS_PER_REV, 1);
    delay(1000);

    /* Motor OFF */
    digitalWrite(ENABLE_PIN, HIGH);

    printf("Done.\n");
    return 0;
}

Walking Through the Code

The delay_ms parameter:

In Step 1, the delay was a hardcoded number inside the loop. Here I moved it into a function parameter. Now I can call rotateMotor(200, 5) for slow or rotateMotor(200, 1) for fast, without changing anything inside the function.

This is a small change, but it is an important habit. When a value is likely to change, give it a name or make it a parameter. Hardcoded numbers buried inside loops are difficult to find and adjust later.

#define STEPS_PER_REV 200:

Same idea. The number 200 comes from the motor spec (1.8 degree step angle → 360 / 1.8 = 200). If I ever switch to a different motor, I only need to update that one line.

The timing per step:

Each step takes delay_ms × 2 milliseconds total — one delay after HIGH, one after LOW. So delay_ms = 2 means 4ms per step, not 2ms. I made this mistake when I first calculated the revolution time and got a number that did not match what I measured with a stopwatch. Worth keeping in mind.

What I Noticed During Testing

Running the three speeds back to back — slow, medium, fast — makes the difference very obvious. The motor sound changes noticeably. At 5ms it sounds deliberate and measured. At 1ms it has a higher pitch and feels more tense.

I also tried going below 1ms by calling delay(0). The motor vibrated and did not complete the revolution at all. So there is a real physical floor here, not just a software one.

One more thing: between the three test runs, there is a delay(1000) pause. Without this, the transitions happen so fast that it is hard to tell where one speed ends and the next begins. Small details like this matter when you are trying to actually observe what the code is doing.

Practice Ideas

Change the three delay values and find the minimum before your motor starts losing steps.
Try calling rotateMotor(STEPS_PER_REV, 3) and time one revolution with a stopwatch. Does the calculated time (200 × 3ms × 2 = 1200ms) match what you measure?
Add a fourth test run between slow and medium — something like delay_ms = 3. Can you hear the difference?
Try STEPS_PER_REV / 2 steps (half a revolution) at different speeds. Does the motor stop at exactly 180 degrees?

What Is Next

Step 3 adds angle control. Right now I have to manually decide how many steps to use. In Step 3, I will build a function where I enter the angle I want — 90 degrees, 180 degrees, whatever — and the code calculates the steps automatically.

See you next time.

Eric Park, from Daegu, South Korea

Tags: raspberrypi c steppermotor 3dprinting beginners embeddedsystems

Step 4: Controlling Direction — and Starting to Track Position

Eric Park — Thu, 26 Mar 2026 11:59:10 +0000

Step 4: Controlling Direction — and Starting to Track Position

Hello everyone. This is Eric Park, 3D Printer Engineer from South Korea.

Quick recap before we start:

Step 1: Made the motor spin for the first time — 200 pulses, one full revolution.
Step 2: Controlled speed by changing the delay between pulses.
Step 3: Built a rotateAngle() function — enter an angle, the code calculates the steps.
Step 4 (today): The motor can now rotate both clockwise and counterclockwise. And we start tracking the current angle.

What Was Still Missing After Step 3

After Step 3, I had a working rotateAngle() function. But it always rotated in the same direction. My motor was stuck going one way.

For anything useful — a printer head moving left and right, a robotic arm returning to start — you need both directions. Step 4 adds that.

And once you have bidirectional movement, a natural question comes up: where is the motor right now? Step 4 introduces a simple way to track that.

How Direction Control Works

The A4988 driver has a DIR pin. The logic is simple:

DIR pin HIGH  =  clockwise (+ direction)
DIR pin LOW   =  counterclockwise (- direction)

Set the pin before sending step pulses, and the motor follows.

In code, I represent direction with a bool:

bool clockwise = true;   /* + direction */
bool clockwise = false;  /* - direction */

And the direction pin gets set once before the loop:

digitalWrite(DIR_PIN, clockwise ? HIGH : LOW);

That one line replaces a whole if-else block. I found the ternary operator a little strange at first, but it reads well once you get used to it: "if clockwise, set HIGH, otherwise set LOW."

The Code

#include <wiringPi.h>
#include <stdio.h>
#include <stdbool.h>   /* bool, true, false */

#define STEP_PIN    4
#define DIR_PIN     3
#define ENABLE_PIN  2

#define STEPS_PER_REV  200

/*
 * g_current_angle: tracks the motor's current angle in degrees
 *
 * This is a global variable. It starts at 0 and gets updated
 * after every call to rotateAngle().
 *
 * It is not perfectly accurate (rounding errors accumulate over time),
 * but it is good enough for learning purposes at this stage.
 */
float g_current_angle = 0.0;

/*
 * rotateAngle: rotate by a specific angle in a specific direction
 *
 * angle     : how many degrees to rotate (positive number)
 * delay_ms  : delay between pulses in milliseconds
 * clockwise : true = clockwise (+), false = counterclockwise (-)
 */
void rotateAngle(float angle, int delay_ms, bool clockwise) {

    /* Convert angle to step count */
    int steps = (int)(angle / 360.0 * STEPS_PER_REV);

    /* Set direction pin BEFORE sending pulses */
    digitalWrite(DIR_PIN, clockwise ? HIGH : LOW);

    printf("Rotating %.1f deg, %s -> %d steps\n",
           angle,
           clockwise ? "CW" : "CCW",
           steps);

    for (int i = 0; i < steps; i++) {
        digitalWrite(STEP_PIN, HIGH);
        delay(delay_ms);
        digitalWrite(STEP_PIN, LOW);
        delay(delay_ms);
    }

    /* Update position tracking */
    if (clockwise) {
        g_current_angle += angle;
    } else {
        g_current_angle -= angle;
    }

    printf("Current angle: %.1f deg\n\n", g_current_angle);
}

int main(void) {

    if (wiringPiSetupGpio() == -1) {
        printf("wiringPi init failed\n");
        return 1;
    }

    pinMode(STEP_PIN,   OUTPUT);
    pinMode(DIR_PIN,    OUTPUT);
    pinMode(ENABLE_PIN, OUTPUT);

    digitalWrite(ENABLE_PIN, LOW);
    delay(100);

    printf("--- Step 4: Direction Control ---\n\n");

    /* Rotate 90 degrees clockwise */
    rotateAngle(90.0, 2, true);
    delay(500);

    /* Rotate 90 degrees counterclockwise — back to start */
    rotateAngle(90.0, 2, false);
    delay(500);

    /* Go forward 180 degrees, then come back */
    rotateAngle(180.0, 2, true);
    delay(500);
    rotateAngle(180.0, 2, false);
    delay(500);

    printf("Final position: %.1f degrees\n", g_current_angle);

    digitalWrite(ENABLE_PIN, HIGH);
    return 0;
}

Walking Through the Code

#include <stdbool.h>

C does not have a built-in bool type by default. This header adds bool, true, and false. Without it, the compiler does not recognize those keywords.

The direction pin:

digitalWrite(DIR_PIN, clockwise ? HIGH : LOW);

This must be set before the step pulses start. If you change direction in the middle of a pulse sequence, the motor gets confused. Set direction first, then pulse.

The global variable g_current_angle:

float g_current_angle = 0.0;

After each rotation, the function adds or subtracts the angle from this variable. It gives us a running record of where the motor is.

I named it with a g_ prefix. This is a naming convention to make global variables easy to spot in the code. When you see g_current_angle anywhere in the file, you know immediately it is a global — not a local variable inside a function.

Updating position after movement:

if (clockwise) {
    g_current_angle += angle;
} else {
    g_current_angle -= angle;
}

Clockwise adds to the angle, counterclockwise subtracts. After the main() test sequence — 90 CW, 90 CCW, 180 CW, 180 CCW — g_current_angle should be exactly 0.0. The motor ends up where it started.

A Limitation I Noticed

The rounding issue from Step 3 still applies here, and it now accumulates.

If I call rotateAngle(30.0, ...) ten times in the same direction, the motor actually moves 28.8 degrees each time (16 steps × 1.8°). After ten calls, g_current_angle says 300 degrees, but the motor has really moved 288 degrees. A 12-degree drift.

For short sequences this is not a problem. But for longer runs, it matters. The real solution is a homing sequence — a physical reference point the motor returns to so position can be reset from reality, not from software tracking alone. We will get to that later in the series.

Practice Ideas

Add a third call in main() to rotate 45 degrees CW, then 45 degrees CCW. Does it return to exactly 0.0?
Try calling rotateAngle(360.0, 2, true) then rotateAngle(360.0, 2, false). Watch the motor go one full revolution and come back.
Change delay_ms to 1 for CW and 3 for CCW. Does the speed actually change by direction?
Print g_current_angle after every call. Can you predict what it will say before running?

What Is Next

Step 5 introduces a coordinate system — tracking not just angle, but position in millimeters. We will define a steps_per_mm value based on the motor and lead screw specs, and the code will start using real physical units.

This is where things start to look like actual machine control.

See you next time.

Eric Park, from Daegu, South Korea

Tags: raspberrypi c steppermotor 3dprinting beginners embeddedsystems

Step 3: Rotating a Stepper Motor by Exact Angle

Eric Park — Wed, 11 Mar 2026 22:37:55 +0000

Step 3: Rotating a Stepper Motor by Exact Angle

Hello everyone! This is Eric Park, 3D Printer Engineer from South Korea.

We are now at Step 3 of our controller series. If you missed the previous posts, here is a quick recap:

Step 1: We made the motor spin for the first time — 200 pulses, one full revolution
Step 2: We controlled the speed by changing the delay between pulses
Step 3 (today): We tell the motor to rotate by a specific angle — 90 degrees, 45 degrees, whatever we want

This is where things start to feel much more like a real machine.

The Goal

By the end of Step 2, I could control speed. But I still could not tell the motor "rotate exactly 90 degrees." I had to manually calculate how many steps to use, which felt clumsy.

Step 3 is about building a rotateAngle() function. I type in the angle I want, and the code figures out the steps automatically.

The Key Formula

A 1.8-degree stepper motor needs 200 steps to complete one full revolution.

Why 200? Because 360 degrees / 1.8 degrees per step = 200 steps.

So if I want to rotate a specific angle:

steps = (angle / 360.0) * 200

Example:

90 degrees → (90 / 360.0) × 200 = 50 steps
45 degrees → (45 / 360.0) × 200 = 25 steps
180 degrees → (180 / 360.0) × 200 = 100 steps

This formula is the entire idea behind Step 3. Everything else is just implementing it in C.

The Code

/*
 * Step 3: Rotate by exact angle
 *
 * Learning goals:
 * - Understand how angle converts to step count
 * - Implement math formulas in C code
 * - Use ENABLE pin to activate and deactivate the motor
 */

#include <wiringPi.h>
#include <stdio.h>

#define STEP_PIN      4    // wiringPi pin 4 = GPIO 23
#define DIR_PIN       3    // wiringPi pin 3 = GPIO 22
#define ENABLE_PIN    2    // wiringPi pin 2 = GPIO 27
#define STEPS_PER_REV 200  // 200 steps = 360 degrees (1.8 degree motor)

// Low-level: send N pulses to the motor
void rotateMotor(int steps, int delayMs) {
    for (int i = 0; i < steps; i++) {
        digitalWrite(STEP_PIN, HIGH);
        delay(delayMs);
        digitalWrite(STEP_PIN, LOW);
        delay(delayMs);
    }
}

// High-level: rotate by angle in degrees
void rotateAngle(float angle, int speedDelay) {
    // Convert angle to step count
    int steps = (int)((angle / 360.0) * STEPS_PER_REV);
    printf("%.1f degrees = %d steps\n", angle, steps);
    rotateMotor(steps, speedDelay);
}

int main(void) {
    // Initialize wiringPi using BCM GPIO numbers
    if (wiringPiSetupGpio() == -1) {
        printf("wiringPi init failed\n");
        return 1;
    }

    pinMode(STEP_PIN,   OUTPUT);
    pinMode(DIR_PIN,    OUTPUT);
    pinMode(ENABLE_PIN, OUTPUT);

    // Activate motor (LOW = enabled for most drivers)
    digitalWrite(ENABLE_PIN, LOW);
    printf("Motor enabled\n");
    delay(100);

    // Set direction (HIGH = clockwise in our setup)
    digitalWrite(DIR_PIN, HIGH);

    printf("Rotating 90 degrees\n");
    rotateAngle(90, 2);
    delay(1000);

    printf("Rotating 45 degrees\n");
    rotateAngle(45, 2);
    delay(1000);

    printf("Rotating 180 degrees\n");
    rotateAngle(180, 2);

    printf("Done!\n");

    // Deactivate motor
    digitalWrite(ENABLE_PIN, HIGH);

    return 0;
}

/*
 * Compile: gcc -o step3 step3_angle_control.c -lwiringPi
 * Run:     sudo ./step3
 */

Walking Through the Code

STEPS_PER_REV

#define STEPS_PER_REV 200

I defined this as a constant at the top. This makes the code easier to read and easier to change. If I ever use a 0.9-degree motor (400 steps/revolution), I only need to change this one line.

If your motor moves the wrong distance, this is the first value to check. Common values are 200 (1.8 degree) and 400 (0.9 degree).

Two separate functions

I split the work into two functions:

void rotateMotor(int steps, int delayMs)  // sends pulses
void rotateAngle(float angle, int speedDelay)  // converts angle, then calls rotateMotor

rotateMotor only knows about pulses. It does not know anything about angles.
rotateAngle only knows about angles. It does the math and passes the result down.

This separation is a good habit. Each function does one thing. If something breaks, I know which layer to look at.

The conversion line

int steps = (int)((angle / 360.0) * STEPS_PER_REV);

The (int) cast truncates the decimal. For example, 33.33 steps becomes 33. This is acceptable for most use cases. The small error is less than one step, which is less than 1.8 degrees.

If you need more precision, a microstepping driver can help — but that is a topic for a later step.

ENABLE pin

In Step 1, I added the ENABLE pin but did not explain it much. Here is the fuller picture.

Most stepper motor drivers have an enable (ENA) input:

LOW: motor is energized and holds its position
HIGH: motor is de-energized, shaft can spin freely

I set it to LOW at startup and HIGH at the end. During operation, the motor holds position. After the program ends, you can spin the shaft by hand without fighting the motor current.

wiringPiSetupGpio() vs wiringPiSetup()

In Step 1, I used wiringPiSetup(). This uses wiringPi's own pin numbering system. In Step 3, I switched to wiringPiSetupGpio(), which uses BCM GPIO numbers directly.

// wiringPiSetup()   → pin 4 = wiringPi pin 4
// wiringPiSetupGpio() → pin 4 = GPIO 4 (BCM)

I made this change because BCM numbers are what most wiring diagrams and documentation use. It reduces confusion when checking your wiring.

What I Tested

After writing the code, I ran a few tests.

First I confirmed 90 degrees → 50 steps → motor turns a quarter of a revolution. That matched visually.

Then I tried the math edge case: rotateAngle(45, 2) gives 25 steps exactly. No rounding issue.

Then I tried rotateAngle(30, 2): (30 / 360.0) × 200 = 16.666... → (int) truncates to 16 steps → 16 × 1.8 = 28.8 degrees instead of 30.

This is a real limitation. The minimum addressable unit is 1.8 degrees (1 step), so any angle that does not divide evenly into the step size will have a small error. For my project at this stage, that is acceptable.

Practice Ideas

If you are following along, try these:

Change STEPS_PER_REV to 400 and see what happens
Try rotateAngle(360, 2) and confirm it is exactly one full revolution
Try rotateAngle(0, 2) — what does (int)(0 / 360.0 * 200) equal? Does it crash or just do nothing?
Change the (int) cast to (int)round(...) — does it improve accuracy for 30 degrees?

What's Next

Step 4 adds direction control. Right now the motor always turns clockwise. In Step 4, I will add the ability to specify a direction — and start tracking where the motor actually is.

That position tracking idea ends up being important later. When we get to Step 7 (acceleration profiles) and eventually G-code parsing, knowing the current position is essential.

See you next Thursday!

Eric Park, from Daegu, South Korea

Tags: raspberrypi c steppermotor 3dprinting beginners embeddedsystems

step.1 start rotation of stepper motor with raspberry pi

Eric Park — Thu, 26 Feb 2026 11:09:43 +0000

Step 1: Let's Spin a Stepper Motor with Raspberry Pi!

Hello everyone! This is Eric Park, 3D Printer Engineer from South Korea.

Welcome to the first real step of our journey — "Making a Controller with Raspberry Pi"!

If you haven't read my introduction post yet, here's the short version: I'm a 3D printer engineer who couldn't understand Marlin or Klipper code, so I decided to study from the very basics — with the help of AI (Claude). And now I want to share everything I learn, step by step, with anyone who feels the same way I did.

Today is Step 1: Make the motor spin. That's it. Simple. Fun. Let's go!

What You Need (BOM - Bill of Materials)

Messy Desk ;)

Wiring Diagram

Note: I'll add a proper image diagram soon! For now, here's the connection table and an ASCII diagram to get you started.

Raspberry Pi GPIO        A4988 Driver Board
─────────────────────────────────────────────
GPIO 4  (Pin 7)  ──────► STEP
GPIO 3  (Pin 5)  ──────► DIR
GPIO 2  (Pin 3)  ──────► ENABLE (active LOW)
GND              ──────► GND (logic side)

12V Power Supply
─────────────────────────────────────────────
12V (+)          ──────► VMOT
GND (-)          ──────► GND (motor side)

Stepper Motor    ──────► A, A̅, B, B̅  (4 wires)

Important notes:

The A4988 has two GND pins — one for logic (connect to RPi GND), one for motor power (connect to 12V GND)
Set the current limit on your A4988 before connecting the motor! (Turn the potentiometer carefully)
ENABLE pin is active LOW — meaning LOW = motor ON, HIGH = motor OFF

The Code — Step 1

Let's look at the code together. I'll explain each part so we can understand what's happening!

/*
 * step1.c
 * Basic Stepper Motor Control
 *
 * Goal:
 *   - Understand GPIO control
 *   - Generate step pulses to spin the motor
 *   - Control direction
 */

#include <wiringPi.h>   // Raspberry Pi GPIO library
#include <stdio.h>

// === Pin Definitions ===
// We use BCM GPIO numbers (wiringPiSetupGpio mode)
#define STEP_PIN    4   // GPIO 4 → sends pulses to move motor
#define DIR_PIN     3   // GPIO 3 → sets rotation direction
#define ENABLE_PIN  2   // GPIO 2 → enables/disables motor

// === Settings ===
#define STEPS_TO_MOVE   200    // 200 steps = 1 full revolution (for 1.8° motor)
#define STEP_DELAY_US   1000   // delay between pulses in microseconds (= speed)

int main(void) {

    // Step 1: Initialize wiringPi with BCM GPIO numbering
    if (wiringPiSetupGpio() == -1) {
        printf("wiringPi init failed!\n");
        return 1;
    }

    // Step 2: Set pin modes
    pinMode(STEP_PIN,   OUTPUT);
    pinMode(DIR_PIN,    OUTPUT);
    pinMode(ENABLE_PIN, OUTPUT);

    // Step 3: Enable the motor driver (ENABLE is active LOW)
    digitalWrite(ENABLE_PIN, LOW);
    printf("Motor enabled!\n");
    delay(500); // small wait after enable

    // Step 4: Set direction (HIGH = one way, LOW = other way)
    digitalWrite(DIR_PIN, HIGH);
    printf("Direction: Forward\n");

    // Step 5: Send step pulses!
    printf("Moving %d steps...\n", STEPS_TO_MOVE);

    for (int i = 0; i < STEPS_TO_MOVE; i++) {

        // One pulse = one step
        digitalWrite(STEP_PIN, HIGH);
        delayMicroseconds(STEP_DELAY_US);  // pulse ON time

        digitalWrite(STEP_PIN, LOW);
        delayMicroseconds(STEP_DELAY_US);  // pulse OFF time
    }

    printf("Done! Motor moved %d steps.\n", STEPS_TO_MOVE);

    // Step 6: Disable motor (saves power, reduces heat)
    digitalWrite(ENABLE_PIN, HIGH);
    printf("Motor disabled.\n");

    return 0;
}

Code Explanation — Let's Read It Together

1. `#include <wiringPi.h>`

This is the library that lets us control the Raspberry Pi's GPIO pins from C code. Think of it as the "translator" between our code and the hardware pins.

2. Pin Definitions (`#define`)

#define STEP_PIN    4
#define DIR_PIN     3
#define ENABLE_PIN  2

Instead of writing the number 4 everywhere in the code, we give it a name STEP_PIN. This makes the code much easier to read and change later. This is a very common practice in C!

3. `wiringPiSetupGpio()`

This tells wiringPi: "I want to use standard BCM GPIO numbers." It must be called once at the very start, before using any GPIO functions.

4. `pinMode(pin, OUTPUT)`

Each GPIO pin can work as either INPUT (read a signal) or OUTPUT (send a signal). Since we're sending pulses to the motor driver, we set all three pins as OUTPUT.

5. The ENABLE Pin — Active LOW Logic

digitalWrite(ENABLE_PIN, LOW);  // LOW = ON (motor enabled)

This is a little confusing at first! The A4988 driver uses "active LOW" logic for ENABLE, which means:

LOW (0V) → Motor is ENABLED
HIGH (3.3V) → Motor is DISABLED

This is common in electronics — don't worry, you'll get used to it!

6. The Step Pulse Loop

for (int i = 0; i < STEPS_TO_MOVE; i++) {
    digitalWrite(STEP_PIN, HIGH);
    delayMicroseconds(STEP_DELAY_US);
    digitalWrite(STEP_PIN, LOW);
    delayMicroseconds(STEP_DELAY_US);
}

Each loop iteration = one step of the motor.

One step is created by:

Pulling STEP pin HIGH → motor driver detects rising edge → motor moves one step
Waiting (delayMicroseconds) → this controls speed!
Pulling STEP pin LOW → ready for the next pulse

Key insight: The smaller the delay, the faster the motor spins!
Try changing STEP_DELAY_US from 1000 to 500 and see what happens.

How to Compile and Run

# Compile
gcc step1.c -o step1 -lwiringPi

# Run (needs sudo for GPIO access)
sudo ./step1

Expected output:

Motor enabled!
Direction: Forward
Moving 200 steps...
Done! Motor moved 200 steps.
Motor disabled.

What Did We Learn?

How to set up GPIO pins with wiringPi
What STEP, DIR, and ENABLE pins do
How a step pulse works (HIGH → delay → LOW → delay)
How delay time controls motor speed
Active LOW logic (ENABLE pin)

What's Next? (Step 2 Preview)

Right now, our motor just spins 200 steps and stops. But what if we want to control how many mm it moves, or make it go back and forth?

Next week (Step 2), we'll add:

Direction control — forward and backward
Loop for continuous movement
Start thinking about converting steps to mm

See you next Thursday!

Let's Talk!

Have any questions? Did your motor spin? Did it NOT spin? Let me know in the comments!

If you're in a similar situation — an engineer who wants to understand the code behind their machines — I hope this series helps you feel less alone in that journey. We're learning together.

And if you have questions about 3D printing, Korea, or anything else — feel free to reach out anytime!

Eric Park, from Daegu, South Korea

Tags: raspberrypi C steppermotor 3dprinting beginners embedded

Greeting from south korea

Eric Park — Tue, 24 Feb 2026 13:11:27 +0000

Greeting, Everyone.

Thank you for reading this article ! :)
This is Eric Park, 3D Printer Engineer from South Korea, Dae-gu.

I was worked as a 3D Printer Engineer for 8 years.
My first 3D Printer is DIY 3D Printer with Marlin 8bit, and now I am using Klipper and with the automation 3D Printing.

in the future, I will prepare and introduce my diy 3d printer.

I was interested in control and code. but, as I am not a code engineer, I can not understand when I see the marlin & klipper code ;(

so, I decided make 3d printer controller with AI.
I was very surprised when I use Claude, and I realise I can make a Code for control 3d printer with Claude.

and now, I am studying code with claude, control stepper motor. and I want to share the my study material who want to study the code, like me.

This travel called "make a controller with raspberrypi".
This travel included 21 steps, and also share everything, code, also BOM.

and in the future, I will make my own firmware and 3d printer, and test with gcode.

I will publish the blog every thursday, following the korea time.

again, thank you for read this article, and anything you want to me, please feel free to contact me. about korea, also.

thanks!

Eric Park, from korea.

DEV Community: Eric Park

Step 6: Moving to an Absolute Position — Let the Code Figure Out the Direction

Step 6: Moving to an Absolute Position — Let the Code Figure Out the Direction

The Problem with Step 5

What Changes

The Code

Walking Through the Key Part

One Detail Worth Explaining: Why g_current_x = targetX Instead of += distance

What the Output Looks Like

Honest Limitation: The Position Tracker Has No Memory

Practice Ideas

What Is Next

Step 5: Moving in Millimeters — Position Tracking with Real Units

Step 5: Moving in Millimeters — Position Tracking with Real Units

Why Millimeters?

The Key Formula

What Changed From Step 4

The Code

Walking Through the Code

What I Discovered During Testing

Adjusting for Your Machine

Practice Ideas

What's Next

Step 2: Controlling the Speed of a Stepper Motor

Step 2: Controlling the Speed of a Stepper Motor

What Controls Speed?

Calculating Speed

A Practical Limit: Too Fast = Missed Steps

The Code

Walking Through the Code

What I Noticed During Testing

Practice Ideas

What Is Next

Step 4: Controlling Direction — and Starting to Track Position

Step 4: Controlling Direction — and Starting to Track Position

What Was Still Missing After Step 3

How Direction Control Works

The Code

Walking Through the Code

A Limitation I Noticed

Practice Ideas

What Is Next

Step 3: Rotating a Stepper Motor by Exact Angle

Step 3: Rotating a Stepper Motor by Exact Angle

The Goal

The Key Formula

The Code

Walking Through the Code

STEPS_PER_REV

Two separate functions

The conversion line

ENABLE pin

wiringPiSetupGpio() vs wiringPiSetup()

What I Tested

Practice Ideas

What's Next

step.1 start rotation of stepper motor with raspberry pi

Step 1: Let's Spin a Stepper Motor with Raspberry Pi!

What You Need (BOM - Bill of Materials)

Messy Desk ;)

Wiring Diagram

The Code — Step 1

Code Explanation — Let's Read It Together

1. #include <wiringPi.h>

2. Pin Definitions (#define)

3. wiringPiSetupGpio()

4. pinMode(pin, OUTPUT)

5. The ENABLE Pin — Active LOW Logic

6. The Step Pulse Loop

How to Compile and Run

What Did We Learn?

What's Next? (Step 2 Preview)

Let's Talk!

Greeting from south korea

One Detail Worth Explaining: Why `g_current_x = targetX` Instead of `+= distance`

1. `#include <wiringPi.h>`

2. Pin Definitions (`#define`)

3. `wiringPiSetupGpio()`

4. `pinMode(pin, OUTPUT)`