Raspberry Pi Pico MicroPython

La Raspberry Pi Pico-W est une carte programmable miniature avec interface WiFi et Bluetooth construite autour d'un microcontrôleur RP2040. Elle est très simple d'accès et propose d'excellentes performances à très faible coût.

• Fonctionnalités:

  Cette version est idéale pour la réalisation de petits projets connectés, à faible consommation et nécessitant la flexibilité et la puissance du microcontrôleur RP2040. Raspberry Pi propose une documentation détaillée permettant aux débutants et amateurs de se familiariser avec la programmation en MicroPython, Python ou encore en C ou C++ de façon simple et ludique.

• Programmation:

  Le Raspberry Pi Pico se programme en MicroPython via son port micro-USB avec l'IDE Thonny , disponible gratuitement pour Windows, macOS et Linux. Le microcontrôleur RP2040 peut également exécuter des instructions via des lignes de commandes (REPL). Pour les utilisateurs plus avancés, des kits de développement (SDK) permettent la réalisation d'applications en C/C++ et Python.

Pour les fonctionnalités des ports en détails il suffit de suivre ce lien.

• Grove est un système de connecteur plug-and-play open-source développé par Seeed Studio.

• Les modules Grove ont été conçus pour l’éducation et le prototypage rapide. Plus de 3000 composants ; capteurs et actionneurs sont disponibles.

• Simple : car vous n’avez pas besoin de réfléchir à « quel fil va où ? ».

• Sûr ; car un détrompeur évite de se tromper avec la polarité.

• Rapide ; car aucune aucune soudure à faire.

• Branchez, codez, alimentez et c’est fait.

• La documentation de Seeed Studio est très détaillée, complète, et comporte des exemples de code pour vous aider à démarrer vos projets.

Zoom

1. Analog Port: include 3 anlog ports, A0, A1, A2.

2. Digital Ports: include 3 digital ports, D16, D18, D20.

3. UART Port: 2 UART port.

4. I2C Ports: 2 I2C ports.

5. Power Switch: 5V/3.3V selectable power switch.

6. SPI port: 1 spi0 port.

• le logiciel « Thonny IDE »installé.

• Une carte Raspberry Pi Pico, bien évidemment

• Un câble USB ↔ microUSB, pour faire la liaison entre votre ordinateur.

Tout d’abord, il faut savoir que tous les Raspberry Pi Pico disposent d’un « bootloader intégré », dans leur mémoire ROM ; c’est à dire un programme de démarrage « gravé dans le dur », dans la mémoire morte du microcontrôleur. Ce programme permet entre autre :

• la communication entre le Raspberry Pico et un ordi, via le port USB

• et l’exécution de code programme, stocké en mémoire FLASH

La mémoire FLASH, peut contenir :

• un programme ; écrit en langage machine, directement compréhensible par le microcontrôleur,

• et d’éventuelles données.

En fait, pour qu’un Raspberry Pi Pico puisse exécuter des scripts écrits en MicroPython, nous allons utiliser la mémoire FLASH.

• la partie programme hébergera un interpréteur micropython. C’est à dire un micrologiciel, aussi appelé firmware en anglais, permettant de transformer à la volée du code MicroPython, en langage machine, que le microcontrôleur saura comprendre.

• et la partie données hébergera nos fichiers-programmes écrits en MicroPython

Ainsi, le microcontrôleur du Pico exécutera du code machine fournit au fur et à mesure par le firmware (l’interpréteur micropython), en sachant que ce code machine proviendra de nos scripts micropython, interprétés à la volée.

Cette étape s'effectue une seule fois à la réception des cartes neuves. L'opération est réversible si on veut programmer en Arduino.

• La première chose à faire, si vous souhaitez exécuter du code micropython sur votre Raspberry Pi Pico, c’est de lui transmettre l’interpréteur micropython, sous forme de firmware. Cet interpréteur, pour rappel, permettra de convertir le code python en langage machine, pour que le microcontrôleur puisse l’exécuter.

• À noter que l’interpréteur micropython (le firmware) se présente sous la forme d’un fichier « .UF2 », téléchargeable sur le site :

  https://micropython.org/download/RPI_PICO_W/

• Il est spécifique à chaque « famille » de microcontrôleur et nous prendrons la dernière version stable.

• Pour installer ce micrologiciel dans votre Pico, nous utiliserons Thonny.

• L'indentation de votre code doit être de 4 caractères ; automatique dans Thonny avec la touche tabulation

• 79 caractères par ligne, pas plus.

• Les bibliothèques ou fonction sont à déclarer au début du script.

Les espaces suivent la syntaxe anglo-saxone et non française.

• Entourer les opérateurs (+, -, /, *, ==, !=, >=, not, in, and, or...) d'un espace avant et d'un espace après.

• Pas d'espace à l'intérieur de crochets, d'accolades et de parenthèses.

• Pas d'espace avant la parenthèse ouvrante d'une fonction ou le crochet ouvrant d'une liste ou d'un dictionnaire.

• On met un espace après les caractères : et , (mais pas avant).

• Écrire les noms de variables en minuscules, avec des underscores (tirets bas).

• Écrire les variables constantes en majuscules, avec des underscores.

• Écrire les noms de fonction avec la même convention que les variables

Une LED est comme une diode, elle ne laisse passer le courant que dans un seul sens. Si vous la branchez mal, elle ne fonctionnera pas. Il suffit de la retourner.

Pour vous aider à raccorder une LED :

• Une LED dispose d'une broche PLUS longue et d'une broche courte. La broche la PLUS longue va au POSITIF.

• Il manque également de la matière sur l'un des côté de la LED. La où il y a de la matière en MOINS c'est la borne NEGATIVE. La borne que l'on raccorde à la masse.

Zoom

Le montage se fait avec une résistance en série. Pour obtenir un résultat optimal avec des leds il faut choisir la valeur de la résistance avec soin. On peut consulter successivement ces trois sites pour choisir la valeur appropriée :

• Calcul de la valeur d'une résistance.

• Calcul appliqué

• Calcul détaillé avec calculateur intégré.

Zoom

La commande peut se faire en :

• Tout ou rien ; allumé ou éteint.

• Ou en PWM c'est à dire en modulation de la largeur d'impulsion donc de manière progressive.

Faire clignoter une LED ou une séquence de LEDs c'est vraiment très sympa. Ce qui est encore mieux, c'est de contrôler la couleur d'une LED. Cela est rendu possible à l'aide d'une LED particulière dite "RGB" ou "RVB". Elle est en fait composée de 3 LEDs de couleurs différentes enfermées dans un seul et même composant.

Les meilleures LEDs RGB seront les LEDs dite à diffusion (LEDs tricolores diffuses)

Zoom

Ce qui est appréciable avec les LED tricolores diffuses c'est que le mélange des couleurs se fait à l'intérieur de la LED.

D'une façon générale, il est préférable d'utiliser une LED tricolores à Anode Commune. L'anode commune signifie que vous connectez la broche commune au +5 Volts et que vous raccordez ensuite les autres broches à la masse au travers d'une résistance.

Il est plus approprié d'utiliser des LEDs RGB à anode commune (le +5 volts commun) plutôt que des LEDs à Cathode Commune (le GND/masse en commun) parce que les circuits intégrés contrôleurs multi-LED sont souvent conçus pour des Anodes Communes et ne peuvent pas être utilisés avec des Cathodes Communes.

Zoom

Dans un premier temps, il faut bien observer la LED pour identifier les différents broches correspondant aux différentes couleurs. La longueur des différentes broches vous y aidera.

Zoom

La LED RGB utilise une anode commune (le + est en commun). Il faut donc manipuler la tension sur les broches négatives des différentes LEDs de couleur.

Pour résumer le fonctionnement:

• On allume une LED de couleur en mettant la broche/pin à 0 volts.

• On éteint une LED en mettant la broche/pin à +5 volts.

Dans le même ordre d'idée, le contrôle PWM fonctionne à l'identique.

• Assigner une valeur 255 en PWM (100% de cycle utile) éteint la LED.

• Assigner une valeur 30 en PWM (30% de cycle utile) allume la LED à 70%.

• Assigner une valeur 0 en PWN (0% de cycle utile) allume la LED à 100%.

Incorporer des hordes de LEDs dans un projet électronique peuvent le transformer en une toile d'araignée de fils et un code difficile à maintenir. L'arrivée de LEDs disposant d'une puce pilote dédicacée change la donne en allégeant le travail du microcontrôleur et le câblage afin de se concentrer sur l'application.

Le WS2812 avec source de lumière intégrée WS2812 Integrated Light Source ou plus communément nommé NeoPixel permet d'obtenir des LEDs pleine de couleurs, simple a mettre en œuvre, évolutive (scalable) et abordable.

Les leds rouge, vert et bleue sont intégrées côte à côte sur un petit support SMD (composants montés en surface) lui-même intégré sur la puce du pilote contrôleur. Le tout contrôlé par un simple fil. Ils peuvent être utilisés individuellement, arrangés pour former une longue chaîne ou assemblés pour réaliser diverses formes.

Zoom

• Toutes les LEDs addressables ne sont pas des NeoPixels. “NeoPixel” est la marque d'Adafruit pour les pixels RGB individuellement adressable et les bandes de pixels (dit "strips") basé sur les LEDs/pilotes WS2812 et WS2811, utilisant un protocole de contrôle à un seul fil. Il existe d'autres produits dont les pixels WS2801, LPD8806 et bande RGB analogique utilisant des méthodologies différentes et disposant de leur propres tutoriels.

• Les NeoPixels ne se contentent pas de s'allumer tout seul, ils nécessitent un microcontrôleur, tel qu'un Raspberry pico et un peu de programmation.

• NeoPixel n'est pas "la réponse idéale" pour tous les projets. Le signal de contrôle exige une gestion du temps très strict.

Puis-je réaliser un afficheur POV ?

NéoPixel n'est pas recommandé pour ce type de projet. Le taux de rafraichissement est relativement faible (environ 400 Hz) et l'affichage des couleurs durant les mouvements rapides pourraient présenter un "effet tacheté" ainsi Les NeoPixels sont parfait pour des afficheurs stationnaires.

Le mouvement plus lent utilisé pour la réalisation de tableau light painting photographique est compatible avec le taux de rafraichissement limité des NéoPixels; Les NéoPixels étant très lumineux, le résultat est excellent, surtout avec l'utilisation de diffuseur de lumière.

La LED intégrée est connectée sur :

• GP25 du RP2040 sur la version sans WIFI (H)

• WL_GPIO0 sur la version avec WIFI (WH)

MicroPython gère automatiquement cette différence en utilisant "LED" comme repère.

Zoom

Cliquez dans le volet principal de l'éditeur de Thonny et entrez le code suivant pour allumer la LED.

from machine import Pin

led = Pin(25, Pin.OUT)

led.toggle()

Cliquez sur le bouton pour exécuter votre code.

Zoom

Thonny vous demandera si vous souhaitez enregistrer le fichier sur Cet ordinateur ou la carte raspberry. Choisir MicroPython sur le périphérique.

Zoom

• Entrer blink.py comme nom de fichier.

• Vous devez entrer .py pour l'extension de fichier pour que Thonny reconnaisse le fichier comme un fichier Python.

• Thonny peut enregistrer votre programme sur votre Raspberry Pi Pico et l'exécuter.

• Vous devriez voir la LLED embarqué activée et désactivée chaque fois que vous cliquez sur le bouton exécuter.

from machine import Pin

from time import *

led_int = Pin("LED", Pin.OUT)  # broche GP25 ou WL_GPI00 en sortie

while True:             # boucle infinie puisque la condition est toujours vraie (True) 

    led_int.value(1)        # allume la LED

    sleep_ms(500)           # pause de 500 ms

    led_int.value(0)        # éteint la LED

    sleep_ms(500)           # pause de 500 ms

N'oubliez pas de faire la même manipulation que précédemment en enregistrant votre programme sous blink5.py

Le stick led est connectée sur :

• Stick 10 LEDs RGB Grove connecté à la broche GP16, repère D16 shield Grove.

Zoom

from machine import Pin

from neopixel import NeoPixel    # import de la bibliothèque NeoPixel

np = NeoPixel(Pin(16), 10)       # crée un objet np de 10 Néopixels connectés broche GP16 (repère D16 shield Grove)

np[0] = (255, 0, 0)              # affecte du rouge au 1er NeoPixel (adresse = 0)

np[1] = (0, 255, 0)              # affecte du verte au 2ème NeoPixel (adresse = 1)

np[2] = (0, 20, 0)               # affecte du vert pale au 3ème NeoPixel (adresse = 2)

np.write()                       # écriture des données vers les NeoPixels

Enregistrez votre programme sous blink3.py

from machine import Pin

from neopixel import NeoPixel    # import de la bibliothèque NeoPixel

np = NeoPixel(Pin(16), 10)       # crée un objet np de 8 Néopixels connectés broche GP16 (repère D16 shield Grove)

for x in range(2, 5):            # boucle pour x de 2 à 4 (2 compris, 5 non compris)

    np[x] = (0, 0, 20)           # affecte du bleu au NeoPixel d'adresse x

np.write()                       # écriture des données vers les NeoPixels

Enregistrez votre programme sous blink3blue.py

from machine import Pin

from neopixel import NeoPixel

from time import sleep_ms

from random import randint

np = NeoPixel(Pin(16), 10)

while True:

    # Pour chaque NeoPixel, de x = 0 à 9

    for x in range(0, 10):

        # intensité aléatoire entre 0-60 par canaux RVB 

        r = randint(0, 60)

        v = randint(0, 60)

        b = randint(0, 60)

        # Affecte le tuple (r, v, b) au NeoPixel

        np[x] = (r, v, b)

        # Envoi des données aux Neopixels

        np.write()

        sleep_ms(100)

Enregistrez votre programme sous blinkAleatoire.py

Bluetooth Low Energy, abrégé BLE, est une variante de la technologie sans fil Bluetooth développée avec comme caractéristique notable une économie d'énergie . Contrairement à Bluetooth Classic qui est toujours actif, BLE peut rester dans un état de sommeil quand il ne transmet pas de données. Cela le rend idéal pour une utilisation dans des appareils fonctionnant sur batterie tels que des montres intelligentes, des trackers de fitness et des dispositifs de surveillance de la sécurité.

Le Pico W fonctionne à la fois avec Bluetooth Classic et Bluetooth Low Energy

BLE a les topologies de communication suivantes:

• Point à Point: Communication entre deux nœuds(appareils) dans un réseau; communication serveur-client.

• Réseau Mesh Network: Plusieurs nœuds peuvent communiquer entre eux dans cette topologie.

• Mode Diffusion: Un serveur diffusera des données sur le réseau qui peuvent être lues par de nombreux appareils.

Pour cette application, nous allons configurer Raspberry Pi Pico dans le rôle périphérique et établir une communication point à point avec un appareil Android via Bluetooth Low Energy.

IL faut que vous ayez installé la dernière version de microPython UF2 pour le raspberry pico w sur votre microcontrôleur.

Pour pouvoir mettre en place la commande Bluetooth il faut tinstaller la bibiothèque supplémentaire suivante ;

ble_simple_peripheral.py

Premier Programme

Nous devrons enregistrer deux programmes MicroPython dans notre RPi Pico pour communiquer via Bluetooth Low Energy. Connectez votre Raspberry Pi Pico W à l'ordinateur à l'aide d'un câble USB. Ouvrez un nouveau programme dans Thonny IDE en allant sur Fichier puis Nouveau. Copiez le code ci-dessous.

# Helpers for generating BLE advertising payloads.

# A more fully-featured (and easier to use) version of this is implemented in

# aioble. This code is provided just as a basic example. See

# https://github.com/micropython/micropython-lib/tree/master/micropython/bluetooth/aioble

from micropython import const

import struct

import bluetooth

# Advertising payloads are repeated packets of the following form:

#   1 byte data length (N + 1)

#   1 byte type (see constants below)

#   N bytes type-specific data

_ADV_TYPE_FLAGS = const(0x01)

_ADV_TYPE_NAME = const(0x09)

_ADV_TYPE_UUID16_COMPLETE = const(0x3)

_ADV_TYPE_UUID32_COMPLETE = const(0x5)

_ADV_TYPE_UUID128_COMPLETE = const(0x7)

_ADV_TYPE_UUID16_MORE = const(0x2)

_ADV_TYPE_UUID32_MORE = const(0x4)

_ADV_TYPE_UUID128_MORE = const(0x6)

_ADV_TYPE_APPEARANCE = const(0x19)

_ADV_MAX_PAYLOAD = const(31)

# Generate a payload to be passed to gap_advertise(adv_data=...).

def advertising_payload(limited_disc=False, br_edr=False, name=None, services=None, appearance=0):

    payload = bytearray()

    def _append(adv_type, value):

        nonlocal payload

        payload += struct.pack("BB", len(value) + 1, adv_type) + value

    _append(

        _ADV_TYPE_FLAGS,

        struct.pack("B", (0x01 if limited_disc else 0x02) + (0x18 if br_edr else 0x04)),

    )

    if name:

        _append(_ADV_TYPE_NAME, name)

    if services:

        for uuid in services:

            b = bytes(uuid)

            if len(b) == 2:

                _append(_ADV_TYPE_UUID16_COMPLETE, b)

            elif len(b) == 4:

                _append(_ADV_TYPE_UUID32_COMPLETE, b)

            elif len(b) == 16:

                _append(_ADV_TYPE_UUID128_COMPLETE, b)

    # See org.bluetooth.characteristic.gap.appearance.xml

    if appearance:

        _append(_ADV_TYPE_APPEARANCE, struct.pack("<h", appearance))

    if len(payload) > _ADV_MAX_PAYLOAD:

        raise ValueError("advertising payload too large")

    return payload

def decode_field(payload, adv_type):

    i = 0

    result = []

    while i + 1 < len(payload):

        if payload[i + 1] == adv_type:

            result.append(payload[i + 2 : i + payload[i] + 1])

        i += 1 + payload[i]

    return result

def decode_name(payload):

    n = decode_field(payload, _ADV_TYPE_NAME)

    return str(n[0], "utf-8") if n else ""

def decode_services(payload):

    services = []

    for u in decode_field(payload, _ADV_TYPE_UUID16_COMPLETE):

        services.append(bluetooth.UUID(struct.unpack("<h", u)[0]))

    for u in decode_field(payload, _ADV_TYPE_UUID32_COMPLETE):

        services.append(bluetooth.UUID(struct.unpack("<d", u)[0]))

    for u in decode_field(payload, _ADV_TYPE_UUID128_COMPLETE):

        services.append(bluetooth.UUID(u))

    return services

def demo():

    payload = advertising_payload(

        name="micropython",

        services=[bluetooth.UUID(0x181A), bluetooth.UUID("6E400001-B5A3-F393-E0A9-E50E24DCCA9E")],

    )

    print(payload)

    print(decode_name(payload))

    print(decode_services(payload))

if __name__ == "__main__":

    demo()

Clique sur Fichier enregistrer sous puis sélectionnez ton raspberry pico

Zoom

Donnez le nom du fichier ble_advertising.py et presse OK.

Deuxième Programme

Répétez la procédure et enregistrez le code ci-dessous en le nommantble_simple_périphérique.py sur votre Pico W.

ATTENTION :

Bien lire les lignes 41 à 46

# This example demonstrates a UART periperhal.

# This example demonstrates the low-level bluetooth module. For most

# applications, we recommend using the higher-level aioble library which takes

# care of all IRQ handling and connection management. See

# https://github.com/micropython/micropython-lib/tree/master/micropython/bluetooth/aioble

import bluetooth

import random

import struct

import time

from ble_advertising import advertising_payload

from micropython import const

_IRQ_CENTRAL_CONNECT = const(1)

_IRQ_CENTRAL_DISCONNECT = const(2)

_IRQ_GATTS_WRITE = const(3)

_FLAG_READ = const(0x0002)

_FLAG_WRITE_NO_RESPONSE = const(0x0004)

_FLAG_WRITE = const(0x0008)

_FLAG_NOTIFY = const(0x0010)

_UART_UUID = bluetooth.UUID("6E400001-B5A3-F393-E0A9-E50E24DCCA9E")

_UART_TX = (

    bluetooth.UUID("6E400003-B5A3-F393-E0A9-E50E24DCCA9E"),

    _FLAG_READ | _FLAG_NOTIFY,

)

_UART_RX = (

    bluetooth.UUID("6E400002-B5A3-F393-E0A9-E50E24DCCA9E"),

    _FLAG_WRITE | _FLAG_WRITE_NO_RESPONSE,

)

_UART_SERVICE = (

    _UART_UUID,

    (_UART_TX, _UART_RX),

)

class BLESimplePeripheral:

		# dans le ligne suivante remplacez mpy-uart par vos deux noms limité aux quatre premières lettres

		# par exemple vos noms et prénoms sont Léonard de Vinci et Arsène Lupin

		# donc vos noms respectifs sont Vinci et Lupin limité aux quatre premières lettres

		# écrites en minuscules 

		# il faudra donc remplacer name="mpy-uart" par

		# name="vinc-lupi"

    def __init__(self, ble, name="mpy-uart"):

        self._ble = ble

        self._ble.active(True)

        self._ble.irq(self._irq)

        ((self._handle_tx, self._handle_rx),) = self._ble.gatts_register_services((_UART_SERVICE,))

        self._connections = set()

        self._write_callback = None

        self._payload = advertising_payload(name=name, services=[_UART_UUID])

        self._advertise()

    def _irq(self, event, data):

        # Track connections so we can send notifications.

        if event == _IRQ_CENTRAL_CONNECT:

            conn_handle, _, _ = data

            print("New connection", conn_handle)

            self._connections.add(conn_handle)

        elif event == _IRQ_CENTRAL_DISCONNECT:

            conn_handle, _, _ = data

            print("Disconnected", conn_handle)

            self._connections.remove(conn_handle)

            # Start advertising again to allow a new connection.

            self._advertise()

        elif event == _IRQ_GATTS_WRITE:

            conn_handle, value_handle = data

            value = self._ble.gatts_read(value_handle)

            if value_handle == self._handle_rx and self._write_callback:

                self._write_callback(value)

    def send(self, data):

        for conn_handle in self._connections:

            self._ble.gatts_notify(conn_handle, self._handle_tx, data)

    def is_connected(self):

        return len(self._connections) > 0

    def _advertise(self, interval_us=500000):

        print("Starting advertising")

        self._ble.gap_advertise(interval_us, adv_data=self._payload)

    def on_write(self, callback):

        self._write_callback = callback

def demo():

    ble = bluetooth.BLE()

    p = BLESimplePeripheral(ble)

    def on_rx(v):

        print("RX", v)

    p.on_write(on_rx)

    i = 0

    while True:

        if p.is_connected():

            # Short burst of queued notifications.

            for _ in range(3):

                data = str(i) + "_"

                print("TX", data)

                p.send(data)

                i += 1

        time.sleep_ms(100)

if __name__ == "__main__":

    demo()

Maintenant, collez le code suivant dans un nouveau projet sur Thonny IDE.

# Import necessary modules

from machine import Pin 

import bluetooth

from ble_simple_peripheral import BLESimplePeripheral

# Create a Bluetooth Low Energy (BLE) object

ble = bluetooth.BLE()

# Create an instance of the BLESimplePeripheral class with the BLE object

sp = BLESimplePeripheral(ble)

# Create a Pin object for the onboard LED, configure it as an output

led = Pin("LED", Pin.OUT)

# Initialize the LED state to 0 (off)

led_state = 0

# Define a callback function to handle received data

def on_rx(data):

    print("Data received: ", data)  # Print the received data

    global led_state  # Access the global variable led_state

    if data == b'toggle\r\n':  # Check if the received data is "toggle"

        led.value(not led_state)  # Toggle the LED state (on/off)

        led_state = 1 - led_state  # Update the LED state

# Start an infinite loop

while True:

    if sp.is_connected():  # Check if a BLE connection is established

        sp.on_write(on_rx)  # Set the callback function for data reception

Exécutez votre code en appuyant sur F5 ou en l'icône verte. Enregistrez le sur votre Raspberry Pi Pico. Nommez ce programme main.py. Il s'exécutera automatiquement lorsque Pico W redémarrera.

Lorsque le script s'exécute, vous verrez le texte “ Starting advertising ” affiché sur la console.

• Pour Android

Installer l'application Terminal Bluetooth série du Play Store qui est disponible gratuitement.

Ouvrez l'application et dans le menu de navigation, cliquez sur Devices.

Faites un Scan sur les réseaux Bluetooth low energy

DAns les options sélectionnez « Show manufacturer data »

Il faut que la géolocalisation soit activée

• Pour iphone l'application Bluetooth Terminal semble convenir

Zoom

Sélectionnez le Bluetooth LE puis appuyez sur SCAN. Vous devez maintenant voir votre appareil répertorié comme vinc-lupi. Sélectionnez le nom de l'appareil pour vous y connecter.

Zoom

Lorsque la connexion est établie, vous pouvez voir le message “Connected” sur l'application Android. La console dans Thonny IDE affichera également le texte “Nouvelle connexion 64”

Zoom

Sur l'application Android, tapez “toggle” sans les guillemets et appuyez sur l'icône d'envoi.

Zoom

La LED embarquée sur Raspberry Pi Pico W doit changer d'état de OFF à ON. L'envoi de la commande à nouveau va basculer son état de ON à OFF.