PRÉSENTATION ET CONFIGURATION DES CARTES DE TYPE RASPBERRY PI PICO UTILISÉES POUR L’EXPÉRIMENTATION

Pour leur programmation, toutes les cartes sont munies d'un port USB (USBC ou micro-USB) qui permet de les relier par câble à un ordinateur hôte.
Il faut faire attention au choix du câble : ne pas choisir un câble de charge uniquement et veiller à ce qu'il soit d'un seul tenant (sans adaptateur supplémentaire).
Attention aussi à bien choisir le port USB sur l'hôte car c'est le protocole USB 1.1 qui permet l'échange entre la carte microcontrôleur et l'hôte. Un port USBC sur l'hôte ne permet pas l'échange.

1.1 Pico

Introduction

La Raspberry Pi Pico est une carte microcontrôleur basée sur la puce de microcontrôleur Raspberry Pi RP2040. Il a été conçu pour être une carte de microcontrôleur à faible coût et à haute performance avec des interfaces numériques flexibles. Le Raspberry Pi Pico dispose de deux Cortex-M0 ARM + cœurs fonctionnant jusqu'à 133MHz, 256 Ko de RAM, 30 broches GPIO et une large gamme d'options d'interfaçage. Ceci est associé à 2 Mo de mémoire flash QSPI embarquée pour le stockage de code et de données.
En plus de ressources matérielles puissantes, Pico dispose d'un support logiciel riche et complet et de ressources communautaires. Il est programmable notamment avec MicroPython SDK.

Spécification

Puce de microcontrôleur RP2040 conçue par Raspberry Pi au Royaume-Uni
Processeur Arm Cortex M0 + à double cœur, horloge flexible fonctionnant jusqu'à 133 MHz
264 Ko de SRAM et 2 Mo de mémoire Flash embarquée
USB 1.1 avec support de l'appareil et de l'hôte
Modes veille et dormant à faible puissance
Programmation par glisser-déposer utilisant le stockage de masse sur USB
26 × broches GPIO multifonctions
2 × SPI, 2 × I2C, 2 × UART, 3 × 12 bits ADC, 16 × canaux PWM contrôlables
Horloge précise et minuterie sur puce
Capteur de température
Bibliothèques à virgule flottante accélérée sur puce
8 machines d'état programmables d'E/S (PIO)

1.2 Pico2W

Par facilité pour le développement expérimental, une version avec broches de couleur a été choisie.
La carte est munie d'une prise micro-usb.

CARACTÉRISTIQUES

La carte microcontrôleur Raspberry Pi Pico2W est fondée sur la puce RP2350 et prend en charge le WIFI et le Bluetooth.
Raspberry Pi Pico2W est une carte microcontrôleur haute performance avec des interfaces numériques flexibles. C'est une amélioration de Raspberry Pi Pico 2 avec communication sans fil, antenne intégrée, doté de WIFI 802.11n 2,4 GHz et Bluetooth 5.2.
Elle adopte une conception double cœur et double architecture : processeur Arm Cortex-M33 dual-core et processeur Hazard3 RISC-V dual-core, horloge flexible fonctionnant jusqu'à 150 MHz
Puce sans fil Infineon CYW43439 intégrée, prend en charge le sans fil WIFI 4 et Bluetooth 5.2
520 Ko de SRAM et 4 Mo de mémoire Flash intégrée
Le module utilisé est muni de broches pratiques pour le développement
C'est le protocole USB 1.1 qui permet l'échange entre l'appareil et l'hôte
Modes veille et veille à faible consommation
Programmation glisser-déposer à l'aide du stockage de masse via USB
26 × broches GPIO multifonction
2 × SPI, 2 × I2C, 2 × UART, 3 × ADC 12 bits, 16 × canaux PWM contrôlables
Capteur de température
12 × machines d'état d'E/S programmables (PIO) pour une prise en charge de périphériques personnalisés

1.3 RT2350-PLUS - 16MB

Cette carte est inspirée du Raspberry Pi Pico, construite autour du microcontrôleur double cœur Raspberry Pi RP2350A. Elle intègre le même processeur Arm Cortex-M33 double cœur et un processeur Hazard 3 RISC-V double cœur, avec des fréquences d'horloge allant jusqu'à 150 MHz. La carte intègre 520Ko de SRAM et 16Mo (option de la carte ici) de mémoire Flash intégrée, ce qui vous offre de nombreuses ressources pour divers projets. Cette carte permet d'améliorer ou d'ajouter des fonctionnalités supplémentaires.

Pour l'alimentation, un connecteur USB Type-C est disponible. L'une des fonctionnalités supplémentaires absentes du Pico 2 est un connecteur de recharge/décharge de batterie au lithium, très utile pour un projet mobile ! La puce MP28164 DC-DC est un convertisseur abaisseur-élévateur haute efficacité à faible courant de repos, capable de fournir un courant de charge maximal de 2 A. La carte est compatible avec la plupart des modules complémentaires Raspberry Pi Pico.

Avec ses 26 broches GPIO multifonctions, cette carte offre une grande flexibilité pour diverses configurations. Elle prend en charge plusieurs interfaces, dont 2 SPI, 2 I2C, 2 UART, 4 canaux ADC 12 bits et 16 canaux PWM contrôlables. Elle est compatible avec C/C++ et MicroPython. Elle dispose d'un SDK complet, de ressources de développement et de tutoriels pour vous aider à démarrer !

PROPRIÉTÉS

Elle adopte le microcontrôleur RP2350A conçu par Raspberry Pi au Royaume-Uni.
Elle adopte une conception unique à double cœur et double architecture, équipé d'un processeur ARM Cortex-M33 double cœur et d'un processeur Hazard3 RISC-V double cœur, avec des fréquences d'horloge allant jusqu'à 150 MHz.
Elle intègre 520Ko de SRAM et 16Mo de mémoire Flash.
En utilisant une interface Type-C, elle s'adapte aux tendances actuelles. Cela évite les enchevêtrements de câbles avant et arrière.
Elle intègre un connecteur de recharge/décharge de batterie au lithium, facilitant l'utilisation mobile.
Elle intègre une puce DC-DC MP28164. C'est une puce abaisseur-élévateur DC-DC haute efficacité avec un courant de charge allant jusqu'à 2 A.
Prise en charge de l'USB 1.1 hôte et périphérique.
Prise en charge des modes veille et hibernation basse consommation.
Téléchargements par glisser-déposer possibles grâce à la reconnaissance USB comme stockage de masse.
26 broches GPIO multifonctions.
Plusieurs périphériques matériels
- SPI × 2
- I2C × 2
- UART × 2
- CAN 12 bits × 4 (Convertisseur Analogique Numérique)
- Canal PWM contrôlable × 16
Horloge et temporisateur précis intégrés
Capteur de température
Bibliothèques de calcul en virgule flottante accélérées intégrées
12 machines d'état d'E/S programmables (PIO) pour la prise en charge de périphériques personnalisés

COMPOSANTS

LED utilisateur (Ce n'est pas un indicateur d'alimentation)
Connecteur USB Type-C
ETA6096 : Gestionnaire de recharge de batterie lithium haute efficacité
MP28164 : Puce abaisseur-élévateur CC-CC haute efficacité
Bouton de démarrage : il faut appuyer dessus lors de la réinitialisation pour accéder au mode téléchargement
Mémoire flash intégrée : 4 Mo ou 16 Mo (en option) : W25Q32JVSSIQ
Bouton de réinitialisation
RP2350A : Double cœur et conception architecturale duale, fréquence de fonctionnement jusqu'à 150MHz
Connecteur de batterie : Connecteur MX1.25, pour batterie lithium 3.7V, permettant de recharger la batterie et d'alimenter la carte simultanément
Brochage : Compatible avec Raspberry Pi Pico 2
Points de test USB : Connexion à l'interface USB
Point de test de démarrage : Connexion au bouton de démarrage
Points de débogage

Le bouton de démarrage (5) a le même usage que le bouton BOOTSEL des cartes de type "Pico".
Le bouton de réinitialisation (7) n'existe pas sur les cartes de type "Pico". Il permet d'interrompre le programme en cours d'exécution et de relancer le programme main.py.

2 Installation du logiciel MicroPython

L'installation des logiciels est semblable pour toutes les cartes microcontrôleur utilisées. On présente ci-après l'installation de MicroPython sur la carte Pico2W

La première étape est d'installer MicroPython sur la carte Pico2W via le câble USB.

La dernière version du micrologiciel MicroPython (exemple : mp_firmware_unofficial_latest.uf2 ) spécifique de Pico2W doit être téléchargée, par exemple à partir de l’URL https://www.raspberrypi.com/documentation/microcontrollers/micropython.html#drag-and-drop-micropython.

La carte Pico2W dispose d'un mode BOOTSEL pour la programmation du micrologiciel MicroPython via le port USB.

On s’assure d'abord que la carte Pico2W n'est branchée à aucune source d'alimentation : le cas échéant, on débranche le câble micro-USB et tous les autres fils qui pourraient alimenter la carte, par exemple via la broche VSYS ou VBUS.
On branche une extrémité d’un câble USB adéquat (par exemple USBA) sur l’ordinateur hôte.
Ensuite, tout en maintenant le bouton BOOTSEL de la carte Pico2W enfoncé, on branche l’autre extrémité (connecteur micro-USB) du câble USB sur la carte Pico2W. On peut ensuite relâcher le bouton BOOTSEL
Un lecteur appelé RP2350 devrait apparaître.
On glisse le fichier MicroPython mp_firmware_unofficial_latest.uf2 sur ce lecteur. Cela programme le micrologiciel MicroPython sur la mémoire flash du Pico2W.
Quelques instants plus tard, le lecteur RP2350 disparaît et le Pico2W exécute ce fichier.

Le micrologiciel MicroPython est équipé d'un port série USB virtuel auquel on accède via le connecteur micro-USB sur le Pico2W. L’ordinateur auquel est connecté le Pico2W devrait remarquer ce port série et le répertorier comme périphérique de caractères, sous le nom /dev/ttyACM0 suite au lancement dans un terminal de l’instruction
ls /dev/tty*
Toujours à partir du terminal, on peut installer minicom, si ce n’est déjà fait :
sudo apt install minicom
et on peut l’ouvrir par l’instruction
minicom -o -D /dev/ttyACM0
Le prompt >>> doit apparaître. MicroPython attend qu’on saisisse une instruction à interpréter.

La LED intégrée sur le Pico2W est connectée à la broche GP25 mais on peut utiliser la chaîne « LED ». On peut l’allumer et l'éteindre.
On peut ainsi saisir successivement au prompt minicom :
>>> from machine import Pin
>>> led = Pin("LED", Pin.OUT)

Le module machine est utilisé pour contrôler le matériel sur la carte. Il s'agit d'un standard sur tous les ports MicroPython. Ici, on l’utilise pour prendre le contrôle d'un GPIO, afin de pouvoir le piloter en mode HAUT et BAS.

Si on saisit ceci :
>>> led.value(1)
La LED doit s'allumer. On peut l'éteindre à nouveau avec
>>> led.value(0)

3 Environnement de développement THONNY

Porter MicroPython vers les appareils comme la carte Pico2W élaborée autour d'un microcontrôleur de la série RP fonctionne avec les environnements de développement couramment utilisés comme THONNY.

On peut installer THONNY sur l’ordinateur hôte par l’instruction suivante dans un terminal :

sudo apt install thonny

Cela ajoutera une icône THONNY au menu du bureau de l’ordinateur hôte.

Lorsqu’on ouvre THONNY pour la première fois, il faut s’assurer que le Pico2W est branché sur le bon interpréteur. Par défaut, l'interpréteur est la copie que Python exécute sur l’ordinateur hôte. Il doit donc être modifié pour exécuter les programmes en MicroPython sur le Pico2W.
Pour ce faire, il faut cliquer sur l’onglet « exécuter » - « Configurer l’interpréteur … » puis « Interpréteur » et dans le menu déroulant

« Which kind of interpreter …. », choisir « MicroPython (Raspberry Pi Pico) »
« Port », choisir « Board in FS mode – Board CDC (dev/ttyACM0) »

THONNY peut changer suivant l’ordinateur hôte qui peut être par exemple un Raspberry Pi 5, et la procédure peut être légèrement différence suivant la dénomination des onglets.

Dans le cas le plus simple, la fenêtre de Thonny est découpée en 2 parties : la partie inférieure pour l’interprétation ligne par ligne comme avec minicom, la partie supérieure permet d’écrire des programmes.

Par exemple, si on écrit dans la partie supérieure

from machine import Pin, Timer

led = Pin("LED", Pin.OUT)
tim = Timer()
def tick(timer):
global led
led.toggle()

tim.init(freq=2.5, mode=Timer.PERIODIC, callback=tick)

on peut exécuter directement le programme en cliquant sur la flèche blanche dans un cercle vert. La led clignote à la fréquence définie dans le programme. On peut arrêter le programme en cliquant sur le carré blanc dans un cercle rouge.
Il est possible d’enregistrer le programme dans la mémoire flash du Pico2W pour exécution immédiate ou ultérieure. Si on l’enregistre dans la mémoire flash du Pico2W sous le nom main.py, le programme sera exécuté dès la mise sous tension du Pico2W.

À partir des boutons, on devrait aussi pouvoir enregistrer le programme dans l’ordinateur hôte à des fin d’archivage, mais ça ne fonctionne pas, bien que cette option soit proposée. Il existe une solution de secours : utiliser l'onglet « Fichier », puis « Enregistrer sous ... » .

4 Pico2W - Bluetooth

On envisage ici de faire communiquer point à point par Bluetooth le pico2W avec un smartphone muni de l'application "Serial Bluetooth Terminal".

MicrPython se fonde ici sur 2 librairies

ble_advertising.py
Les advertisers (advertising payloads) émettent des trames qui contiennent des informations sous une forme bien précise (voir librairie).
ble_peripheral.py
Trouve un périphérique série UART et s'y connecte.

fournies par exemple par le lien https://electrocredible.com/raspberry-pi-pico-w-bluetooth-ble-micropython/ et enregistrées dans le répertoire "lib" du pico 2 W.

Cette référence fournit aussi en exemple un programme (ble_LED.py) pour maitriser la led de la carte pico 2 W, c'est-à-dire qu'à partir d'un smartphone, on peut allumer et éteindre la led de la carte pico 2 W.

Lorsque le programme tourne sur pico2W,

on lance l'application Serial Bluetooth Terminal sur le smartphone
en haut à gauche de "Terminal", on appuye sur les 3 petites lignes horizontales et on choisit le menu "Devices"
On choisit le mode de connexion "Bluetooth LE", puis on SCANne les périphériques disponibles en Bluetooth
Dans la liste qui apparait, on choisit "mpy-uart"
L'écran du "Terminal" réapparaît avec la mention "Connecting to mpy-uart" et peu après apparaît "connected"
Alors le "Terminal" attend qu'on envoie en dessous le mot clé "toggle" défini dans le programme pour changer à chaque fois le statut de la led.

5 Pico2W - WiFi

Le module de communication WiFi permet d'utiliser le pico2W en 2 modes différents :

Terminal WiFi sur réseau local
Serveur WiFi (Point d’Accès) indépendant du réseau local

Les deux modes sont déclarés et utilisés de façon identique, seuls quelques mots-clés diffèrent. La communication de fait en trois grandes étapes :

Définition du réseau (Création ou intégration) - Importation de la classe MicroPython "network".
Cette étape conduit à la définition de l'adresse IP du Pico2W et à son établissement dans le réseau.
La deuxième étape définit le noeud de communication - Importation de la classe MicroPython "socket".
Cette étape établit les conditions de la communication : création d'une instance de noeud, port de communication, nombre de connexions possibles.
La troisième étape concerne la communication elle-même : dans une boucle infinie, attente d'une demande de communication client à partir d'un navigateur, acceptation de la communication, transmission de la demande du client, traitement de la demande, réponse éventuelle du Pico2W.

Les détails sont donnés ci-après.

5.1 Pico2W - Terminal WiFi sur réseau local

5.1.1 Insertion de la carte Pico2W comme terminal WiFi dans le réseau local

Le programme BOX_connect_reseau.py donne les différentes étapes.
La LED utilisateur intégrée au Pico2W permet de concrétiser ces différentes étapes.

Création d'une interface "terminal WiFi" :
wlan=network.WLAN(network.STA_IF) # Le mot clé STA_IF = STAtion Interface
Activation du terminal :
wlan.active(True)
Requète de connexion du terminal à la box du réseau local (nécessité de transmettre le nom de la box avec son mot de passe) :
wlan.connect(ssid='Livebox-xxxx',key='blablabla')
Attente de connexion :
while not wlan.isconnected(): pass
Transmission par la box de l'adresse IPv4 attribuée par la box au terminal Pico2W :
ip = wlan.ifconfig()[0]
Le protocole IPv4 est le plus courant. Cette adresse permettra plus tard la liaison entre le terminal et un navigateur sur une machine quelconque.

5.1.2 Suite de la configuration du Pico2W comme terminal du réseau local : nœud IPv4

La programmation par nœud (sockets = prise ou nœud) permet de connecter deux nœuds d'un réseau pour communiquer entre eux. Un nœud écoute sur un port spécifique d'une adresse IP. Le serveur forme le nœud d'écoute tandis que le client établit la connexion avec le serveur.

Création du nœud :
s = socket.socket() # arguments par défaut - équivalent à "s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)"
- AF_INET fait référence à la famille d'adresses IPv4.
- SOCK_STREAM désigne le protocole TCP orienté connexion.
Le nœud possède plusieurs ports :
s.bind(('', 80)) # associe la prise au port indiqué - Ici 80 (traditionnel)
On autorise ensuite le nœud à accepter un certain nombre de connexions (maximum 5):
s.listen(5)

On peut maintenant se connecter au serveur (box) via ce nœud (socket ou prise).

5.1.3 Exemples

5.1.3.1 Hello World

Le programme BOX_connect_HelloWorld.py est le premier exemple bien simple.

Séquences de configuration (wlan et socket).
Définition d'une page web en html
Boucle gérant chaque requète extérieure au terminal, avec les points suivants :
- Acceptation de la demande de connexion et ouverture de la connexion
- Réception de données précisant la demande
- Envoi de données correspondant à la demande, par exemple le site web avec "HelloWorld"
- Fermeture de la connexion

5.1.3.2 Exemples de commande de processus par le web

Les programmes BOX_connect_LED.py et BOX_web_control_test.py sont des exemples qui permettent de commander, par une page web, un processus lié au serveur.
Dans le premier exemple, on utilise des boutons et dans le second exemple, une disposition spatiale qui ressemble beaucoup à celle utilisée par la classe Python - Bluedot dans la commande du véhicule autonôme, non présente dans MicroPython et qui en constitue donc une alternative.

Séquences de configuration (wlan et socket).
Définition sous forme de fonctions MicroPython des processus à exécuter

Définition d'une page web interactive en html, ici pour le second exemple

Emploi de formulaires : (balise form) qui conduisent à une action (définie sous l'attribut action) lorsque qu'une entrée est sollicitée.
Cinq actions sont prévues ici : avant, gauche, stop, droite, arriere.
Ces entrées sont décrites sous la balise input dépendant de form. Pratiquement, chaque entrée est constituée ici d'un carré de dimensions données et contenant un texte qui rappelle l'action à effectuer lorsqu'on clique dans le carré : Avant, Gauche, STOP, Droite, Arrière.

Chaque requète extérieure au terminal est gérée par la fonction serve(), avec les points suivants :
- Acceptation de la demande de connexion et ouverture de la connexion
- Réception de données précisant la demande et qui contient donc, entre autres, le texte de l'action à effectuer
  - Isolation du texte de l'action à effectuer
  - Appel à la fonction MicroPython en adéquation avec la requète de l'action à effectuer
- Envoi de données, ici le site web
- Fermeture de la connexion

L'explorateur peut être lancé sur un smartphone Android. Dans ce cas, le résultat ressemble fort à celui qu'on peut obtenir avec BlueDot sous python3. BlueDot n'est pas disponible sous MicroPython.

5.2 Pico2W - Serveur WiFi (Point d’Accès) indépendant du réseau local

5.2.1 Serveur indépendant du réseau local

On peut utiliser le Pico2W pour créer un réseau sans fil personnel auquel d'autres appareils peuvent se connecter.
C'est le mode AP (AP = Access Point).

Voici quelques exemples d'utilisation du mode AP sur le Pico2W :

Héberger un serveur Web simple, qui peut être utilisé pour afficher des informations ou contrôler d'autres appareils.
Contrôler d'autres appareils sur le réseau, par exemple, une ampoule ou un moteur.
Partage de fichiers avec d'autres appareils sur le réseau.
Création d'un réseau temporaire à des fins de débogage ou de test.

5.2.2 Configuration

Voici les étapes de la configuration du Pico2W comme serveur web indépendant du réseau local, donc pour agir comme un point d'accès.
La première partie est montrée dans le programme AP_connect_reseau.py mais toutes les parties sont rassemblées dans le programme AP_connect_HelloWorld.py
Cet exemple simple permet essentiellement aux clients de se connecter au Pico2W.
Lorsqu'un client s'y connecte, il reçoit une simple page HTML en guise de réponse.

Le code commence par importer les modules requis : réseau, heure et socket.

Il existe une fonction définie appelée web_page(), qui renvoie une chaîne HTML. C'est ce que le serveur Web créé affichera une fois que le serveur sera visité à partir d'un périphérique externe. Il peut être personnalisé.

Une série de commandes MicroPython est responsable de l'activation du mode point d'accès (AP) sur un périphérique et de la création du serveur Web sur le Pico2W.

Un objet point d'accès (ap) est créé à l'aide de

ap = network.WLAN(network.AP_IF)

Associés à cet objet, 2 paramètres importants sont à choisir : ssid (le nom de la connexion Internet) et password (mot de passe pour la connexion Internet - Au moins 8 caractères) :

ap.config(essid='pico2w',password='Bizarre_1234')

Pour l’afficher sur d’autres appareils, le point d’accès doit être activé par

ap.active(True)

Le code entre dans une boucle while et attend que le point d’accès devienne actif. Cette boucle ne s'exécute généralement jamais car le mode AP s'active rapidement.

Une fois le point d’accès actif, il affiche un message indiquant que le mode AP est actif et fournit l'adresse IP à laquelle se connecter. Mais il faut plus d’informations pour la suite.

print(ap.ifconfig())

permet d’btenir les paramètres de l'interface réseau au niveau IP : adresse IP, masque de sous-réseau, passerelle et serveur DNS.

Ici, on obtient : (‘192.168.4.1’,’255.255.255.0’,’192.168.4.1’,’0.0.0.0’)

Le reste du code est un code client-serveur très simple.

https://fr.wikipedia.org/wiki/Socket

Le composant de base de la plupart des connexions Internet est le socket, mot anglais qui signifie prise. Dans le contexte des logiciels, on peut le traduire par connecteur réseau ou interface de connexion. Ces sockets fournissent un flux fiable d'octets entre les périphériques réseau connectés.

La communication par socket est souvent comparée aux communications humaines. On distingue ainsi deux modes de communication :

le mode connecté (comparable à une communication téléphonique), utilisant le protocole TCP. Dans ce mode de communication, une connexion durable est établie entre les deux processus, de telle façon que l’adresse de destination n’est pas nécessaire à chaque envoi de données;
le mode non connecté (analogue à une communication par courrier), utilisant le protocole UDP. Ce mode nécessite l’adresse de destination à chaque envoi, et aucun accusé de réception n’est donné.

Un objet socket s est créé à l'aide de

s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

AF_INET est une famille d'adresses qui est utilisée pour désigner le type d'adresses avec lesquelles le socket peut communiquer (dans ce cas, les adresses Internet Protocol v4). Lorsqu'on crée un socket, il faut spécifier sa famille d'adresses, et on ne peut ensuite utiliser que des adresses de ce type avec le socket. Le noyau Linux, par exemple, prend en charge 29 autres familles d'adresses telles que les sockets UNIX (AF_UNIX) et IPX (AF_IPX), ainsi que les communications avec IRDA et Bluetooth (AF_IRDA et AF_BLUETOOTH, mais il est peu probable qu'on les utilise à un niveau aussi bas).

Dans la plupart des cas, s'en tenir à AF_INET pour la programmation de sockets sur un réseau est l'option la plus sûre. Il existe également AF_INET6 pour les adresses Internet Protocol v6.

SOCK_STREAM signifie qu’il s’agit d’un socket de type TCP.

Le socket est lié au port général 80 avec

s.bind(('', 80))

Un port est comme un numéro de téléphone.

Le socket commence à écouter les connexions entrantes avec

s.listen(5)

Jusqu'à 5 appareils peuvent être connectés en mode AP.

Le code entre dans une autre boucle while pour gérer en continu les connexions entrantes. Cela fonctionnera indéfiniment jusqu'à ce que le code soit arrêté ou le Pico W débranché.

conn, addr = s.accept()

Accepte une connexion. Le socket doit être lié à une adresse et écouter les connexions. La valeur de retour est une paire (conn, address) où "conn" est un nouvel objet socket utilisable pour envoyer et recevoir des données sur la connexion, et "address" est l'adresse liée au socket à l'autre extrémité de la connexion.

Lorsqu'une connexion est reçue, elle imprime l'adresse du client.

La demande reçue du client est stockée dans la variable de demande à l'aide de

request = conn.recv(1024)

socket.recv(bufsize[, flags]) reçoit des données depuis le socket. La valeur de retour est un objet bytes représentant les données reçues. La quantité maximale de données à recevoir en une fois est spécifiée par bufsize. Un objet bytes vide renvoyé indique que le client s'est déconnecté. Consultez la page de manuel Unix recv(2) pour connaître la signification des arguments optionnels flags ; la valeur par défaut est zéro.

response = web_page()

La fonction web_page() est appelée pour générer une réponse HTML, qui est stockée dans la variable de response.

La réponse est envoyée au client à l'aide de

conn.send(response)

D’autres réponses sont générées et envoyées au client. Elles sont simplement affichées à la suite l’une de l’autre sur l’écran du client. Les sauts de ligne ne sont pas encore maîtrisés.

La connexion est fermée avec

conn.close()

5.2.3 Exemples

5.2.3.1 Exemple simple utilisé pour illustrer la configuration en mode AP

À titre d'exemple, prenons le programme MicoPython AP_connect_HelloWorld.py

On lance le programme sur le Pico2W créant ainsi un serveur web d'adresse 192.168.4.1.
Pour s'y connecter à partir par exemple d'un ordinateur portable, il faut d'abord activer le WiFi
Puis dans les paramètres, choisir l'essid défini dans le programme (pico2w)
Il demandera le mot de passe (TryphonT)

NOTE : Sur mon smartphone, il faut d'abord supprimer les "Données mobiles"

5.2.3.2 Exemple plus étendu

Soit le programme AP_connect_bienvenue.py

Dans ce programme, la page web est un peu plus développée et les envois ( conn.send(response) ) sont divers :

la page web, bien sûr
un simple texte ("Résultat d'un calcul")
une variable numérique (A = 2+5) d'abord transformée en chaîne de caractères

La mise en ligne est identique à celle de l'exemple simple.

5.2.3.3 Exemples de commande de processus par le web

Soit les programmes AP_connect_LED.py et AP_web_control_test.py semblables aux programmes ci-dessus.

Dans ce dernier programme, la page web utilise des formulaires liés à des actions. Ces actions sont définies par des fonctions MicroPython.
La mise en ligne est identique à celle de l'exemple simple.
Sur la page web, apparaissent des carrés avec des actions prédéfinies qui sont déclenchées en cliquant dessus.