COMMUNICATION SANS FIL

La communication sans fil de type WiFi ou encore Bluetooth doit surtout permettre l'échange de données entre cartes Raspberry Pi ou entre cartes Raspberry Pi et autres appareils comme un PC ou un Smartphone.

1. Communication sur réseau local existant

1.1. Échange entre PC et Raspberry Pi 4B (RasPi4B) sur réseau local

Dans un premier exemple, le RasPi4B qui va envoyer des données au PC qui va accuser réception : (Programmes python3: PC_Client_Box.py et RasPi4B_Client_Box.py.

La mise en œuvre de python3 pour l'échange de données se fonde sur la classe socket. La classe principale, socket.socket, permet de créer des objets socket, qui servent de points d'entrée pour la communication réseau (par exemple, pour créer un serveur TCP ou un client TCP).

Liens :

• https://docs.python.org/fr/3.13/howto/sockets.html
• https://docs.python.org/3/library/socket.html

• recv() : Réception des données du socket
  La valeur de retour est un objet bytes (octets) représentant les données reçues. La quantité maximale de données à recevoir simultanément est spécifiée par bufsize. Un objet bytes vide renvoyé indique que le client est déconnecté.
• encode(), decode() ( https://www.geeksforgeeks.org/python/python-strings-encode-method/ ) :
  La méthode encode() en Python 3 est utilisée pour convertir une chaîne de caractères (string) en une séquence d'octets (bytes) selon un encodage spécifié.
  Elle est essentielle lorsque l'on doit préparer des données pour le stockage, la transmission ou le traitement dans des formats binaires. Ici, les données s'échangent sous forme de bytes et non d'une chaîne de caractères.
  Supposons un message texte à envoyer. On utilise encode() sur la chaîne pour la transformer en format bytes. Par défaut, encode() utilise l'encodage UTF-8, équivalent à encode("utf-8").
• La ligne serveur / client doit est fermée.
  Cette fermeture est assez délicate. En effet, une fermeture mal faite conduit à des erreurs rendant très difficile la communication. C'est pourquoi, on a utilisé la formulation
  with socket.socket() as s:
  qui permet d'assurer une fermeture correcte ( https://www.pythonlore.com/closing-and-releasing-resources-with-socket-close/ )

AU NIVEAU DU PC :
Dans un terminal démarré à partir du répertoire contenant le programme PC_Client_Box.py, on va le lancer par
sudo python3 PC_Client_Box.py
Le PC joue le rôle de serveur, c'est-à-dire qu'il va attendre une demande de connexion d'un appareil extérieur, demande qu'il va accepter en révélant qui s'est connecté (adresse IP du RasPi4B), puis va recevoir des données et envoyer un accusé de réception

1.2. Raspberry Pi Pico2W comme client sur réseau local

1.2.1. Insertion du Pico2W dans le réseau local par WiFi

• connecter le Pico2W à un ordinateur hôte pour sa programmation
• sur cet ordinateur hôte, démarrer l'éditeur Thonny et le configurer en programmation du Pico2W
• charger le programme micropython Pico2W_IP_Box.py dans l'éditeur de Thonny. En voici les 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.
• lancer le programme

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

1.2.3. Échange entre PC et Pico2W sur réseau local

On va s'intéresser aux 2 programmes python3 et micropython : PC_Client_Box.py et Pico2W_Client_Box.py.

Le programme PC_Client_Box.py de l'exemple précédent est en principe valable ici aussi.

• La première partie est l'insertion du Pico2W dans le réseau WiFi comme dans le programme Pico2W_IP_Box.py
• La seconde partie est en principe la même que la procédure d'échange du programme RasPi4B_Client_Box.py

1.3. Carte Pico2W comme Terminal WiFi sur réseau local hébergeant un site web

1.3.1. Site Web simple "Hello World"

Tout comme le programme Pico2W_Client_Box.py, le programme Pico2W_SiteWEB.py est décomposé en 2 parties.
La partie 1, c'est-à-dire l'insertion dans le réseau du Pico2W est identique.
Au début de la partie 2, le Pico2W est configuré comme serveur, attendant que des clients demandent une connexion.

• On lance le programme sur le Pico2W récupérant ainsi son adresse IP sur le réseau local, par exemple 192.168.1.34.
  Il faut retenir cette adresse car elle sera toujours attribuée par le routeur dans le réseau local, aussi quand le Pico2W fonctionnera en dehors de l'éditeur Thonny.
• Sur une autre machine connectée au réseau local, on ouvre un navigateur avec comme URL l'adresse IP communiquée ci-dessus.
  
  On peut s'y connecter à partir par exemple d'un ordinateur portable connecté au réseau local, en Wifi ou en filaire. On peut s'y connecter aussi à partir d'un smartphone. Dans ce cas, il ne faut pas oublier d'activer préalablement le WiFi en liaison avec la box.
• À l'acceptation de la demande de connexion, le navigateur envoie ses caractéristiques (request).
• Le serveur (lePico2W) envoie alors la page WEB préparée.
• Le serveur est dans une boucle infinie, permettant ainsi à plusieurs clients de s'y connecter

1.3.2. Commande extérieure de processus Pico2W

Les programmes Pico2W_Box_web_control_LED.py et Pico2W_Box_web_control_mouv.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.

Les grandes étapes sont identiques à celles de l'exemple précédent, mais avec quelques particularités à souligner.
• 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 et qu'il faut traîter
    • 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.

2. Communication WiFi sur réseau privé à construire (Point d'Accès - Hotspot)

2.1. Un PC configuré comme serveur WiFi et un Raspberry Pi 4B comme client

La création d'un Point d'Accès sans fil sous Linux est nettement facilité par la mise en œuvre de l'utilitaire linux-WiFi-hotspot.

Pour installer linux-WiFi-hotspot sur une machine Ubuntu, il faut ajouter l'archive de packages personnels lwh à l'aide de add-apt-repository :
sudo add-apt-repository ppa:lakinduakash/lwh
Maintenant, il faut mettre à jour les applications et installer linux-WiFi-hotspot avec :
sudo apt update
sudo apt install linux-WiFi-hotspot
Une fois le processus terminé, dans un terminal, on exécute
wihotspot
Une fenêtre apparaît, dans laquelle il faut définir un SSID (Nom du Point d'Accès), par exemple "Legion" et un mot de passe par exemple "blablabla".
Dans les paramètres avancés, on découvre le numéro de la passerelle associée (Gateway), par exemple 192.168.12.1, dont on aura besoin plus tard.
Il faut ensuite cliquer sur "Create hotspot" pour créer le point d'accès Legion, cette création n'étant valable que pour la session en cours.
En cas de besoin, dans une nouvelle cession, on exécute à nouveau
wihotspot
sachant que SSID et mot de passe ne doivent plus être redéfinis. Par contre "Create hotspot" est nécessaire.

En fonction de l'historique WiFi, une erreur peut intervenir suite à la commande
wihotspot

Error: Failed to run hostapd, maybe a program is interfering.
If an error like 'n80211: Could not configure driver mode' was thrown
try running the following before starting create_ap:
    nmcli r WiFi off
    rfkill unblock wlan
Command not found or exited with error status

2.1.2. Mise en œuvre de python3 pour l'échange de données

Voici la procédure du programme PC_Serveur_wifi.py

• Un PC sous UBUNTU 24.04.5 est utilisé comme serveur (créé hors programme python3)
• Création d'un simple ligne serveur / client qui se met en attente de connexion
• Lorsqu'un client (au maximum 5) demande une connexion, le serveur accepte
• Ici, c'est le serveur qui reçoit des données de la part du client
• Le serveur envoie alors un accusé de réception
• La ligne serveur / client doit est fermée.
  Cette fermeture est assez délicate. C'est pourquoi, on a utilisé la formulation
  with socket.socket() as s:
  qui permet d'assurer une fermeture correcte ( https://www.pythonlore.com/closing-and-releasing-resources-with-socket-close/ ).

• Un Raspberry Pi 4B sous OS bookworm est utilisé comme client
• Avant de lancer le programme python3, il faut connecter le RasPi4B sur le WiFi Legion du PC qui, on le rappelle, a été préalablement configuré comme serveur WiFi hotspot
• Le programme python3 définit d'abord les caractéristique de sa ligne client / serveur
• Il se connecte ensuite en utilisant l'adresse IP du serveur (donnée lors de la création du serveur) et le port en service (80)
• Il envoie les données
• Il reçoit une réponse du serveur, ici un accusé de réception

2.2. Un Raspberry Pi 4B configuré comme serveur WiFi et un PC comme client

2.2.1. Création du point d'accès

La création d'un Point d'Accès sans fil sous Linux est nettement facilité en installant d'abord l'utilitaire Pi-Apps qui permet d'installer facilement des applications sur Raspberry Pi 4B :
wget -qO- https://raw.githubusercontent.com/Botspot/pi-apps/master/install | bash

On peut alors installer linux-WiFi-hotspot à partir du menu des applications :
Accessoires / Pi Apps / Tools / Linux Wifi Hotspot

Pour créer l'émetteur WiFi, il faut aller dans le Menu des applications / Outils système et lancer
Wifi Hotspot
Il faut nommer le réseau (SSID par exemple "Suisse") et donner un mot de passe (par exemple "blablabla"). Il faut ensuite cliquer sur Create hotspot.
Le réseau est alors visible sur d'autres appareils, par exemple le PC. Cette création n'est valable que pour la session en cours.
En cas de besoin, dans une nouvelle cession, on retourne dans le Menu des applications / Outils système et on relance
Wifi Hotspot
sachant que SSID et mot de passe ne doivent plus être redéfinis. Par contre "Create hotspot" est nécessaire.

ATTENTION :
Un gros problème : en quittant le hotspot, la situation antérieure (client WiFi pour se relier à la box, par exemple) n'est pas rétablie.
Dans un terminal, la commande
nmcli device status
montre que le WiFi est non-géré !
En fait la configuration du NetWorkManager a dû être modifiée par la création hotspot ! On peut éditer la configuration du NetWorkManager par :
sudo nano /etc/NetworkManager/NetWorkManager.conf
Sous [ifupdown], il faut modifier "managed=false" par "managed=true" et
sous [keyfile], il faut modifier "unmanaged..." par "managed..."
La commande
nmcli device status
montre que maintenant le WiFi est géré.

2.2.2. Mise en œuvre de python3 pour l'échange de données

Voici la procédure du programme RasPi4B_Serveur_wifi.py

• Un Raspberry Pi 4B sous OS bookworm est utilisé comme serveur (créé hors programme python3)
• Création d'un simple ligne serveur / client qui se met en attente de connexion
• Lorsqu'un client (au maximum 5) demande une connexion, le serveur accepte
• Ici, c'est le serveur qui reçoit des données de la part du client
• Le serveur envoie alors un accusé de réception
• La ligne serveur / client doit est fermée.
  Cette fermeture est assez délicate. C'est pourquoi, on a utilisé la formulation
  with socket.socket() as s:
  qui permet d'assurer une fermeture correcte ( https://www.pythonlore.com/closing-and-releasing-resources-with-socket-close/ )

• Un PC est utilisé comme client
• Il faut connecter le PC en WiFi sur le RasPi4B préalablement configuré comme serveur WiFi hotspot
• Le programme python3 définit d'abord les caractéristique de sa ligne client / serveur
• Il se connecte ensuite en utilisant l'adresse IP du serveur (donnée lors de la création du serveur) et le port en service (80)
• Il envoie les données
• Il recoit une réponse du serveur, ici un accusé de réception
• La ligne serveur / client doit est fermée.
  Cette fermeture est assez délicate. C'est pourquoi, on a utilisé la formulation
  with socket.socket() as s:
  qui permet d'assurer une fermeture correcte ( https://www.pythonlore.com/closing-and-releasing-resources-with-socket-close/ )

2.3. Un Raspberry Pi Pico2W comme Point d'Accès (serveur WiFi)

La carte microcontrôleur Pico2W n'intègre pas de périphérique permettant l'affichage ou l'échange d'informations. Pac contre, son module WiFi engage son utilisateur à le définir comme Point d'Accès (AP) et à le configurer comme serveur web. Ainsi n'importe quel autre appareil du genre PC ou Smartphone disposant d'un navigateur peut se connecter à ce HotSpot WiFi permettant ainsi tout échange d'information, y compris graphique, prévue par le langage HTML.

2.3.1. Configuration du Pico2W comme Point d'Accès WiFi

Le programme Pico2W_AP.py valable en microPython comprend les étapes suivantes :

• 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='TryphonT')
• 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 immédiatement.
• 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.
  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’)

2.3.2. Exemples d'utilisation du Pico2W comme serveur WiFi

2.3.2.1. Serveur web simple - Affichage d'informations

Éléments sur la PARTIE 2 du programme Pico2W_AP_bienvenue.py :

• Création d'une prise de type socket

  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.

  En résumé : Suite à une demande extérieure de connexion à partir d'un navigateur, acceptation du serveur

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

• La réponse est envoyée au client à l'aide de
  conn.send(response)

• 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


• L'instruction conn.send('<br />') permet de sauter de ligne avant la prochaine impression.
• La boucle while True: permet à d'autres clients de se connecter

• Il faut d'abord avoir lancé le programme ci-dessus sur le Pico2W pour créer le HotSpot
  Rappel : Si au niveau du Pico2W le programme a été renommé main.py, le programme se lance dès que le Pico2W est alimenté.
• à partir d'un ordinateur portable ou d'un Raspberry Pi 4B, il faut d'abord activer le WiFi
  • puis dans les paramètres, choisir l'essid (pico2w) défini dans le programme
  • et donner le mot de passe (TryphonT)
• à partir d'un smartphone,
  • il faut d'abord supprimer l'option "Données mobiles"
  • activer le WiFi
  • choisir l'essid (pico2w) défini dans le programme
  • et donner le mot de passe (TryphonT)

2.3.2.2. Serveur web pour commande simple

Éléments sur la PARTIE 2 du programme Pico2W_AP_web_control_LED.py :

• L'objectif est de commander à distance la led du Pico2W
• Le programme contient une définition de site web semblable à celle définie dans l'exemple précédent
  • Mais la définition du site web fait intervenir la balise a href qui est utilisée habituellement pour renvoyer à une ligne interne ou une URL externe.
    Dans l'expression html <a href="?led=on">MARCHE</a>, le point d'interrogation dans l'attribut href signifie le début d'une chaîne de requête dans l'URL.
    Plus précisément, il indique que ce qui suit sont des paramètres qui seront envoyés au serveur ou traités par la page ciblée. Ici, ?led=on est un paramètre de requête où led est une variable et on sa valeur. Cela permet de transmettre des données, par exemple pour activer un état ou une fonction spécifique sur la page liée.
    Ainsi, le point d'interrogation sert de séparateur entre l'URL de base et les paramètres qui suivent, utilisés souvent pour passer des informations dynamiques à une application web ou un script côté serveur.
    Donc dans ce cas précis, le lien pointe vers la même page (car il n'y a pas d'adresse avant le ?), mais en ajoutant le paramètre led=on dans l'URL, on peut déclencher une action liée à ce paramètre (par exemple, allumer une LED dans un dispositif connecté web) lorsqu'on clique sur le lien "MARCHE".
  • Justement, la partie MARCHE est interactive. Elle peut être activée avec une souris, un clavier, un doigt, une commande vocale ou toute autre technologie d'assistance. Une fois activée, elle peut déclencher une action telle qu'envoyer un formulaire ou ouvrir une boite de dialogue.
  • L'élément HTML <button> est purement graphique. Il permet de mettre "MARCHE" dans un cadre suggérant un bouton à activer.
• Le fonctionnement peut être déduit du programme mais les notes suivantes peuvent aider à la compréhension :
  • Un client demande une connexion depuis le navigateur d'un autre appareil et elle est acceptée par le serveur
  • En réponse, le serveur (Pico2W) envoie le site web
  • Le client accuse réception en envoyant toutes ses caractéristiques sous forme de blocs de 1024 octets (ici 2 blocs).
    La reception de chaque bloc nécessite nouvelle connexion.
  • Pour information, ces 2 blocs sont analysés
  • La méthode split() de python3 permet de fractionner des chaînes de caractères.
    Par exemple
    text = "Ceci est un exemple"; print(text.split()) donne : ["Ceci", "est", "un", "exemple"] et
    print(text.split()[1]) donne : ["est"]
  • Suivant la valeur de request, une action est décidée sur la led
• Le programme Pico2W_AP_web_control_LED_r.py est le même programme mais opérationnel, c'est-à-dire débarrassé des ordres d'impression superflus mais utiles à la compréhension lorsque le programme est lancé à partir de Thonny.

2.3.2.3. Serveur web pour commande du mouvement d'un véhicule

Éléments sur la PARTIE 2 du programme Pico2W_AP_web_control_mouv.py :

• Ce programme est le squelette pour commander un véhicule en marche avant ou arrière, tourner à droite ou à gauche
• Le graphique généré par html doit être explicite pour ces commandes
• Au lieu de a href et button, on utilise ici form action et input suivi d'options claires sur l'exemple présenté.
• Sinon la structure du programme est identique.

2.3.2.4. Serveur pour transmission de cap défini par un capteur "boussole"

Le programme MicroPython Pico_I2C_boussole.py a permis de réceptionner le module boussole électronique QMC5883L sans transmission des valeurs mesurées ou de leurs dérivés. Voir ici.

Ici

• le programme MicroPython Pico2W_I2C_boussole.py configure d'abord le Pico2W comme serveur WiFi, puis effectue les mesures et enfin les transmet par WiFi à un client qui se connecte au serveur.
• le client est le l'ordinateur de bureau sous UBUNTU connecté en WiFi à l'adresse donnée par le serveur. Le programme Python3 client_pico2w_0.py demande d'accéder au serveur puis reçoit les informations de cap sous forme de chaîne de caractères dont on extrait finalement les valeurs numériques intéressantes.

La carte Pico2W sert aussi à télécommander un bras manipulateur en InfraRouge. (Voir le programme MicroPython Pico_IR_Bras.py présenté ici)
Le simple enchaînement des deux programmes MicroPython Pico_IR_Bras.py et Pico2W_I2C_boussole.py fonctionne à priori, mais seulement pour la transmission de 15 valeurs concernant la boussole.
Ce problème est courant lors des échanges entre un serveur MicroPython (ici sur un Pico2W) et un client Python3 sous Ubuntu : la connexion fonctionne pour un nombre limité d’envois (15 dans ce cas), puis s’arrête, tandis que le serveur continue à générer des données sans que le client ne les reçoive.
La cause probable est le blocage du tampon d’envoi série ou socket sur le Pico2W/MicroPython qui se remplit parce que le client ne lit pas assez vite ou coupe la connexion prématurément. Lorsque le tampon est plein, les appels d’envoi (send, print, etc.) sur le Pico sont alors bloquants ou échouent silencieusement, mais la boucle du serveur peut continuer à générer des données. La solution a été ici d'introduire un échange simple d'acquittements (ACK) après réception de chaque message côté client.
Les deux programmes résultants sont :

• Pico2W_IR_Bras_Bousolle.py, du côté serveur (Pico2W)
• client_pico2w.py, du côté client (PC sous Ubuntu)

3. Communication Bluetooth

3.1. Généralités sur le Bluetooth pour comprendre les programmes utilisés

3.2. Commande à distance des broches GPIO du Raspberry Pi 4B par Smartphone via Bluetooth

3.2.1. Liens

• Description du processus : https://www.youtube.com/watch?v=bhQnU422NFM
• python classe bluedot – Présentation générale et exemples : https://bluedot.readthedocs.io/en/latest/
• python classe bluedot : https://bluedot.readthedocs.io/en/latest/dotapi.html
• Blue Dot, application Androïd : https://bluedot.readthedocs.io/en/latest/bluedotandroidapp.html

3.2.2. Principe

3.2.3. Connexion Bluetooth entre Smartphone et Raspberry Pi

3.2.4. Expérimentation

L'expérimentation est ici très simple. Une LED est reliée à la broche GPIO18 par l'intermédiaire d'une résistance 220Ω.
A l'exécution, le programme python3 Bluetooth.py, très simple aussi, signale que le serveur a démarré mais qu'il attend la connexion.
Il faut alors démarrer l'application "Blue Dot" sur le Smartphone et le connecter au Raspberry Pi. Un gros point bleu apparaît alors sur le Smartphone.
En mettant le doigt dessus, la LED s'allume et lorsqu'on retire le doigt, la LED s'éteint.

Un application plus étendue est développée ici et là.

3.3. Application du Bluetooth au Pico2W

https://picockpit.com/raspberry-pi/fr/tout-sur-le-bluetooth-sur-le-raspberry-pi-pico-w/

Le Pico2W fonctionne à la fois avec Bluetooth Classic et Bluetooth Low Energy. Bluetooth Classic et Bluetooth Low Energy (BLE) sont deux façons différentes pour les appareils de communiquer dans le cadre de la spécification Bluetooth.

Bluetooth Classic, également connu sous le nom de Bluetooth Basic Rate/Enhanced Data Rate (BR/EDR), est la version originale de Bluetooth. Elle a été conçue pour la transmission de données à haut débit, le streaming audio et le couplage d'appareils. Bluetooth Classic est couramment utilisé pour des applications telles que les haut-parleurs audio sans fil, les claviers, les souris et le transfert de fichiers entre appareils.

Bluetooth Low Energy (BLE), également connu sous le nom de Bluetooth Smart, est une variante économe en énergie de Bluetooth. BLE a été introduit dans le cadre de la spécification Bluetooth 4.0 et est optimisé pour les appareils à faible consommation d'énergie qui nécessitent une longue durée de vie de la batterie, tels que les trackers de fitness, les smartwatches, les appareils de domotique et les capteurs sans fil.

• Point à point : communication entre deux nœuds (appareils) d'un réseau ; communication serveur-client.
• Réseau maillé : plusieurs nœuds peuvent communiquer entre eux dans cette topologie.
• Mode diffusion : un serveur diffuse des données sur le réseau, lisibles par de nombreux appareils.

Note : Le Pico2W peut fonctionner à la fois comme un dispositif central et comme un dispositif périphérique.

3.3.1. Raspberry Pi Pico2W utilisant le Bluetooth pour communiquer avec une application Android

https://electrocredible.com/raspberry-pi-pico-w-bluetooth-ble-micropython/

On envisage ici de lire le status d'un bouton poussoir et d'envoyer des commandes pour contrôler la led du Pico2W en utilisant l'application Android Serial Bluetooth Terminal).

Deux outils généraux MicroPython doivent être inclus dans un répertoire lib du Pico2W. Il s'agit des fichiers

• ble_advertising.py
  Ce fichier est un module d'aide destiné à simplifier la création et l'analyse des "payloads" (données d'annonce) Bluetooth Low Energy (BLE) pour l’utilisation avec la bibliothèque native bluetooth de MicroPython. Il n'assure pas la gestion d'une connexion BLE complète, mais génère et décode les paquets d’annonce nécessaires pour que le microcontrôleur (ex : Pico2W) soit visible, avec nom, services et apparence personnalisés.
  Ce module s’utilise comme un bloc utilitaire “boîte noire” : on assemble une annonce BLE compatible, sans manipuler les bits et bytes à la main, ce qui est particulièrement utile pour le développement rapide et la compatibilité multi-appareils.
• ble_simple_peripheral.py
  Ce fichier "périphérique" permet au Pico2W de fonctionner en tant que périphérique. Il fait usage de ble_advertising.py. C'est d'ailleurs aussi dans ce fichier qu'est défini le nom qu'aura le Pico2W dans la liste des appareils Bluetooth auquels on peut se connecter, c'est-à-dire ici mpy-uart.

Le programme Pico2W_Ble_LED.py lance l'application :

• Dans Thonny, apparaît l'expression "Starting advertising", ce qui signifie que le Pico2W est visible par une application Android ici sous le nom mpy-uart
• On ouvre l'application Serial Bluetooth Terminal préalablement installée sur un smartphone Android.
• Dans cette application, on clique à gauche au dessus les 3 barres et on choisit "Devices".
• On choisit le mode de connexion "Bluetooth LE", puis on SCANne les périphériques disponibles en Bluetooth
• mpy-uart apparaît. Ce qui permet ce choix.
• L'écran du "Terminal" réapparaît avec la mention "Connecting to mpy-uart" et peu après apparaît "connected"
• L'application est maintenant connectée au Pico2W
• Les ordres "on", "off" ou "toggle" peuvent être inscrits dans la barre de commande en dessous, ce qui permet de modifier l'état de la led du Pico2W.
• Note : 6 boutons peuvent être programmés pour éviter de chaque fois retaper l'ordre : il suffit d'appuyer plus longtemps sur le bouton qu'on veut programmer.
• Le programme communique aussi au smartphone le délai temporel où les boutons ont été poussés, ce qui démontre les possibilités d'échange de données entre le smartphone et le Pico2W