DigiKey-eMag-Embedded and MCUs-Vol 16

Getting started with the Raspberry Pi Pico multicore microcontroller board using C

mkdir build

the peripherals and connection options shown in Figure 3. These include power, ground, a universal asynchronous receiver and transmitter (UART), general purpose input and output (GPIO), pulse width modulation (PWM), an analog-to-digital converter (ADC), a serial peripheral interconnect (SPI), an inter-integrated circuit (I2C) interface, and debugging. Breakout board options When the Raspberry Pi is going to be used for rapid prototyping, there is a need to gain easy access to the board’s edge connectors. One option for accessing them is to populate the headers and use a breadboard. However, this solution can often result in a mess of wires that can lead to errors. So instead, there are several options for breakout boards that expand the edge connectors to more readily available interfaces. For example, the MM2040EV Pico module board from Bridgetek breaks most of the edge connectors into pin and socket connections. Additionally, there is the 103100142 shield for the Pico from Seeed Studio that provides each peripheral interface as a connector. Each connector is pin compatible with expansion boards to add functions such as inertial sensors, motor drivers, and range finders.

To C or to MicroPython?

Setting up the C SDK When using the C SDK to create a blinky LED application, there are several options. The first is to review the SDK documentation and follow the instructions. The second is to use a preset Docker container to automatically install all the tools necessary to get started. A third option is to install the toolchains and the Raspberry Pi Pico example code manually, including: ■ Git ■ Python 3 ■ Cmake ■ gcc-arm-none-eabi \ ■ libnewlib-arm-none-eabi Retrieving the Raspberry Pi Pico example code can be done by cloning Raspberry Pi’s git repo using the following command: git clone https://github.com/ raspberrypi/pico-sdk /home/sdk/ pico-sdk && \ cd /home/sdk/pico-sdk && \

Copy

cd build

Embedded systems have traditionally been written in C because it balances low-level control with higher-level system application approaches. The problem with C today is that it’s an antiquated, fifty-year-old programming language that is rarely taught in universities. It is also too easy to accidentally inject bugs and cause damage. Despite these potential issues, C is the language of choice for the majority of embedded systems development. An alternative to using C, provided by the Raspberry Pi Pico ecosystem, is MicroPython. MicroPython is a CPython port designed to run on MCU-based systems. While it is undoubtedly a heavier processor user than C, it is a modern language with which many developers are familiar and comfortable. MicroPython can abstract out low-level details of the MCU and hardware. Hardware accesses are through high-level application programming interfaces (APIs) that are easy to learn – an important feature with tight project deadlines. When selecting which software development kit (SDK) to use – C or MicroPython – developers need to focus on specific needs. Compared to MicroPython, using C will provide low-level access to the MCU’s registers, have a smaller memory footprint, and be more efficient.

Next, cmake needs to be prepared for the build by executing the following command: cmake Now, a developer can change to the blinky directory and run make: cd blink

#include “pico/stdlib.h”

make

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_put(LED_PIN, 1); sleep_ms(250); gpio_put(LED_PIN, 0); sleep_ms(250); } #endif } Code listing: the Raspberry Pi Pico uses the PICO_DEFAULT_LED_PIN directive to set up an I/O pin and blink it with a 250 ms delay. Code source: Raspberry Pi

The output from the build process will be a blinky.uf2 file. The compiled program can be loaded on the Raspberry Pi Pico by holding down the BOOTSEL pin and powering up the board. The RP2 will then appear as a mass storage device. The developer needs to drag the blinky.uf2 file to the drive, at which point the bootloader will install the application. Once completed, the LED should begin blinking.

git submodule update --init &&

Conclusion

Once these libraries and the source code are installed, the next step is to explore and compile a blinky LED application.

The Raspberry Pi Pico is an attractive solution for embedded developers looking for flexibility in their development cycle. Several options are available, including standalone solutions or boards with wireless connectivity. In addition, the ecosystem supports C and C++, as well as MicroPython. Developers can pick which language works best for their application and then leverage the corresponding SDK to accelerate software development.

Writing a first blinky application

up an I/O pin and blink it with a 250 millisecond (ms) delay Per the listing, the LED_PIN is assigned the default pin; calls are then made to the C gpio APIs. gpio_ init is used to initialize the pin, while gpio_set_dir is used to set the LED_ PIN to an output. An infinite loop is

then created that toggles the state of the LED every 250 ms. Compiling the application is relatively straightforward. First, a developer needs to create a build directory in their Raspberry Pi Pico folder using the following commands:

The C SDK comes with a blinky example that developers can use to build their first application. The Code Listing below uses the Pico’s onboard LED and the PICO_ DEFAULT_LED_PIN directive to set

we get technical