Development Board and Microcontroller

What is a Development Board?

A development board is a complete electronic platform designed to help us prototype, test, and program embedded systems easily. It includes a microcontroller as its main brain, along with additional components such as voltage regulators, USB interface, communication ports, buttons, LEDs, and sometimes wireless modules.

In simple words, the development board is the physical platform that allows us to interact with the microcontroller safely and efficiently without building the entire circuit from scratch.

What is a Microcontroller?

A microcontroller is a small integrated circuit that acts as the brain of an embedded system. It contains a processor (CPU), memory, input/output pins, and communication interfaces all inside a single chip. It executes programs written by the user to control sensors, motors, LEDs, displays, and communication systems.

Every development board includes at least one microcontroller. The board provides the supporting electronics, while the microcontroller performs the actual computation and control tasks.

Development Boards Comparison

Individual assignment

In this individual assignment, I will test and compare two different microcontroller boards: the Seeeduino and the Arduino R4. The objective is to evaluate their behavior, compatibility, and performance for my embedded systems development.

Before working with the physical boards, I will first use a simulation environment. This allows me to validate the circuit design, test the code, and detect possible errors in a safe and controlled way. Using a simulator reduces the risk of damaging components and helps optimize the development process.

1) Embedded Systems

An embedded system is a specialized computing system designed to perform a specific task within a larger device or process. Unlike general-purpose computers, embedded systems are built for dedicated functions such as sensing, control, automation, and real-time interaction. They are commonly found in robots, industrial equipment, smart devices, and manufacturing systems.

Basic Composition: Input → Controller → Output

In general, an embedded system can be described using three main blocks:

• Input: Sensors or user inputs that provide data to the system (e.g., button, LDR, potentiometer, temperature sensor).
• Controller: The microcontroller that reads inputs, processes information, and makes decisions (e.g., Seeeduino, Arduino UNO R4).
• Output: Actuators or indicators controlled by the system (e.g., LED, buzzer, motor, LED matrix).

Input

Controller

Output

2) System Architecture

The embedded workflow follows a standard architecture where the controller reads an input signal, processes it, and produces an output action. In addition, the system can communicate the measured values and states to a computer or another device using a wired or wireless connection.

Workflow

1. Read input: Acquire data from a sensor or button (analog/digital).
2. Process data: Filter, average, debounce, or compare against a threshold.
3. Decision: Determine the system state (e.g., ON/OFF, alert/not alert).
4. Drive output: Activate an actuator (LED, buzzer, motor, LED matrix).
5. Communicate: Send values and system state through Serial (wired) or WiFi/BLE (wireless, if available).

3) Safety First: Simulation Before Hardware (Tinkercad)

Before building the circuit physically, I will first test the logic and wiring using a simulator (Tinkercad). Simulating the circuit helps validate connections and program behavior in a controlled environment, reducing the risk of short circuits, incorrect pin usage, or damaging the board and components. Once the simulation results match the expected behavior, I will implement the same circuit on real hardware and perform final tests.

Exercise 2.1

In the simulation, the onboard LED responded immediately after uploading the code, confirming that the digital output pin was correctly configured. The LED turned on and off at the programmed interval without delays or unstable behavior, validating the basic output.

Exercise 2.2

During the simulation, the external LED connected through the breadboard behaved as expected when the digital signal was activated. The resistor correctly limited the current, and no abnormal behavior was observed. The simulation allowed verification of wiring connections and polarity before assembling the real circuit.

4) Exercises

I prepared three small exercises to demonstrate embedded interaction and communication-ready structure: (1) Seeeduino blinking an LED, (2) Arduino UNO R4 blinking an LED, and (3) Arduino UNO R4 controlling the built-in LED matrix. Each code block is included as plain text so anyone can copy and paste it directly from the repository.

Exercise 1 — Seeed Studio: BLINK LED

This program turns an LED on and off repeatedly. It can use the onboard LED (LED_BUILTIN) or an external LED connected to a digital pin.

// Exercise 1: Seeed Studio - Blink LED
const int LED_PIN = LED_BUILTIN; // or set a pin number, e.g., 6

void setup() {
  pinMode(LED_PIN, OUTPUT);
}

void loop() {
  digitalWrite(LED_PIN, HIGH);
  delay(500);
  digitalWrite(LED_PIN, LOW);
  delay(500);
}

This code configures a digital pin as an output and repeatedly turns the LED on and off. It demonstrates basic digital control and timing using delays.

Exercise 2 — Arduino UNO R4: BLINK LED

Same idea as Exercise 1, but tested on Arduino UNO R4.

// Exercise 2: Arduino UNO R4 - Blink LED
const int LED_PIN = LED_BUILTIN;

void setup() {
  pinMode(LED_PIN, OUTPUT);
}

void loop() {
  digitalWrite(LED_PIN, HIGH);
  delay(300);
  digitalWrite(LED_PIN, LOW);
  delay(300);
}

This code verifies correct digital output behavior on the Arduino UNO R4 and confirms proper pin configuration.

For the physical implementation, I will use an external LED mounted on a prototyping board (breadboard). The LED will be connected to a digital output pin through a current-limiting resistor (110Ω–220Ω) to prevent damage. This setup allows me to clearly visualize the output behavior of the Arduino UNO R4 during testing.

// Exercise 2: Arduino UNO R4 - External LED on pin 6
const int LED_PIN = 6;

void setup() {
  pinMode(LED_PIN, OUTPUT);
}

void loop() {
  digitalWrite(LED_PIN, HIGH);
  delay(300);
  digitalWrite(LED_PIN, LOW);
  delay(300);
}

This program controls an external LED and validates real hardware connections using a current-limiting resistor.

I added a push button connected to pin 2 to allow user interaction.

// Arduino UNO R4 - LED controlled by Button on pin 2
const int buttonPin = 2;
const int ledPin = 6;

void setup() {
  pinMode(buttonPin, INPUT_PULLUP);
  pinMode(ledPin, OUTPUT);
}

void loop() {
  int buttonState = digitalRead(buttonPin);

  if (buttonState == LOW) {
    digitalWrite(ledPin, HIGH);
  } else {
    digitalWrite(ledPin, LOW);
  }
}

This code reads a digital input from a button and controls an LED, demonstrating real-time interaction.

Exercise 3 — Arduino UNO R4 WiFi: Built-in LED Matrix

This exercise displays a simple pattern on the built-in LED matrix.

#include <Arduino_LED_Matrix.h>

ArduinoLEDMatrix matrix;
uint8_t frame[8][12] = {0};

void setup() {
  matrix.begin();
  frame[0][0] = 1;
  matrix.loadPixels(frame);
}

void loop() {}

This code initializes the LED matrix and displays a simple pixel, demonstrating control of more complex output devices.

5) Technical Comparison: Seeed Studio XIAO nRF52840 vs Arduino UNO R4

Both controllers can run embedded applications (read inputs, process data, drive outputs, and communicate), but they differ in processing, memory, logic voltage, and onboard features. Since my Seeeduino is the Seeed Studio XIAO nRF52840, the specs below refer to this exact model.