Primeiros passos com a placa microcontroladora multinúcleo Raspberry Pi Pico usando C

Há uma necessidade inerente nos sistemas embarcados de ter uma unidade microcontroladora (MCU) poderosa e de baixo custo. Esses dispositivos desempenham um papel importante não apenas no produto, mas também no suporte a testes, prototipagem rápida e recursos como aprendizado de máquina (ML). No entanto, começar a usar MCUs geralmente requer um conhecimento profundo da tecnologia MCU e das linguagens de programação de baixo nível. Além disso, as placas de desenvolvimento geralmente custam entre US$ 20 e US$ 1.000, o que pode ser muito caro para muitos desenvolvedores. Também, nem sempre há uma placa de desenvolvimento disponível e, mesmo quando há, os projetistas costumam ter dificuldades para colocar uma placa em funcionamento.

Este artigo apresenta o Raspberry Pi Pico (SC0915) como uma placa de desenvolvimento de baixo custo para a MCU RP2040 que oferece aos desenvolvedores uma ampla gama de recursos. O artigo explora o Pico e algumas placas de expansão, examina os diferentes kits de desenvolvimento de software compatíveis com o Raspberry Pi Pico e demonstra como criar um aplicativo de LED piscante usando o C SDK.

Introdução ao Raspberry Pi Pico

O Raspberry Pi Pico foi apresentado pela primeira vez em 2021 como a plataforma de desenvolvimento para o microcontrolador RP2040. O Pico pode ser usado como uma placa de desenvolvimento autônoma ou pode ser projetado diretamente em um produto devido às conexões de borda que podem ser soldadas a uma placa portadora (Figura 1). Entre o custo inferior a US$ 5 do Pico e seu uso multiuso, ele se tornou uma solução popular para criadores e desenvolvedores profissionais.

Figura 1: O Raspberry Pi Pico é uma placa de desenvolvimento de baixo custo que contém tudo o que é necessário para desenvolver aplicativos no microcontrolador RP2040. (Fonte da imagem: Raspberry Pi)

O RP2040 apresenta um processador Arm® Cortex®-M0+ de dois núcleos com clock de 133 megahertz (MHz) e inclui até 264 quilobytes (Kbytes) de SRAM. O RP2040 não inclui flash no chip. Em vez disso, o Raspberry Pi Pico fornece um chip flash externo de 2 megabytes (Mbyte) que faz interface com o RP2040 por meio de uma interface periférica serial quádrupla (QSPI). A placa também fornece um LED para o usuário, um oscilador de cristal que a malha de captura de fase (PLL) usa para criar um clock estável de alta velocidade para a CPU e um pushbutton para configurar se o processador será inicializado normalmente ou em um carregador de inicialização.

Um ecossistema extenso

O Raspberry Pi Pico já possui um extenso ecossistema que permite que os desenvolvedores escolham entre usar os kits de desenvolvimento de software MicroPython ou C para escrever aplicativos para a placa. Uma observação interessante sobre o Raspberry Pi Pico é que não há apenas uma única placa de desenvolvimento disponível. Em vez disso, há três: o SC0915 original com uma configuração padrão, o SC0917, que inclui conectores de barra de pinos, e o SC0918, que inclui um chip Wi-Fi de baixo custo para aplicativos conectados (Figura 2).

Figura 2: O Raspberry Pi Pico está disponível em três configurações. (Fonte da imagem: Beningo Embedded Group, LLC)

Para cada uma dessas versões, a pegada geral da placa permanece a mesma. As conexões de borda da placa consistem em conexões de borda de 40 pinos para os periféricos e as opções de conexão mostradas na Figura 3. Isso inclui alimentação, aterramento, um receptor e transmissor assíncrono universal (UART), entrada e saída de uso geral (GPIO), modulação por largura de pulso (PWM), um conversor analógico-digital (ADC), uma interconexão periférica serial (SPI), uma interface de circuito inter-integrado (I2C) e depuração.

Figura 3: A pinagem conectada à borda do Raspberry Pi Pico oferece uma ampla variedade de acesso a periféricos. (Fonte da imagem: Raspberry Pi)

Opções de placa breakout

Quando o Raspberry Pi é usado para prototipagem rápida, é necessário obter acesso fácil aos conectores de borda da placa. Uma opção para acessá-los é preencher as barras de pinos e usar uma matriz de contatos. No entanto, essa solução muitas vezes pode resultar em uma confusão de fios que pode levar a erros. Portanto, em vez disso, há várias opções de placas de breakout que expandem os conectores de borda para interfaces mais prontamente disponíveis.

Por exemplo, a placa do módulo Pico MM2040EV da Bridgetek divide a maioria dos conectores de borda em conexões de pinos e soquetes. Além disso, há o shield 103100142 para o Pico da Seeed Studio que fornece cada interface periférica como um conector. Cada conector é compatível em pinos com placas de expansão para adicionar funções como sensores inerciais, acionadores de motor e medidores de distância.

Para C ou para MicroPython?

Tradicionalmente, os sistemas embarcados são escritos em C porque equilibram o controle de baixo nível com abordagens de aplicativos de sistema de nível superior. O problema com o C atualmente é que se trata de uma linguagem de programação antiquada, com cinquenta anos de idade, que raramente é ensinada nas universidades. Também é muito fácil injetar bugs acidentalmente e causar danos. Apesar desses possíveis problemas, C é a linguagem escolhida para a maior parte do desenvolvimento de sistemas embarcados.

Uma alternativa ao uso do C, fornecida pelo ecossistema do Raspberry Pi Pico, é o MicroPython. O MicroPython é uma porta CPython projetada para ser executada em sistemas baseados em MCU. Embora seja, sem dúvida, um usuário de processador mais pesado do que o C, é uma linguagem moderna com a qual muitos desenvolvedores estão familiarizados e se sentem confortáveis. O MicroPython pode abstrair detalhes de baixo nível da MCU e do hardware. Os acessos ao hardware são feitos por meio de interfaces de programação de aplicativos (APIs) de alto nível que são fáceis de aprender — um recurso importante para prazos de projeto apertados.

Ao selecionar o kit de desenvolvimento de software (SDK) a ser usado — C ou MicroPython —, os desenvolvedores precisam se concentrar em necessidades específicas. Em comparação com o MicroPython, o uso do C fornecerá acesso de baixo nível aos registradores da MCU, terá uma pegada de memória menor e será mais eficiente.

Configurando o C SDK

Ao usar o C SDK para criar um aplicativo de LED piscante, há várias opções. A primeira é revisar a documentação do SDK e seguir as instruções. A segunda é usar um contêiner Docker predefinido para instalar automaticamente todas as ferramentas necessárias para começar. Uma terceira opção é instalar manualmente os conjuntos de ferramentas e o código de exemplo do Raspberry Pi Pico, incluindo:

• Git
• Python 3
• Cmake
• gcc-arm-none-eabi \
• libnewlib-arm-none-eabi

A recuperação do código de exemplo do Raspberry Pi Pico pode ser feita clonando o repositório git do Raspberry Pi usando o seguinte comando:

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

cd /home/sdk/pico-sdk && \

git submodule update --init &&

Depois que essas bibliotecas e o código-fonte estiverem instalados, a próxima etapa é explorar e compilar um aplicativo de LEDs piscantes.

Escrevendo um primeiro aplicativo blinky

O C SDK é fornecido com um exemplo de blinky que os desenvolvedores podem usar para criar seu primeiro aplicativo. A listagem de código abaixo usa o LED na placa do Pico e a diretiva PICO_DEFAULT_LED_PIN para configurar um pino de E/S e fazê-lo piscar com um atraso de 250 milissegundos (ms).

Copiar
	/**
	 * Copyright (c) 2020 Raspberry Pi (Trading) Ltd.
	 *
	 * SPDX-License-Identifier: BSD-3-Clause
	 */
	

	#include "pico/stdlib.h"
	

	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
	}

Listagem de código: O Raspberry Pi Pico usa a diretiva PICO_DEFAULT_LED_PIN para configurar um pino de E/S e fazê-lo piscar com um atraso de 250 ms. (Fonte do código: Raspberry Pi)

De acordo com a listagem, o LED_PIN é atribuído ao pino padrão; em seguida, são feitas chamadas para as APIs gpio do C. gpio_init é usado para inicializar o pino, enquanto gpio_set_dir é usado para definir o LED_PIN como uma saída. Em seguida, é criado um loop infinito que alterna o estado do LED a cada 250 ms.

A compilação do aplicativo é relativamente simples. Primeiro, o desenvolvedor precisa criar um diretório de compilação na pasta Raspberry Pi Pico, usando os seguintes comandos:

mkdir build

cd build

Em seguida, o cmake precisa ser preparado para a compilação, executando o seguinte comando:

cmake

Agora, um desenvolvedor pode mudar para o diretório blinky e executar o make:

cd blink

make

O resultado do processo de compilação será um arquivo blinky.uf2. O programa compilado pode ser carregado no Raspberry Pi Pico mantendo pressionado o pino BOOTSEL e ligando a placa. O RP2 aparecerá como um dispositivo de armazenamento em massa. O desenvolvedor precisa arrastar o arquivo blinky.uf2 para a unidade e, nesse momento, o carregador de inicialização instalará o aplicativo. Depois de concluído, o LED deve começar a piscar.

Conclusão

O Raspberry Pi Pico é uma solução atraente para desenvolvedores de embarcados que buscam flexibilidade em seu ciclo de desenvolvimento. Há várias opções disponíveis, incluindo soluções autônomas ou placas com conectividade sem fio. Além disso, o ecossistema oferece suporte a C e C++, bem como a MicroPython. Os desenvolvedores podem escolher a linguagem mais adequada para seu aplicativo e, em seguida, aproveitar o SDK correspondente para agilizar o desenvolvimento do software.