SansFil

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

Généralement à la maison, on dispose d'une connexion internet par fibre reliée à un terminal jouant le rôle de routeur. A partir de ça, on peut se créer un réseau filaire ou de communication par WiFi.
Un réseau local se compose donc d'un serveur et de clients.
Le serveur est le routeur au bout de la fibre, les clients pouvant être des imprimantes, des PC ou autres Raspberry Pi.
On se propose d'échanger des données soit par réseau filaire, soit par WiFi.
Si un Raspberry Pi Pico2W est dans la boucle, il ne peut communiquer sur le réseau local que par WiFi et il lui faudra d'abord s'insérer dans le réseau.

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

J'ai constitué à la maison un réseau local filaire (LAN). Le PC et le RasPi4B peuvent donc être connectés à la box par fil ou par WiFi de façon traditionnelle.

**Adresses IPv4 en usage ici**
	PC	RasPi4B
LAN	192.168.1.25	192.168.1.46
WiFi	192.168.1.41	192.168.1.24

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 :

Les méthodes utilisées dans les programmes python n'ont pas besoin d'être introduites, sauf :

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

AU NIVEAU DU RasPi4B
Après avoir démarré le programme au niveau du PC, on lance le programme au niveau du RasPi4B : dans un terminal démarré à partir du répertoire du programme RasPi4B_Client_Box.py, on le lance par
python3 RasPi4B_Client_Box.py
Le RasPi4B demande de se connecter au PC puis envoie des données et reçoit une réponse.

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

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.

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

Le PC est connecté à la box par fil ou par WiFi de façon traditionnelle. Il faut aussi s'assurer d'avoir lancé le WiFi à partir de la box.

Ensuite, avant de procéder à l'échange de données, il faut insérer le Pico2W dans le réseau :

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

On récupère ainsi l'adresse IPv4, par exemple 192.168.1.34. Ce résultat n'est pas vraiment utile mais permettra plus tard de vérifier les connexions.

1.2.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).

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.

Le programme Pico2W_Client_Box.py contient 2 parties :

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

Cependant l'exécution de ce dernier programme conduit à une erreur : la méthode with ... as ... n'est pas valable avec MicroPython utilisé pour programmer le Pico2W. Cette méthode a donc été remplacée et le bloc se termine maintenant par l'instruction s.close(), mais on sait que la fermeture n'est pas complète. Ceci peut poser problème lorsqu'on relance les programmes.
Alors l'instruction s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) a été rajoutée dans le programme PC_Client_Box.py comme le suggère le lien
https://lxadm.com/socket-error-errno-98-address-already-in-use/
pour permettre la réutilisation immédiate du port, même si celui-ci est dans l’état TIME_WAIT.
Ce programme devient donc maintenant PC_Client_Box2.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.

Voici la procédure d'exécution :

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.

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)

Un réseau privé contient aussi un serveur et des clients. Mais ici, il faut configurer un appareil comme serveur appelé aussi "Point d'Accès" ou "Hotspot". Plusieurs situations sont présentées :

Un PC est configuré comme serveur WiFi et un Raspberry Pi 4B est un client
Un Raspberry Pi 4B est configuré comme serveur WiFi et un PC est un client
Un Raspberry Pi Pico2W est configuré comme serveur WiFi et un Raspberry Pi 4B est un client

Le WiFi de la box internet n'est donc pas utilisé ici.

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

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

Le Point d'Accès est créé ici sur un ordinateur portable fonctionnant sous Ubuntu 24.04.5 LTS.

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

Les commandes
nmcli r WiFi off
rfkill unblock wlan
rectifient effectivement la situation permettant
wihotspot
de s'effectuer maintenant sans erreur.

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/ ).

Voici la procédure du programme RasPi4B_Client_wifi.py

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

Le Raspberry Pi 4B fonctionne sous OS bookworm.

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

Le Point d'Accès doit être créé ici sur un Raspberry Pi 4B fonctionnant sous OS bookworm.

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/ )

Voici la procédure du programme PC_Client_wifi.py

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)

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.

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.

Les exemples de cette section illustrent ces possibilités.

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. Serveur web simple - Affichage d'informations

Tous les exemples ici possèdent contiennent 2 parties.

La PARTIE 1 est la même pour tous : La carte Pico2W est configurée comme Point d’Accès WiFi d'adresse 192.168.4.1

É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

Quelques remarques pour s'y connecter comme client :

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.3. 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.4. 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.5. Capteur "boussole"

Un module boussole électronique QMC5883L, capteur de champ magnétique à trois axes, est connecté à la carte Pico2W en I2C (pin 0 pour sda et pin 1 pour scl sans oublier l'alimentation 5V et la masse).
L'idée est de déterminer le cap magnétique d'après les mesures et de le transmettre par WiFi à un client, par exemple un PC, pour une utilisation ultérieure.

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. Il utilise obligatoirement un éditeur du genre Thonny pour récupérer les résultats. Il n'est donc pas compatible avec une mise en oeuvre indépendante du Pico. Voir Mise en œuvre du module QMC5883L, capteur de champ magnétique à trois axes - Boussole.

Ici, le transfert du programme sur Pico2W et son adaptation permet la transmission des données par WiFi de deux façons :

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 par l'intermédiaire d'un navigateur comme Firefox. Les données sont transmises au navigateur à un rythme imposé par le serveur. Le navigateur les affiche les informations simplement au fur et à mesure de leur envoi.
Le client peut être un PC ou un smartphone. L'URL est "192.168.4.1".

le programme MicroPython Pico2W_I2C_boussole0.py est une adaptation du précédent. le client est un ordinateur capable d'exécuter Python3 et connecté en WiFi à l'adresse donnée par le serveur (192.168.4.1). Le programme Python3 du client client_Pico2W_I2C_boussole0.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. Ce programme client constitue un préalable à tout programme visant à utiliser ces valeurs numériques.

2.3.6. Boussole et bras manipulateur

La même carte Pico2W recueille les données de la boussole mais doit aussi servir à télécommander un bras manipulateur en InfraRouge (Voir le programme MicroPython Pico_IR_Bras.py présenté dans la section Bras manipulateur avec télécommande IR).

De nouveau la transmission des données par WiFi des informations "boussole" s'effectue de deux façons :

Le programme MicroPython Pico2W_bras_boussole.py est un enchaînement des deux programmes MicroPython Pico_IR_Bras.py et Pico2W_I2C_boussole.py légèrement adapté.
Le client est un navigateur avec l'URL 192.168.4.1.
Le programme MicroPython Pico2W_bras_boussole0.py est une adaptation du précédent pour transmettre les informations "boussole" pour un usage ultérieur.
Le programme Python3 du client reste client_Pico2W_I2C_boussole0.py et donc 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. Ce programme client constitue un préalable à tout programme visant à utiliser ces valeurs numériques.

2.3.7. Boussole et bras manipulateur sur 2 coeurs

La carte Pico2W intègre un microcontrôleur RP2350 avec 2 coeurs (core0 et core1) mais sans programmation spécifique, le travail ne se répartit pas sur les 2 coeurs.
Pour accélérer l'exécution, on peut cependant répartir le travail sur les 2 coeurs : bras sur core0 et boussole sur core1.
Cependant la technique impliquant la méthode _thread est assez délicate et a nécessité des étapes préalables pour sa mise au point.

Un petit programme de clignotement de la LED interne au Pico2W (script_led.py) a été utilisé comme programme complémentaire pour être exécuté conjointement avec le programme de boussole. Le Pico2w est toujours le serveur et le client est un navigateur (Firefox), sur URL 192.168.4.1.

Deux possibilités ont été considérées :

core2a0.py, où le programme de boussole s'exécute sur le coeur principal core0 et le programme de clignotement de la LED interne s'exécute sur core1.

Le programme script_led.py est importé sans problème et, grâce à la fonction _thead, fonctionne sans problème sur le core1.

Le programme Pico2W_I2C_boussole.py, bien que transformé en script importable, ne fonctionnant pas sur core0, a été copié directement dans core2.py. Une erreur a alors été détectée sur import socket. Tous les "import ..." ont alors été rassemblés en début de programme avant l'appel à _thead. Ça a fonctionné.
core2a1.py, où le programme de clignotement de la LED interne s'exécute sur le coeur principal core0 et le programme de boussole s'exécute sur core1.

Pico2W_I2C_boussole.py, bien que transformé en script importable , ne fonctionnant pas sur le core1, la création du point d'accès a été retirée du script_boussole.py initial pour être tranféré au début du programme principal. Ça a fonctionné.

Finalement, en tenant compte de toutes ces "découvertes", le programme core2.py a pu être développé. Le programme de bras manipulateur ainsi que la création du point d'accès WiFi s'exécutent sur le coeur principal core0 et le programme de boussole s'exécute sur core1 où plutôt son script importable script_boussole.py.

La technique 2 coeurs permet aussi d'avoir des variables communes aux deux programmes s'exécutant sur les 2 coeurs. Ces variables doivent être déclarées globales. Ceci peut être intéressant pour des développements futurs. Par contre, il faut régler le problème d'accès simultanés. La création d'un verrou et son utilisation permettent de régler ce problème : voir Pico2W_MemPartage.py.

2.4. Connexion d'un client à l'URL définie par le Pico2W configuré comme Point d'Accès (serveur WiFi)

Les procédures sont parfois très délicates à mettre au point et diffèrent d'après le dispositif support du client.

2.4.1. Le dispositif client est un ordinateur portable sous Ubuntu 24.04 LTS - L'interface est Firefox

Du côté "serveur", le programme tournant sur le Pico2W est Pico2W_AP_bienvenue.py.
Du côté "client" comme l'interface utilisateur est firefox, il n'y a pas besoin de programme python3.

Procédure :

Il faut d'abord s'assurer qu'aucun autre dispositif ne veuille se brancher sur le WiFi du Pico2W configuré comme point d'accès.
Arrêter le WiFi du client
S'assurer que Firefox n'est pas lancé
Lancer le programme sur le Pico2W
Lancer le WiFi du client et s'assurer qu'il se connecte bien au WiFi du Pico2W
Mettre en route le Firefox et ouvrir un nouvel onglet
Saisir l'adresse "http://192.128.4.1" (En fait l'URL définie par le Pico2W)

Les informations voulues doivent maintenant s'afficher à l'écran.

Pour interrompe le programme, il suffit de débrancher le Pico2W.

Si la procédure ne marche plus, il faut penser à redémarrer l'ordinateur

Cette procédure est à essayer avec tout dispositif client, mais cela ne marche pas toujours, comme montré ci-après

2.4.2. Le dispositif client est un smartphone de type Samsung Galaxy A23 sous Android 14 - L'interface est Firefox

Si du côté "serveur", le programme du Pico2W Pico2W_AP_bienvenue.py est lancé par l'éditeur Thonny tournant sur PC, le smartphone android utilisé ici, un Samsung Galaxy A23, réagit correctement selon la procédure ci-dessus. Par contre, si le programme est lancé directement au branchement d'une batterie sur le Pico2W, le smartphone bug. Si on remplace le smartphone Samsung Galaxy A23 par un smartphone Huawei P10 Lite ou un PC, pas de problème.

Certains rapports montrent que si le Pico2W ne répond pas assez vite ou avec le bon format HTTP à la demande initiale du navigateur Android, la session échoue ou bug, alors qu'elle est tolérée sur PC.
La solution est d'ajouter un délai [par exemple time.sleep(10)] au début du script après la mise sous tension peut laisser au Wi-Fi et au serveur le temps de s'initialiser correctement avant de commencer à servir les pages web.

Certains programmes testés avec le smartphone ont été adaptés en ce sens, mais suivant les circonstances, le délai introduit peut être diminué ou augmenté. Ici, ce délai n'a pas été optimisé.

2.4.3. Le dispositif client est un ordinateur portable sous Ubuntu 24.04 LTS - L'interface est un programme python3

Si l'objectif est simplement de voir les informations, l'interface Firefox est certainement la plus confortable, puisqu'elle ne nécessite pas de développer de programme python du côté "client".
Mais souvent, ces données doivent être transmises pour servir dans des algorithmes, par exemple de pilotage. Là, Firefox n'est pas adapté.

Du côté "serveur", le programme MicroPython Pico2W_I2C_boussole0.py et
du côté "client", le programme Python3 client_Pico2W_I2C_boussole0.py
ont déjà été présenté plus haut lorsque le client est un ordinateur portable. Nous n'y revenons pas.

Tout fonctionne, que le Pico2W soit lancé par Thonny ou par une batterie extérieure

Cependant, la boussole ne fonctionne bien qu'à l'extérieur, en particulier sa calibration. De ce fait, lancer le Pico2W à l'aide d'une batterie et recevoir les données sur un smartphone paraît être optimal du moins pour la calibration.

2.4.4. Le dispositif client est un smartphone de type Samsung Galaxy A23 sous Android 14 - L'interface est un programme python3

Il faut d'abord introduire la mise en oeuvre de python3 sur le smartphone, ici un Samsung Galaxy A23.

Il existe plusieurs applications, particulièrement destinés à l'enseignement et qui comprennent aussi un éditeur Python. Par contre, ici, les programmes ont déjà été développé par ailleurs et n'ont besoin que d'être transférés sur le smartphone. C'est pourquoi, on utilise ici l’application Termux qui est un émulateur de terminal Linux. On se retrouve ainsi dans une situation symétrique à celle utilisée sur PC ou Raspberry Pi 4B.

Voici les étapes initiales

Ouvrir Termux et mettre à jour les paquets avec la commande :
pkg update && pkg upgrade

Installer Python avec :
pkg install python

Permettre l'accès au stockage interne :
termux-setup-storage

Ouvrir le répertoire du stockage interne :
Remarque : Termux ne permet pas un accès facile à la carte SD *.
cd storage/shared/

*
- Avec une application comme "Gestionnaire de fichiers", sélectionner un répertoire sur la carte SD, par exemple "Documents"
- Regarder les propriétés qui donnent le chemin d'accès par exemple /storage/9C33-3BBD/Documents
- Il suffit alors dans Termux de se positionner sur ce répertoire par
cd /storage/9C33-6BBD/Documents

Créer sur le stockage interne du smartphone un répertoire dédié par exemple "Python"
mkdir Python

Exporter un programme python3 vers ce répertoire, par exemple client_Pico2W_I2C_boussole0.py en reliant par exemple le PC au smartphone par USB.

Exécution des programmes

Pico2W
1. Le programme Pico2W_I2C_boussole0.py est chargé préalablement dans la mémoire du Pico2W sous le nom main.py à l'aide de "Thonny".
2. Le programme est lancé en reliant le Pico2W à une alimentation, comme une batterie externe.

Smartphone / Termux
1. Ouvrir le répertoire adhoc :
  cd storage/shared/Python
2. Exécuter le programme client_Pico2W_I2C_boussole0.py:
  python3 client_Pico2W_I2C_boussole0.py

COMMUNICATION SANS FIL

MENU