DEV Community: Przemysław Papla

Raspberry Pico C: Remote Sensor

Przemysław Papla — Sat, 30 Dec 2023 14:04:32 +0000

Please, check out my previous article before continuing. As we will be relying on it.

Introduction

In this article, we'll take on an interesting Raspberry Pi Pico project, aiming to turn it into an efficient temperature
measurement device. I'll guide you through the basics of sensor interfacing and data acquisition, with a special focus
on optimizing power usage. The unique aspect of this project involves periodically putting the Raspberry Pi Pico into a
sleep state to conserve power. When it wakes up, it will make several measurements and transmit data to a remote server,
repeating this cycle. Join me as we go step by step, emphasizing the importance of power efficiency in our endeavor.

Raspberry Pico

To achieve our goals, we need a Raspberry Pico W. The "W" in Raspberry Pico products indicates the inclusion of
wireless features such as WiFi and Bluetooth.

Connect the DHT22 sensor to your Raspberry Pico. You can find the DHT22
datasheet here. Ensure that you have the required
resistor.

Note: It can be any sensor, I will use DHT22 for demonstration purposes.

Project setup

Development environment

Before you begin, make sure to set up the necessary environment variables:

PICO_BOARD: pico_w
PICO_SDK_PATH: <your-path>

Raspberry Pico will connect to a server via a TCP connection, so we need to set the following CMake options:

TCP_SERVER_IP: Address of the server that will listen to Raspberry Pico eg. 192.168.1.XX
TCP_PORT: Port on the server that is open for communication eg. 8008
WIFI_SSID: Your WiFi network's SSID
WIFI_PASSWORD: Your WiFi network's password

Note: Raspberry must connect to network where such host server exists.

Prepare project

Copying the files lwipopts.h, lwipopts_examples_common.h and pico_extras_import.cmake, pico_sdk_import.cmake is
essential for configuring and importing necessary settings and dependencies. Here's a
breakdown of each file:

lwipopts.h and lwipopts_examples_common.h:
These files contain configuration options for the Lightweight IP (lwIP) stack, which is crucial for networking
functionality.
pico_extras_import.cmake and pico_sdk_import.cmake:
- These CMake scripts are necessary for importing the Pico SDK and associated extras into your project.
- pico_sdk_import.cmake imports the core Pico SDK, while pico_extras_import.cmake imports additional extras for specific functionalities.

By copying these files, you set up the foundational configurations and dependencies needed for networking and general
development on the Raspberry Pico platform.

You can find them in the Pico SDK repository. Follow these steps:

lwipopts.h and lwipopts_examples_common.h:
- Navigate to the Pico Examples repository.
- Inside the repository, locate the pico_w/wifi directory.
- Copy the wifi/lwipopts.h and lwipopts_examples_common.h files from this directory to your project.
pico_sdk_import.cmake:
- In the Pico SDK repository, find the external/pico_sdk_import.cmake file
- Copy this file into your project directory.
pico_extras_import.cmake:
- In the Pico Extras repository, find the external/pico_extras_import.cmake file
- Copy this file into your project directory.

Writing code

The code is available on
my GitHub repository

Cmake

Let's dive into the code, starting with the essential CMake configuration:

cmake_minimum_required(VERSION 3.13)
include(pico_sdk_import.cmake)
include(pico_extras_import.cmake)
project(raspberry_pico_c_remote_sensor C CXX ASM)

set(CMAKE_C_STANDARD 11)
set(CMAKE_CXX_STANDARD 17)
set(WIFI_SSID ${WIFI_SSID} CACHE INTERNAL "WiFi SSID")
set(WIFI_PASSWORD ${WIFI_PASSWORD} CACHE INTERNAL "WiFi password")
set(TCP_SERVER_IP ${TCP_SERVER_IP} CACHE INTERNAL "TCP server ip")
set(TCP_PORT ${TCP_PORT} CACHE INTERNAL "TCP server port")

message("Raspberry Pi Pico SDK version ${PICO_SDK_VERSION_STRING}")

pico_sdk_init()

add_executable(raspberry_pico_c_remote_sensor main.c src/dht.c src/tcp_utils.c src/sleep_utils.c)
target_include_directories(raspberry_pico_c_remote_sensor PRIVATE ${CMAKE_CURRENT_LIST_DIR})
target_link_libraries(raspberry_pico_c_remote_sensor
        pico_cyw43_arch_lwip_poll # pico_cyw43_arch_lwip_threadsafe_background
        pico_stdlib
        hardware_gpio
        hardware_sleep
)
target_compile_definitions(raspberry_pico_c_remote_sensor PRIVATE
        WIFI_SSID=\"${WIFI_SSID}\"
        WIFI_PASSWORD=\"${WIFI_PASSWORD}\"
        TCP_SERVER_IP=\"${TCP_SERVER_IP}\"
        TCP_PORT=\"${TCP_PORT}\"
)

pico_enable_stdio_usb(raspberry_pico_c_remote_sensor 1)
pico_enable_stdio_uart(raspberry_pico_c_remote_sensor 0)

pico_add_extra_outputs(raspberry_pico_c_remote_sensor)

In a previous article, we provided a detailed description of a similar file. Here, you'll find a comparable one, with
added environment variables
and Pico Extras that adds pico_sleep functionality.

Main

Now, let's move on to the main C file:

#include <stdlib.h>

#include "pico/stdlib.h"
#include "pico/cyw43_arch.h"

#include "src/sleep_utils.h"
#include "src/tcp_utils.h"
#include "src/dht.h"

int main(void) {
    //...
}

Here we have included:

<stdlib.h>: Standard C library for general utilities
"pico/stdlib.h": Pico SDK standard library header for Raspberry Pi Pico
"pico/cyw43_arch.h": Header for the Wi-Fi chip used with the Raspberry Pi Pico
"src/..."": Our files, which we will implement in a moment

We will also need some utils methods:

/**
 * Additional PIN for debugging
 */
#define LED_PIN 22

int init_led(void) {
    gpio_init(LED_PIN);
    gpio_set_dir(LED_PIN, GPIO_OUT);
    return 0;
}

int init_wifi(void) {
    if (cyw43_arch_init_with_country(CYW43_COUNTRY_POLAND)) {
        printf("Wi-Fi failed to initialise\n");
        return 1;
    }

    cyw43_arch_enable_sta_mode();

    printf("Connecting to Wi-Fi...\n");
    if (cyw43_arch_wifi_connect_timeout_ms(WIFI_SSID, WIFI_PASSWORD, CYW43_AUTH_WPA2_AES_PSK, 10000)) {
        printf("Failed to connect.\n");
        return 1;
    }

    printf("Connected.\n");
    return 0;
}

Here's a brief overview of the Wi-Fi Initialization Function:

int init_wifi(void) { /*...*/ }: This function initializes the Wi-Fi module using the Cypress CYW4343X chip.
cyw43_arch_init_with_country(CYW43_COUNTRY_POLAND): Initializes the Wi-Fi module with the specified country code (Poland in this case).
If initialization fails, an error message is printed, and the function returns 1.
cyw43_arch_enable_sta_mode(): Enables the Wi-Fi station mode.
The function attempts to connect to the Wi-Fi network using the provided SSID, password, and encryption type ( WPA2 in this case) with a timeout of 10 seconds.
If the connection fails, an error message is printed, and the function returns 1.
If the connection is successful, a success message is printed, and the function returns 0.

int comparator(const void *p, const void *q) {
    return (int)(((dht_reading*)p)->temp_celsius - ((dht_reading*)q)->temp_celsius);
}

The provided C function, named comparator, is designed for comparing two objects of type dht_reading based on their
temperature values in Celsius. This function will be used as a callback function for sorting an array of dht_reading
objects.

static volatile bool awake;

static void sleep_callback(void) {
    awake = true;
}

int main(void) {
    /* Initialize */

    stdio_init_all();
    init_led();
    dht_init();

    /* Definitions */

    dht_reading measurements[5];

    uint scb_orig = scb_hw->scr;
    uint clock0_orig = clocks_hw->sleep_en0;
    uint clock1_orig = clocks_hw->sleep_en1;

    datetime_t t = {
            .year  = 2020,
            .month = 06,
            .day   = 05,
            .dotw  = 5, // 0 is Sunday, so 5 is Friday
            .hour  = 15,
            .min   = 00,
            .sec   = 00
    };

    rtc_init();

    /* Logic */

    sleep_ms(2000);
    measure_freqs();
    sleep_ms(1000);

    while (1) {
        awake = false;
        gpio_put(LED_PIN, 0);
        if (cyw43_is_initialized(&cyw43_state)) {
            cyw43_arch_deinit();
        }
        sleep_run_from_xosc(); // UART will be reconfigured by sleep_run_from_xosc
        rtc_set_datetime(&t);
        rtc_sleep(1, 0, sleep_callback);

        while (!awake) {
            printf("Should be sleeping\n");
        }

        gpio_put(LED_PIN, 1);
        recover_from_sleep(scb_orig, clock0_orig, clock1_orig);
        init_wifi();

        for (int c = 0; c < 5; ++c) {
            dht_reading data;
            read_from_dht(&data);
            printf("%f %f\n", data.temp_celsius, data.humidity);
            measurements[c] = data;
            sleep_ms(2000);
        }
        qsort((void*)measurements, 5, sizeof(dht_reading), comparator);

        send_measurements(&measurements[2]);
    }

    return 0;
}

The provided C code represents the main logic for the project involving sleep cycles, sensor measurements, and wireless
communication. Here's a breakdown of the code:

Global Variables:
- static volatile bool awake;: Declares a global boolean variable to track the wake state of the system.
Sleep Callback Function:
- static void sleep_callback: Defines a callback function triggered when the system wakes from sleep. It sets the global awake variable to true.
Initialization:
- stdio_init_all(): Initializes standard I/O for printf.
- init_led(): Initializes an LED PIN.
- dht_init(): Initializes the DHT sensor.
Definitions:
- Defines an array dht_reading measurements[5] for storing sensor readings.
- Initializes variables for storing original values of certain hardware registers.
Date and Time Configuration:
- Defines a datetime_t structure with a specific date and time.
- Initializes the RTC (Real-Time Clock) with the provided date and time.
Main Loop:
- Initiates a loop for continuous operation.
- Sets awake to false and turns off the LED.
- Checks if the Wi-Fi module is initialized and deinitializes it if necessary.
- Initiates a sleep cycle using rtc_sleep() and waits for the sleep callback to set awake to true.
- Prints a message during the sleep cycle.
- Turns on the LED and recovers from sleep.
- Initializes the Wi-Fi module.
- Reads sensor data from the DHT sensor, sorts the measurements, and sends the data wirelessly.
- Repeats the loop.

Server

This Python server script serves as a TCP server for Raspberry Pi Pico. It listens for incoming connections, receives
temperature and humidity data in a specific format from the Pico device. The server runs indefinitely, continuously
accepting and processing incoming data.

# imports

def main(config: argparse.Namespace) -> None:
    buffer_size = 8
    payload_size = 8  # Specific to what PICO sends

    with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as server:
        server.bind((config.ip, config.port))
        server.listen(1)
        print('Listening for client...')

        try:
            while True:
                try:
                    conn, addr = server.accept()
                    print(f"Connected by {addr}")
                    while True:
                        data = conn.recv(buffer_size)
                        if len(data) == payload_size:
                            humidity, temperature = struct.unpack('ff', data)
                            print(f"Temp: {temperature}, Humidity: {humidity}")
                            if not data:
                                break
                        else:
                            conn.close()
                            break
                except KeyboardInterrupt:
                    print('Exiting...')
                    break
        finally:
            server.close()

# ...

Key functionalities include:

Database Storage: The server can save the received temperature and humidity measurements to a local SQLite database if configured.
Continuous Operation: The script runs continuously, maintaining an open connection for data reception.
Connection Handling: The server handles incoming connections, receiving and processing data in the expected format.
Graceful Exit: The script can be interrupted with a keyboard interrupt (Ctrl+C), allowing for a graceful exit.

Usage

-p or --port: Specifies the port on which the server listens (default is 8008).
--ip: Specifies the IP address on which the server operates (default is an empty string, allowing connections from any IP).
--db: Specifies the location of the SQLite database for storing temperature and humidity data.

To run the server, execute the script and provide any necessary configuration options.

Testing

Server Setup:
- Begin by launching the Python server script on the designated host machine. Ensure that the server is running and ready to accept connections.
Raspberry Pico Flashing:
- Flash the Raspberry Pico with the programmed firmware using the appropriate development environment or tool.
Observation:
- Observe the behavior and interactions between the Raspberry Pico and the server.
- Verify that temperature and humidity data is successfully transmitted from the Pico to the server.
- Confirm any expected actions or responses, such as database storage on the server.
Enjoy the Results:
- Once the testing process is complete and the interactions are confirmed, you can consider the setup successful.

Summary

In summary, this article provides a comprehensive guide for creating a temperature measurement system using the
Raspberry Pi Pico. Starting from the basics of sensor interfacing and data acquisition, we progress through the
essential steps of configuring the Pico to act as a robust temperature monitor. We extend our exploration to seamlessly
forward this valuable temperature data to a remote server, adding a layer of connectivity to our Pico project. At the
end, you have a smart temperature monitoring solution, offering practical insights for real-world applications.

RaspberryPi Pico with C: Blinking LED

Przemysław Papla — Sat, 05 Aug 2023 19:40:07 +0000

Introduction

In this article, we'll explore embedded programming and show you how to make a blinking LED on the Raspberry Pico
using C language. Whether you're a beginner or have some experience, we'll go through each step to help you get the most
out of your Raspberry Pico.

We will use CMake. CMake is a open-source cross-platform tool that simplifies the process of building and managing
software projects. It helps developers create consistent and platform-independent build configurations, making it easier
to work on different systems.

Setup

Preparations

To ensure a comprehensive working environment, install the necessary libraries. On Ubuntu you can run the following
command:

sudo apt install cmake gcc-arm-none-eabi libnewlib-arm-none-eabi libstdc++-arm-none-eabi-newlib

In addition to this we will need pico_sdk_import.cmake file. In order to get this we copy it
from $PICO_SDK_PATH/external

git clone https://github.com/raspberrypi/pico-sdk.git

Development environment

We'll be using CLion by JetBrains as our IDE for this project. CLion streamlines coding with features like intelligent
code completion and robust debugging tools, making our development process more efficient.

Remember to set essential evironment variables like PICO_BOARD or PICO_SK_PATH

Let's code it

To begin, create or update the CMakeLists.txt file with the following content:

cmake_minimum_required(VERSION 3.26)

include(pico_sdk_import.cmake)
project(raspberry_pico_c_blinking_led C CXX ASM)
pico_sdk_init()
add_executable(raspberry_pico_c_blinking_led main.c)
target_link_libraries(raspberry_pico_c_blinking_led pico_stdlib)
pico_add_extra_outputs(raspberry_pico_c_blinking_led)

Here's a breakdown of the key elements:

include(pico_sdk_import.cmake): This line imports the pico_sdk, an essential component for Raspberry Pico development.
project(raspberry_pico_c_blinking_led C CXX ASM): Declares the project, specifying support for C, C++, and Assembly languages.
pico_sdk_init(): Initializes the pico_sdk for the project.
add_executable(raspberry_pico_c_blinking_led main.c): Defines the executable and points to the main source file ( main.c).
target_link_libraries(raspberry_pico_c_blinking_led pico_stdlib): Links the pico_stdlib library to the executable.
pico_add_extra_outputs(raspberry_pico_c_blinking_led): Adds extra outputs for the project.

Now, let's move on to the main.c file:

#include "pico/stdlib.h"

void gpio_toggle(uint pin) {
    gpio_put(pin, !gpio_get(pin));
}

int main() {
#ifndef PICO_DEFAULT_LED_PIN
#warning blink example requires a board with a regular LED
#else
    const uint LED_PIN = PICO_DEFAULT_LED_PIN;
    gpio_init(LED_PIN);
    gpio_set_dir(LED_PIN, GPIO_OUT);
    while (true) {
        gpio_toggle(LED_PIN);
        sleep_ms(250);
    }
#endif
}

Here's a breakdown of the code:

Include Statement: The code includes the necessary header file pico/stdlib.h which is part of the Pico SDK.
gpio_toggle Function:
- This function takes a GPIO pin as a parameter.
- It toggles the state of the specified GPIO pin (switches it from high to low and vice versa).
main Function:
- The #ifndef PICO_DEFAULT_LED_PIN block, checks if the default LED pin is defined for the board. If not, it emits a compilation warning.
- Inside the #else block (indicating that a regular LED pin is available):
  - The LED pin is set as PICO_DEFAULT_LED_PIN.
  - GPIO initialization and configuration are performed to set the LED pin as an output.
  - The main loop toggles the LED state and sleeps for 250 milliseconds, creating a blinking effect.

The code is available on
my GitHub repository

Flashing Raspberry Pico

To begin the update process, reload your CMake project in CLion. Once reloaded, proceed by clicking the 'Build' button.
This action initiates the compilation process, resulting in the creation of a .uf2 file. You can find this file within
the build folder of your project directory.

To flash your raspberry follow steps from the previous article.

Summary

I've guided through the process of implementing a blinking LED on the Raspberry Pico using the C programming language.
We set up the development environment within CLion, installed necessary libraries, and coded the LED blinking
functionality. To conclude, we've learned the flashing procedure, creating a .uf2 file for the Raspberry Pico by
reloading the CMake project and initiating the Build operation.

References

Raspberry Pico C/C++ SDK Documentation

RaspberryPI Pico with Python: Make Firmware

Przemysław Papla — Sun, 30 Jul 2023 07:32:37 +0000

Introduction

In this article, I'll walk you through the process of crafting a custom firmware file for the Raspberry Pi Pico using
MicroPython. We'll explore the simplicity and power of MicroPython, providing step-by-step
instructions for creating a personalized firmware. By the end, you'll have the skills to shape the capabilities of your
Raspberry Pi Pico, enhancing its versatility and tailoring it to your specific project needs. Let's delve into the world
of MicroPython and enhance your microcontroller programming experience!

Setup

Clone micropython

Choose Location:
- Decide on a suitable location on your PC where you want to store the MicroPython repository.
Open Terminal:
- Navigate to the location where you want to clone the repository. You can use the cd command to change directories.

Clone the Repository:

Run the following command to clone the MicroPython repository into the chosen location:

  git clone git@github.com:micropython/micropython.git
  cd micropython
  git submodule update --init lib/pico-sdk lib/tinyusb

Once these steps are completed, you'll have successfully cloned the MicroPython repository to your local machine, and
you can proceed with the next steps in your project.

Create module

Create a new file named main.py within the $MICROPYTHON_PATH/ports/rp2/modules directory. This is a file in which
you can write your own script. As example, I will use the following snippet:

import time
from machine import Pin

led = Pin(25, Pin.OUT)

while True:
    led.value(0)
    time.sleep(0.5)
    led.value(1)
    time.sleep(0.5)

Create firmware

This sequence of commands is used to build and compile our firmware.

micropython/mpy-cross$ make
micropython/ports/rp2$ make submodules
micropython/ports/rp2$ make

make: This command is executed in the micropython/mpy-cross directory. It invokes the make tool to build the MicroPython cross-compiler.
make submodules: Executed in the micropython/ports/rp2 directory, this command initializes and updates the submodules required for the Raspberry Pico.
make: The final command, also executed in the micropython/ports/rp2 directory, triggers the actual build process for MicroPython on the Raspberry Pi Pico. It compiles the code and generates the firmware that can be flashed onto the microcontroller

Upon executing the specified commands, a uf2 file will be generated as the output. This uf2 file encapsulates the
compiled and processed MicroPython firmware, ready to be flashed onto the Raspberry Pico or the target device
specified in the build configuration.

ls build-PICO/*.uf2

To flash your raspberry follow steps from the previous article.

Summary

In short, this article helps you make a custom firmware for the Raspberry Pico using MicroPython. It explains setup
steps, like cloning MicroPython and creating a module with a sample LED blink script. The step-by-step guide then shows
how to create a uf2 file ready to flash onto the Raspberry Pico.

The complete code is available on
my GitHub repository.

References

MicroPython

RaspberryPI Pico with Python: Blinking LED

Przemysław Papla — Fri, 28 Jul 2023 16:32:23 +0000

Introduction

The Raspberry Pico, developed by the Raspberry Pi Foundation, is a specialized microcontroller board designed for a
variety of applications. Unlike traditional Raspberry Pi single-board computers, it caters specifically to the needs of
microcontroller projects, providing a compact and versatile platform for both beginners and experienced developers.

Key features of the Raspberry Pico include:

RP2040 MCU: Pico features a dual-core ARM Cortex-M0+ for balanced performance and power efficiency.
26 GPIO Pins: Equipped for easy connection and control of external devices and sensors.
Versatile Peripherals: Supports SPI, I2C, UART, PWM, and more for diverse hardware interfacing.
Multi-Language Support: Pico is programmable in MicroPython and for C language.
Cost-Effective, Compact: Budget-friendly and designed for space-constrained embedded projects.

The Raspberry Pico is commonly used in projects that require the functionality of a microcontroller, such as
robotics, embedded systems, and various DIY electronics projects. It provides an affordable and accessible platform for
learning and experimenting with physical computing.

Development Environment

We will utilize PyCharm as our preferred IDE (integrated development environment) for
programming the Raspberry Pico. PyCharm provides a user-friendly interface, powerful code editing features, and
seamless integration with Python development.

In this article we will be programming using the MicroPython, so you will need to install the MicroPython plugin. It can
be downloaded from the following page. If you're using a
different IDE, be sure to explore and install the appropriate plugins accordingly.

Write the code

Create a new PyCharm project and create the main.py file. Then paste the following snippet. This code is a simple
example of controlling an LED.

import time
from machine import Pin

led = Pin(25, Pin.OUT)

while True:
    led.value(1)
    time.sleep(0.5)
    led.value(0)
    time.sleep(0.5)

Let's break down the code step by step:

The code begins by importing two modules:
- time for managing time-related functions,
- and Pin from the machine module, which is commonly used in MicroPython for GPIO (General-Purpose Input/Output) operations.
Initializing LED Pin
- It creates an instance of the Pin class named led. This pin is configured as an output (Pin.OUT) and is connected to physical pin 25 on the microcontroller or board.
LED Blinking Loop:
- The code enters an infinite loop (while True) to continuously toggle the LED on and off.
- led.value(1) sets the LED pin to a high state (turning the LED on).
- time.sleep(0.5) pauses the program for 0.5 seconds, creating a half-second delay.
- led.value(0) sets the LED pin to a low state (turning the LED off)
- Another time.sleep(0.5) introduces another half-second delay before the loop repeats.

This code creates a simple blinking pattern for an LED connected to pin 25. The LED turns on for 0.5 seconds, turns off
for 0.5 seconds, and the cycle repeats indefinitely.

In Raspberry Pico, pin 25 is connected with builtin green LED (For more details
see pinout schemas)

Flashing

Flashing the Raspberry Pico involves updating the firmware on the microcontroller.

Prerequisites

Raspberry Pico: Ensure you have the Raspberry Pico microcontroller board.
Micro USB Cable: Use a micro USB cable to connect the Pico to your computer.
Get the right MicroPython UF2 file by downloading it from the official source, such as the latest Raspberry Pico file.

Flash Raspberry Pico with MicroPython

Enter Bootloader Mode:
- Ensure the Raspberry Pico is not connected to power.
- Hold down the BOOTSEL button on the Pico.
- While holding the button, connect the Pico to your computer using the micro USB cable.
Locate Pico as a Mass Storage Device:
- The Raspberry Pico will appear as a mass storage device on your computer.
Drag and Drop Firmware:
- Open the folder containing the firmware file.
- Drag and drop the firmware file onto the mass storage device representing the Pico.
Wait for Flashing:
- The Pico will automatically reboot and start flashing the new firmware.
- The ACT (Activity) LED on the Pico will blink rapidly during the flashing process.
Reconnect Pico:
- After the flashing is complete, disconnect the Pico from your computer.
Power Cycle Pico:
- Reconnect the Pico to power or press the RESET button to start running the new program.

Upload our code

Make sure you have enabled MicroPython support and selected desired device.
To upload our code, right click main.py file and then select Run 'Flash main.py' or simply press CTRL+SHIFT+F10.

Troubleshooting / Tips

Bootloader Mode Button: If you encounter issues entering bootloader mode, double-check that you are holding down the BOOTSEL button while connecting the Pico to your computer.
Verify Flashing: Some firmware files may include a verification step. Ensure that the flashing process completes without errors, and the ACT LED indicates successful activity.
Check Firmware Compatibility: Ensure that the firmware you are flashing is compatible with the Raspberry Pico and its hardware specifications.

If you end up with failed to access /dev/ttyACM0 error then you will need to adjust permissions:

 $ ls -la /dev/ttyACM0
 crw-rw---- 1 root dialout 166, 0 Jul 28 19:51 /dev/ttyACM0
 $ chmod 777 /dev/ttyACM0
 # or
 $ usermod -a -G dialout $USER && reboot

Tests

After testing, we confirm that the blinking LED using MicroPython on the Raspberry Pico works as intended. The
results give us confidence in the reliability of the code and the accuracy of GPIO control. This success lays a solid
foundation for future projects and developments.

Summary

In conclusion, this article explored the foundational steps of using MicroPython on the Raspberry Pico to control an
LED. By importing essential modules such as time and machine, and leveraging the Pin class, we initialized the LED pin
and implemented a straightforward blinking pattern. The code, encapsulated in an infinite loop, demonstrated the
sequential activation and deactivation of the LED with half-second intervals, providing a hands-on introduction to basic
GPIO operations. This exercise serves as a fundamental building block for more complex projects and serves as a
practical starting point for those delving into embedded systems development with MicroPython on the Raspberry Pico.

The complete code is available on
my GitHub repository.