Read the original article here.

---

Arduino: A Gateway to Embedded Systems and Prototyping

In the context of "The Lost Art of Building a Computer from Scratch," platforms like Arduino represent a modern, accessible pathway into understanding how computers interact with the physical world, specifically within the realm of embedded systems. While building a computer entirely from scratch involves designing and fabricating fundamental components like the CPU, memory, and bus architecture, and programming at the most basic levels (assembly or even logic gates), Arduino provides a ready-made foundation – a single-board microcontroller – that allows individuals to bypass these foundational steps and jump directly into applying computing power to control hardware and interact with sensors. It's a powerful tool for learning embedded programming, electronics interfacing, and rapid prototyping without needing to master the complexities of chip design or low-level bootstrapping.

Arduino is an Italian open-source project encompassing hardware, software, and a vibrant user community. Its primary goal is to design and manufacture single-board microcontrollers and associated kits, making the creation of digital devices interactive and accessible to both novices and seasoned professionals. The platform's open-source nature extends to its hardware designs, licensed under Creative Commons, and its software, licensed under GNU licenses, encouraging widespread adoption, modification, and distribution.

At its core, an Arduino board is a specialized, compact computer designed for controlling electronics. These boards feature microcontrollers equipped with digital and analog input/output (I/O) pins. These pins serve as the interface to the external world, allowing users to connect various components like sensors (to read information from the environment) and actuators (to control physical devices like motors, lights, or displays).

Programming Arduino boards is typically done using a dialect of the C and C++ languages, known as the Arduino Programming Language or Arduino API. This language provides a simplified, high-level interface to the microcontroller's capabilities, abstracting away much of the complex, low-level register manipulation usually required in traditional embedded programming. The development is facilitated by an Integrated Development Environment (IDE), simplifying the process of writing code, compiling it, and uploading it to the board.

Historical Development

The Arduino project originated in 2005 at the Interaction Design Institute Ivrea (IDII) in Ivrea, Italy. The motivation was rooted in making electronics prototyping more affordable and user-friendly for students and designers who lacked deep engineering backgrounds. At the time, available microcontroller platforms, such as the BASIC Stamp, were relatively expensive (around $50).

The project built upon the work of Wiring, a development platform created by Hernando Barragán as a master's thesis project at IDII in 2004. Wiring consisted of a printed circuit board (PCB) featuring an ATmega128 microcontroller, an IDE based on the Processing language, and a set of libraries to simplify programming.

Recognizing the need for an even more accessible platform, Massimo Banzi, along with students David Mellis and David Cuartielles, extended the Wiring concept in 2005. They focused on supporting the much cheaper ATmega8 microcontroller, leading to the creation of the Arduino project, initially forked from Wiring. The name "Arduino" was adopted from a local café where some founders met.

The initial core team included Massimo Banzi, David Cuartielles, Tom Igoe, Gianluca Martino, and David Mellis. Their efforts resulted in a platform that was significantly less expensive and easier to use than its predecessors, quickly gaining traction in the open-source community. By 2013, hundreds of thousands of official Arduino boards were in circulation, demonstrating its rapid global adoption.

The project faced significant challenges, notably a trademark dispute that began in 2008 when one co-founder secretly registered the Arduino trademark in Italy. This led to a split in the community and legal battles, eventually resolved with the merger of competing entities under the Arduino brand. Despite these internal conflicts, the project's commitment to open-source principles ensured its continued growth and the proliferation of compatible hardware and software worldwide.

Hardware Overview

Arduino boards are a prime example of a single-board microcontroller design. They integrate the core processing unit, memory, power regulation, and necessary programming interfaces onto a single PCB, making them compact and easy to integrate into projects.

Core Components

Most classic Arduino boards are based on 8-bit Atmel AVR microcontrollers, such as the ATmega328P (used in the popular Arduino Uno), ATmega168, ATmega1280, or ATmega2560 (used in the Arduino Mega for more I/O and memory). More powerful boards, like the Arduino Due, utilize 32-bit ARM Cortex-M processors (specifically the Atmel SAM3X8E), offering increased processing power and memory.

Key components found on typical Arduino boards include:

1. Microcontroller: The brain of the board, executing the program.

   Definition: Microcontroller: A compact integrated circuit designed to govern operations in an embedded system. It combines a CPU, memory (Flash for program storage, SRAM for data), and programmable input/output peripherals on a single chip.

2. Digital I/O Pins: Pins configured to read digital signals (HIGH/LOW) or output digital signals. Some digital pins also support Pulse-Width Modulation (PWM).
3. Analog Input Pins: Pins designed to read a continuous range of voltage values, converting them into digital values using an onboard Analog-to-Digital Converter (ADC).
4. Power Connector/Regulator: Allows the board to be powered from external sources (like batteries or power adapters) and regulates the voltage to the level required by the microcontroller (typically 5V or 3.3V).
5. Clock: A crystal oscillator or ceramic resonator (often 16 MHz on 5V boards) provides the timing signal that synchronizes the microcontroller's operations.
6. Programming Interface: Usually a USB port, connected via a USB-to-serial adapter chip (like FTDI or a dedicated AVR chip with USB firmware) to the microcontroller's serial communication pins. This allows programs to be uploaded from a computer.
7. Reset Button: Allows manual restarting of the microcontroller and the running program.

Programming Interface and Bootloader

A crucial feature that simplifies using Arduino, especially for beginners, is the presence of a bootloader pre-programmed onto the microcontroller.

Definition: Bootloader: A small, resident program stored in a protected area of the microcontroller's flash memory. When the microcontroller powers on or resets, the bootloader runs first. Its function is to listen for a program to be uploaded (typically over a serial connection, like USB). If a program is received, the bootloader writes it to the main application flash memory. If no program is received within a short time, the bootloader hands control over to the program already stored in flash memory.

The bootloader eliminates the need for an external hardware programmer (like an ISP programmer), which is traditionally required to load code onto a bare microcontroller chip. This feature significantly lowers the barrier to entry for prototyping, as users only need a USB cable and the Arduino IDE to get started.

Modern Arduino boards primarily use a USB connection for programming and serial communication. Early boards might have used RS-232 and required level shifters, but USB has become the standard.

Expansion Capabilities: Shields

Arduino boards feature standardized headers that allow the connection of expansion boards called shields.

Definition: Shields: Printed circuit boards designed to plug directly into the headers of an Arduino board, adding specific functionalities. They act like modular add-ons, providing capabilities such as Ethernet connectivity, motor control, GPS, LCD displays, or even simple prototyping areas (breadboard shields).

Shields simplify hardware integration by providing pre-built circuits for common tasks. Multiple shields can often be stacked on top of each other, though care is needed to avoid conflicts if they share the same pins (some use protocols like I²C to address multiple devices on shared lines). This modular approach is a significant advantage for rapid prototyping compared to wiring every component manually on a breadboard or custom PCB.

Open Hardware Philosophy

Arduino's hardware designs are open-source, licensed under Creative Commons. This means anyone can access the schematics and layout files, study them, modify them, and even manufacture their own boards based on the design. While the use of the official "Arduino" name is restricted to official products, this open approach has fostered a large ecosystem of compatible and derivative boards from various manufacturers (often branded with names ending in "-duino"), driving innovation and reducing costs.

Software Environment

The Arduino platform provides a user-friendly software environment primarily centered around the Arduino IDE.

Arduino IDE (Integrated Development Environment)

The Arduino IDE is a cross-platform application (available for Windows, macOS, and Linux) that serves as the primary tool for writing, compiling, and uploading programs to Arduino boards. Its design is based on the Processing IDE and incorporates the Wiring API for programming.

Key features of the IDE include:

• Code Editor: Provides standard features like syntax highlighting, text editing, searching, and automatic indentation.
• Compiler: Translates the human-readable C/C++ code into machine code that the microcontroller can understand and execute. The IDE uses the GNU toolchain internally.
• Uploader: Communicates with the bootloader on the Arduino board to transfer the compiled program into the microcontroller's flash memory. It typically uses a tool like avrdude.
• Serial Monitor: A built-in terminal that allows communication between the computer and the Arduino board over the serial connection (usually USB). This is essential for debugging and sending/receiving data.
• Board Manager & Library Manager: Tools within the IDE to easily install support for different types of Arduino boards and additional software libraries.

While the original IDE was simpler, the more recent Arduino IDE 2.0 (based on Eclipse Theia) offers enhanced features like a more professional interface, improved auto-completion, project exploration, and, significantly, debugging capabilities (requiring compatible hardware and a debug probe), moving the platform closer to professional development environments.

The Arduino Programming Language / API

The core of Arduino software development is the use of a simplified C/C++ programming interface often referred to as the Arduino Programming Language or API. This API provides a set of standard functions that make interacting with the hardware much easier than writing code directly for the microcontroller's registers.

For example, instead of writing complex code to set up a pin as an output and then manipulate specific hardware registers to turn it on or off, the Arduino API provides simple functions:

• pinMode(pin, mode): Configures a specified pin to behave as an input or output.
• digitalWrite(pin, value): Writes a digital value (HIGH or LOW) to a digital output pin.
• digitalRead(pin): Reads the digital value (HIGH or LOW) from a digital input pin.
• analogRead(pin): Reads the analog value from an analog input pin.
• delay(milliseconds): Pauses the program for a specified number of milliseconds.

These functions, part of the Wiring library included in the IDE, abstract away the underlying hardware details, allowing users to focus on the logic of their project.

Sketches: The Arduino Program Structure

A program written for Arduino using the IDE is called a sketch. Sketches are saved as text files with the .ino file extension. A minimal Arduino sketch has a specific structure consisting of two essential functions:

1. void setup(): This function is executed once when the Arduino board powers up or resets. It's used for initialization tasks, such as configuring pin modes (input/output), starting serial communication, and initializing libraries. It's analogous to the main() function's initialization phase in traditional C programs.
2. void loop(): After the setup() function finishes, the loop() function is executed repeatedly in an endless cycle. This is where the main logic of the program resides – reading sensors, controlling actuators, sending/receiving data, etc. This function is analogous to an infinite while(1) loop in traditional embedded programming.

This simple, two-function structure makes it easy for beginners to understand the program flow: initialize once, then do the main task over and over.

Example: The "Blink" Sketch

The "Blink" sketch is the quintessential "Hello, World!" program for Arduino. Most Arduino boards have a built-in LED connected to digital pin 13, making this example possible with just the board itself. The sketch demonstrates basic digital output and timing.

void setup() {
  // Initialize digital pin 13 as an output.
  pinMode(13, OUTPUT);
}

void loop() {
  // Turn the LED on (HIGH is the voltage level)
  digitalWrite(13, HIGH);
  // Wait for a second
  delay(1000);
  // Turn the LED off by making the voltage LOW
  digitalWrite(13, LOW);
  // Wait for a second
  delay(1000);
}

This simple example uses pinMode() to set the pin as an output, digitalWrite() to turn the LED on and off, and delay() to create the blinking effect.

Example: The "Sweep" Sketch (using a Library)

Interacting with more complex components often requires using libraries. A common example is controlling a servo motor.

Definition: Servo Motor: A type of motor with a built-in control circuit that allows it to be precisely positioned to specific angles, typically between 0° and 180°. They are often used in robotics and automation for controlled movements.

The Arduino Servo library simplifies the complex PWM signals needed to control a servo. The "Sweep" sketch demonstrates moving a servo back and forth across its range.

#include <Servo.h> // Include the Servo library

Servo myServo;  // Create a servo object

void setup() {
  myServo.attach(9); // Attach the servo on pin 9 to the servo object
}

void loop() {
  int pos; // Variable to store the servo position

  // Move the servo from 0 to 180 degrees
  for (pos = 0; pos <= 180; pos += 1) {
    myServo.write(pos); // Tell servo to go to position in variable 'pos'
    delay(15);          // Waits 15ms for the servo to reach the position
  }

  // Move the servo from 180 to 0 degrees
  for (pos = 180; pos >= 0; pos -= 1) {
    myServo.write(pos); // Tell servo to go to position in variable 'pos'
    delay(15);          // Waits 15ms for the servo to reach the position
  }
}

This sketch demonstrates how including #include <Servo.h> accesses the library, how Servo myServo; creates an object representing the servo, and how functions like attach() and write() from the library simplify controlling the motor's position. Connecting the servo typically involves connecting its power and ground wires to the Arduino (or an external power source) and the signal wire to a PWM-capable digital pin (like pin 9 on many boards).

Libraries and Ecosystem

The open-source nature has led to a vast collection of free software libraries contributed by the community. These libraries provide pre-written code for interacting with a myriad of sensors, displays, communication modules (like Wi-Fi, Bluetooth, GPS), motor drivers, and more. Using libraries allows developers to quickly add complex functionality to their projects without writing the low-level code themselves, significantly accelerating the prototyping process.

For more advanced applications, ports of operating systems or threading libraries like Xinu OS, Protothreads, and FreeRTOS are available, allowing for more complex program structures and concurrent task management beyond the simple loop() model.

Relationship to "The Lost Art of Building a Computer from Scratch"

For someone interested in the absolute fundamentals of computing – building a CPU, memory, and peripherals from basic logic gates, wiring a bus, writing assembly language, and bootstrapping an operating system – Arduino represents a significant leap forward in the abstraction layer.

Building a computer from scratch involves:

1. Digital Logic Design: Designing fundamental components like adders, registers, counters, etc., often using discrete logic ICs or even individual transistors.
2. CPU Architecture: Designing the instruction set, control unit, and datapath of the processor.
3. Memory Systems: Designing RAM and ROM interfaces and organization.
4. Bus Design: Laying out the communication channels between components.
5. Peripheral Interfacing (Low-Level): Understanding and writing code to interact directly with hardware registers of input/output devices.
6. Assembly Language/Machine Code: Programming the CPU using its native instruction set.
7. Bootstrapping: Writing the initial code that runs when the computer powers on (analogous to a highly simplified bootloader, but often much more complex).

Arduino, in contrast, provides:

• A Fully Built Microcontroller: The CPU, memory (Flash and SRAM), timers, communication interfaces (UART, SPI, I²C), Analog-to-Digital Converters (ADC), and Digital-to-Analog Converters (DAC) are all integrated onto a single, pre-fabricated chip. You don't design or build these.
• A Complete Single Board System: The board includes power regulation, clock circuitry, and the programming interface (USB/serial) needed to power and program the microcontroller. You don't design the power supply or figure out USB communication protocols from scratch.
• A High-Level Programming Abstraction: The Arduino API allows you to interact with hardware features using simple, intuitive function calls (digitalWrite, analogRead, etc.) instead of manipulating specific hardware registers directly, which is required when programming the bare microcontroller in traditional embedded C or assembly.
• A Bootloader: This small program simplifies the process of getting your code onto the chip, eliminating the need for external, dedicated programmers and the complex boot sequence setup that would be necessary when working with a blank chip.

Therefore, Arduino is not a tool for learning the deepest levels of computer architecture or digital logic design. Instead, it's a platform that allows users to focus on the interaction between a computer (the microcontroller) and the physical world (sensors and actuators). It provides a foundational understanding of embedded programming, digital and analog I/O, communication protocols (like Serial, I²C, SPI, often facilitated by libraries), and the project lifecycle of building interactive electronic devices.

For someone starting their journey towards understanding computers, Arduino serves as an excellent intermediate step. It bridges the gap between purely software-based programming and low-level hardware interaction. It allows learners to experiment with electronics, build physical projects, and see their code directly influence the real world, without being overwhelmed by the complexity of building the computational engine itself. It teaches the "art" of making hardware do things with software, which is a critical part of computing, even if it bypasses the "lost art" of fabricating the computer from its most basic components.

Applications

The accessibility and versatility of Arduino have led to its adoption in a wide range of applications, particularly in education, hobbyist projects, and rapid prototyping:

• Educational Tools: Used extensively in schools and universities to teach programming, electronics, and robotics.
• Hobbyist Projects: The core of countless DIY projects, from automated plant watering systems and custom LED displays to weather stations and home automation.
• Robotics: Used to control motors, read sensor data, and implement navigation logic in simple robots and drones (e.g., Ardupilot hardware/software).
• Art Installations: Incorporated into interactive art pieces that respond to audience presence or environmental factors.
• Prototyping: Enables engineers and designers to quickly build and test proof-of-concept devices before committing to custom hardware development.
• Data Logging: Used in scientific or environmental monitoring projects to collect data from sensors.
• Control Systems: Implemented in simple control systems for machinery, lighting, and other devices (e.g., OpenEVSE for EV charging).
• Interactive Devices: Used in projects like handheld game consoles (Arduboy), MIDI controllers (Arduinome), and car trip computers (OBDuino).

Tools like Tinkercad provide online simulators that support Arduino, allowing users to build and test circuits and code virtually before working with physical hardware.

Conclusion

Arduino has profoundly impacted the world of physical computing and embedded systems by democratizing access to microcontroller technology. By providing affordable, open-source hardware with a user-friendly software environment and a supportive community, it allows individuals with varying technical backgrounds to design, build, and program interactive electronic devices.

While it abstracts away the fundamental complexities of building a computer from its silicon core – the essence of "The Lost Art of Building a Computer from Scratch" – Arduino serves as an invaluable tool for learning the crucial aspects of hardware-software interaction, electronics interfacing, and embedded programming. It empowers makers, students, and professionals to translate digital ideas into physical reality, making it a vital platform in the modern landscape of technology and education.