Raspberry

PICO

Table des matières 1 Présentation .................................................................................................................................... 3

1.1 Achat ........................................................................................................................................ 4

1.2 Préparation .............................................................................................................................. 5

2 Premier branchement ..................................................................................................................... 6

3 Premier programme ........................................................................................................................ 7

3.1 Faire clignoter la LED interne en Python ................................................................................. 7

3.1.1 Interpréteur Python ........................................................................................................ 7

3.1.2 Configuration de l’IDE Thonny ......................................................................................... 8

3.1.3 Programme pour faire clignoter la LED ......................................................................... 10

3.2 Faire clignoter la LED interne en C ........................................................................................ 12

3.2.1 Installation et paramétrage du SDK .............................................................................. 12

3.2.2 Compilation du programme exemple blink ................................................................... 14

3.2.3 Copie et exécution de blink sur le PICO......................................................................... 18

4 Les ports d’entrées-sorties ............................................................................................................ 20

5 PWM .............................................................................................................................................. 21

5.1 Fonctionnement d’un servo .................................................................................................. 27

6 Convertisseur AD ........................................................................................................................... 28

7 I2C .................................................................................................................................................. 31

8 SPI .................................................................................................................................................. 32

9 Fonctionnement d’un module ultrason HC-04 .............................................................................. 33

10 Communication grâce à un NRF24L01 ...................................................................................... 34

11 Documentation .......................................................................................................................... 36

1 Présentation Tout d’abord, qu’est-ce qu’un Raspberry PICO ?

Contrairement aux autres Raspberry qui sont des micro-ordinateurs, c’est-à-dire qu’ils fonctionnent

avec un système d’exploitation, une carte SD faisant office de disque dur, un écran etc…, le Raspberry

PICO est un microcontrôleur. Il n’a donc pas de système d’exploitation et il ne peut stocker et faire

fonctionner qu’un seul programme à la fois.

Il est donc basé sur le même concept que les Arduino. Il utilise la puce RP2040 (un processeur ARM

Cortex M0 + double cœur fonctionnant jusqu'à 133 Mhz), 2 Mo de mémoire Flash, 264 ko de RAM, 26

broches GPIO multifonctions dont trois entrées analogiques, deux UART, deux contrôleurs SPI, deux

contrôleurs I2C, 16 canaux PWM et un contrôleur USB 1.1. Il existe également huit machines à états

d'E/S programmables, une horloge, un capteur de température.

La consommation indiquée dans le datasheet est entre 90 et 100mA en fonctionnement et entre 1.5

et 2mA en mode sommeil. C’est un peu plus qu’un ESP8266, mais ça peut faire un bon microcontrôleur

pour des objets connectés.

Il ne comporte par contre pas de module WIFI comme un ESP82666.

On pourrait passer des heures à le comparer aux Arduino et autres micro contrôleurs du marché, lui

trouver des avantages et des inconvénients, mais je ne vais pas m’y lancer, il y a assez de boulot déjà

pour tester ce nouvel arrivant.

1.1 Achat Son tarif est très attractif, début avril 2021, on le trouve à 4€20 chez Kubii.

1.2 Préparation Prévoir 23 pico pour souder sur les broches. 20 de chaque côté et 3 pour la partie débug (pour le

côté pratique, mettre les 3 pico de débug vers le haut).

Il peut également être directement souder sur un circuit imprimé.

2 Premier branchement Un premier test consiste à brancher le PICO sur un port USB d’un ordinateur Windows ou Linux.

Bizarrement, le PICO semble se faire passer pour une clef USB de 128Mo, mais il n’en est rien. Le PICO

ne comporte en fait que 2Mo de mémoire flash. Il ne pourra également rien faire avec des fichiers

autres que des programmes.

Par défaut, il ne comporte que deux petits fichiers, un fichier texte d’information et un fichier html

qui redirige vers la documentation.

3 Premier programme L’éternel premier programme sera bien sûr de faire clignoter une LED. Pas besoin de faire de

branchement, le PICO comporte une LED câblée sur la sortie GPIO25.

Les deux langages supportés actuellement sont le Python et le C/C++

3.1 Faire clignoter la LED interne en Python

3.1.1 Interpréteur Python En premier, pour que le Pico exécute du Python, il lui faut l’interpréteur Python.

Aller sur le site de la documentation et sélectionnez l’onglet MicroPython

Il faut récupérer l’interpréteur et le copier dans le PICO.

Au moment où j’écris ces lignes, le lien propose une version 1.14-8 dite « instable »

J’avoue que je n’aime pas trop les versions dites instables, mais on peut toujours la remplacer par

une version stable en allant la chercher sur le site micropython.

Copier l’interpréteur choisi dans le Pico.

Dès que le programme est copié, il prend le dessus sur le bootloader qui permet d’avoir le disque

virtuel. Le disque virtuel s’arrête instantanément. Il peut être récupéré pour changer de logiciel ou de

version de Python en appuyant sur le bouton « BOOTSEL » au moment du branchement du PICO sur la

prise USB.

3.1.2 Configuration de l’IDE Thonny L’IDE Thonny est un IDE spécialisé Python disponible directement sur les dernières versions de

Raspberry OS.

Afin de configurer l’IDE, il faut suivre ce tutoriel.

Dans la version de Raspberry OS du 11 janvier 2021, il est inutile d’installer le Plugins dans le chapitre

« Installer la liaison avec PICO », c’est déjà fait.

Lorsque le PICO se connecte, il indique la version de l’interpréteur MicroPython (ici, notre 1.14 dite

instable copiée au chapitre précédent)

Un petit bonjour à la mode C

Et un petit allumage manuel de la LED

3.1.3 Programme pour faire clignoter la LED Et maintenant un programme plus complet pour faire clignoter la LED

En cliquant sur le bouton , cela déclenche la sauvegarde du fichier

Sélectionnez et nommez le programme « main.py ».

Le nom est important car cela permet au programme de se lancer automatiquement dès que le PICO

est alimenté. La sauvegarde avec un autre nom oblige à se reconnecter avec Thonny pour ouvrir le

programme et l’exécuter.

Le programme se lance alors automatiquement et fait clignoter la LED à 2.5Hz, et ce à chaque

branchement du PICO.

3.2 Faire clignoter la LED interne en C

3.2.1 Installation et paramétrage du SDK Encore un petit tutoriel à suivre pour installer tous les logiciels requis.

Voici juste les copies d’écran des commandes du tutoriel. Cette installation prend une dizaine de

minutes avec une ligne fibre haut débit.

3.2.2 Compilation du programme exemple blink

3.2.3 Copie et exécution de blink sur le PICO Connexion du PICO en appuyant sur le bouton « BOOTSEL »

Copie du programme blink.uf2 dans le PICO

Et le PICO clignote à 2Hz (250ms allumé et 250ms éteint).

Si l’interpréteur Python était installé, le programme blink.uf2 le remplace.

4 Les ports d’entrées-sorties Le Pico comporte un grand nombre de ports d’entrées-sorties lui permettant d’envoyer et de recevoir

des informations

Le plan est le suivant :

5 PWM

5.1 LED interne A noter qu’ici, la GPIO25 avec sa LED interne est encore utilisée, bien que la notice indique qu’il n’est

pas recommandé de le faire. Vous pouvez tester sur une autre broche GPIO en y câblant une LED et

une résistance (330Ω par exemple) entre la broche GPIO et la masse.

5.1.1 Python Le programme d’exemple est tiré de ce site.

from machine import Pin, PWM

from time import sleep

pwm = PWM(Pin(25))

pwm.freq(1000)

while True:

for duty in range(65025):

pwm.duty_u16(duty)

sleep(0.0001)

for duty in range(65025, 0, -1):

pwm.duty_u16(duty)

sleep(0.0001)

Voici un deuxième programme utilisant la fonction sleep_ms

from machine import Pin, PWM

import time

pwm = PWM(Pin(25))

pwm.freq(1000)

while True:

for duty in range(0, 65025, 10):

pwm.duty_u16(duty)

time.sleep_ms(1)

for duty in range(65025, 0, -10):

pwm.duty_u16(duty)

time.sleep_ms(1)

Ce programme active le PWM de la broche à 1000Hz puis fait varier le rapport cyclique de 0 à 100%.

Dans le premier programme, le rapport cyclique change toutes les 10µs. La LED fera donc une variation

toute les 13s (10µs * 2 * 65025)

Afin de faire fonctionner le programme, il faut recharger l’interpréteur Python puis charger le

programme tel que défini dans le chapitre permettant de faire clignoter une LED. Ne pas oublier de le

nommer main.py et de le stocker dans le Raspberry PICO si l’on veut que le programme démarre à

l’allumage du PICO.

Le premier programme a un cycle d’environ 4s, alors qu’il devrait être de 13s, par contre le deuxième

programme est quant à lui très précis.

Après des tests, il semble que la fonction sleep manque de précision sur les très petites valeurs. Dans

le premier programme, une valeur sleep de 0.01s associée à un pas de 100 pour rétablir le temps,

fourni bien un cycle de 13s.

5.1.2 C / C++ Le programme sera le programme exemple pwm_led_fade.c.

Pour la compilation, voir celle du programme de clignotement de la LED

Et copie du programme pwm_led_fade.uf2 dans le PICO

Le fonctionnement est beaucoup plus rapide avec un cycle de l’ordre d’une seconde et semble

beaucoup plus progressif à visualiser.

5.2 LED multicolore

5.2.1 Python

5.2.2 C / C++

5.3 Fonctionnement d’un servo

5.3.1 Python

5.3.2 C / C++

6 Convertisseur AD

6.1 Python

6.2 C / C++

7 Horloge

7.1 Python

7.2 C / C++

8 Température

8.1 Python

8.2 C / C++

9 I2C

9.1 Python

9.2 C / C++

10 SPI

10.1 Python

10.2 C / C++

11 Fonctionnement d’un module ultrason HC-04

11.1 Python

11.2 C / C++

12 Communication grâce à un NRF24L01

12.1 Python

12.2 C / C++

13 Mode sleep

13.1 Python

13.2 C / C++

14 Documentation https://www.raspberrypi.org/documentation/rp2040/getting-started/

https://datasheets.raspberrypi.org/pico/raspberry-pi-pico-c-sdk.pdf

https://github.com/raspberrypi/pico-examples

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