Pont Bascule Connector (Raspberry Pi) — FastAPI + Serial + Tailscale

API HTTP (FastAPI) qui pilote un pont bascule connecté en USB (port série) sur Raspberry Pi.

Objectif : permettre à une application/serveur distant d'interroger le pont bascule via réseau (Tailscale), avec une contrainte stricte : 1 requête série à la fois.

---

Fonctionnement global

Client (PC / serveur / app) --HTTP--> Raspberry Pi (FastAPI)
                                      |
                                      | 1 appel à la fois (lock)
                                      v
                                Port série (/dev/ttyUSB0)
                                      |
                                      v
                                 Pont bascule

Accès distant :

• via IP Tailscale 100.x.x.x (VPN mesh)
• optionnellement via tailscale serve pour exposer l'API sur le port 80 sans :8000

---

Prérequis

Raspberry Pi

• Raspberry Pi OS (Lite recommandé)
• Python 3
• Accès SSH
• Tailscale installé et connecté

Matériel

• Pont bascule branché en USB (ou via adaptateur USB↔RS232/RS485 selon le matériel)

---

Installation (Raspberry Pi)

1) Récupérer le projet

cd ~
git clone <URL_DE_TON_REPO> pont-bascule-connector
cd pont-bascule-connector

2) Environnement Python

Deux options :

Option A : venv global (recommandé si déjà en place)

python3 -m venv /home/malio/venv
source /home/malio/venv/bin/activate
pip install --upgrade pip
pip install -r requirements.txt

Option B : venv dans le projet

python3 -m venv ./venv
source ./venv/bin/activate
pip install --upgrade pip
pip install -r requirements.txt

3) Configuration série (.env)

Créer un fichier .env à la racine du projet :

cd ~/pont-bascule-connector
nano .env

Exemple :

SERIAL_PORT=/dev/ttyUSB0
SERIAL_BAUDRATE=9600
SERIAL_TIMEOUT_S=1.0
SERIAL_OPEN_DELAY_S=2.0
SERIAL_POST_WRITE_DELAY_S=0.5

Notes importantes :

• SERIAL_OPEN_DELAY_S=2.0 et SERIAL_POST_WRITE_DELAY_S=0.5 reproduisent le comportement du script Tkinter historique :
  • attente 2s après ouverture du port
  • envoi trame
  • attente 0.5s
  • lecture une seule fois de in_waiting
• Si ton port est /dev/ttyACM0, adapte SERIAL_PORT

4) Droits port série (dialout)

Vérifier les devices :

ls /dev/ttyUSB* 2>/dev/null || true
ls /dev/ttyACM* 2>/dev/null || true
dmesg | tail -n 30

Ajouter l'utilisateur au groupe dialout :

sudo usermod -aG dialout malio
sudo reboot

---

Lancer l'API (mode manuel)

source /home/malio/venv/bin/activate   # ou ./venv/bin/activate
uvicorn app.main:app --host 0.0.0.0 --port 8000

Test local :

curl http://127.0.0.1:8000/health

---

Lancer l'API au démarrage (systemd)

1) Créer le service

sudo nano /etc/systemd/system/pont-bascule-api.service

Contenu (adapter les chemins si nécessaire) :

[Unit]
Description=Pont bascule API (FastAPI)
After=network-online.target tailscaled.service
Wants=network-online.target

[Service]
User=malio
WorkingDirectory=/home/malio/pont-bascule-connector
EnvironmentFile=/home/malio/pont-bascule-connector/.env
ExecStart=/home/malio/venv/bin/uvicorn app.main:app --host 0.0.0.0 --port 8000
Restart=always
RestartSec=2

[Install]
WantedBy=multi-user.target

2) Activer et démarrer

sudo systemctl daemon-reload
sudo systemctl enable --now pont-bascule-api
sudo systemctl status pont-bascule-api --no-pager

3) Logs

journalctl -u pont-bascule-api -f

---

API — Endpoints

Santé

GET /health

Exemple :

curl http://127.0.0.1:8000/health

Dernière réponse (debug)

GET /last

Envoi trame "Esclave"

POST /send/esclave

curl -X POST http://127.0.0.1:8000/send/esclave

Envoi trame "DSD"

POST /send/dsd

curl -X POST http://127.0.0.1:8000/send/dsd

Envoi trame custom (hex)

POST /send/custom

curl -X POST http://127.0.0.1:8000/send/custom \
  -H "Content-Type: application/json" \
  -d '{"hex":"01 0D 0A"}'

Format de réponse

La réponse renvoie :

• response_ascii : texte décodé ASCII (souvent le poids + infos)
• response_hex : trame brute
• duration_ms : durée de l'opération
• error : message d'erreur si problème

Exemple (indicatif) :

{
  "ok": true,
  "mode": "serial",
  "port": "/dev/ttyUSB0",
  "baudrate": 9600,
  "request_hex": "01 0D 0A",
  "response_hex": "30 30 31 32 2E 33 34 20 6B 67",
  "response_ascii": "0012.34 kg",
  "duration_ms": 2600,
  "error": null
}

---

Contrainte "1 appel à la fois" (important)

Le port série ne doit pas être utilisé en concurrence.

Si une requête est déjà en cours, l'API renvoie :

• HTTP 409
• message BUSY

---

Accès à distance via Tailscale

1) Vérifier Tailscale

Sur le Raspberry :

tailscale status
tailscale ip -4

Exemple : IP Tailscale du Pi 100.122.43.54.

2) Appeler l'API via Tailscale (simple)

curl http://100.122.43.54:8000/health
curl -X POST http://100.122.43.54:8000/send/esclave

3) Option recommandée : exposer sans port avec tailscale serve

Sur le Raspberry :

sudo tailscale serve --http=80 localhost:8000
sudo tailscale serve status

Ensuite :

curl http://100.122.43.54/health
curl -X POST http://100.122.43.54/send/esclave

4) SSH via Tailscale

tailscale ssh malio@raspberrypi

---

Dépannage rapide

API down

sudo systemctl status pont-bascule-api --no-pager
journalctl -u pont-bascule-api -n 100 --no-pager

Port série introuvable

ls /dev/ttyUSB* /dev/ttyACM* 2>/dev/null
dmesg | tail -n 50

Permission refusée

groups
# dialout doit apparaître

Pas de réponse

• vérifier le baudrate
• vérifier le port /dev/ttyUSB0 vs /dev/ttyACM0
• augmenter SERIAL_POST_WRITE_DELAY_S (ex: 1.0) si la réponse arrive lentement

---

Sécurité recommandée (à faire)

1. Exposer l'API uniquement via Tailscale :

   • faire écouter uvicorn en local seulement (--host 127.0.0.1)
   • utiliser tailscale serve comme reverse proxy

2. Ajouter un token API si besoin (header Authorization)

3. Ajouter une route /weight qui parse la chaîne response_ascii et renvoie weight + unit + ticket proprement.

---

Autres recommandations (vraiment utiles)

1) Sécuriser l'API

Aujourd'hui tu exposes 0.0.0.0:8000 → accessible depuis le LAN.

Si tu veux "Tailscale only" (recommandé) :

• Dans systemd : --host 127.0.0.1
• Et tu actives tailscale serve --http=80 localhost:8000

2) Ajouter une route /weight

Tu m'envoies 1 exemple de response_ascii (exact) et je te code un parseur robuste qui sort :

{
  "weight": 12.34,
  "unit": "kg",
  "ticket": "000123",
  "raw": "..."
}

3) Port série stable (udev)

Si ton port passe parfois de /dev/ttyUSB0 à /dev/ttyUSB1, on peut créer une règle udev pour avoir un nom fixe, genre /dev/pontbascule.