Day 3: Intro to Stepper Motors:

Why should I even bother spending my time understanding stepper motors?
What’s the purpose of writing code, and what does a “good reflection” even mean when I’m drowning in questions?

I’ve thrown every spare moment of my life into chasing new things—new ideas, new tools, new possibilities. But I never stop to look back. The further I stretch my gaze, the smaller I become, as if I’m collapsing under the sheer weight of everything I’m supposed to learn. It’s overwhelming, almost suffocating, to stare into an infinity of knowledge and realize how little of it I actually grasp.

I wish I had more time to explore the robotic arm, to actually touch the future I keep imagining. But the window to that future is so high above me that I can barely see the light leaking through. And somewhere along the way, I realized the truth: before I can reach that window, I have to build a ladder—one rung at a time. Before I can touch the “cool stuff,” I have to grind, to dig in, to strengthen the foundations I’ve been pretending I already had.

I can’t build an empire of knowledge out of thin air. And right now, I’m standing here without the bones, without the structure, without the anchor I need to support everything I’m trying to become.

Less is more…

Stepper Motors

I am going to provide a simple summary of this video. For those who have a attention span of less than 5 seconds, this will only take 5 hours. Let assume 5 hour < 5 seconds.

I will attach the video link again for reference:

So let look at these two photos:

StepA
StepB

A stepper motor does not spin continuously like a DC motor.
Instead, it moves in discrete steps. This comes from the interaction between two things inside the motor:

  1. Permanent Magnets

The rotor contains permanent magnets. Their north and south poles are fixed and never change. Sometimes in a “Hybrid” Motor, you will see N and S on different directional axels.

  1. Coils

Around the rotor, there are multiple coils of wire.
When electric current flows through a coil, it becomes an electromagnet.
The Opposite ends of N/S motivates the permanent magnets to adjust.

The stepper driver energizes the coils in a specific sequence.
Every time the magnetic field shifts to a new coil, the rotor aligns itself with that coil.

This alignment is one “step”.

Did YOU KNOW:
The Rotor have more teeth than the stator.
The Rotor have 50 TEETH and the STATOR have 48.

Why the Rotor Has More Teeth Than the Stator

If the rotor and stator had the same number of teeth, the motor would only snap into one alignment for each stator position.
That would give you terrible resolution.

Instead, the designers intentionally make the rotor tooth count slightly different from the stator tooth count.

This creates a “detuning” effect.

You can think of it like two gears with slightly different tooth counts. As you energize different stator poles, the rotor’s tooth alignment shifts by a tiny angle each time.

Why Stepper Motors Are Precise

You know exactly how many steps the motor must take to rotate by a chosen angle.
For example:

1.8° per step

50 steps = 90°

200 steps = full rotation

This is why 3D printers, CNCs, and your 3D scanner use them. No encoders are required for position.

The A4988 Stepper Motor Driver

The A4988 is the small module between your Arduino and the motor.
Its job is to do all the coil switching and current control.
You do not energize coils yourself; you just send simple logic signals.

A4988 Inputs IMPORTANTE

STEP pin
Each rising edge = one microstep.
Pulse the STEP pin fast → motor moves fast.

DIR pin
High = one direction.
Low = opposite direction.

ENABLE pin
Low = motor is active.
High = motor is disabled and free to move.

What the A4988 Actually Does Internally

It switches current between the two motor windings in the correct sequence so the rotor turns.

It uses an internal chopper circuit to limit the current to a safe value.

It generates microsteps, which interpolate the current between coils.

It handles high motor current even though the Arduino pins supply almost none.

Video Explaining Stepper Motor:

Simple Stepper Motor Code:

SET UP

I plug in the stepper motor on the X of the CNC shield.

Shield

We know that the Step pin for X axis is 2, and Direction Pin is 5.

So we write:

1
2
3
const int STEP_PIN = 2;
const int DIR_PIN = 5;
const int ENABLE_PIN = 8;

Where:

  • STEP_PIN = 2 → Arduino digital pin 2 is wired to the A4988 STEP input.

  • DIR_PIN = 5 → Arduino digital pin 5 is wired to the A4988 DIR (direction) input.

  • ENABLE_PIN = 8 → Arduino digital pin 8 is wired to the A4988 ENABLE input.

Next: We want to set up a standard pause time.
So we write:

1
const int STEP_DELAY_US = 1000

Now We have to setup() Where the code only runs once, uno,----:

1
2
3
4
5
6
7
void setup() {
  pinMode(STEP_PIN, OUTPUT);
  pinMode(DIR_PIN, OUTPUT);
  pinMode(ENABLE_PIN, OUTPUT);

  digitalWrite(ENABLE_PIN, LOW);  // Enable the driver (LOW = ON)
}

So UNPACK:

  • pinMode(STEP_PIN, OUTPUT);

  • Tells the Arduino: “Pin 2 will send signals out,” not read them.

  • pinMode(DIR_PIN, OUTPUT);

  • Pin 5 is also an output; we’ll use it to set the direction.

  • pinMode(ENABLE_PIN, OUTPUT);

  • Pin 8 is an output; used to enable/disable the driver

  • Note: This is consistent for X,Y,and Z axis.

  • digitalWrite(ENABLE_PIN, LOW);

  • On A4988: ENABLE = LOW means “turn the driver ON.”
    So as soon as setup finishes, the motor is energized and holding position.

LOOP FUNC

Next Lep write a Loop function:

1
2
3
4
5
6
7
8
9
10
11
12
13
void loop() {
  // Spin clockwise
  digitalWrite(DIR_PIN, HIGH);
  stepMotor(200);   // number of steps to move

  delay(500);

  // Spin counter-clockwise
  digitalWrite(DIR_PIN, LOW);
  stepMotor(200);

  delay(500);
}

This code sets the direction into clockwise, and calls in the function stepMotor and asks it to move 200 steps.

And we will have to write the function by ourselves.

Our expected solution will be.

1
> | > | > | > | < | < | < | <

Where > mean High or Clockwise Position, and | mean delay 500 msec and < mean Counter Clockwise Position.

STEPPerMOTOR FUNC

1
2
3
4
5
6
7
8
void stepMotor(int steps) {
  for (int i = 0; i < steps; i++) {
    digitalWrite(STEP_PIN, HIGH);
    delayMicroseconds(STEP_DELAY_US);
    digitalWrite(STEP_PIN, LOW);
    delayMicroseconds(STEP_DELAY_US);
  }
}

This is a function that only takes in 1 Input:

1
void stepMotor(int steps)
  • Void: means that the function doesn’t return and value.

The medium difficulty part: For-Loop

Let use the basic example of for loops in Python
for i in range(steps):

1
2
3
for char in "Hello":
    print(char)
# Output: H, e, l, l, o

Now let transform it into C:

1
2
3
for (int i = 0; i < steps; i++) {

}

If you want to make it crazier:

1
2
3
4
5
6
7
8
9
names = ["Thomas", "Fat", "Pig"]
ages = [25, 30, 35]
locations = ["Moon", "Mars", "Sun"]
scores = [85, 92, 78]

for name, age, city, score in zip(names, ages, locations, scores):
    status = "Pass" if score >= 80 else "Fail"
    print(f"{name} ({age}) from {location}: {score} - {status}")

1
2
3
4
# The expected output would be:
Thomas (25) from Moon: 85 - Pass
Fat (30) from Mars: 92 - Pass
Pig (35) from Sun: 78 - Fail

In C how should you write it???
Well you can’t or it is very painful:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
#include <stdio.h>
#include <string.h>

int main() {
    // Define arrays
    char *names[] = {"Thomas", "Fat", "Pig"};
    int ages[] = {25, 30, 35};
    char *locations[] = {"Moon", "Mars", "Sun"};
    int scores[] = {85, 92, 78};
    
    // Get array length
    int length = sizeof(names) / sizeof(names[0]);
    
    // Loop through arrays
    for (int i = 0; i < length; i++) {
        // Determine status
        char *status = (scores[i] >= 80) ? "Pass" : "Fail";
        
        // Print formatted output
        printf("%s (%d) from %s: %d - %s\n", 
               names[i], ages[i], locations[i], scores[i], status);
    }
    
    return 0;
}

Back to stepMotor Func:

1
2
3
4
5
6
7
8
void stepMotor(int steps) {
  for (int i = 0; i < steps; i++) {
    digitalWrite(STEP_PIN, HIGH);
    delayMicroseconds(STEP_DELAY_US);
    digitalWrite(STEP_PIN, LOW);
    delayMicroseconds(STEP_DELAY_US);
  }
}

  1. Starts with i = 0.

  2. Repeats the code inside while i < steps.

  3. Each time it runs, i increases by 1 using (i++) or i = i + 1.

  • So if steps = 200, it runs 200 times.
  1. digitalWrite(STEP_PIN, HIGH);

  • Sets the STEP pin to HIGH.

  • The A4988 looks for a LOW → HIGH to trigger a step.

  1. delayMicroseconds(STEP_DELAY_US);
  • Wait so the pulse stays HIGH long enough to be registered. If it’s too short, the driver might miss it.
  1. digitalWrite(STEP_PIN, LOW)
  • Sets the STEP pin back to LOW.
  1. delayMicroseconds(STEP_DELAY_US);
  • Wait again before sending the next step.
    The delay also determine the maximum time needed to perform each step.

Day 4 Combining

How should we combine all of our progress.
How should I obtain and use all of my data.
And How can I apply the theories into test?

To be Honest, by this point of the day, I still don’t have a clear strategy to which I am able to play with both the IR sensor and the Stepper Motor at the same time.

My mistake:

Though I had clarified what I need and what I want, Steps and Measurements, I wrote the wrong variable name, confused myself with Directions and tricked myself with incorrect data_.

I am going to list my code here and debug my data:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
// IR sensor on A2, Stepper on pins 2,5,8

// Pins
const int STEP_PIN_X = 2;
const int DIR_PIN_X = 5;
const int ENABLE_PIN = 8;
const int SENSOR_PIN = A2;

// Stepper settings
const int STEPS_PER_REV = 200;
const int STEP_DELAY_US = 2000;

// Scanning settings
const int SCAN_ANGLE = 90;
const int ANGLE_INCREMENT = 1;

// Measure voltage at 2 known distances and fill these in:
const float VOLTAGE_AT_CLOSE = 2.8;  // Voltage at 50mm
const float DISTANCE_CLOSE = 50;     // mm
const float VOLTAGE_AT_FAR = 0.5;    // Voltage at 600mm
const float DISTANCE_FAR = 600;      // mm

void setup() {
  Serial.begin(115200);
  
  pinMode(STEP_PIN_X, OUTPUT);
  pinMode(DIR_PIN_X, OUTPUT);
  pinMode(ENABLE_PIN, OUTPUT);
  digitalWrite(ENABLE_PIN, LOW);
  pinMode(SENSOR_PIN, INPUT);
  
  //Serial.println("Scanner Ready!");
  //Serial.println("Angle,Distance");
  delay(2000);
}

void loop() {
  scan(true);   
  delay(2000);
  moveSteps(50, false);  
  delay(2000);
}

void scan(bool clockwise) {
  int stepsPerMove = 1; //ANGLE_INCREMENT * STEPS_PER_REV / 360;
  int cumulativeSteps = 0;  // ← ADDED: Track total steps
  
  digitalWrite(DIR_PIN_X, clockwise ? HIGH : LOW);
  
  for (int angle = 0; angle <= SCAN_ANGLE; angle += ANGLE_INCREMENT) {
    int currentAngle = clockwise ? angle : (SCAN_ANGLE - angle);
    
    float distance = getDistance();
    //Serial.print("Steps: ");
    Serial.print(cumulativeSteps);  // ← FIXED: Print cumulative steps
    Serial.print(",");
    //Serial.print("Distance: ");
    Serial.println(distance);
    

    if (angle < SCAN_ANGLE) {
      moveSteps(stepsPerMove, false);
      cumulativeSteps += stepsPerMove;  // ← ADDED: Increment step counter
      delay(200);
    }
  }
}

void moveSteps(int steps, bool direction) {
  digitalWrite(DIR_PIN_X, direction);  
  for (int i = 0; i < steps; i++) {
    digitalWrite(STEP_PIN_X, HIGH);
    delayMicroseconds(STEP_DELAY_US);
    digitalWrite(STEP_PIN_X, LOW);
    delayMicroseconds(STEP_DELAY_US);
  }
}

float getDistance() {
  float voltage = analogRead(SENSOR_PIN) * (5.0 / 1023.0);
  
  float slope = (DISTANCE_FAR - DISTANCE_CLOSE) / (VOLTAGE_AT_FAR - VOLTAGE_AT_CLOSE);
  float distance = DISTANCE_CLOSE + slope * (voltage - VOLTAGE_AT_CLOSE);
  
  // Constrain to reasonable range
  if (distance < 20) distance = 20;
  if (distance > 800) distance = 800;
  
  return distance;
}

Debugging Time:

OOFF: That must be overwhelming watching so much code.

Mistake 1: Self-Contradictory Scanning;

In Scan, I set the direction:

1
2
3
4
5
6
7
void scan(bool clockwise) {
  ...
  digitalWrite(DIR_PIN_X, clockwise ? HIGH : LOW);
  ...
      moveSteps(stepsPerMove, false);
  ...
}

Or in if-else statement:

1
2
3
4
5
6
7
8
9
10
11
void scan(bool clockwise) {
  ...
  if (clockwise) {
    digitalWrite(DIR_PIN_X, HIGH);
  } else {
    digitalWrite(DIR_PIN_X, LOW);
  }
  ...
  moveSteps(stepsPerMove, false);
  ...
}

However, I then wrote in moveSteps:

1
2
3
4
void moveSteps(int steps, bool direction) {
  digitalWrite(DIR_PIN_X, direction);  
  ...
}

Why does having an direction assigned in a direction matter? Why is it problematic?

This is because the real direction used is whatever I pass as direction into moveSteps(), not the clockwise value I set before the loop.

And inside the scan(bool clockwis), I already set the direction:

1
moveSteps(stepsPerMove, false);

This means that clockwise is completely ignored.
And the motor always moves in false direction, regardless of moveSteps.

SOLUTION:

The answer is easy, I simply have to pass it through. I will remove the settling of dir in scan() and pass it:

1
2
3
4
5
6
7
8
9
10
11
12
void scan(bool clockwise) {
  ...
  for (...) {
    ...
    moveSteps(stepsPerMove, clockwise);
  }
}

void moveSteps(int steps, bool clockwise) {
  digitalWrite(DIR_PIN_X, clockwise ? HIGH : LOW);
  ...
}

Mistake 2: I am terrible at fundamentals:

We know that: int is always an integer.

Therefore: 2/3 equals to 0, because it truncates.

However, I did this:

1
int stepsPerMove = 1; //ANGLE_INCREMENT * STEPS_PER_REV / 360;

Consequently:

1
2
3
4
5
ANGLE_INCREMENT * STEPS_PER_REV / 360
= 1 * 200 / 360
= 200 / 360
= 0   // because integer division truncates!

So I should change it into a float:

1
2
const float STEPS_PER_DEG = (float)STEPS_PER_REV / 360.0;
const int stepsPerMove = (int)(ANGLE_INCREMENT * STEPS_PER_DEG + 0.5); // rounded

Continue: Mapping

Ignore all the bug, and here is a very last minute test:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
import serial
import matplotlib.pyplot as plt

# --- read data from Arduino ---
arduino = serial.Serial(port='/dev/cu.usbmodem21301', baudrate=115200, timeout=3)
print('Connected')

steps = []
dists = []

for _ in range(50):          # or however many samples per scan
    data_bytes = arduino.read_until()
    line = data_bytes.decode(errors="ignore").strip()
    if not line:
        continue
    try:
        s, d = line.split(',')
        steps.append(int(s))
        dists.append(float(d))
        print(s, d)
    except ValueError:
        print("Skipping bad line:", repr(line))

arduino.close()

# --- visualize (distance vs step index) ---
plt.figure()
plt.plot(steps, dists, marker='o')
plt.xlabel("Step index")
plt.ylabel("Distance (mm)")
plt.title("IR Distance vs Step Position")
plt.grid(True)
plt.tight_layout()
plt.show()

I used pip to download both pyserial and matplotlib

Then here is a 10 step summary from WebbGPT

  1. Import serial for Arduino communication and matplotlib.pyplot for plotting.

  2. Open a serial port connection on /dev/cu.usbmodem21301 at 115200 baud.

  3. Initialize two empty lists to store step indices and distance readings.

  4. Loop up to 50 times to read individual data lines from the Arduino.

    • 50 * 1.8 = 90

  5. Read each line using read_until() and decode it from bytes to text.

  6. Skip empty lines that contain no usable data.

  7. Attempt to split each line into a step value and a distance value separated by a comma.

  8. Convert the parsed step to int and distance to float, then append them to lists.

  9. Handle and report any malformed lines using a ValueError exception block.

  10. After closing the serial connection, plot the collected step vs. distance data with labels, grid, and markers.

Day 0 Images:

Here is how I thought I could implement it:
Looking back, it is. a lot of confusion and excitement.
I look forward to work with the CAD team!
A
B