When Code Spins a Motor

I still remember the first time I used an Arduino.

Wrote a tiny sketch. Uploaded it. Watched a servo motor twitch and rotate.

And I just sat there thinking, Wait what? How did that happen?

I typed some text into a computer. Hit upload. And the next thing I know, something in the physical world moved. Like, actually moved. That single moment unlocked a kind of wonder that never really left me.

We talk a lot about software eating the world. But what still blows my mind is how software touches it.

Like, Take this line for example:

To us, that’s just a function call. A high-level instruction.

But the more you zoom in, the more surreal it gets.

Let’s go all the way down.

Step 1: From text to binary

When I hit "Compile" in the Arduino IDE, my C++ code gets compiled.

It’s first translated into assembly, a low-level set of instructions specific to the ATmega328 chip (used in the Arduino Uno).

That assembly is then converted into machine code - just raw binary. A stream of 1s and 0s. The actual opcodes the microcontroller understands. All of this is done using a tool called avr-gcc.

After this, the binary is then converted into a .hex file.

Still even after all of this, it's just bits on my laptop.

Step 2: Flashing into memory

Now we need to get those bits transferred into the microcontroller.

Not "uploaded". Not "installed".

"Transferred". Bit by bit. Electrically.

This is where the Arduino bootloader comes in. It's a small piece of code that runs when the Arduino is powered on. It's responsible for loading the program from the .hex file into the microcontroller's flash memory.

Here's how it works:

→ It starts with a signal.

→ When I hit upload, my laptop sends a command over USB.

→ The Arduino has a tiny second chip - a USB-to-serial converter (like ATmega16U2) - whose only job is to listen for these commands and translate them into a simpler protocol the main chip understands: UART.

→ That chip briefly pulls a pin on the main microcontroller low - the RESET pin.

→ That low voltage pulse is enough to reboot the entire chip.

→ Not restart our code, at least not yet.

→ The microcontroller boots into a special mode.

→ It jumps to a small area of memory - a region burned during manufacturing - where the bootloader lives. This isn’t our program. This is a separate, pre-written piece of code whose only job is to say:

“Is someone trying to send me new instructions?”

So it waits.

And then the stream begins.

The .hex file - a human-readable format of our machine code - starts flowing in over the serial connection.

Each line contains bytes. Each byte contains 8 bits. Each bit is a single high ↑ or low ↓ voltage signal.

1s and 0s. Fast, tiny pulses of electricity. Like Morse code, but smaller.

The bootloader receives each byte, parses it, and figures out where it should go in flash memory. Then it writes it.

And this is where it stops being just “software.”

We are literally slamming electrons into a cage and leaving them there until further notice.

The bootloader does this over and over, for every byte in our program.

A cascade of high voltage pulses. Thousands of gates, each either filled with electrons or left empty.

And when it’s done, our entire programm the one we typed, compiled, and sent, is now physically etched into the chip.

Not metaphorically. Not symbolically. But physically, in silicon :)

In trapped charge. In electrons that are now sitting inside a gate that will remember them even when the power is gone.

Imagine there’s no hard disk. No file system. No OS. Just raw memory cells. Charged or not. Beauty 🤌🏻

Step 3: CPU starts executing

When the board powers up, the chip’s program counter starts at memory address 0x0000.

The CPU fetches the instruction stored there. Decodes it. Executes it. Then moves to the next.

Fetch → Decode → Execute → Repeat.

Forever.

That’s how programs “run.” Not because of some magic, but because a control circuit is hardwired to read bytes from memory, interpret them as instructions, and toggle internal signals accordingly.

Everything we write eventually becomes this: a pattern of voltage inside silicon.

What actually happens when we call servo.write(90)?

Here’s the fun part.

When we call servo.write(90), we’re not telling the motor to rotate 90°. We’re telling the chip to start generating a PWM (Pulse Width Modulated) signal i.e. a series of HIGH and LOW pulses on a digital pin.

Servos are hardcoded to interpret the pulse width like this:

$$\begin{aligned} \text{1ms ON} &\rightarrow 0^\circ \\ \text{1.5ms ON} &\rightarrow 90^\circ \\ \text{2ms ON} &\rightarrow 180^\circ \end{aligned}$$

So that line of code sets up a timer inside the chip. That timer toggles a pin ON for 1.5ms, then OFF, repeatedly, in a 20ms cycle.

That’s it. That’s what the servo understands. It doesn’t speak English. It listens to pulse width.

All we did was flick a wire on and off in rhythm. And the motor moved.

Let’s go even deeper

How does the chip actually flick that pin?

Each I/O pin on a microcontroller is mapped to a specific memory address. When we call something like:

Under the hood, we’re just writing a 1 into a particular bit in a register.

And that causes a transistor to switch on. Current flows. Voltage on the pin goes HIGH.

That’s all it is.

Software writing into memory. Memory controlling wires. Wires toggling voltage. Voltage creating meaning.

No layers. No metaphors. Just electricity.

The real stack

We often talk about “the stack” in software, frontend, backend, databases, infra.

But there is another one as well, The one that actually moves things :)

$$\begin{aligned} &\text{C++ Code} \\ &\downarrow \\ &\text{Compiler} \\ &\downarrow \\ &\text{Machine Code} \\ &\downarrow \\ &\text{Flash Memory} \\ &\downarrow \\ &\text{Program Counter} \\ &\downarrow \\ &\text{Decoder} \\ &\downarrow \\ &\text{Registers Set} \\ &\downarrow \\ &\text{Pin goes HIGH} \\ &\downarrow \\ &\text{PWM Signal} \\ &\downarrow \\ &\text{Motor Rotates} \end{aligned}$$

It's still wild, isn't it?

We didn’t write “rotate to 90 degrees.” We wrote a rhythm of voltage. And that rhythm made something move.

Why this still blows my mind?

Most of the code I write today lives inside browsers. React. Next.js. Animations. Design systems. All abstract stuff.

But every now and then, it’s nice to remember,

Underneath all of it, it’s still just current.

Still just electrons moving through a wire...

We don’t think about it much. But every time we write a loop, or a conditional, or a return statement, we’re shaping how current flows through silicon.

Even the highest abstractions end here: A chip. A wire. A voltage. A decision.

And sometimes I think back to that moment, when a little motor turned because I asked it to in one line of code. For me, that’s still one of the coolest things I’ve ever built :)

P.S. There’s so much we take for granted. Sometimes I forget how magical this world already is.