Arduino Programming: Hardware Meets Code

Every program you have written so far lived entirely inside a screen. You told the computer to print words, add numbers, or draw shapes, and the results appeared as pixels. But look around your home and you will see computers that do not have screens at all. The washing machine that beeps when the cycle ends, the microwave that counts down and then stops the plate, the traffic signal at your street corner that turns red for exactly the right number of seconds — every one of these contains a tiny computer whose whole job is to sense the physical world and change it back. It reads a button, a temperature, a beam of light, and in response it turns on a motor, flashes a light, or makes a sound. Programming these hidden computers is a completely different feeling from writing a program that only manipulates text, and that is exactly what Arduino lets a beginner do. In this chapter you will learn to write code that reaches out of the screen and controls electricity in the real world.

What exactly is an Arduino?

An Arduino is a small board, about the size of a matchbox, with a microcontroller chip at its centre. A microcontroller is a full computer squeezed onto a single chip: it has a processor to run instructions, a small amount of memory to hold your program, and — this is the important part — rows of metal pins along its edges that connect directly to wires, lights, buttons, and motors. The most common board for beginners is the Arduino Uno. Its chip, the ATmega328P, runs at 16 MHz, which means it executes 16 million simple steps every second. That sounds fast, and for controlling a light it is plenty fast, but it is worth being honest about the scale: a modern laptop CPU runs at roughly 2 to 3 GHz, that is 2000 to 3000 MHz. So the Uno's clock is over a hundred times slower than a laptop's, and it also does far less work per tick. The Uno is not trying to browse the web or play video; it is trying to switch a pin on and off reliably, and for that a slow, simple, dependable chip is exactly right.

People often confuse the Arduino board with the Raspberry Pi, and clearing this up early saves a lot of confusion. A Raspberry Pi is a tiny full computer that runs an operating system like Linux, boots up, and can run many programs at once. An Arduino runs one program, forever, the moment it gets power — no operating system, no booting, no multitasking. That single-mindedness is a feature. When you want a light to blink with precise timing and never crash, you do not want an operating system deciding to do background work at the wrong moment.

One quick, honest note on cost, because students plan purchases carefully. A genuine Arduino Uno R3 in India generally costs somewhere around a thousand rupees or more; the very cheap boards you see listed for only a few hundred rupees are almost always clones — compatible copies made by other manufacturers. Clones work fine for learning and are completely legal to use, but do not expect a genuine board at a clone's price.

The two-part shape of every Arduino program

Here is the smallest complete Arduino program. It does nothing visible, but its structure is the skeleton of every sketch (Arduino calls programs "sketches") you will ever write.

void setup() {
  // runs once, right after the board powers on
}

void loop() {
  // runs again and again, forever
}

Notice there is no main() like in ordinary C. Instead, the Arduino framework guarantees two things. First, it calls setup() exactly one time when the board wakes up. This is where you announce how you intend to use each pin. Second, after setup() finishes, it calls loop() over and over, endlessly, until the power is cut. The word "loop" is literal: the instant the last line of loop() runs, the first line runs again. If you have ever wondered how a device can "watch" a button forever, this is the answer — it is checking, thousands of times per second, inside loop().

Think of a security guard at a gate. In the morning the guard sets up: unlocks the register, puts on the whistle, positions the chair. That is setup(), done once. Then all day the guard repeats the same rounds: look at the gate, check for visitors, note the time, look again. That endless patrol is loop(). The guard does not re-unlock the register every round; the one-time preparation and the endless patrol are genuinely different phases, and Arduino gives you one function for each.

Making a real light blink

Let us control something you can see. The Uno has a small built-in LED wired to pin 13, so you do not even need to attach anything to run this. Here is the famous "Blink" sketch, and we will trace it line by line.

void setup() {
  pinMode(13, OUTPUT);      // tell the board pin 13 will send signals out
}

void loop() {
  digitalWrite(13, HIGH);   // put ~5 volts on pin 13 -> LED turns ON
  delay(1000);              // wait 1000 milliseconds = 1 second
  digitalWrite(13, LOW);    // put 0 volts on pin 13 -> LED turns OFF
  delay(1000);              // wait another 1 second
}

Trace it as the chip would. On power-up, setup() runs once and pinMode(13, OUTPUT) configures pin 13 as an output, meaning the chip will drive voltage onto it rather than listen to it. Then loop() begins. digitalWrite(13, HIGH) raises pin 13 to about 5 volts; current flows through the LED and it lights up. delay(1000) freezes the program for 1000 milliseconds — the pin stays HIGH the whole time, so the LED stays on for one full second. Next, digitalWrite(13, LOW) drops the pin to 0 volts and the LED goes dark, and delay(1000) holds that darkness for another second. Now loop() hits its closing brace and immediately restarts from the top: ON, wait, OFF, wait, forever. The result is a light that blinks once every two seconds. Change both delays to 250 and it blinks four times faster.

Two vocabulary words are worth pinning down because CBSE and every later project use them constantly. Digital means a signal that is only ever one of two values: HIGH or LOW, on or off, 5 volts or 0 volts — like a light switch with no dimmer. delay() takes its number in milliseconds, thousandths of a second, so delay(1000) is one second and delay(500) is half a second. Getting the units wrong is the single most common beginner slip.

A diagram of the whole flow

The picture below shows how your code, the pin, and the physical LED connect, and how loop() keeps cycling.

Reading the world: inputs and a real decision

Blinking is output — the board pushing electricity out. The other half of "hardware meets code" is input: the board listening. Suppose you wire a push button to pin 2 and an LED to pin 8, and you want the LED to light only while the button is pressed. Now the program must make a decision, and you already know the tool for decisions from earlier chapters: the if statement.

void setup() {
  pinMode(2, INPUT_PULLUP);   // button pin, listening, with internal resistor
  pinMode(8, OUTPUT);         // LED pin, driving
}

void loop() {
  int state = digitalRead(2);     // read the button: HIGH or LOW
  if (state == LOW) {             // pressed pulls the pin to LOW
    digitalWrite(8, HIGH);        // button down -> LED on
  } else {
    digitalWrite(8, LOW);         // button up -> LED off
  }
}

Here digitalRead(2) checks the voltage on pin 2 and hands back HIGH or LOW, which we store in the variable state. The if then chooses what to do. Because loop() runs thousands of times a second, the moment your finger presses the button the very next pass through loop() notices and switches the LED — it feels instant.

This example hides a genuine subtlety that trips up almost every beginner, so let us confront it directly. Why does pressing the button make the pin go LOW rather than HIGH? You would reasonably expect "pressed" to mean "on". The reason is the INPUT_PULLUP mode. Inside the chip there is a resistor that gently pulls the pin up to 5 volts (HIGH) when nothing else is happening. We wire the button so that pressing it connects the pin to ground (0 volts). So an unpressed button leaves the pin floating HIGH, and a pressed button forces it LOW. It feels backwards, but it exists for a good reason: without that pull-up resistor, an unconnected input pin picks up stray electrical noise from the air and reads randomly HIGH and LOW on its own — a "floating" input. The internal pull-up gives the pin a definite resting value so your reading is reliable. The misconception to correct is this: an input pin with nothing firmly connected does not read a steady LOW — it reads garbage. Always give an input a known resting state, which is exactly what INPUT_PULLUP does for you.

Analog: when the world is not just on or off

Real quantities are rarely just on or off. The brightness of a room, the position of a volume knob, the temperature of water — these vary smoothly. The Uno can read such values on its special pins labelled A0 to A5 using analogRead(). This function reports a whole number from 0 to 1023, where 0 means 0 volts and 1023 means 5 volts. Why 1023? The chip measures with 10 bits of precision, and 10 bits can represent 2¹⁰ = 1024 distinct levels, numbered 0 through 1023. So the smallest change it can detect is one step out of 1024, roughly 5 volts ÷ 1024 ≈ 0.0049 volts, about 5 millivolts.

Let us do a concrete conversion, the kind CBSE loves. Suppose a light sensor on pin A0 gives a reading of 512. What voltage is that? Set up the proportion: reading 1023 corresponds to 5 volts, so reading 512 corresponds to

voltage = (reading / 1023) * 5.0
        = (512 / 1023) * 5.0
        = 0.5005 * 5.0
        ≈ 2.50 volts

A reading of 512, being almost exactly half of 1023, sensibly gives about half of 5 volts. Here is a sketch that turns on an LED only when a room gets dark — an automatic night light, the same idea as the street lamps that switch on at dusk.

void setup() {
  pinMode(8, OUTPUT);
  Serial.begin(9600);          // open a text link back to the computer
}

void loop() {
  int light = analogRead(A0);  // 0 (dark) ... 1023 (bright)
  Serial.println(light);       // print the number so we can watch it
  if (light < 300) {           // below our darkness threshold
    digitalWrite(8, HIGH);     // dark -> lamp on
  } else {
    digitalWrite(8, LOW);      // bright enough -> lamp off
  }
  delay(200);                  // check five times per second
}

The new tool here is Serial. Because the Arduino has no screen, Serial.begin(9600) opens a text channel over the USB cable, and Serial.println(light) sends each reading to the "Serial Monitor" window on your computer. This is how you debug hardware: you cannot see voltages, but you can print the numbers and watch them rise and fall as you cover the sensor with your hand. The threshold 300 is not magic — you choose it by watching the printed values in a bright room versus a dark one and picking a number in between.

A slightly bigger project: counting with memory

To show that these are real programs and not just one-liners, here is a sketch that counts how many times a button is pressed and reports the running total. It needs a variable that survives across many passes of loop(), so we declare it outside both functions — a global variable.

int count = 0;          // lives for the whole program, not reset each loop
int lastState = HIGH;   // remembers the button's previous reading

void setup() {
  pinMode(2, INPUT_PULLUP);
  Serial.begin(9600);
}

void loop() {
  int now = digitalRead(2);
  if (lastState == HIGH && now == LOW) {   // just went from up to down
    count = count + 1;                    // one fresh press
    Serial.print("Presses: ");
    Serial.println(count);
  }
  lastState = now;        // remember for next time
  delay(20);              // small wait to steady the reading
}

The clever part is the condition lastState == HIGH && now == LOW. It is true only at the exact instant the button changes from released to pressed — the falling edge. Without this "was it different last time?" check, a button held down for half a second would race through loop() dozens of times and add dozens to the count from a single press. By comparing the current reading to the remembered previous one, we count each press exactly once. This pattern — remember the last value, act only on change — appears everywhere in real embedded code, from a turnstile counting people entering a metro station to a game controller registering a jump.

Common mistakes, gathered

• Forgetting pinMode. If you never declare a pin as OUTPUT, digitalWrite may do nothing useful. Set the mode in setup() for every pin you use.
• Milliseconds versus seconds. delay(1) is one thousandth of a second, not one second. For one second you need delay(1000).
• Using = instead of ==. Inside an if, state == LOW tests equality; state = LOW would assign and is a bug. This is the most frequent beginner error in C-style code.
• Blocking with delay. While delay(1000) runs, the board is frozen and cannot read a button. For now that is fine, but remember it — big projects avoid long delays for exactly this reason.

Active recall — try these before moving on

1. In the Blink sketch, both delays are delay(1000). Rewrite the delays so the LED is on for 2 seconds and off for half a second. (Trace your answer: how long is one full cycle now?)
2. An analog sensor on A0 reads 768. Using voltage = (reading / 1023) * 5.0, compute the voltage. Is it above or below the 300 threshold used in the night-light sketch, and would the lamp be on or off?
3. Explain in one sentence why a button in INPUT_PULLUP mode reads LOW when pressed, not HIGH.
4. In the press-counter, what would go wrong if you deleted the line lastState = now;? Trace two passes of loop() with the button held down.
5. Why does an Arduino not need an operating system, and how does that make it different from a Raspberry Pi?

Quick answers to check yourself. (1) digitalWrite(13, HIGH); delay(2000); digitalWrite(13, LOW); delay(500); — one full cycle is now 2.5 seconds. (2) (768 / 1023) × 5.0 ≈ 0.751 × 5.0 ≈ 3.75 volts; the reading 768 is well above 300, so the room is bright and the lamp would be off. (3) Pressing connects the pin to ground (0 V) while the internal resistor otherwise holds it at 5 V, so "pressed" shows up as LOW. (4) Without updating lastState, the change-detection never resets, so a single held press keeps satisfying the condition each fast loop and the count balloons. (5) An Arduino runs exactly one fixed program straight from power-on with precise timing and no multitasking, so it needs no OS; a Raspberry Pi is a full computer running Linux that boots up and juggles many programs.

Summary

An Arduino is a small, single-minded microcontroller board that bridges code and the physical world through its pins. Every sketch has two parts: setup(), which runs once to configure pins, and loop(), which repeats forever to do the work. Output means driving a pin — digitalWrite(pin, HIGH/LOW) switches things like LEDs on and off, and delay() pauses in milliseconds. Input means reading a pin — digitalRead() returns HIGH or LOW for on/off sensors like buttons, while analogRead() returns 0 to 1023 for smoothly varying signals like light, which you can convert to a voltage with a simple proportion. Because the board has no screen, Serial lets you print values back to your computer to see what is happening. With just these tools plus the if statements and variables you already knew, you can build automatic night lights, press counters, and the same kind of sense-and-respond logic hiding inside the everyday machines all around you. That is the real lesson: programming is not trapped behind glass — with a few lines of code, it can turn on a light.

Think About It

Think about this: How would you explain arduino programming: hardware meets code to a friend who has never seen a computer? What real-world analogy would you use? Imagine you had to build a system using these concepts — what would be your first step? Try this: before moving on, write down three things you learned and one question you still have.

Practice Exercises

Now it is time to practice! Complete these challenges to solidify your understanding:

• Exercise 1: Write a short program that demonstrates the core concept from this chapter. Test it with at least 3 different inputs.
• Exercise 2: Find a real-world example where arduino programming: hardware meets code is used in an Indian company (like TCS, Infosys, Flipkart, or ISRO). Write a paragraph explaining the connection.
• Exercise 3: Create a mind-map connecting arduino programming: hardware meets code to at least 3 other topics you have studied.