Archives par étiquette : python

Envoyez l’heure de coucher du soleil en MQTT

Voici un script Python3 qui permet d’envoyer une trame MQTT formatée json sur le topic de votre choix, contenant l’heure de coucher du soleil. Ici, en vous abonnant à home/sunset, vous recevrez par exemple :

{« sunset_time »: « 17:41:25 », « latitude »: 47.4108, « longitude »: -2.1692, « timestamp »: « 2026-01-11T16:14:45.542727 »}
Notez qu’il est possible de n’avoir que l’heure en modifiant le code comme suit :

# AVANT (JSON)
payload = {
    "sunset_time": sunset_time,
    "latitude": lat,
    "longitude": lon,
    "timestamp": datetime.now().isoformat()
}
result = client.publish(topic, json.dumps(payload), qos=1, retain=True)

# APRÈS (texte simple)
result = client.publish(topic, sunset_time, qos=1, retain=True)
```

Voici le script Json de base :

#!/usr/bin/env python3
"""
Script pour publier l'heure de coucher du soleil via MQTT
"""

import requests
from datetime import datetime
from zoneinfo import ZoneInfo
import paho.mqtt.client as mqtt
import json

# Configuration MQTT
MQTT_BROKER = "localhost"  # Adresse de votre broker MQTT
MQTT_PORT = 1883
MQTT_TOPIC = "home/sunset"
MQTT_CLIENT_ID = "sunset_publisher"
MQTT_USERNAME = "username"      # Remplacez par votre login
MQTT_PASSWORD = "mot_de_passe"  # Remplacez par votre mot de passe

# Configuration localisation - CROSSAC, France
LATITUDE = 47.4108
LONGITUDE = -2.1692
TIMEZONE = "Europe/Paris"  # Fuseau horaire français (gère CET/CEST automatiquement)

def get_sunset_time(lat, lon, timezone="Europe/Paris"):
    """
    Récupère l'heure de coucher du soleil via l'API sunrise-sunset.org
    Retourne l'heure en heure locale du fuseau horaire spécifié
    (gère automatiquement heure d'été/hiver)
    """
    url = f"https://api.sunrise-sunset.org/json?lat={lat}&lng={lon}&formatted=0"
    
    try:
        response = requests.get(url, timeout=10)
        response.raise_for_status()
        data = response.json()
        
        if data['status'] == 'OK':
            sunset_utc = data['results']['sunset']
            # Conversion en objet datetime UTC
            sunset_dt = datetime.fromisoformat(sunset_utc.replace('Z', '+00:00'))
            
            # Conversion en heure locale du fuseau horaire spécifié
            tz = ZoneInfo(timezone)
            sunset_local = sunset_dt.astimezone(tz)
            
            # Format avec indication du fuseau horaire
            heure_locale = sunset_local.strftime("%H:%M:%S")
            fuseau = sunset_local.strftime("%Z")  # CET ou CEST
            
            print(f"  Heure UTC: {sunset_dt.strftime('%H:%M:%S')} UTC")
            print(f"  Heure locale: {heure_locale} {fuseau}")
            
            return heure_locale
        else:
            return None
    except Exception as e:
        print(f"Erreur lors de la récupération du coucher de soleil: {e}")
        return None

def publish_sunset(broker, port, topic, lat, lon, timezone="Europe/Paris"):
    """
    Publie l'heure de coucher du soleil sur le topic MQTT
    """
    sunset_time = get_sunset_time(lat, lon, timezone)
    
    if sunset_time is None:
        print("Impossible de récupérer l'heure du coucher de soleil")
        return False
    
    # Création du payload
    payload = {
        "sunset_time": sunset_time,
        "latitude": lat,
        "longitude": lon,
        "timestamp": datetime.now().isoformat()
    }
    
    try:
        # Connexion au broker MQTT
        client = mqtt.Client(client_id=MQTT_CLIENT_ID)
        
        # Authentification
        client.username_pw_set(MQTT_USERNAME, MQTT_PASSWORD)
        
        client.connect(broker, port, 60)
        
        # Publication du message
        result = client.publish(topic, json.dumps(payload), qos=1, retain=True)
        
        if result.rc == mqtt.MQTT_ERR_SUCCESS:
            print(f"✓ Message publié sur {topic}")
            print(f"  Coucher du soleil: {sunset_time}")
            print(f"  Localisation: {lat}, {lon}")
            return True
        else:
            print(f"✗ Erreur lors de la publication: {result.rc}")
            return False
            
    except Exception as e:
        print(f"Erreur MQTT: {e}")
        return False
    finally:
        client.disconnect()

if __name__ == "__main__":
    # Exemple d'utilisation
    publish_sunset(
        broker=MQTT_BROKER,
        port=MQTT_PORT,
        topic=MQTT_TOPIC,
        lat=LATITUDE,
        lon=LONGITUDE,
        timezone=TIMEZONE
    )

Ce script a été en partie généré par Claude AI

Raspberry Pi Pico W : MQTT et commande de la LED interne

Comment commander la LED interne en toute simplicité sur un Raspberry Pi Pico W ?

Suivez le code ci-après et envoyer le via Thonny par exemple :

import machine
import time
from umqtt.simple import MQTTClient
import network

# Configuration WiFi
ssid = "nom_du_reseau_wifi"
password = "mot_de_passe_wifi"

station = network.WLAN(network.STA_IF)
station.active(True)
station.connect(ssid, password)

while not station.isconnected():
    pass
print("Connexion Wi-Fi établie")


# Configuration client MQTT
mqtt_server = "adresse_serveur_mqtt"
mqtt_port = 1883
mqtt_user = "login_mqtt"
mqtt_password = "mot_de_passe_mqtt"
mqtt_topic = b"/maison/led"
client_id = "wemosd1"
client = MQTTClient(client_id, mqtt_server, mqtt_port, mqtt_user, mqtt_password)

# Set up LED pin
led = machine.Pin("LED", machine.Pin.OUT)

# Define MQTT callback function
def mqtt_callback(topic, msg):
    if topic == mqtt_topic:
        if msg == b"on":
            led.value(1)
            print("LED allumée")
        elif msg == b"off":
            led.value(0)
            print("LED éteinte")

# Subscribe to MQTT topic
client.set_callback(mqtt_callback)
client.connect()
client.subscribe(mqtt_topic)

# Main loop
while True:
    client.check_msg()
    time.sleep(1)

Vous allez pouvoir maintenant tester votre nouveau script en micro-python, par exemple depuis un terminal sous Linux, et allumer la LED interne :

mosquitto_pub -h mon_serveur_mqtt -u mon_login -P mon_mon_de_passe -t "/maison/led" -m "on"

Simple non ? Ce script a été généré à la base par ChatGPT, mais a par la suite été modifié pour corriger quelques erreurs.

 

 

Raspberry Pi Pico W : utilisation de la LED interne

Voici venir le tout nouveau Raspberry Pi Pico W, avec le WiFi intégré :

Force est de constater que cette p’tite framboise à 6 € offre de multiples possibilités pour qui voudra programmer en Python, oubliant le langage plutôt hermétique des ardui-bidules, pas forcément ma tasse de thé vous l’aurez compris.

Nous allons voir ici comment connecter le Pico W au WiFi, créer une simple page Web et venir allumer la LED interne sitée à proximité du connecteur USB. Nous supposerons que vous avez déjà installé le firmware et allez utiliser Thonny, le soft idéal pour programmer et injecter vos scripts python.

Commençons par créer un fichier secrets.py que nous allons sauvegarder sur le Pico W, fichier qui aura le contenu suivant :

SSID = "nom_du_réseau_wifi"
PASSWORD = "clé_de_sécurité"

Passons ensuite au script principal qui sera lui sauvegardé dans main.py sur le Pico W :

import usocket as socket
import network
from machine import Pin
import secrets

wlan = network.WLAN(network.STA_IF)
wlan.active(True)
wlan.connect(secrets.SSID, secrets.PASSWORD)
light = machine.Pin("LED", machine.Pin.OUT)

Led = "ON"

htmlresponse = """HTTP/1.0 200 OK
Content-Type: text/html

<!DOCTYPE html>
<meta charset="UTF-8">
<html>
    <head>
        <title>Serveur RaspiPicoW</title>
    </head>
    <body>
        <p>Etat de la LED : {} </p>
        <p> <a href = "/?etat=on" >Led ON </a>  </p>
        <p> <a href = "/?etat=off" >Led OFF </a> </p>
        <p> <a href = "/?etat=toggle" >TOGGLE </a> </p>
    </body>
</html>
"""

def connexion_wifi(ssid,password):
    wlan = network.WLAN(network.STA_IF)
    wlan.active(True)
    if not wlan.isconnected():
        print("connexion",ssid)
        wlan.connect(secrets.SSID, secrets.PASSWORD)
        while not wlan.isconnected():
            pass
    print("Adresse IP :", wlan.ifconfig()[0])
    print("Masque réseau : ", wlan.ifconfig()[1])
    print("Gateway :", wlan.ifconfig()[2])
    print("Serveur DNS :", wlan.ifconfig()[3])
    return wlan.ifconfig()[0]

AdresseIP = connexion_wifi(secrets.SSID, secrets.PASSWORD)
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
s.bind((AdresseIP,8080))
s.listen(1)

while True :
    print("Attente connexion ...")
    connexion = s.accept()
    ClientAddress = connexion[1]
    ClientSocket = connexion[0]
    print("Adresse client connecté :",ClientAddress[0])
    request = ClientSocket.recv(2048)
    Lrequest = request.decode('utf-8').split(' ')
    if Lrequest[0] == 'GET' :
        url =Lrequest[1]
        if url[0:7] =="/?etat=":
            if url[7:] == 'on':
                light.on()
                Led = "ON"
            elif url[7:] == 'off':
                light.off()
                Led = "OFF"
            elif url[7:] == 'toggle':
                light.toggle()
        ClientSocket.send(htmlresponse.format(Led))
    ClientSocket.close()

Il ne vous reste plus qu’à exécuter le script, le Shell vous affichera l’adresse IP obtenue une fois le WiFi connecté. Rendez vous sur cette adresse IP via votre navigateur internet et hop :

La page web interne s’affiche, à vous de jouer maintenant !

Raspberry Pi Zero W : dév python en biologie

Il arrive parfois qu’un client ait besoin d’un développement particulier, ici pour effectuer des mesures biologiques. Je ne rentrerai volontairement pas dans les détails pour le moment, mais je peux vous montrer le proto en cours d’assemblage :

  • Raspberry Pi Zero W
  • Ecran LCD avec boutons et mini-joystick
  • Commande d’une LED via un GPIO
  • Sonde en I2C (visible à droite de la vidéo)

 

On presse sur le mini-joystick, un flash, le capteur mesure la luminosité du moment et enregistre la valeur dans un fichier CSV.
Bien entendu, ceci n’est qu’un proto destiné à valider une solution technique : les vrais éléments prendront place plus tard, bien plus tard.

 

Waveshare e-Paper et Raspberry Pi ZeroW

Waveshare propose des écrans e-Paper de bonne qualité et relativement faciles à installer sur un simple Raspberry Pi Zero W dans notre exemple :

Les instructions d’installation sont sur ce lien.

Le raccordement au Raspberry Pi Zero W est facilité par la présence d’un connecteur JST et de connecteurs à enficher sur le connecteur GpIO de la framboise :

Vous pourrez imprimer en 3D le boitier disponible sur Thingiverse :

En Python, la programmation est relativement simple en installant les librairies epd4in2 disponibles sur Github.

Ces librairies permettront d’afficher une image bmp que vous aurez au préalable générée avec The Gimp par exemple, mais également de venir tracer, via un script Python utilisant PIL, des lignes, des cercles, écrire du texte ou insérer des images comme sur cet exemple d’affichage :

Ici, nous avons récupéré en MQTT les températures et pression locales, via un appel curl les heures de lever et coucher du soleil ainsi que la température à Lyon :

    proc3 = subprocess.Popen(['curl -s http://domogeek.entropialux.com/sun/nantes/sunset/now'], stdout=subprocess.PIPE, shell=True)
    proc4 = subprocess.Popen(['curl -s http://domogeek.entropialux.com/sun/nantes/sunrise/now'], stdout=subprocess.PIPE, shell=True)
    proc5 = subprocess.Popen(['curl -s http://wttr.in/Lyon?format=%t'], stdout=subprocess.PIPE, shell=True)
  
    (out3, err) = proc3.communicate()
    (out4, err) = proc4.communicate()
    (out5, err) = proc5.communicate()
    out5 = out5[:-3]

Les informations récupérées sont stockées dans les variables out3, out4, et out5. A noter qu’out5 supprime les 3 derniers caractères (°C) pour ne pas perturber l’affichage e-Paper.

Pour afficher les images et les re-dimensionner :

    temperature = Image.open('/home/pi/icones/tempelogo.png')
    temperature = temperature.resize((60,60))
    qnh = Image.open('/home/pi/icones/pression.png')
    qnh = qnh.resize((60,60))
    sun = Image.open('/home/pi/icones/sun.png')
    sun = sun.resize((60,60))

    image.paste(temperature,(1,1), temperature)
    image.paste(qnh,(240,1), qnh)
    image.paste(sun,(1,70), sun)

Vous adapterez les noms de fichier selon vos besoins, bien évidemment.

Attention toutefois à ne pas actualiser trop souvent votre écran, les e-Paper ont la réputation de ne pas résister à trop d’appels, sinon passez sur un écran LCD tactile, la version 7″ du Raspberry Pi est relativement sympa et lisible, mais plus gourmande en énergie.

Domoticz : script Python pour envois MQTT simples

On le lit ici et là, Domoticz utilise une façon bien à lui pour publier du MQTT, avec ce Json qui n’est pas forcément toujours très utile ni très pratique. Personnellement, il est même plutôt hermétique j’avoue

Voici donc la raison d’exister de ce petit script Python, mqttpub.py, destiné à être appelé depuis un interrupteur Domoticz par exemple.

Le script pour commencer :



#
#
# Récuperation du topic et du message à envoyer en MQTT :
# python mqttpub.py domoticz/in 1234 par ex
#
sujet = sys.argv[1]
msg = sys.argv[2]
#
# Informations de connexion à votre broker MQTT : 
# adresse IP, login, mot de passe
broker = "192.168.1.200"
login = "login_a_moi"
pwd = "mon_password"
#
# on se connecte au broker et on publie le message sur le topic
#
client = mqtt.Client()
client.username_pw_set(username=login,password=pwd)
client.connect(broker, 1883, 60)
client.publish(sujet, msg, qos=0, retain=False)

Sauvegardez ce script dans /home/pi/domoticz/scripts/python et rendez le exécutable avec un chmod +x mqttpub.py

Sur un switch de Domoticz, vous allez alors ajouter dans On Action et Off Action la ligne :



script://python/mqttpub.py home/sonoff/commands/MQTTtoSRFB 4195665

Ceci est un exemple qui diffuse la trame radio 4195655 sur un Sonoff Bridge flashé avec OpenMQTTGateway : à vous de l’adapter à vos trames MQTT. 

Wifipak Mini + imprimante : développements en labo

De nouveaux développements sont en cours pour le hotspot Wifipak Mini livré avec imprimante de codes.

Désormais, il vous est possible de générer des codes sur mesure avec ou sans impression :

Dans ce cas, retenez le code, il ne sera pas imprimé, pas affiché, juste transmis à votre gestionnaire Wifipak Mini et c’est tout : pratique pour économiser du papier ! De même, les codes générés manuellement peuvent fonctionner sur une durée d’une année : là encore, c’est très pratique si vous avez des utilisateurs sur une longue durée, un camping par exemple, ou des résidences hôtelières.

En développement, nous avons un système permettant de générer des coupons sous forme de planche à imprimer sur une imprimante ordinaire :

Pour le moment nous n’avons pas modifié les quantités de 1, 5 et 10 coupons, le temps de valider le processus en labo. Une fois le choix effectué, par exemple 10 codes d’une journée, vous obtenez l’affichage d’une planche sous forme d’image :

Cette planche peut être imprimée sur votre laser ou jet d’encre du bureau, vous pouvez également faire un clic droit pour la sauvegarder sous forme d’image et l’imprimer ultérieurement.La fonctionnalité sera sans doute disponible sous forme de 10, 20 ou 30 codes. Il nous faut maintenant améliorer le temps de traitement, une génération de 30 codes prenant actuellement environ 30 secondes.

Un script interne a également été remis à jour, script qui se charge de gérer les utilisateurs expirés et qui pouvait poser quelques soucis à certains moments.

Toutes ces fonctionnalités seront gratuitement disponibles, le moment venu, aux utilisateurs actuels de Wifipak Mini + imprimante qui en feront la demande : nous vous demanderons certains accès à distance sur votre matériel, le temps de venir injecter les nouveaux fichiers (ssh, ftp, http essentiellement).

Pour finir, le développement d’un module tactile est toujours en cours : appuyez sur un petit écran de 7″ pour générer des codes d’une heure, un jour, une semaine, ou un mois, avec des quantités de 1, 5, ou 10 pièces.

Sur ce projet novateur, nous avons besoin de vérifier la bonne tenue en charge du petit Raspberry Pi 3 utilisé, tenue en charge de son alimentation également, et tester la résistance de l’ensemble sur une longue durée. Rien n’est encore fait, mais le prototype utilisé en labo est opérationnel, très simple et souple d’emploi : posez le sur un comptoir, et imprimez sans avoir à utiliser votre ordinateur ! Difficile de faire plus simple !

 

Mikrotik : un « UserManager » pas au point !

Avec le développement de l’impression de tickets sur les hotspots Mikrotik, j’ai pu pas mal jouer avec le fameux User Manager, destiné à gérer les utilisateurs, leur affecter des profils, des durées, des limitations. Ce petit ajout au firmware RouterOS qui équipe les matériels Mikrotik semblait, sur le papier, plutôt sympa. Pour dialoguer avec, une simple connexion SSH initiée depuis un script Python sur un p’tit Raspberry Pi. Ca, c’est du moins la théorie, car en pratique, plusieurs bugs semblent subsister sur ce User Manager, et pas des moindres :

[badlist]

  • l’ajout d’utilisateur en ssh fonctionne, mais affecter un profil ne fonctionne qu’une fois sur deux : il faut envoyer la commande, vérifier, renvoyer la commande, vérifier, etc. Cela prend du temps, et lorsque vous voulez générer des dizaines de codes, la galère prend rapidement l’eau.
  • un utilisateur reçoit un profil qui lui attribue une durée d’utilisation : 1 jour, 1 heure, 1 minute, c’est vous qui décidez. Cela fonctionne super bien, sauf qu’une fois la durée expirée, votre utilisateur restera en mémoire : pas moyen de lister simplement tous les utilisateurs expirés. On les voit dans la liste car ils n’ont alors plus de profil mentionné : les supprimer supposerait de charger TOUTE la liste, de venir chercher utilisateur après utilisateur ce que contient la configuration, d’inscrire les logins à supprimer, etc. Imaginez le script de manipulation de chaine bien lourd qu’il faudrait, alors qu’une simple commande /tool usermanager delete expired aurait été d’un emploi si simple…. ben non 🙁

[/badlist]

 

De ce fait, après une journée perdue passée à cherche une solution fiable, stable, et universelle, force est de constater qu’il fallait se passer de ce User Manager encore trop peu stable pour un usage professionnel intensif et automatisé. Je précise bien automatisé car si vous gérez tout depuis l’interface d’administration, forcément cela fonctionne sans trop de soucis. Par contre, vous perdez alors la possibilité d’imprimer des coupons et n’avez toujours pas de fonctionnalité pour supprimer les codes expirés… on tourne en rond 🙁

Imprimante tickets pour hotspot Mikrotik

Retour donc à une solution plus simple, plus pratique : le gestionnaire utilisateur directement géré par la fonction /ip hotspot du firmware, et basta ! Là, la génération de code est bien plus simple : un login, un mot de passe, une durée et c’est tout ! Pas besoin de venir ajouter un profile ou je ne sais quoi d’autre.

Lorsque nous générons un code, voyons ce qu’il donne depuis l’accès ssh au hotspot :

name=« wsxb » password=« awfn » profile=default limit-uptime=1h uptime=0s bytes-in=0 bytes-out=0 packets-in=0 packets-out=0

limit-uptime=1h indique que ce code, wsxb dispose d’1 heure d’accès, pas plus. uptime=0s montre que le code n’a pas encore expiré, sans quoi nous aurions uptime=1h et là, nous pourrions clairement identifier le code pour venir le supprimer, étant expiré.

En conclusion, l’utilisation de RouterOS n’est pas si simple, les bugs subsistent et certaines fonctionnalités manquent cruellement. Si vous n’avez pas besoin de limiter vos utilisateurs autrement que sur la durée, User Manager ne vous sera d’aucune utilité. Espérons juste qu’il évolue vers une version plus « capable » et soit un jour en mesure d’effacer simplement les codes expirés.

 

Wifipak mini : hotspot avec imprimante de tickets

La solution Wifipak Mini avec une imprimante de tickets arrive, le développement en labo se présente plutôt bien, jugez plutôt avec l’interface d’administration :

Ici, depuis une interface Web disponible sur votre hotspot, vous allez pouvoir générer vos coupons sur demande, un client à la fois, voir 5, ou même 10 si un groupe se présente. Vous pourrez également effacer les coupons expirés, ou même effacer TOUS les utilisateurs de votre hotspot WiFi, mais attention à ne pas cliquer au mauvais endroit…

Lorsque vous cliquez pour générer un coupon, le système va exécuter un script, générer un login et un mot de passe, l’envoyer à votre hotspot Wifipak Mini, générer un ticket, l’imprimer et couper le papier. A la fin, une fenêtre pop-up s’affiche, vous indiquant la fin de l’impression, vous pouvez passer au ticket suivant.

La génération via une interface web s’accompagnera d’une génération via un simple clavier numérique relié en usb sur votre contrôleur : les touches 0 à 9 permettront d’activer une génération rapide des coupons, sans avoir à utiliser votre ordinateur. C’est simple, rapide, efficace !

Dans le conception de ce produit, nous avons opté pour certains critères, quitte à faire augmenter un peu le prix de revient, mais c’est une condition sine-qua-non pour avoir une durabilité :

  • un Raspberry Pi 3 pour la gestion
  • Raspbian pour le système d’exploitation (pas question ici de programmer avec Winchose et ses multiples bugs à répétition lol)
  • une imprimante Brother QL-570 : ce choix est dicté par un papier de bonne qualité, en rouleau continu (contrairement à Dymo qui propose des rouleaux d’étiquettes), une impression thermique (= pas de cartouche à changer), un matériel utilisé ici depuis plusieurs années, sans failles.

  • un clavier USB « commercial » : pas de bricolage sur le Raspberry Pi pour venir ajouter un bouton, pas de perçages horribles, aucun risque de mauvais contact sur la durée.

A terme, il n’est pas exclu de concevoir un bloc écran tactile + Raspberry Pi :

Mais, car il y a un mais, cela ajoute encore un peu plus d’euros au prix de revient, est-ce bien une idée ? L’autre mais, c’est l’exploitation de l’écran, pouvoir utiliser un script qui va véritablement afficher ce que nous voulons, sans afficher l’environnement graphique du Raspberry Pi mais uniquement un écran avec des pavés de sélection, sans autre accès possible pour ne pas remettre en question la stabilité de l’appareil ?

Nous allons prochainement vérifier si la p’tite framboise est capable de gérer à la fois la génération des accès hotspot ET l’enregistrement des connexions. Logiquement oui, à condition de bien concevoir et d’optimiser les scripts.

 

Mikrotik, hotspot, et imprimante

Longtemps assez dégoûté du peu d’ergonomie de RouterOS, le firmware des matériels Mikrotik, j’ai été contraint de passer énormément de temps pour chercher à mieux le comprendre. Désormais, maitrisant le système, il est facile de venir développer des solutions originales, comme la gamme Wifipak Mini par exemple, et ce n’est pas terminé.

Wifipak Mini + 4 bornes PoE

C’est souvent en expérimentant qu’arrivent souvent les idées intéressantes. Tenez, là il est question d’aller générer des utilisateurs à la volée dans le User Manager de Mikrotik, depuis un script Python sur un Raspberry Pi, et pourquoi pas le Raspberry Pi utilisé comme enregistreur de connexions tiens !

Prenons donc notre Mikrotik préconfiguré en hotspot, muni de son User Manager, sans mot de passe, avec l’IP 192.168.1.123. Depuis notre Raspberry Pi, nous allons créer le script Python mikro.py après avoir installé au préalable Paramiko (je vous laisse chercher un peu sur Google, c’est assez simple) :

from random import choice
from string import digits
from string import ascii_lowercase
import paramiko
import time
target = '192.168.1.123'
ssh = paramiko.SSHClient()
ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())
ssh.connect(target, username='admin', password='', look_for_keys=False)
for x in range(0,10):
  login=''.join(choice(ascii_lowercase) for i in range(4))
  mdp=''.join(choice(ascii_lowercase) for i in range(4))
  msg = "/tool user-manager user add customer=admin username=us" + login + " password=" + mdp
  msg2 = "/tool user-manager user create-and-activate-profile us" + login + " customer=admin profile=wifipakmini"
  stdin,stdout,stderr = ssh.exec_command(msg)
  stdin,stdout,stderr = ssh.exec_command(msg2)
  time.sleep(0.8)
  stdin,stdout,stderr = ssh.exec_command(msg2)

A chaque exécution du script, nous allons générer deux variables, login et mdp contenant respectivement le login et le mot de passe d’un utilisateur. Cet utilisateur va être créé dans le gestionnaire Mikrotik et sera affecté au profile wifipakmini qui indique le temps disponible en ligne, 1 minute pour les essais.

Sur notre Mikrotik de test, peu puissant, une pause est nécessaire, ainsi qu’une répétition des commandes, sans cela certains utilisateurs ne sont pas affectés au profil wifipakmini et ne fonctionnent donc pas.

Ce script tourne 10 fois et va au final générer 10 utilisateurs d’un coup avec des logins qui débutent par « us ». Quel intérêt puisque le gestionnaire intégré permet de le faire ? Réfléchissez un peu, imaginez les possibilités et vous trouverez des applications potentiellement intéressantes.. En effet, si toi, ami Geek, tu es capable d’aller gérer en direct depuis le gestionnaire, quid de Mme Michu, paumée au fin fond de la Creuse, sans connaissances poussées en hotspot ? Ne va-t-elle pas préférer générer ses utilisateurs automatiquement et dans un langage clair, via une p’tite page html sur le Raspberry Pi par exemple ?

Allez, poussons un peu plus notre script, avec cette fois un nouveau, efface.py, qui sera lancé deux fois par jour par un simple Crontab sur le Raspberry Pi :

import paramiko
target = '192.168.1.123'
ssh = paramiko.SSHClient()
ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())
ssh.connect(target, username='admin', password='', look_for_keys=False)
msg = "/tool user-manager user remove [find uptime-used=1m]"
stdin,stdout,stderr = ssh.exec_command(msg)
print stdout.read()

Ici, nous allons chercher tous les utilisateurs ayant utilisé leur temps de connexion, 1m (= 1 minute) pour nos essais, mais ce peut-être 1d (= 1 jour) si vous modifiez le profil wifipakmini du gestionnaire Mikrotik. Tous les utilisateurs ayant la mention 1m dans uptime-used (= temps de connexion utilisé) seront ainsi effacés, évitant de saturer le hotspot avec des codes dévalidés.

Et après ?

Eh oui, tout ceci est bien mimi, c’est choupinou de générer des scripts, des utilisateurs, le principe fonctionne, mais après, que faire ? Imaginons par exemple que nous allons générer des planches avec tous les codes regroupés sur une seule et même feuille : le script se lance, une planche s’affiche en pdf ou en png, vous l’imprimez, tout ceci de façon simple, via un bout de script Php sur le Raspberry Pi, chargé de lancer toutes les actions.

Imaginons également que l’on vienne brancher une imprimante à tickets sur le Raspberry Pi : vous allez ainsi pouvoir générer un ticket à volonté, pourquoi pas en n’appuyant que sur un simple bouton installé sur la p’tite framboise. Et hop, un hotspot avec imprimante à ticket, pour un coût réduit, largement inférieur aux solutions commerciales habituelles, tel ce pack Zyxel vendu près de 1900 € avec enregistreur, WiFi local et imprimante :

Avec un calcul rapide et pas du tout optimisé, une solution équivalente pourrait sortir à bien moins cher, plus de deux fois moins cher en tout cas.

Vous le voyez, se creuser la tête avec des produits issus du monde libre permet de pas mal s’amuser. Le Raspberry Pi est un allié précieux pour développer, sa petite taille et sa modularité en font un outil indispensable pour développer de nouveaux projets.