Premiers pas avec la carte de microcontrôleur multicœur Raspberry Pi Pico avec le langage C

Les systèmes embarqués ont besoin d'un microcontrôleur (MCU) puissant et peu coûteux. Ces dispositifs jouent un rôle important non seulement pour le produit, mais également dans la prise en charge des tests, du prototypage rapide et des capacités telles que l'apprentissage automatique (ML). Cependant, pour commencer à utiliser les microcontrôleurs, il faut généralement avoir une connaissance approfondie de la technologie des microcontrôleurs et des langages de programmation de bas niveau. En outre, les cartes de développement coûtent souvent entre 20 et 1000 dollars, ce qui peut s'avérer trop onéreux pour de nombreux développeurs. Par ailleurs, il n'est pas toujours possible d'obtenir une carte de développement, et même lorsque c'est le cas, les concepteurs ont souvent du mal à la mettre en place et à la faire fonctionner.

Cet article présente la carte de développement à faible coût Raspberry Pi Pico (SC0915) pour le microcontrôleur RP2040 qui offre aux développeurs un large éventail de fonctionnalités. Il décrit la carte Pico et d'autres cartes d'extension, examine les différents kits de développement logiciel pris en charge par le Raspberry Pi Pico et montre comment créer une application de LED clignotante à l'aide du kit de développement SDK C.

Présentation du Raspberry Pi Pico

Le Raspberry Pi Pico a été présenté pour la première fois en 2021 en tant que plateforme de développement pour le microcontrôleur RP2040. Le Pico peut être utilisé comme carte de développement autonome ou être intégré directement dans un produit grâce à des connexions de bord qui peuvent être soudées à une carte de support (Figure 1). Grâce à son prix inférieur à 5 dollars et à son utilisation polyvalente, le Pico est devenu une solution populaire tant pour les makers que pour les développeurs professionnels.

 Figure 1 : Le Raspberry Pi Pico est une carte de développement à faible coût qui contient tout le nécessaire pour développer des applications sur le microcontrôleur RP2040. (Source de l'image : Raspberry Pi)

Le RP2040 dispose d'un processeur double cœur Arm® Cortex®-M0+ cadencé à 133 mégahertz (MHz) et comprenant jusqu'à 264 Kilo-octets (Ko) de SRAM. Le RP2040 n'inclut pas de Flash sur puce. En revanche, le Raspberry Pi Pico fournit une puce Flash externe de 2 méga-octets (Mo) qui communique avec le RP2040 via une interface périphérique série quadruple (QSPI). La carte fournit également une LED utilisateur, un oscillateur à quartz que la boucle à verrouillage de phase (PLL) utilise pour créer une horloge de processeur haute vitesse stable et un bouton-poussoir pour déterminer si le processeur doit démarrer normalement ou dans un chargeur d'amorçage.

Un vaste écosystème

Le Raspberry Pi Pico dispose déjà d'un vaste écosystème qui permet aux développeurs de choisir entre l'utilisation de kits de développement logiciel MicroPython ou C pour écrire des applications pour la carte. Il est intéressant de noter qu'il n'existe pas qu'une seule carte de développement pour le Raspberry Pi Pico. Il en existe trois ; le SC0915 original avec une configuration standard, le SC0917 qui comprend des connecteurs d'embase et le SC0918 qui comprend une puce Wi-Fi à faible coût pour les applications connectées (Figure 2).

Figure 2 : Le Raspberry Pi Pico est disponible en trois configurations. (Source de l'image : Beningo Embedded Group, LLC)

Pour chacune de ces versions, l'encombrement général de la carte reste le même. Les connexions de bord de la carte impliquent des connexions de bord à 40 broches pour les périphériques et les options de connexion illustrées à la Figure 3. Il s'agit notamment de l'alimentation, de la masse, d'un émetteur-récepteur universel asynchrone (UART), d'une entrée et d'une sortie à usage général (GPIO), d'une modulation de largeur d'impulsion (PWM), d'un convertisseur analogique-numérique (CAN), d'une interconnexion périphérique série (SPI), d'une interface de circuit inter-intégré (I2C) et d'un débogage.

Figure 3 : Le brochage connecté sur le bord du Raspberry Pi Pico offre une grande variété d'accès aux périphériques. (Source de l'image : Raspberry Pi)

Options de carte Breakout

Si le Raspberry Pi doit être utilisé pour le prototypage rapide, il est nécessaire de pouvoir accéder facilement aux connecteurs enfichables de la carte. Une option pour y accéder consiste à équiper les embases et à utiliser un montage d'essai. Cependant, cette solution se traduit souvent par un enchevêtrement de fils susceptible d'entraîner des erreurs. Il existe donc plusieurs options pour les cartes Breakout qui permettent d'étendre les connecteurs enfichables à des interfaces plus facilement disponibles.

Par exemple, la carte du module Pico MM2040EV de Bridgetek transforme la plupart des connecteurs enfichables en connexions à broches et à douilles. De plus, il existe le shield 103100142 pour le Pico de Seeed Studio qui fournit chaque interface périphérique sous forme de connecteur. Chaque connecteur est compatible avec les broches des cartes d'extension permettant d'ajouter des fonctions telles que des capteurs inertiels, des variateurs moteurs et des télémètres.

Programmation en C ou en MicroPython ?

Les systèmes embarqués sont traditionnellement écrits en C car ce langage permet d'équilibrer le contrôle de bas niveau avec des approches d'application de système de niveau supérieur. Le problème avec C aujourd'hui tient au fait qu'il s'agit d'un langage de programmation désuet, vieux de cinquante ans, qui est rarement enseigné dans les universités. Il est également trop facile d'injecter accidentellement des bugs et de provoquer des dommages. En dépit de ces problèmes potentiels, le langage C reste le choix de prédilection pour la majorité des développements de systèmes embarqués.

Une alternative à l'utilisation du langage C, fournie par l'écosystème Raspberry Pi Pico, est MicroPython. MicroPython est un port CPython conçu pour fonctionner sur des systèmes basés sur un microcontrôleur. Bien qu'il soit sans aucun doute plus gourmand en ressources processeur que C, il s'agit d'un langage moderne avec lequel de nombreux développeurs sont familiers et à l'aise. MicroPython peut faire abstraction des détails de bas niveau du microcontrôleur et du matériel. Les accès au matériel s'effectuent par l'intermédiaire d'interfaces de programmation d'applications (API) de haut niveau faciles à maîtriser, une caractéristique importante lorsque les délais du projet sont serrés.

Lors de la sélection du kit de développement logiciel (SDK) à utiliser (C ou MicroPython), les développeurs doivent se concentrer sur leurs besoins spécifiques. Par rapport à MicroPython, l'utilisation du langage C permet un accès de bas niveau aux registres du microcontrôleur, offre une empreinte mémoire plus petite et est plus efficace.

Configuration du kit de développement logiciel (SDK) C

Plusieurs options s'offrent à vous lorsque vous utilisez le SDK C pour créer une application de LED clignotante. La première consiste à consulter la documentation du kit SDK et à suivre les instructions. La seconde consiste à utiliser un conteneur Docker prédéfini pour installer automatiquement tous les outils nécessaires au démarrage. Une troisième option consiste à installer manuellement les chaînes de compilation et l'exemple de code Raspberry Pi Pico, en incluant les éléments suivants :

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

La récupération de l'exemple de code Raspberry Pi Pico peut être effectuée en clonant le référentiel git de Raspberry Pi à l'aide de la commande suivante :

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

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

git submodule update --init &&

Une fois ces bibliothèques et le code source installés, l'étape suivante consiste à explorer et à compiler une application de LED clignotante.

Rédaction d'une première application clignotante

Le SDK C est accompagné d'un exemple de LED clignotante que les développeurs peuvent utiliser pour créer leur première application. Le code ci-dessous utilise la LED intégrée du Pico et la directive PICO_DEFAULT_LED_PIN pour configurer une broche d'E/S et la faire clignoter avec un délai de 250 millisecondes (ms).

Copier
	/**
	 * 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
	}

Liste des codes : le Raspberry Pi Pico utilise la directive PICO_DEFAULT_LED_PIN pour configurer une broche d'E/S et la faire clignoter toutes les 250 ms. (Source du code : Raspberry Pi)

Selon cette liste, LED_PIN est assigné à la broche par défaut ; des appels sont ensuite effectués vers les API C gpio. gpio_init est utilisé pour initialiser la broche, tandis que gpio_set_dir permet de définir la broche LED_PIN sur une sortie. Une boucle infinie est alors créée qui fait basculer l'état de la LED toutes les 250 ms.

La compilation de l'application est relativement simple. Tout d'abord, un développeur doit créer un répertoire de compilation (build) dans son dossier Raspberry Pi Pico à l'aide des commandes suivantes :

mkdir build

cd build

Ensuite, cmake doit être préparé pour la compilation en exécutant la commande suivante :

cmake

Désormais, un développeur peut accéder au répertoire blink et exécuter make :

cd blink

make

Le résultat du processus de compilation prend la forme d'un fichier blinky.uf2. Le programme compilé peut être chargé sur le Raspberry Pi Pico en maintenant la broche BOOTSEL enfoncée et en mettant la carte sous tension. Le RP2 apparaît alors comme un périphérique de stockage de masse. Le développeur doit faire glisser le fichier blinky.uf2 sur le lecteur, ce qui permet au chargeur d'amorçage d'installer l'application. Une fois l'opération terminée, la LED doit se mettre à clignoter.

Conclusion

Le Raspberry Pi Pico est une solution intéressante pour les développeurs de systèmes embarqués qui souhaitent apporter de la flexibilité dans leur cycle de développement. Plusieurs options sont disponibles, notamment des solutions autonomes ou des cartes avec connectivité sans fil. De plus, l'écosystème prend en charge les langages C et C++, ainsi que MicroPython. Les développeurs peuvent choisir le langage qui convient le mieux à leur application, puis tirer parti du kit de développement logiciel correspondant pour accélérer le développement logiciel.