4. Embedded Programming

This week, we studied embedded programming for microcontrollers. It was challenging for me because I wasn't sure where to begin, and it was my first time learning about programming in general.

Hero Shot

Group assignment

For the group assignment, we compared different programming languages for a microcontroller. We needed to write one program for RP2040, in two different programming languages and compare the execution speed of each.

First, I downloaded and installed the Arduino IDE. Since the RP2040 is not included in the Arduino IDE's default list of supported boards, we must manually add it. To do this, I clicked "File" and then "Settings". In the "Additional boards manager URLs" field, I inserted the following link.

https://github.com/earlephilhower/arduino-pico/releases/download/global/package_rp2040_index.json

After that, I need to find the XIAO RP2040 board in the boards manager and install it.

Speed Test

We used an oscilloscope to measure the speed of each code's execution.

Mkhitar wrote this code using micropython.

led = machine.Pin(26, machine.Pin.OUT)

while True:
  led.high()
  led.low()

Following Maxim's instructions, I created a simple code for c++ with Arduino Framework

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

void loop() {
  digitalWrite(1, HIGH);
  digitalWrite(1, LOW);
}

And bare metal version, for register-level interaction.

int main() {
        /*
        0x400140d4: GPIO26_CTRL: GPIO 26 control including function select and overrides.
        0x05: from "2.19.2. Function Select": selects function SIO (Single-Cycle IO)
        */

        // same for GPIO26_CTRL
        *((volatile unsigned int*) 0x400140d4) = 0x05;    

        /*
        Output enable registers, GPIO_OE and GPIO_HI_OE, are used to enable the output driver. 0 for high-impedance, 1
        for drive high/low based on GPIO_OUT and GPIO_HI_OUT.
        sets the 27th bit of this register to 1 in order to enable output
        */
        *((volatile unsigned int*) 0xd0000020) = (1 << 26);  // GPIO_OE


        while( 1 )
        {
          //toggles the pin 26 high and low
          *((volatile unsigned int*) 0xd000001c) ^= ( 1 << 26);
        }

        return 0;
}

Test Results

The closer the code is to the hardware, the faster the microcontroller will work.

• MicroPython is the slowest, as the code is executed by an interpreter, rather than directly.
• C++ with Arduino is faster, but it still has intermediate layers (libraries) that add some delay.
• Pure C++ on registers is as fast as it can be, as commands go directly to the processor with no unnecessary delays.

In conclusion, MicroPython is convenient, Arduino is a good middle ground, and registers provide maximum speed.

microcontroller	language	oscillation frequency
XIAO RP2040	MicroPython	82.8 kHz
XIAO RP2040	c++ with Arduino Framework	618.2 kHz
XIAO RP2040	register level c++	12.5 MHz

Individual assignment

Simulation of LED Control on Raspberry Pi Pico

I created a simulation on Wokwi using a Raspberry Pi Pico to control six LEDs.

First, I selected pins 1–6 for connecting the LEDs and configured them as outputs. Then, I implemented the logic in the main loop: the LEDs turn on sequentially with a 500-millisecond delay. After all the LEDs are lit, there is a pause, and then they turn off for 500 milliseconds. This process is looped, creating a sequential blinking effect. This simulation allows me to test the code before uploading it to a real device.

Test 1

After creating the first version, I modified the settings to implement a new LED control algorithm.
I updated the logic: now the LEDs light up in a different order and with a changed delay, making the operation more dynamic. After making these changes, I tested the simulation in Wokwi and confirmed that the system works correctly. This version alters the blinking effect and makes the LED operation more interesting.

Test 2

After the simulation in Wokwi, I decided to reproduce a similar test in real conditions, using a single LED. To do this, I transferred the control algorithm to the physical environment to check how it would work on real hardware.

5V Water Pump Control with RP2040

I have assembled a system to control a 5V water pump using the RP2040 microcontroller and the IRFZ44N transistor. The system includes the pump and controls it with the transistor, which turns on and off at a specific interval. To visualize the pump's operation, I added an LED that blinks together with the pump.

The following components are used in the project.

• RP2040 — microcontroller that controls the transistor. Here you can see pinout of XIAO-RP2040

• IRFZ44N — N-channel MOSFET that switches the pump's power.

• 10kΩ Resistor — pull-down resistor that prevents the transistor from turning on by itself.

• 220Ω Resistor — resistor between RP2040 and the transistor's gate to limit the current.
• 5V Pump — the pump that I control in this project.
• LED on pin 13 — indicator showing the pump's status, lighting up along with the pump.

Here is the assembled circuit.

Working Logic

The code for controlling the water pump was based on a simulation from Wokwi. It provided basic output signal control functionality but required modifications to be adapted to the specific conditions of the project. During the modification process, changes were made to the operation logic, pump control, and LED indication. Additionally, status output to the Serial Monitor was added.

Once the circuit is assembled and the code is uploaded, the pump turns on and off for 3 seconds. This cycle repeats endlessly. To monitor the pump's operation, I use Serial Monitor to display status messages via the Serial.println() command.

Here is the description of the main commands and functions that I used.

To understand how to write the code, I found a useful resource — Arduino Language Reference.
This is the official reference for the Arduino language, where commands and functions are explained in simple terms, along with examples of how to use them in practice.

The site provides code examples and descriptions that helped me better understand how to use commands like pinMode(), digitalWrite(), millis(), and Serial.print().
Thanks to this resource, it became easier for me to write and test the code, as well as to understand what each line of the program actually does.

1. #define Is a preprocessor directive that lets you assign a meaningful name to a pin number on the board. For example, when we write #define PUMP_PIN 1, we’re saying: “We will refer to pin 1 as PUMP_PIN and use it to control the pump.” This way, instead of raw numbers in the code, you immediately see what each pin does, without having to remember which number corresponds to which function.

2. setup() function. Runs once when the board is powered on or reset. Here we:

   • Set the pins as outputs.
   • Start communication with the computer.
   • Turn off the pump and LED.

3. loop() function. This is an endless cycle: as soon as one iteration finishes, the next one starts. This function contains the main actions of the program. Everything repeats as long as the board is powered.

4. pinMode(…, OUTPUT) This command tells the board that the pin will be an output, meaning it will supply power to a connected device (such as a pump or LED).

5. Serial.begin(9600) Sets up communication with the computer. The number 9600 is the speed of data transmission, like how fast the information will be exchanged.

6. Serial.println("…") Sends text to the computer screen. This text can then be seen in a special program on the computer that displays messages from the board.

7. digitalWrite(…, HIGH/LOW) Controls the pin:

   • HIGH turns the device on (for example, a pump or LED).

   • LOW turns the device off.

8. delay(3000) A delay of 3000 milliseconds (or 3 seconds). The board simply "waits" for 3 seconds before continuing with the program.

  #define PUMP_PIN 1  // Define the pin for controlling the pump
  #define LED_PIN 13  // Define the pin for controlling the LED

  void setup() {

      pinMode(PUMP_PIN, OUTPUT); // Set the pump pin as an output
      pinMode(LED_PIN, OUTPUT); // Set the LED pin as an output
      Serial.begin(9600); // Start serial communication with serial monitor at 9600 baud rate
      digitalWrite(PUMP_PIN, LOW); // Ensure the pump is off at startup
      digitalWrite(LED_PIN, LOW); // Ensure the LED is off at startup
  }

  void loop() {

      Serial.println("Turning on the pump..."); // Print message to Serial Monitor
      digitalWrite(PUMP_PIN, HIGH); // Turn on the pump
      digitalWrite(LED_PIN, HIGH); // Turn on the LED
      Serial.println("The pump is on!"); // Print status message
      delay(3000); // Keep the pump and LED on for 3 seconds
      Serial.println("Turning off the pump..."); // Print message to Serial Monitor
      digitalWrite(PUMP_PIN, LOW); // Turn off the pump
      digitalWrite(LED_PIN, LOW);  // Turn off the LED
      Serial.println("The pump is off!"); // Print status message
      delay(3000); // Wait 3 seconds before repeating the cycle
  }

Conclusion

I explored the fundamentals of embedded programming, learning various approaches and languages such as MicroPython C++ and bare-metal. Additionally, I developed a 5V pump control system using a transistor, which allowed me to apply practical knowledge of microcontrollers and hardware. I also find out that I can simulate a process virtually and see the workflow, and after that to use the physical components.

Source Fles

• Wokwi simulation 1

• Wokwi simulation 2

• Pump test