Programming Protocol

The Raspberry Pi Pico (RP2040) is a powerful and low-cost microcontroller board designed for embedded projects. It features a dual-core ARM Cortex-M0+ processor, flexible GPIO pins, and supports multiple programming languages such as MicroPython, C/C++, and Arduino. Its versatility and performance make it ideal for handling sensors, displays, and communication modules in compact electronic systems.

Programming Protocol

ESP32-3c – Features & Specifications

The Raspberry Pi Pico (RP2040) is a powerful and low-cost microcontroller board designed for embedded projects. It features a dual-core ARM Cortex-M0+ processor, flexible GPIO pins, and supports multiple programming languages such as MicroPython, C/C++, and Arduino. Its versatility and performance make it ideal for handling sensors, displays, and communication modules in compact electronic systems.

Setup Arduino IDE

At this stage, the development environment Arduino IDE (v2.3.6) was configured to program the Raspberry Pi Pico based on the RP2040; a sketch was created where the DIR and PUL pins were defined to control three stepper motors using drivers such as the TB6600, adjusting step and speed parameters, and setting all pins as outputs in setup(), leaving the system ready for motion testing and further hardware integration.

⚙️ Accessing Preferences in Arduino IDE

In this step, the Arduino IDE (v2.3.6) interface is shown with the File menu open, highlighting the Preferences option, which is where the necessary settings are configured to enable support for the Raspberry Pi Pico based on the RP2040. This section is essential for adding additional board manager URLs and adjusting the IDE configuration so that new boards and cores can be installed, allowing the development environment to properly recognize and program the Raspberry Pi Pico for upcoming embedded programming tasks.

Here, the Arduino IDE (v2.3.6) Preferences window is shown, where key settings are adjusted to prepare the environment for programming the Raspberry Pi Pico powered by the RP2040. This step is crucial because the “Additional Boards Manager URLs” field is where the RP2040 core repository is added, enabling the IDE to recognize and install support for the Raspberry Pi Pico and related boards, ensuring the toolchain is fully ready for compiling and uploading embedded projects.

In this step, the Arduino IDE Preferences panel shows the “Additional Boards Manager URLs” field filled with the repository link needed to install support for the Raspberry Pi Pico, which runs on the RP2040. By adding this URL (from the Arduino-Pico core maintained by Earle Philhower), the IDE can download and install the correct board definitions and tools, enabling proper compilation and upload of sketches to the Raspberry Pi Pico.

In this step, the Arduino IDE (v2.3.6) menu path Tools → Board → Boards Manager is opened to install the necessary board packages. This is where you search for and install support for the Raspberry Pi Pico (RP2040 core) after adding the Boards Manager URL, allowing the IDE to recognize the board, enable compilation for the RP2040, and make it available for selection before uploading your sketches.

Here, the Boards Manager inside Arduino IDE (v2.3.6) is used to search for and install the board package for the Raspberry Pi Pico (RP2040 family). After adding the additional Boards Manager URL, the Raspberry Pi Pico/RP2040 package appears in the list, and by clicking Install, the IDE downloads the core, drivers, and toolchain needed to compile and upload sketches to boards based on the RP2040, completing the setup to start programming the Pico.

At this point, the Boards Manager in Arduino IDE (v2.3.6) is actively downloading and installing the required packages for the Raspberry Pi Pico family. The output console shows the toolchain components being fetched (such as the RP2040 GCC compilers), which are necessary to compile and upload sketches to boards based on the RP2040. Once this process finishes, the board will be fully available for selection in the IDE and ready for development and testing.

// LED Blink Example - Arduino

int ledPin = 13;

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

void loop() {
  digitalWrite(ledPin, HIGH);
  delay(1000);
  digitalWrite(ledPin, LOW);
  delay(1000);
}

Simulation in Wokwi Led

This scene shows a simulation in Wokwi where the Raspberry Pi Pico is being programmed and tested using an Arduino-like sketch. The left panel displays the code that defines three pins (RED, YELLOW, and GREEN) configured as outputs, while the right panel shows the virtual circuit with three LEDs connected to the board. The simulation executes an on/off sequence that mimics a traffic light (green, yellow, and red) with varying delay times, allowing the program logic and connections to be validated before physical implementation on real hardware. 🚦

Code Execution

This step shows the physical setup of a Raspberry Pi Pico mounted on a breadboard and powered via USB from a computer. The onboard LEDs are illuminated, indicating that the board is receiving power correctly and that the uploaded program is running as expected. This quick hardware test helps verify proper power delivery, device recognition by the development environment, and basic functionality before moving on to integrating sensors, actuators, or other modules into the project.

🧩 Joystick and OLED Display Simulation with Raspberry Pi Pico

This image shows a simulated electronics setup where a Raspberry Pi Pico is connected on a breadboard to a joystick module and a small OLED display. The wiring links the joystick’s power and signal pins to the Pico’s GPIO and analog inputs, allowing the microcontroller to read directional movements, while the OLED screen is connected via an I²C interface to display real-time feedback or system status. This simulation is useful for validating pin connections and interaction logic in a virtual environment before building the circuit on real hardware, reducing wiring errors and speeding up prototyping.

Code Writing

Joystick OLED Game - Arduino Code

#include <Wire.h>
#include <Adafruit_SSD1306.h>

Adafruit_SSD1306 d(128, 64, &Wire, -1);

// Pines
#define X 26
#define Y 27

int px = 10, py = 10;
int dx = 1, dy = 0;
int fx = 5, fy = 5;

void setup() {
  Wire.begin();
  d.begin(SSD1306_SWITCHCAPVCC, 0x3C);
  randomSeed(analogRead(0));
}

void loop() {
  int a = analogRead(X);
  int b = analogRead(Y);

  if (a < 1000) { dx = -1; dy = 0; }
  if (a > 3000) { dx =  1; dy = 0; }
  if (b < 1000) { dx = 0; dy =  1; }
  if (b > 3000) { dx = 0; dy = -1; }

  px += dx;
  py += dy;

  if (px < 0) px = 31;
  if (px > 31) px = 0;
  if (py < 0) py = 15;
  if (py > 15) py = 0;

  if (px == fx && py == fy) {
    fx = random(32);
    fy = random(16);
  }

  d.clearDisplay();
  d.fillRect(fx * 4, fy * 4, 4, 4, 1);
  d.fillRect(px * 4, py * 4, 4, 4, 1);
  d.display();

  delay(120);
}

By distributing the slots symmetrically and constraining them to the center of the circle, the design remains balanced and fully adjustable. This allows the same piece to be reused in different configurations, such as building a phone holder or other creative structures depending on the user’s imagination.