Gestionnaire automatique de connexion Wi-Fi

Introduction

Ce système permet de basculer automatiquement entre différents réseaux Wi-Fi préconfigurés et un mode hotspot local si aucun réseau approprié n’est disponible. Il est conçu pour être exécuté sur un appareil Linux (comme un Raspberry Pi) disposant de nmcli (NetworkManager) et d’une interface sans fil.

Le programme repose sur deux fichiers principaux :

auto_wifi.py : script principal qui gère la logique d’auto-connexion.
lib_wifi.py : bibliothèque fournissant les fonctions bas-niveau de gestion Wi-Fi.

Un client MQTT est utilisé pour publier les événements de connexion/déconnexion. Utiliser par exemple mosquitto pour installer le serveur MQTT sur le Raspberry (Robot).

Configuration

Fichier de configuration : `wifi_config.txt`

Le fichier wifi_config.txt contient la configuration des réseaux Wi-Fi autorisés.

Format :

50
Maison=motdepasse123
Atelier=ateli3r123

La première ligne est le seuil minimal de signal (%).
Chaque ligne suivante est de la forme SSID=motdepasse.

Variables importantes dans `auto_wifi.py`

BROKER = "localhost"             # Adresse du broker MQTT
PORT = 1883                      # Port du broker MQTT
CONFIG_FILE = "wifi_config.txt" # Fichier de configuration
CHECK_INTERVAL_MINUTES = 1      # Fréquence des vérifications (en minutes)
HOTSPOT_SSID = "tondeuse"        # SSID du mode hotspot
HOTSPOT_PASSWORD = "tondeuse"    # Mot de passe du hotspot
IP = "192.168.1.151"             # IP locale fixe pour les connexions

Installation

Dépendances :

Python 3
nmcli (inclus avec NetworkManager, notamment sous Bookworm pour les Raspberry)
paho-mqtt

Installation de paho-mqtt :

pip install paho-mqtt

Utilisation

Lancement du programme

python3 auto_wifi.py

Le script :

Tente de se connecter à un réseau Wi-Fi préféré avec signal suffisant.
Sinon, active un mode hotspot local (AP).
Publie les événements sur le canal MQTT autowifi.

Log des événements

Tous les événements sont journalisés dans log.txt avec un timestamp.

Détails techniques

Classe `WiFiManager` (lib_wifi.py)

Permet d’exécuter des commandes nmcli et d’interagir avec l’interface Wi-Fi.

Principales méthodes :

get_wifi_list() : Liste les réseaux disponibles avec leur signal.
get_wifi_info() : Informations sur le réseau actuel.
connect_wifi(ssid, password, ip) : Connexion à un réseau Wi-Fi.
set_hotspot(ssid, password, ip) : Active un hotspot local.

Classe `WiFiAutoSwitcher` (auto_wifi.py)

Implémente la logique d’auto-switch :

Lecture du fichier de config
Sélection du meilleur réseau disponible
Activation du hotspot si aucun réseau n’est acceptable
Boucle de vérification en tâche de fond

MQTT

Le client MQTT se connecte au broker localhost, publie sur le topic autowifi, et peut s’abonner à tous les messages (#). Le callback on_message est commenté mais peut être activé pour ajouter des commandes distantes.

Extension possible

Ajout de commandes MQTT

En décommentant on_message, il est possible de réagir à des messages MQTT pour forcer des actions :

# Exemple : forcer le mode hotspot ou recharger la config

Interface Web de supervision

Une page Flask pourrait être ajoutée sur le même hôte pour afficher l’état courant, les réseaux visibles, etc.

Bonnes pratiques

Tester manuellement la commande nmcli pour chaque SSID avant usage automatique.
Conserver les identifiants Wi-Fi à jour dans le fichier wifi_config.txt.
Éviter des noms de réseau SSID contenant des caractères spéciaux.

Exemple de sortie console

20250702 15:03 [INFO] Connexion conservée grimeco (60%)
20250702 15:04 [INFO] Signal trop faible (18%) sur grimeco
20250702 15:04 [INFO] Connexion au meilleur réseau : grimeco_EXT
20250702 15:05 [INFO] Signal trop faible (15%) sur grimeco_EXT
20250702 15:05 [INFO] Passage en mode hotspot.
20250702 15:06 [INFO] Toujours en mode hotspot.
20250702 15:07 [INFO] Toujours en mode hotspot.
20250702 15:08 [INFO] Connexion au meilleur réseau : grimeco
20250702 15:09 [INFO] Connexion conservée grimeco (63%)
20250702 15:10 [INFO] Connexion conservée grimeco (65%)

Maintenance

Supprimer manuellement les connexions obsolètes via nmcli con delete si nécessaire.
Utiliser nmcli dev wifi list pour vérifier la qualité du signal et les SSID visibles.

Auteurs

Ce programme a été conçu pour automatiser la gestion réseau sur un robot autonome (ex. tondeuse connectée).

Licence

Ce code est open-source et peut être adapté à d’autres projets de robotique ou domotique basés sur Linux et MQTT.

Sources

lib_wifi.py

Python

import subprocess
import re

class WiFiManager:
    def __init__(self, interface="wlan0"):
        self.interface = interface

    def run_cmd(self, cmd):
        result = subprocess.run(cmd, shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
        out = result.stdout.decode().strip()
        err = result.stderr.decode().strip()
        if err and "Warning" not in err:
            print(f"[CMD] {cmd}")
            print(f"[ERROR] {err}")
        return out

    def freq_to_channel(self, freq_ghz):
        freq_mhz = round(freq_ghz * 1000)
        if 2412 <= freq_mhz <= 2472:
            return (freq_mhz – 2407) // 5
        elif freq_mhz == 2484:
            return 14
        return None  # Hors 2.4 GHz

    def dbm_to_percent(self, dbm):
        if dbm is None:
            return None
        dbm = max(-90, min(-30, dbm))
        return int((dbm + 90) * 100 / 60)

    def get_wifi_info(self):
        try:
            result = subprocess.check_output(["iwconfig", self.interface], stderr=subprocess.DEVNULL).decode()
        except subprocess.CalledProcessError:
            return None
        ssid_match = re.search(r'ESSID:"([^"]+)"', result)
        ssid = ssid_match.group(1) if ssid_match else None
        signal_match = re.search(r'Signal level=(-?\d+) dBm', result)
        signal_dbm = int(signal_match.group(1)) if signal_match else None
        signal_percent = self.dbm_to_percent(signal_dbm)
        freq_match = re.search(r'Frequency:(\d+\.\d+)', result)
        freq = float(freq_match.group(1)) if freq_match else None
        channel = self.freq_to_channel(freq) if freq else None
        return {
            "ssid": ssid,
            "signal_dbm": signal_dbm,
            "signal_percent": signal_percent,
            "frequency": freq,
            "channel": channel
        }

    def get_wifi_list(self):
        self.run_cmd("nmcli device wifi rescan")
        output = self.run_cmd("nmcli -t -f SSID,SIGNAL device wifi list")
        wifi_list = []
        for line in output.strip().split("\n"):
            if not line.strip():
                continue
            parts = line.split(":", 1)
            if len(parts) != 2:
                continue
            ssid, signal = parts
            ssid = ssid.strip()
            try:
                signal = int(signal.strip())
                if ssid:
                    wifi_list.append((ssid, signal))
            except ValueError:
                continue
        wifi_list.sort(key=lambda x: x[1], reverse=True)
        return wifi_list

    def set_hotspot(self, ssid, password, ip=None, channel=6):
        self.run_cmd(f"nmcli con delete '{ssid}'")
        self.run_cmd(f"nmcli con add type wifi ifname {self.interface} con-name '{ssid}' ssid '{ssid}'")
        self.run_cmd(f"nmcli con modify '{ssid}' 802-11-wireless.mode ap 802-11-wireless.band bg")
        self.run_cmd(f"nmcli con modify '{ssid}' 802-11-wireless.channel {channel}")
        self.run_cmd(f"nmcli con modify '{ssid}' wifi-sec.key-mgmt wpa-psk wifi-sec.psk '{password}'")
        if ip:
            self.run_cmd(f"nmcli con modify '{ssid}' ipv4.addresses {ip}/24")
            self.run_cmd(f"nmcli con modify '{ssid}' ipv4.method shared")
            self.run_cmd(f"nmcli con modify '{ssid}' ipv6.method ignore")
        self.run_cmd(f"nmcli con up '{ssid}'")

    def connect_wifi(self, ssid, password, ip=None):
        self.run_cmd(f"nmcli con delete '{ssid}'")
        self.run_cmd(f"nmcli con add type wifi ifname {self.interface} con-name '{ssid}' ssid '{ssid}'")
        self.run_cmd(f"nmcli con modify '{ssid}' wifi-sec.key-mgmt wpa-psk")
        self.run_cmd(f"nmcli con modify '{ssid}' wifi-sec.psk '{password}'")
        if ip:
            gateway = ip.rsplit('.', 1)[0] + ".1"
            self.run_cmd(f"nmcli connection modify '{ssid}' ipv4.addresses {ip}/24")
            self.run_cmd(f"nmcli connection modify '{ssid}' ipv4.method manual")
            self.run_cmd(f"nmcli connection modify '{ssid}' ipv4.gateway {gateway}")
            self.run_cmd(f"nmcli connection modify '{ssid}' ipv4.dns 8.8.8.8")
        self.run_cmd(f"nmcli connection up '{ssid}'")

auto_wifi.py

Python

import time,threading
from lib_wifi import *
from datetime import datetime
import paho.mqtt.client as mqtt

BROKER = "localhost"
PORT = 1883
CONFIG_FILE = "wifi_config.txt"
CHECK_INTERVAL_MINUTES = 1
HOTSPOT_SSID = "tondeuse"
HOTSPOT_PASSWORD = "tondeuse"
IP="192.168.1.151"

def on_connect(client, userdata, flags, rc, properties=None):
    if rc == 0:
        print("Connecté au broker MQTT !")
        client.subscribe("#")
    else:
        print(f"Échec de la connexion, code de retour : {rc}")
"""
def on_message(client, userdata, msg):
    w=msg.payload.decode()
    print(w)
"""    
client = mqtt.Client(callback_api_version=mqtt.CallbackAPIVersion.VERSION2)
client.on_connect = on_connect
#client.on_message = on_message
client.connect(BROKER, PORT, 120)
client.loop_start() 
 
def log(path,line):
    with open(path,"a",encoding="utf-8") as fout:
        fout.write(line+"\n")
            
def p(msg):
    now=datetime.now().strftime("%Y%m%d %H:%M")
    w=now+" "+msg
    print(w)
    log("log.txt",w)
    client.publish("autowifi",w)
    
class WiFiAutoSwitcher:
    def __init__(self, config_path, interface="wlan0"):
        self.config_path = config_path
        self.wifi = WiFiManager(interface)
        self.signal_threshold = 50
        self.networks = {}
        self.in_hotspot_mode = False
        self.read_config()
        self.wifi_list={}

    def read_config(self):
        self.networks.clear()
        try:
            with open(self.config_path, "r", encoding="utf-8") as f:
                lines = [line.strip() for line in f if line.strip() and not line.strip().startswith("#")]
                if lines:
                    self.signal_threshold = int(lines[0])
                    for line in lines[1:]:
                        if "=" in line:
                            ssid, password = line.split("=", 1)
                            self.networks[ssid.strip()] = password.strip()
        except Exception as e:
            p(f"[ERROR] Impossible de lire wifi_config.txt")

    def find_best_network(self):
        self.wifi_list = self.wifi.get_wifi_list()
        for ssid, signal in self.wifi_list:
            if ssid in self.networks and signal >= self.signal_threshold:
                return ssid, self.networks[ssid]
        return None, None

    def aff_reseaux(self):
        for ssid,signal in self.wifi_list:
           p(f"[INFO] {ssid} {signal}")
            
    def switch(self):
        #self.read_config()
        info = self.wifi.get_wifi_info()
        #self.aff_reseaux()
        if info and info["ssid"] in self.networks:
            signal = info["signal_percent"]
            if signal is not None and signal >= self.signal_threshold:
                p(f"[INFO] Connexion conservée {info['ssid']} ({signal}%)")
                self.in_hotspot_mode = False
                return
            else:
                p(f"[INFO] Signal trop faible ({signal}%) sur {info['ssid']}")

        ssid, password = self.find_best_network()
        if ssid:
            p(f"[INFO] Connexion au meilleur réseau : {ssid}")
            self.wifi.connect_wifi(ssid, password,ip=IP)
            self.in_hotspot_mode = False
        else:
            if not self.in_hotspot_mode:
                p("[INFO] Passage en mode hotspot.")
                self.wifi.set_hotspot(HOTSPOT_SSID, HOTSPOT_PASSWORD,ip=IP)
                self.in_hotspot_mode = True
            else:
                p("[INFO] Toujours en mode hotspot.")

    def start_loop(self):
        while True:
            try:
                self.switch()
            except Exception as e:
                p(f"[ERROR] {e}")
            time.sleep(CHECK_INTERVAL_MINUTES * 60)

# Lancer dans un thread
def run_wifi_manager():
    manager = WiFiAutoSwitcher(CONFIG_FILE)
    #manager.find_best_network()
    #manager.aff_reseaux()
    manager.start_loop()

if __name__ == "__main__":
    thread = threading.Thread(target=run_wifi_manager, daemon=True)
    thread.start()

    # Main thread peut être laissé vide ou utilisé pour autre chose
    while True:
        time.sleep(3600)

Grimeco

Gestionnaire automatique de connexion Wi-Fi

Introduction

Configuration

Fichier de configuration : `wifi_config.txt`

Variables importantes dans `auto_wifi.py`

Installation

Dépendances :

Utilisation

Lancement du programme

Log des événements

Détails techniques

Classe `WiFiManager` (lib_wifi.py)

Principales méthodes :

Classe `WiFiAutoSwitcher` (auto_wifi.py)

MQTT

Extension possible

Ajout de commandes MQTT

Interface Web de supervision

Bonnes pratiques

Exemple de sortie console

Maintenance

Auteurs

Licence

Sources

A DECOUVRIR EGALEMENT

PTA 98 Guide Utilisateur & Développeur

🖥️ Démarrer automatiquement une application graphique Python au boot sur Raspberry Pi (méthode .desktop)

Gestion du WI-FI & Hotspot via nmcli

Laisser un commentaire Annuler la réponse

Gestionnaire automatique de connexion Wi-Fi

Introduction

Configuration

Fichier de configuration : wifi_config.txt

Variables importantes dans auto_wifi.py

Installation

Dépendances :

Utilisation

Lancement du programme

Log des événements

Détails techniques

Classe WiFiManager (lib_wifi.py)

Principales méthodes :

Classe WiFiAutoSwitcher (auto_wifi.py)

MQTT

Extension possible

Ajout de commandes MQTT

Interface Web de supervision

Bonnes pratiques

Exemple de sortie console

Maintenance

Auteurs

Licence

Sources

A DECOUVRIR EGALEMENT

PTA 98 Guide Utilisateur & Développeur

🖥️ Démarrer automatiquement une application graphique Python au boot sur Raspberry Pi (méthode .desktop)

Gestion du WI-FI & Hotspot via nmcli

Laisser un commentaire Annuler la réponse

Fichier de configuration : `wifi_config.txt`

Variables importantes dans `auto_wifi.py`

Classe `WiFiManager` (lib_wifi.py)

Classe `WiFiAutoSwitcher` (auto_wifi.py)