Alessio/docker-voltronic-homeassistant
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

feat(v2.0): Auto-discovery, correzione bug critici, e documentazione completa
Build Docker Image for Raspberry Pi / build-and-push (push) Failing after 4m42s
Details

Browse Source 
🆕 Funzionalità Auto-Discovery
- Aggiunto metodo AutoDiscoverBufferSizes() per rilevamento automatico QPIGS/QPIRI/QMOD/QPIWS
- Supporto variabili d'ambiente (INVERTER_DEVICE, MQTT_SERVER, etc.)
- Caching persistente buffer sizes in /cache/inverter.conf.cache
- Flag -a/--auto-discover per modalità auto-detection

🐛 Bug Fixes Critici
- **Parsing interi**: Aggiunta attemptAddSettingInt() con stoi() invece di stof()
  - Fix: stof('98') = 98.0f → 97 (int), ora stoi('98') = 98 direttamente
  - Applicato a: qpiri, qpiws, qmod, qpigs
- **Thread sync**: Aggiunto ups_qpiws_changed a main loop e condizione exit poll()
  - Fix: loop principale controllava solo 3 flag su 4, causava hang
  - Fix: thread poll() non usciva in runOnce perché mancava controllo QPIWS
- **Config accuracy**: Corretti buffer sizes (qpiri: 98→103, qpiws: 36→40)
  - Rimosso sources/inverter-cli/inverter.conf che sovrascriveva config globale
  - Validato con test: inverter_poller -1 completa in 6s con JSON completo

📚 Documentazione Completa
- Creato documentation/CODE_ARCHITECTURE.md (38KB)
  - Mappa logica variabili globali
  - Flusso esecuzione main() con diagrammi ASCII
  - Sequence diagram classe cInverter (poll, query, auto-discovery)
  - Thread synchronization diagrams
  - MQTT integration bash scripts flow
  - Mappa concettuale 5-layer system architecture
  - Error handling e performance optimizations
- Organizzati file .md in documentation/ (AUTO_DISCOVERY, IMPLEMENTATION, QUICKSTART, DEBUG)
- Aggiornato README.md con sezione v2.0 e indice documentazione
- Aggiornato .github/copilot-instructions.md con novità v2.0

🔧 Miglioramenti Build & CI/CD
- Gitea Actions per build multi-arch (arm/v6, arm/v7, arm64, amd64, 386)
- Configurazione VS Code completa (tasks, launch, debug GDB)
- Script test-autodiscovery.sh e test-device.sh

✅ Testing Validato
- inverter_poller -1 completa in 6 secondi
- Output JSON completo con tutte le metriche
- Exit pulito senza timeout (exit code 0)
- Tutte le 4 query QMOD/QPIGS/QPIRI/QPIWS funzionanti
This commit is contained in:
Pi Developer
2026-01-25 15:00:48 +01:00
parent ac2642639f
commit 6af9fcad7e
30 changed files with 4503 additions and 139 deletions
Download Patch File Download Diff File Expand all files Collapse all files
.gitea/ACTIONS.md
+116
View File
@@ -0,0 +1,116 @@
# Gitea Actions per Docker - Raspberry Pi
Questo progetto utilizza Gitea Actions per automatizzare la build e il deployment delle immagini Docker per architetture ARM (Raspberry Pi).
## Workflows Disponibili
### 1. docker-build.yml
Build e push automatico delle immagini Docker multi-architettura per Raspberry Pi.
**Trigger:**
- Push su branch `main`, `master`, o `develop`
- Creazione di tag con pattern `v*` (es. v1.0.0)
- Pull request su `main` o `master`
**Architetture supportate:**
- `linux/arm/v6` - Raspberry Pi Zero, Pi 1
- `linux/arm/v7` - Raspberry Pi 2, 3, 4 (32-bit)
- `linux/arm64` - Raspberry Pi 3, 4 (64-bit)
### 2. docker-test.yml
Test della build Docker senza pubblicazione.
**Trigger:**
- Pull request su branch principali
### 3. docker-cleanup.yml
Pulizia periodica delle immagini Docker vecchie.
**Trigger:**
- Schedulato: ogni domenica alle 2:00 AM
- Manuale: tramite workflow_dispatch
## Configurazione
### Secrets Richiesti
Per utilizzare questi workflows, devi configurare i seguenti secrets in Gitea:
1. **DOCKER_USERNAME**: Il tuo username Docker Hub
2. **DOCKER_PASSWORD**: Il tuo password/token Docker Hub
#### Come aggiungere i secrets in Gitea:
1. Vai nelle impostazioni del repository
2. Seleziona `Secrets` → `Actions`
3. Aggiungi i seguenti secrets:
- Nome: `DOCKER_USERNAME`, Valore: `tuo-username-dockerhub`
- Nome: `DOCKER_PASSWORD`, Valore: `tuo-password-o-token-dockerhub`
### Configurazione Runner Gitea
Assicurati di avere un Gitea Actions runner configurato. Se stai usando un Raspberry Pi come runner:
```bash
# Installa il runner Gitea (act_runner)
wget https://dl.gitea.com/act_runner/latest/act_runner-latest-linux-arm64 -O act_runner
chmod +x act_runner
# Registra il runner
./act_runner register --instance https://tuo-gitea-server.com --token IL_TUO_TOKEN
# Avvia il runner
./act_runner daemon
```
## Tag e Versioning
Le immagini Docker vengono taggate automaticamente:
- `latest` - ultima versione del branch principale
- `main` / `master` / `develop` - nome del branch
- `v1.2.3` - versioni semver dai tag Git
- `1.2` - major.minor dai tag semver
- `pr-123` - numero della pull request
## Build Locale
Per testare la build localmente:
```bash
# Build per Raspberry Pi 4 (64-bit)
docker buildx build --platform linux/arm64 -f Dockerfile.multiarch -t ha-voltronic-mqtt:test .
# Build per Raspberry Pi 3 (32-bit)
docker buildx build --platform linux/arm/v7 -f Dockerfile.multiarch -t ha-voltronic-mqtt:test .
# Build multi-arch (richiede buildx con QEMU)
docker buildx build --platform linux/arm/v6,linux/arm/v7,linux/arm64 \
-f Dockerfile.multiarch -t ha-voltronic-mqtt:test .
```
## Cache
I workflow utilizzano GitHub Actions cache (compatibile con Gitea) per velocizzare le build successive:
- `cache-from: type=gha` - utilizza cache esistente
- `cache-to: type=gha,mode=max` - salva cache completa
## Troubleshooting
### Build fallisce con "platform not supported"
Verifica che il runner abbia QEMU installato e configurato per l'emulazione multi-arch.
### Secrets non trovati
Assicurati di aver configurato correttamente i secrets nelle impostazioni del repository Gitea.
### Runner non esegue i workflow
Verifica che il runner sia attivo e registrato correttamente con il comando:
```bash
./act_runner daemon --log-level debug
```
## Note
- Le build multi-arch possono richiedere diversi minuti, specialmente su hardware limitato
- Per Raspberry Pi si consiglia di usare un server separato per le build, non il Pi stesso
- Il workflow utilizza Docker Buildx per supporto multi-architettura
.gitea/workflows/docker-build.yml
+69
View File
@@ -0,0 +1,69 @@
name: Build Docker Image for Raspberry Pi
on:
push:
branches:
- main
- master
- develop
tags:
- 'v*'
pull_request:
branches:
- main
- master
jobs:
build-and-push:
runs-on: ubuntu-latest
steps:
- name: Checkout code
uses: actions/checkout@v3
- name: Set up QEMU
uses: docker/setup-qemu-action@v2
with:
platforms: linux/arm/v6,linux/arm/v7,linux/arm64
- name: Set up Docker Buildx
uses: docker/setup-buildx-action@v2
- name: Docker meta
id: meta
uses: docker/metadata-action@v4
with:
images: |
${{ secrets.DOCKER_USERNAME }}/ha-voltronic-mqtt
tags: |
type=ref,event=branch
type=ref,event=pr
type=semver,pattern={{version}}
type=semver,pattern={{major}}.{{minor}}
type=raw,value=latest,enable={{is_default_branch}}
- name: Login to Docker Hub
if: github.event_name != 'pull_request'
uses: docker/login-action@v2
with:
username: ${{ secrets.DOCKER_USERNAME }}
password: ${{ secrets.DOCKER_PASSWORD }}
- name: Build and push Docker image
uses: docker/build-push-action@v4
with:
context: .
file: ./Dockerfile.multiarch
platforms: linux/arm/v6,linux/arm/v7,linux/arm64
push: ${{ github.event_name != 'pull_request' }}
tags: ${{ steps.meta.outputs.tags }}
labels: ${{ steps.meta.outputs.labels }}
build-args: |
BUILD_DATE=${{ github.event.repository.updated_at }}
VERSION=${{ steps.meta.outputs.version }}
VCS_REF=${{ github.sha }}
cache-from: type=gha
cache-to: type=gha,mode=max
- name: Image digest
run: echo ${{ steps.meta.outputs.tags }}
.gitea/workflows/docker-cleanup.yml
+29
View File
@@ -0,0 +1,29 @@
name: Docker Image Cleanup
on:
schedule:
# Esegui ogni domenica alle 2:00 AM
- cron: '0 2 * * 0'
workflow_dispatch:
jobs:
cleanup-old-images:
runs-on: ubuntu-latest
if: github.ref == 'refs/heads/main' || github.ref == 'refs/heads/master'
steps:
- name: Checkout code
uses: actions/checkout@v3
- name: Login to Docker Hub
uses: docker/login-action@v2
with:
username: ${{ secrets.DOCKER_USERNAME }}
password: ${{ secrets.DOCKER_PASSWORD }}
- name: Cleanup old development images
run: |
echo "Pulizia delle immagini Docker vecchie (mantenere solo le ultime 10 versioni)"
# Questo script può essere personalizzato in base alle tue esigenze
# Per ora è solo un placeholder per future implementazioni
echo "Cleanup completato"
.gitea/workflows/docker-test.yml
+46
View File
@@ -0,0 +1,46 @@
name: Test Docker Build
on:
pull_request:
branches:
- main
- master
- develop
jobs:
test-build:
runs-on: ubuntu-latest
steps:
- name: Checkout code
uses: actions/checkout@v3
- name: Set up QEMU
uses: docker/setup-qemu-action@v2
with:
platforms: linux/arm/v7,linux/arm64
- name: Set up Docker Buildx
uses: docker/setup-buildx-action@v2
- name: Test build for ARM platforms
uses: docker/build-push-action@v4
with:
context: .
file: ./Dockerfile.multiarch
platforms: linux/arm/v7,linux/arm64
push: false
build-args: |
BUILD_DATE=${{ github.event.repository.updated_at }}
VERSION=test
VCS_REF=${{ github.sha }}
cache-from: type=gha
cache-to: type=gha,mode=max
- name: Test build dev Dockerfile
uses: docker/build-push-action@v4
with:
context: .
file: ./Dockerfile.dev
platforms: linux/arm/v7
push: false
.github/copilot-instructions.md
+473
View File
@@ -0,0 +1,473 @@
# GitHub Copilot Instructions - Voltronic/Axpert MQTT Home Assistant Integration
## Panoramica del Progetto
Questo progetto è un'applicazione Docker che monitora inverter solari Voltronic, Axpert, MPPSolar PIP, Voltacon, Effekta e altri inverter OEM basati su protocollo RS232. L'applicazione raccoglie dati telemetrici dall'inverter e li invia a Home Assistant tramite MQTT, permettendo anche di inviare comandi per controllare l'inverter remotamente.
### 🆕 Version 2.0 - Auto-Discovery Feature
La versione 2.0 introduce l'**auto-discovery automatica** dei buffer sizes dell'inverter, eliminando la necessità di configurazione manuale. Al primo avvio, l'applicazione:
1. Rileva automaticamente le dimensioni corrette dei buffer per QPIGS, QPIRI, QMOD, QPIWS
2. Salva i valori in `/cache/inverter.conf.cache`
3. Nei successivi avvii, utilizza i valori cached per startup immediato
**Novità tecniche principali:**
- 🔍 **Auto-detection buffer sizes**: Metodo `AutoDiscoverBufferSizes()` con iterazione 80-120 bytes
- ⚙️ **Configurazione ENV**: Supporto variabili d'ambiente (`INVERTER_DEVICE`, `MQTT_SERVER`, etc.)
- 💾 **Caching persistente**: Volume Docker `/cache/` per persistenza tra restart
- 🐛 **Bug fixes critici**:
- Parsing interi: aggiunta `attemptAddSettingInt()` con `stoi()` invece di `stof()` che troncava valori
- Thread sync: aggiunta `ups_qpiws_changed` al loop principale e condizione exit `poll()`
- Config accuracy: corretti buffer sizes (qpiri=98→103, qpiws=36→40)
📖 **Documentazione completa:** [documentation/CODE_ARCHITECTURE.md](../documentation/CODE_ARCHITECTURE.md)
### Architettura
```
┌─────────────────┐
│ Inverter │ ← RS232/USB
│ (Hardware) │
└────────┬────────┘
│
┌────▼────────┐
│ inverter-cli│ (C++ - polling e parsing dati)
│ poller │ 🆕 + Auto-Discovery
└────┬────────┘
│ JSON output
┌────▼────────┐
│ mqtt-push.sh│ (bash - push su MQTT)
│ script │
└────┬────────┘
│ MQTT
┌────▼────────┐
│ Home │
│ Assistant │
└─────────────┘
```
## Struttura del Progetto
### Directory Principali
- **`sources/inverter-cli/`** - Applicazione C++ per la comunicazione con l'inverter
- `main.cpp` - Entry point, parsing argomenti, loop principale, 🆕 auto-discovery
- `inverter.cpp/h` - Classe per gestione comunicazione seriale e polling
- `tools.cpp/h` - Utilities per logging
- `inputparser.cpp/h` - Parser argomenti da riga di comando
- `CMakeLists.txt` - Configurazione build CMake
- **`sources/inverter-mqtt/`** - Script bash per integrazione MQTT
- `entrypoint.sh` - Entry point del container Docker
- `mqtt-init.sh` - Inizializzazione sensori in Home Assistant
- `mqtt-push.sh` - Invio dati MQTT e opzionalmente InfluxDB
- `mqtt-subscriber.sh` - Ascolto comandi da Home Assistant
- **`config/`** - File di configurazione
- `inverter.conf` - Configurazione device seriale, intervalli polling, fattori di correzione
- `mqtt.json` - Configurazione MQTT server, credenziali, topic, mapping InfluxDB
- **`documentation/`** - Documentazione completa del progetto
- `CODE_ARCHITECTURE.md` - 🆕 Mappa logica funzioni/variabili, flusso esecuzione, mappe concettuali
- `AUTO_DISCOVERY.md` - Guida completa auto-discovery feature
- `IMPLEMENTATION.md` - Changelog implementazione v2.0
- `QUICKSTART.md` - Setup rapido e comandi essenziali
- `DEBUG.md` - Guida completa debugging con GDB
- `README.md` - Setup ambiente sviluppo VS Code
- **`homeassistant/`** - Template Lovelace dashboard
- **`.gitea/workflows/`** - Gitea Actions per build automatica multi-arch
## Componenti Chiave
### 1. inverter-cli (C++)
**Linguaggio:** C++11
**Build system:** CMake
**Dependencies:** pthread
#### File principali:
- **main.cpp**:
- Legge configurazione da `/etc/inverter/inverter.conf`
- Supporta flag: `-d` (debug), `-1` (run-once), `-r <command>` (raw command), 🆕 `-a` (auto-discover)
- Output JSON su stdout
- Loop di polling con thread separati
- 🆕 Funzione `attemptAddSettingInt()` per parsing interi (usa `stoi()` invece di `stof()`)
- 🆕 Correzione bug: aggiunto `ups_qpiws_changed` al loop principale
- **inverter.cpp**:
- Classe `cInverter` per comunicazione seriale
- Configurazione porta seriale: 2400 baud, 8N1
- Supporta comandi: QPIGS, QPIRI, QMOD, QPIWS
- CRC checksum verification
- Thread-safe con mutex
- 🆕 Metodo `AutoDiscoverBufferSizes()` per rilevamento automatico
- 🆕 Correzione bug: aggiunto `ups_qpiws_changed` alla condizione di exit del thread `poll()`
- 🆕 Supporto ENV variables per configurazione runtime
#### Comandi supportati dall'inverter:
**Query (lettura dati):**
- `QPIGS` - General Status Parameters (voltaggio, corrente, potenza, batteria)
- `QPIRI` - Current Settings (rated voltages, currents, battery settings)
- `QMOD` - Mode inquiry (Power On, Standby, Line, Battery, Fault, Power Saving)
- `QPIWS` - Warning Status
**Controllo (scrittura):**
- `POP0x` - Set output source priority (Utility/Solar/SBU)
- `PCP0x` - Set charger priority
- `PBDV/PBCV/PBFT/PCVV` - Battery voltage settings
- `PEx/PDx` - Enable/Disable features (buzzer, bypass, power saving, etc.)
### 2. MQTT Integration (Bash)
**mqtt-push.sh**:
- Esegue `inverter_poller -1` per ottenere snapshot JSON
- Parsa JSON con `jq`
- Pubblica ogni metrica su topic separato
- Formato topic: `homeassistant/sensor/{devicename}_{metric}`
- Supporto opzionale InfluxDB
**mqtt-subscriber.sh**:
- Ascolta topic command: `homeassistant/sensor/{devicename}/command`
- Valida comandi con regex
- Esegue `inverter_poller -r <command>` per inviarli
**mqtt-init.sh**:
- Auto-discovery Home Assistant
- Crea configurazione sensori MQTT
- Definisce icone, unità di misura, device class
### 3. Docker Setup
**Dockerfile.multiarch**:
- Base: `debian:stretch`
- Architetture supportate: `linux/arm/v6`, `linux/arm/v7`, `linux/arm64`, `linux/amd64`, `linux/386`
- Build cmake dell'applicazione C++
- Healthcheck ogni 30s
**docker-compose.yml**:
- Servizio `voltronic-mqtt` con privilegi per accesso device
- Mapping device: `/dev/ttyUSB0`, `/dev/ttyS0`, `/dev/hidraw0`
- Volume config: `./config/:/etc/inverter/`
- Watchtower opzionale per auto-update
## Convenzioni di Codice
### C++ (inverter-cli)
- **Standard:** C++11 (`--std=c++0x`)
- **Stile nomi:**
- Classi: `cNomeClasse` (prefisso 'c')
- Metodi: `PascalCase` (es. `GetMode()`, `SetMode()`)
- Variabili locali: `snake_case` (es. `voltage_grid`, `batt_capacity`)
- Variabili globali: `camelCase` (es. `devicename`, `runinterval`)
- Costanti: `UPPER_CASE` (es. `LOG_FILE`)
- **Threading:**
- Usare `std::mutex` per proteggere dati condivisi
- Pattern detached thread per polling: `thread t1(&cInverter::poll, this); t1.detach();`
- Usare `atomic_bool` per flag di stato
- **Logging:**
- Funzione `lprintf()` per debug condizionale
- Scrive su stdout e file di log
- Thread-safe con mutex
- **Error handling:**
- Try-catch per parsing configurazione
- Controllo errno per operazioni file/seriale
- Sleep e retry su errori apertura device
### Bash Scripts
- **Stile:**
- Variabili uppercase per config (es. `MQTT_SERVER`)
- Backtick o `$()` per command substitution
- Controllo valori vuoti: `[ ! -z "$var" ]`
- **Pattern comuni:**
```bash
VAR=`cat /etc/inverter/mqtt.json | jq '.key' -r`
[ ! -z "$VAR" ] && pushMQTTData "metric" "$VAR"
```
## Configurazione
### inverter.conf
```properties
device=/dev/ttyUSB0 # Device seriale (/dev/ttyS0, /dev/hidraw0)
run_interval=120 # Polling frequency (120 = ogni 30s)
amperage_factor=1.0 # Fattore correzione amperaggio
watt_factor=1.01 # Fattore correzione wattaggio
qpiri=103 # 🆕 Buffer size comando QPIRI (corretto da 98)
qpiws=40 # 🆕 Buffer size comando QPIWS (corretto da 36)
qmod=5 # Buffer size comando QMOD
qpigs=110 # Buffer size comando QPIGS
```
### mqtt.json
```json
{
"server": "192.168.1.100",
"port": "1883",
"topic": "homeassistant",
"devicename": "voltronic",
"username": "",
"password": "",
"clientid": "voltronic_<random_hash>",
"influx": {
"enabled": "false",
"host": "http://influxdb:8086",
...
}
}
```
## Build e Deployment
### Build Locale (inverter-cli)
```bash
cd sources/inverter-cli
mkdir -p bin
cmake .
make
./bin/inverter_poller -h
```
### Build Docker
```bash
# Single platform
docker build -f Dockerfile.multiarch -t voltronic-mqtt .
# Multi-platform (richiede buildx)
docker buildx build \
--platform linux/arm/v6,linux/arm/v7,linux/arm64 \
-f Dockerfile.multiarch \
-t voltronic-mqtt:latest .
```
### Debug
```bash
# Test diretto con debug
docker exec -it voltronic-mqtt bash -c '/opt/inverter-cli/bin/inverter_poller -d -1'
# Test comando raw
docker exec -it voltronic-mqtt bash -c '/opt/inverter-cli/bin/inverter_poller -r QPIGS'
# Logs container
docker logs -f voltronic-mqtt
```
## Testing
### Test Comunicazione Inverter
1. Verifica device disponibile: `ls -la /dev/tty*`
2. Test read-only: `inverter_poller -d -1`
3. Test comando: `inverter_poller -r QPIGS`
### Test MQTT
```bash
# Subscribe a tutti i topic
mosquitto_sub -h localhost -t "homeassistant/#" -v
# Pubblica comando test
mosquitto_pub -h localhost \
-t "homeassistant/sensor/voltronic/command" \
-m "QPIGS"
```
## Metriche Principali
### Dati Real-time (QPIGS)
- **AC Grid:** Voltage, Frequency
- **AC Output:** Voltage, Frequency, Load (VA/Watt/%),
- **PV Input:** Voltage, Current, Watts, WattHour
- **Battery:** Voltage, Capacity %, Charge Current, Discharge Current
- **System:** Bus Voltage, Heatsink Temperature, Device Status
- **SCC:** Voltage (Solar Charge Controller)
### Configurazione Inverter (QPIRI)
- Rated values (grid, output, battery)
- Battery settings (recharge, under, bulk, float voltages)
- Max charge currents
- Priorities (output source, charger source)
### Status (QMOD)
1. Power_On
2. Standby
3. Line
4. Battery
5. Fault
6. Power_Saving
## Protocolli e Comunicazione
### RS232 Protocol
- **Baud Rate:** 2400
- **Data bits:** 8
- **Parity:** None
- **Stop bits:** 1
- **Flow control:** None
### Formato Messaggi
**Query:**
```
<command><CRC_HIGH><CRC_LOW><CR>
Esempio: QPIGS + CRC + \r
```
**Response:**
```
(<data> ... <data><CRC_HIGH><CRC_LOW><CR>
Esempio: (230.0 50.0 ... \r
```
### CRC Calculation
- CRC-16-CCITT modificato
- Polynomiale: custom implementation in `inverter.cpp`
- Verifica sia su TX che RX
## Home Assistant Integration
### Auto-Discovery
Il container pubblica automaticamente la configurazione dei sensori MQTT:
- Topic: `homeassistant/sensor/{devicename}_{metric}/config`
- Payload JSON con: name, state_topic, unit_of_measurement, device_class, icon
### Invio Comandi
Pubblica su topic: `homeassistant/sensor/{devicename}/command`
Esempio automation:
```yaml
automation:
- alias: "Switch to Solar Priority Morning"
trigger:
platform: time
at: "06:00:00"
action:
service: mqtt.publish
data:
topic: "homeassistant/sensor/voltronic/command"
payload: "POP01"
```
## Gitea Actions
### Workflows
1. **docker-build.yml** - Build e push multi-arch su tag/push
2. **docker-test.yml** - Test build su PR
3. **docker-cleanup.yml** - Pulizia immagini vecchie (schedulato)
### Secrets Richiesti
- `DOCKER_USERNAME`
- `DOCKER_PASSWORD`
## Troubleshooting
### Problemi Comuni
**"Unable to open device file":**
- Verificare permessi device: `ls -la /dev/ttyUSB0`
- Verificare mapping in docker-compose.yml
- Usare `privileged: true` nel container
**"CRC error":**
- Controllare cablaggio RS232
- Verificare buffer size in inverter.conf
- Provare con debug: `-d` flag
**"MQTT not connecting":**
- Verificare configurazione mqtt.json
- Testare con mosquitto_pub/sub manualmente
- Controllare firewall/rete
**"Wrong values":**
- Calibrare `amperage_factor` e `watt_factor`
- Confrontare con multimetro
- Verificare versione firmware inverter
## Note di Sicurezza
⚠️ **ATTENZIONE:**
- Non inviare comandi senza comprendere l'effetto
- Voltaggio batteria errato può danneggiare le batterie
- Testare in ambiente sicuro prima di produzione
- Backup configurazione inverter prima di modifiche
- Usare voltage/temperature sensors per automazioni critiche
## Risorse Utili
- **Protocol Manual:** `/manual/` directory
- **Forum AEVA:** http://forums.aeva.asn.au/viewtopic.php?t=4332
- **Skyboo Original:** https://skyboo.net/2017/03/monitoring-voltronic-power-axpert-mex-inverter-under-linux/
- **Docker Hub:** bushrangers/ha-voltronic-mqtt
- **Home Assistant MQTT:** https://www.home-assistant.io/integrations/mqtt/
## Suggerimenti per AI Coding
Quando lavori su questo progetto:
1. **Modifiche C++:**
- Sempre verificare thread-safety con mutex
- Testare con `-d -1` dopo modifiche
- Controllare CRC per nuovi comandi
- Mantenere compatibilità con buffer sizes configurabili
- 🆕 Usare `attemptAddSettingInt()` per parsing interi, `attemptAddSetting()` per float
2. **Modifiche Bash:**
- Usare jq per parsing JSON
- Verificare valori non vuoti prima di push MQTT
- Mantenere pattern consistente con script esistenti
3. **Nuove metriche:**
- Aggiungere parsing in main.cpp
- Aggiungere push in mqtt-push.sh
- Aggiungere init in mqtt-init.sh
- Documentare in README.md
4. **Testing:**
- Build prima di commit
- Test con inverter reale se possibile
- Verificare output JSON valido
- Test MQTT end-to-end
- 🆕 Testare sia con `-1` (run-once) che loop continuo
5. **Docker:**
- Testare su architettura ARM prima di push
- Verificare healthcheck funzionante
- Mantenere immagine leggera
- Documentare breaking changes
- 🆕 Verificare volume `/cache/` per persistenza config
6. **🆕 Bug Fixes & Best Practices:**
- **Integer parsing**: Sempre usare `stoi()` per interi, mai `stof()` che tronca valori
- **Thread sync**: Verificare che tutti i flag atomic siano inclusi nelle condizioni di exit
- **Config values**: Usare auto-discovery `-a` per determinare buffer sizes corretti
- **Debug output**: Usare `fprintf(stderr, ...)` per output incondizionato, `lprintf()` per debug
- **Documentazione**: Consultare [CODE_ARCHITECTURE.md](../documentation/CODE_ARCHITECTURE.md) per comprendere il flusso completo
## Version History
- **v1.x** - Supporto base Voltronic
- **v2.0** - 🆕 Multi-arch builds, Gitea Actions, Auto-discovery, Bug fixes critici
- **Future:** Extended inverter models, WebUI, Grafana integration
.github/workflows/build-workflow.yml
-70
View File
@@ -1,70 +0,0 @@
# Docker Hub CI/CD for Multi Arch Images...
name: buildx
on:
pull_request:
branches:
- master
- releases/*
- actions
push:
branches:
- master
- releases/*
- actions
tags:
jobs:
buildx:
runs-on: ubuntu-latest
steps:
-
name: Prepare
id: prepare
run: |
if [[ $GITHUB_REF == refs/tags/* ]]; then
echo ::set-output name=version::${GITHUB_REF#refs/tags/v}
else
echo ::set-output name=version::${GITHUB_SHA::8}
fi
echo ::set-output name=build_date::$(date -u +'%Y-%m-%dT%H:%M:%SZ')
echo ::set-output name=docker_platforms::linux/amd64,linux/arm/v6,linux/arm/v7,linux/arm64,linux/386
echo ::set-output name=docker_image::bushrangers/ha-voltronic-mqtt
-
name: Checkout
uses: actions/checkout@v1
-
name: Set up Docker Buildx
id: buildx
uses: crazy-max/ghaction-docker-buildx@v1
with:
version: latest
-
name: Available platforms
run: echo ${{ steps.buildx.outputs.platforms }}
-
name: Docker Login
if: success()
env:
DOCKER_USERNAME: ${{ secrets.DOCKER_USERNAME }}
DOCKER_PASSWORD: ${{ secrets.DOCKER_PASSWORD }}
run: |
echo "${DOCKER_PASSWORD}" | docker login --username "${DOCKER_USERNAME}" --password-stdin
-
name: Run Buildx (Push to Docker Hub)
run: |
docker buildx build --platform ${{ steps.prepare.outputs.docker_platforms }} \
--output "type=image,push=true" \
--build-arg "BUILD_DATE=${{ steps.prepare.outputs.build_date }}" \
--build-arg "VCS_REF=${GITHUB_SHA::8}" \
--build-arg "VERSION=${{ steps.prepare.outputs.version }}" \
--tag "${{ steps.prepare.outputs.docker_image }}:latest" \
--tag "${{ steps.prepare.outputs.docker_image }}:${{ steps.prepare.outputs.version }}" \
--file Dockerfile.multiarch .
-
name: Clear
if: always()
run: |
rm -f ${HOME}/.docker/config.json
.gitignore
+39 -1
View File
@@ -1,8 +1,46 @@
# Build artifacts
voltronic-cli/bin/skymax.bak voltronic-cli/bin/skymax.bak
voltronic-cli/bin/skymax voltronic-cli/bin/skymax
voltronic-cli/test/ voltronic-cli/test/
CMakeFiles
# CMake build files
CMakeFiles/
CMakeCache.txt CMakeCache.txt
cmake_install.cmake cmake_install.cmake
Makefile Makefile
sources/inverter-cli/bin/
sources/inverter-cli/CMakeFiles/
sources/inverter-cli/CMakeCache.txt
sources/inverter-cli/cmake_install.cmake
sources/inverter-cli/Makefile
# Compiled binaries
*.o
*.a
*.so
*.exe
# IDE files
.DS_Store .DS_Store
*.swp
*.swo
*~
# Logs
*.log
/tmp/inverter.log
# GDB files
gmon.out
core
core.*
# VS Code - keep configuration but ignore local user settings
.vscode/ipch/
.vscode/.cmaketools.json
.vscode/compile_commands.json
# Docker volumes and temp files
docker-compose.override.yml
.env.local
.vscode/c_cpp_properties.json
Vendored
+27
View File
@@ -0,0 +1,27 @@
{
"configurations": [
{
"name": "Linux",
"includePath": [
"${workspaceFolder}/**",
"${workspaceFolder}/sources/inverter-cli",
"/usr/include",
"/usr/local/include"
],
"defines": [],
"compilerPath": "/usr/bin/g++",
"cStandard": "c11",
"cppStandard": "c++11",
"intelliSenseMode": "linux-gcc-arm",
"configurationProvider": "ms-vscode.cmake-tools",
"compileCommands": "${workspaceFolder}/sources/inverter-cli/compile_commands.json",
"browse": {
"path": [
"${workspaceFolder}/sources/inverter-cli"
],
"limitSymbolsToIncludedHeaders": true
}
}
],
"version": 4
}
.vscode/extensions.json
Vendored
+12
View File
@@ -0,0 +1,12 @@
{
"recommendations": [
"ms-vscode.cpptools",
"ms-vscode.cmake-tools",
"twxs.cmake",
"ms-azuretools.vscode-docker",
"timonwong.shellcheck",
"foxundermoon.shell-format",
"redhat.vscode-yaml",
"GitHub.copilot"
]
}
.vscode/launch.json
Vendored
+127
View File
@@ -0,0 +1,127 @@
{
// Use IntelliSense to learn about possible attributes.
// Hover to view descriptions of existing attributes.
// For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
"version": "0.2.0",
"configurations": [
{
"name": "(gdb) Debug inverter_poller",
"type": "cppdbg",
"request": "launch",
"program": "${workspaceFolder}/sources/inverter-cli/bin/inverter_poller",
"args": [
"-d",
"-1"
],
"stopAtEntry": false,
"cwd": "${workspaceFolder}/sources/inverter-cli",
"environment": [],
"externalConsole": false,
"MIMode": "gdb",
"setupCommands": [
{
"description": "Enable pretty-printing for gdb",
"text": "-enable-pretty-printing",
"ignoreFailures": true
},
{
"description": "Set Disassembly Flavor to Intel",
"text": "-gdb-set disassembly-flavor intel",
"ignoreFailures": true
}
],
"preLaunchTask": "build-inverter-cli",
"miDebuggerPath": "/usr/bin/gdb",
"logging": {
"engineLogging": false
}
},
{
"name": "(gdb) Debug inverter_poller - Run Once with Debug",
"type": "cppdbg",
"request": "launch",
"program": "${workspaceFolder}/sources/inverter-cli/bin/inverter_poller",
"args": [
"-d",
"-1"
],
"stopAtEntry": false,
"cwd": "${workspaceFolder}/sources/inverter-cli",
"environment": [],
"externalConsole": false,
"MIMode": "gdb",
"setupCommands": [
{
"description": "Enable pretty-printing for gdb",
"text": "-enable-pretty-printing",
"ignoreFailures": true
}
],
"preLaunchTask": "build-inverter-cli-debug",
"miDebuggerPath": "/usr/bin/gdb"
},
{
"name": "(gdb) Debug inverter_poller - Loop Mode",
"type": "cppdbg",
"request": "launch",
"program": "${workspaceFolder}/sources/inverter-cli/bin/inverter_poller",
"args": [
"-d"
],
"stopAtEntry": false,
"cwd": "${workspaceFolder}/sources/inverter-cli",
"environment": [],
"externalConsole": false,
"MIMode": "gdb",
"setupCommands": [
{
"description": "Enable pretty-printing for gdb",
"text": "-enable-pretty-printing",
"ignoreFailures": true
}
],
"preLaunchTask": "build-inverter-cli-debug",
"miDebuggerPath": "/usr/bin/gdb"
},
{
"name": "(gdb) Debug inverter_poller - Raw Command",
"type": "cppdbg",
"request": "launch",
"program": "${workspaceFolder}/sources/inverter-cli/bin/inverter_poller",
"args": [
"-r",
"QPIGS"
],
"stopAtEntry": false,
"cwd": "${workspaceFolder}/sources/inverter-cli",
"environment": [],
"externalConsole": false,
"MIMode": "gdb",
"setupCommands": [
{
"description": "Enable pretty-printing for gdb",
"text": "-enable-pretty-printing",
"ignoreFailures": true
}
],
"preLaunchTask": "build-inverter-cli-debug",
"miDebuggerPath": "/usr/bin/gdb"
},
{
"name": "(gdb) Attach to running inverter_poller",
"type": "cppdbg",
"request": "attach",
"program": "${workspaceFolder}/sources/inverter-cli/bin/inverter_poller",
"processId": "${command:pickProcess}",
"MIMode": "gdb",
"setupCommands": [
{
"description": "Enable pretty-printing for gdb",
"text": "-enable-pretty-printing",
"ignoreFailures": true
}
],
"miDebuggerPath": "/usr/bin/gdb"
}
]
}
.vscode/settings.json
Vendored
+23
View File
@@ -0,0 +1,23 @@
{
"cmake.sourceDirectory": "/home/pi/Progetti/sources/inverter-cli",
"files.associations": {
"*.h": "cpp",
"*.cpp": "cpp",
"*.sh": "shellscript"
},
"C_Cpp.default.configurationProvider": "ms-vscode.cmake-tools",
"C_Cpp.default.cppStandard": "c++11",
"C_Cpp.default.cStandard": "c11",
"cmake.configureOnOpen": false,
"cmake.buildDirectory": "${workspaceFolder}/sources/inverter-cli/bin",
"editor.formatOnSave": false,
"files.exclude": {
"**/.git": true,
"**/CMakeFiles": true,
"**/CMakeCache.txt": true
},
"search.exclude": {
"**/bin": true,
"**/CMakeFiles": true
}
}
.vscode/tasks.json
Vendored
+128
View File
@@ -0,0 +1,128 @@
{
"version": "2.0.0",
"tasks": [
{
"label": "build-inverter-cli",
"type": "shell",
"command": "cd ${workspaceFolder}/sources/inverter-cli && mkdir -p bin && cmake . && make",
"group": {
"kind": "build",
"isDefault": true
},
"problemMatcher": [
"$gcc"
],
"detail": "Build inverter_poller con cmake (Release mode)"
},
{
"label": "build-inverter-cli-debug",
"type": "shell",
"command": "cd ${workspaceFolder}/sources/inverter-cli && mkdir -p bin && cmake -DCMAKE_BUILD_TYPE=Debug . && make",
"group": "build",
"problemMatcher": [
"$gcc"
],
"detail": "Build inverter_poller con debug symbols (Debug mode)"
},
{
"label": "clean-inverter-cli",
"type": "shell",
"command": "cd ${workspaceFolder}/sources/inverter-cli && rm -rf bin CMakeFiles CMakeCache.txt cmake_install.cmake Makefile",
"group": "build",
"problemMatcher": [],
"detail": "Pulisce i file di build di inverter-cli"
},
{
"label": "rebuild-inverter-cli",
"type": "shell",
"dependsOn": [
"clean-inverter-cli",
"build-inverter-cli"
],
"dependsOrder": "sequence",
"group": "build",
"problemMatcher": [],
"detail": "Pulisce e ricompila inverter_poller"
},
{
"label": "run-inverter-cli-once",
"type": "shell",
"command": "${workspaceFolder}/sources/inverter-cli/bin/inverter_poller -d -1",
"group": "test",
"problemMatcher": [],
"detail": "Esegue inverter_poller una volta con debug",
"dependsOn": "build-inverter-cli",
"presentation": {
"echo": true,
"reveal": "always",
"focus": false,
"panel": "shared",
"showReuseMessage": true,
"clear": false
}
},
{
"label": "run-inverter-cli-loop",
"type": "shell",
"command": "${workspaceFolder}/sources/inverter-cli/bin/inverter_poller -d",
"group": "test",
"problemMatcher": [],
"detail": "Esegue inverter_poller in loop mode con debug",
"dependsOn": "build-inverter-cli",
"isBackground": true,
"presentation": {
"echo": true,
"reveal": "always",
"focus": false,
"panel": "dedicated",
"showReuseMessage": true,
"clear": false
}
},
{
"label": "docker-build",
"type": "shell",
"command": "docker build -f ${workspaceFolder}/Dockerfile.dev -t voltronic-mqtt:dev .",
"options": {
"cwd": "${workspaceFolder}"
},
"group": "build",
"problemMatcher": [],
"detail": "Build Docker image locale per development"
},
{
"label": "docker-run",
"type": "shell",
"command": "docker-compose up -d",
"options": {
"cwd": "${workspaceFolder}"
},
"group": "test",
"problemMatcher": [],
"detail": "Avvia il container con docker-compose"
},
{
"label": "docker-logs",
"type": "shell",
"command": "docker logs -f voltronic-mqtt",
"options": {
"cwd": "${workspaceFolder}"
},
"group": "test",
"problemMatcher": [],
"isBackground": true,
"detail": "Mostra i log del container in tempo reale"
},
{
"label": "docker-stop",
"type": "shell",
"command": "docker-compose down",
"options": {
"cwd": "${workspaceFolder}"
},
"group": "test",
"problemMatcher": [],
"detail": "Ferma il container docker-compose"
}
]
}
README.md
+109 -9
View File
@@ -4,6 +4,19 @@
![License](https://img.shields.io/github/license/ned-kelly/docker-voltronic-homeassistant.svg) ![Docker Pulls](https://img.shields.io/docker/pulls/bushrangers/ha-voltronic-mqtt.png) ![buildx](https://github.com/ned-kelly/docker-voltronic-homeassistant/workflows/buildx/badge.svg) ![License](https://img.shields.io/github/license/ned-kelly/docker-voltronic-homeassistant.svg) ![Docker Pulls](https://img.shields.io/docker/pulls/bushrangers/ha-voltronic-mqtt.png) ![buildx](https://github.com/ned-kelly/docker-voltronic-homeassistant/workflows/buildx/badge.svg)
## ✨ Version 2.0 - Auto-Discovery Feature
Questa versione introduce l'**auto-discovery automatica dei parametri dell'inverter**, eliminando la necessità di configurazione manuale dei buffer sizes. Il container rileva automaticamente i parametri corretti al primo avvio e li salva per utilizzi futuri.
**Novità principali:**
- 🔍 Auto-detection buffer sizes per diversi modelli di inverter
- ⚙️ Configurazione tramite variabili d'ambiente Docker
- 💾 Caching persistente dei parametri scoperti
- 🔄 Multi-inverter support con discovery indipendente
- 🐛 Bug fixes: parsing interi, sincronizzazione thread, gestione QPIWS
📖 **Documentazione completa:** [documentation/](documentation/)
---- ----
The following other projects may also run on the same SBC _(using the same style docker setup as this)_, to give you a fully featured solution with other sensors and devices: The following other projects may also run on the same SBC _(using the same style docker setup as this)_, to give you a fully featured solution with other sensors and devices:
@@ -60,26 +73,40 @@ vi config/inverter.conf
# If your MQTT server does not need a username/password just leave these values empty. # If your MQTT server does not need a username/password just leave these values empty.
vi config/mqtt.json vi config/mqtt.json
# OPTIONAL: Configure auto-discovery environment variables in docker-compose.yml
# See AUTO_DISCOVERY.md for detailed documentation
vi docker-compose.yml
``` ```
Then, plug in your Serial or USB cable to the Inverter & stand up the container: Then, plug in your Serial or USB cable to the Inverter & stand up the container:
```bash ```bash
docker-compose up -d docker-compose up -d
``` ```
_**Note:**_ ### 🆕 Auto-Discovery Feature (v2.0+)
- builds on docker hub are currently for `linux/amd64,linux/arm/v6,linux/arm/v7,linux/arm64,linux/386` -- If you have issues standing up the image on your Linux distribution (i.e. An old Pi/ARM device) you may need to manually build the image to support your local device architecture - This can be done by uncommenting the build flag in your docker-compose.yml file. The container now includes **automatic buffer size detection** for different inverter models. At first startup, it will:
- The default `docker-compose.yml` file includes Watchtower, which can be configured to auto-update this image when we push new changes to github - Please **uncomment if you wish to auto-update to the latest builds of this project**. 1. **Auto-detect** the correct communication parameters for your specific inverter
2. **Save** the discovered settings to `/etc/inverter/.discovery_done`
3. **Reuse** saved settings on subsequent startups (instant start)
## Integrating into Home Assistant. **Environment Variables:**
```yaml
environment:
- INVERTER_DEVICE=/dev/ttyUSB1 # Your RS232/USB device
- FORCE_DISCOVERY=false # Re-run discovery on every start
- SKIP_DISCOVERY=false # Skip discovery, use inverter.conf values
```
Providing you have setup [MQTT](https://www.home-assistant.io/components/mqtt/) with Home Assistant, the device will automatically register in your Home Assistant when the container starts for the first time -- You do not need to manually define any sensors. **📖 See [AUTO_DISCOVERY.md](AUTO_DISCOVERY.md) for complete documentation** including:
- How auto-discovery works
From here you can setup [Graphs](https://www.home-assistant.io/lovelace/history-graph/) to display sensor data, and optionally change state of the inverter by "[publishing](https://www.home-assistant.io/docs/mqtt/service/)" a string to the inverter's primary topic like so: - Environment variable reference
- Multi-inverter setups
- Troubleshooting guide
- Migration from older versions
![Example, Changing the Charge Priority](images/mqtt-publish-packet.png "Example, Changing the Charge Priority") ![Example, Changing the Charge Priority](images/mqtt-publish-packet.png "Example, Changing the Charge Priority")
_Example: Changing the Charge Priority of the Inverter_ _Example: Changing the Charge Priority of the Inverter_
@@ -127,13 +154,14 @@ Just head to the `sources/inverter-cli` directory and build it directly using: `
Basic arguments supported are: Basic arguments supported are:
``` ```
USAGE: ./inverter_poller <args> [-r <command>], [-h | --help], [-1 | --run-once] USAGE: ./inverter_poller <args> [-r <command>], [-h | --help], [-1 | --run-once], [-a | --auto-discover]
SUPPORTED ARGUMENTS: SUPPORTED ARGUMENTS:
-r <raw-command> TX 'raw' command to the inverter -r <raw-command> TX 'raw' command to the inverter
-h | --help This Help Message -h | --help This Help Message
-1 | --run-once Runs one iteration on the inverter, and then exits -1 | --run-once Runs one iteration on the inverter, and then exits
-d Additional debugging -d Additional debugging
-a | --auto-discover Auto-detect correct buffer sizes for your inverter
``` ```
@@ -147,3 +175,75 @@ Note that in addition to merging the sample Yaml files with your Home Assistant,
- [vertical-stack-in-card](https://github.com/custom-cards/vertical-stack-in-card) - [vertical-stack-in-card](https://github.com/custom-cards/vertical-stack-in-card)
- [circle-sensor-card](https://github.com/custom-cards/circle-sensor-card) - [circle-sensor-card](https://github.com/custom-cards/circle-sensor-card)
---
## 📚 Documentazione
### Guide Utente
- **[AUTO_DISCOVERY.md](documentation/AUTO_DISCOVERY.md)** - Guida completa all'auto-discovery
- Come funziona
- Variabili d'ambiente
- Scenari d'uso e troubleshooting
- Setup multi-inverter
- **[QUICKSTART.md](documentation/QUICKSTART.md)** - Setup rapido del progetto
- Build e debug locale
- Configurazione VS Code
- Comandi essenziali
### Documentazione Tecnica
- **[CODE_ARCHITECTURE.md](documentation/CODE_ARCHITECTURE.md)** - Architettura completa del codice
- Mappa logica funzioni e variabili
- Flusso di esecuzione dettagliato
- Diagrammi e mappe concettuali
- Sincronizzazione multi-thread
- **[IMPLEMENTATION.md](documentation/IMPLEMENTATION.md)** - Changelog implementazione v2.0
- Feature aggiunte
- Bug risolti
- Test eseguiti
### Guide Sviluppatore
- **[DEBUG.md](documentation/DEBUG.md)** - Guida completa al debugging
- Configurazioni VS Code
- GDB workflows
- Troubleshooting comuni
- **[.vscode/README.md](documentation/README.md)** - Setup ambiente sviluppo
- Estensioni raccomandate
- Tasks e launch configurations
- Shortcuts utili
---
## 🤝 Contributing
Contributions are welcome! Per contribuire al progetto:
1. Fork del repository
2. Crea branch feature (`git checkout -b feature/AmazingFeature`)
3. Commit delle modifiche (`git commit -m 'feat: Add amazing feature'`)
4. Push al branch (`git push origin feature/AmazingFeature`)
5. Apri Pull Request
**Per sviluppatori:** Consulta [CODE_ARCHITECTURE.md](documentation/CODE_ARCHITECTURE.md) per comprendere il flusso del codice prima di contribuire.
---
## 📜 License
This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
---
## 🙏 Credits
- Original skymax project by [manio](https://github.com/manio/skymax-demo)
- [Skyboo's monitoring tutorial](https://skyboo.net/2017/03/monitoring-voltronic-power-axpert-mex-inverter-under-linux/)
- [AEVA Forums](http://forums.aeva.asn.au/viewtopic.php?t=4332) for protocol documentation
---
**Version:** 2.0.0
**Last Updated:** 25 gennaio 2026
docker-compose.yml
+13
View File
@@ -17,6 +17,19 @@ services:
privileged: true privileged: true
restart: always restart: always
# Environment variables for auto-discovery
environment:
# Default device (can be ttyUSB0, ttyUSB1, ttyS0, hidraw0, etc.)
- INVERTER_DEVICE=/dev/ttyUSB1
# Force auto-discovery on every container start (default: false)
# Set to "true" to re-run discovery even if previous results exist
- FORCE_DISCOVERY=false
# Skip auto-discovery completely (default: false)
# Set to "true" to use only values from inverter.conf
- SKIP_DISCOVERY=false
volumes: volumes:
- ./config/:/etc/inverter/ - ./config/:/etc/inverter/
documentation/AUTO_DISCOVERY.md
+392
View File
@@ -0,0 +1,392 @@
# Auto-Discovery Feature
Il sistema di auto-discovery rileva automaticamente i parametri di comunicazione corretti del tuo inverter all'avvio del container.
## Come Funziona
All'avvio, il container:
1. **Controlla** se esiste già una configurazione salvata (`.discovery_done`)
2. **Testa** la comunicazione con l'inverter inviando i 4 comandi principali
3. **Rileva** le dimensioni corrette del buffer per ogni comando
4. **Salva** i parametri scoperti in `/etc/inverter/.discovery_done`
5. **Aggiorna** `/etc/inverter/inverter.conf` con i valori corretti
6. **Avvia** i servizi MQTT normalmente
## Variabili d'Ambiente
### `INVERTER_DEVICE`
Specifica il device seriale dell'inverter.
**Default:** `/dev/ttyUSB0`
**Esempi:**
```yaml
environment:
- INVERTER_DEVICE=/dev/ttyUSB1 # USB-to-Serial adapter
- INVERTER_DEVICE=/dev/ttyS0 # Built-in serial port
- INVERTER_DEVICE=/dev/hidraw0 # USB HID device
```
### `FORCE_DISCOVERY`
Forza l'auto-discovery ad ogni avvio, anche se esistono già parametri salvati.
**Default:** `false`
**Quando usarlo:**
- Dopo aver cambiato inverter
- Se sospetti che i parametri salvati siano errati
- Per debug o testing
**Esempio:**
```yaml
environment:
- FORCE_DISCOVERY=true
```
### `SKIP_DISCOVERY`
Salta completamente l'auto-discovery e usa solo i valori da `inverter.conf`.
**Default:** `false`
**Quando usarlo:**
- Quando conosci già i parametri corretti
- Per velocizzare l'avvio (risparmia ~10 secondi)
- In ambienti di produzione stabili
**Esempio:**
```yaml
environment:
- SKIP_DISCOVERY=true
```
## Scenari d'Uso
### Scenario 1: Primo Avvio (Default)
```yaml
services:
voltronic-mqtt:
environment:
- INVERTER_DEVICE=/dev/ttyUSB1
```
**Cosa succede:**
- ✓ Container rileva che non esiste `.discovery_done`
- ✓ Esegue auto-discovery (~10-15 secondi)
- ✓ Salva i parametri trovati
- ✓ Avvia i servizi MQTT
**Log:**
```
=== Voltronic MQTT Bridge Starting ===
Configuration:
Device: /dev/ttyUSB1
Force Discovery: false
Skip Discovery: false
ℹ No previous discovery found, will run auto-discovery
=== Running Auto-Discovery ===
This will take about 10-15 seconds...
Testing QMOD command (buffer 5-100)...
✓ QMOD: found response at 5 bytes
...
✓ Auto-discovery completed successfully!
device=/dev/ttyUSB1
qmod=5
qpigs=110
qpiri=103
qpiws=40
```
### Scenario 2: Avvii Successivi (Cached)
```yaml
services:
voltronic-mqtt:
environment:
- INVERTER_DEVICE=/dev/ttyUSB1
```
**Cosa succede:**
- ✓ Container trova `.discovery_done` esistente
- ✓ Verifica che il device non sia cambiato
- ✓ Carica i parametri salvati
- ✓ Avvia immediatamente i servizi (nessun ritardo)
**Log:**
```
=== Voltronic MQTT Bridge Starting ===
Configuration:
Device: /dev/ttyUSB1
Force Discovery: false
Skip Discovery: false
✓ Using previous discovery results
Current configuration:
device=/dev/ttyUSB1
qmod=5
qpigs=110
qpiri=103
qpiws=40
=== Starting MQTT Bridge Services ===
```
### Scenario 3: Cambio Device
```yaml
services:
voltronic-mqtt:
environment:
- INVERTER_DEVICE=/dev/ttyUSB0 # Cambiato da ttyUSB1
```
**Cosa succede:**
- ✓ Container rileva che il device è cambiato
- ✓ Elimina `.discovery_done` esistente
- ✓ Esegue nuovamente l'auto-discovery
- ✓ Salva i nuovi parametri
**Log:**
```
⚠ Device changed from /dev/ttyUSB1 to /dev/ttyUSB0
Running new discovery...
=== Running Auto-Discovery ===
...
```
### Scenario 4: Force Discovery
```yaml
services:
voltronic-mqtt:
environment:
- INVERTER_DEVICE=/dev/ttyUSB1
- FORCE_DISCOVERY=true
```
**Cosa succede:**
- ✓ Ignora `.discovery_done` esistente
- ✓ Esegue sempre auto-discovery
- ✓ Aggiorna parametri salvati
**Quando usarlo:** Dopo aggiornamento firmware inverter, troubleshooting.
### Scenario 5: Skip Discovery
```yaml
services:
voltronic-mqtt:
environment:
- INVERTER_DEVICE=/dev/ttyUSB1
- SKIP_DISCOVERY=true
```
**Cosa succede:**
- ✓ Non esegue mai auto-discovery
- ✓ Usa solo valori da `config/inverter.conf`
- ✓ Avvio istantaneo
**Quando usarlo:** Parametri già noti e stabili, avvio rapido richiesto.
## File Generati
### `/etc/inverter/.discovery_done`
Contiene i parametri scoperti con timestamp:
```bash
device=/dev/ttyUSB1
qmod=5
qpigs=110
qpiri=103
qpiws=40
timestamp=2024-01-15T10:30:00+01:00
```
Questo file è **persistente** nel volume `./config/` e sopravvive ai restart del container.
### `/etc/inverter/inverter.conf.backup`
Backup automatico della configurazione originale prima dell'auto-discovery.
## Troubleshooting
### Discovery Fallisce
**Log:**
```
✗ Auto-discovery failed!
Please check:
1. Inverter is powered on
2. Cable is properly connected
3. Device path is correct: /dev/ttyUSB1
Falling back to default configuration...
```
**Soluzioni:**
1. Verifica che l'inverter sia acceso
2. Controlla il cablaggio RS232/USB
3. Verifica il device corretto: `ls -la /dev/tty*`
4. Testa manualmente:
```bash
docker exec -it voltronic-mqtt /opt/inverter-cli/bin/inverter_poller -a
```
### Device Non Trovato
**Errore:**
```
Unable to open device file
```
**Soluzioni:**
1. Verifica mapping in docker-compose.yml:
```yaml
devices:
- /dev/ttyUSB1:/dev/ttyUSB1:rwm
```
2. Controlla permessi: `sudo chmod 666 /dev/ttyUSB1`
3. Verifica che il device esista: `ls -la /dev/ttyUSB1`
### Valori Scoperti Errati
**Soluzione 1 - Force Discovery:**
```yaml
environment:
- FORCE_DISCOVERY=true
```
**Soluzione 2 - Configurazione Manuale:**
```yaml
environment:
- SKIP_DISCOVERY=true
```
E modifica manualmente `config/inverter.conf`:
```bash
device=/dev/ttyUSB1
qmod=5
qpigs=110
qpiri=103
qpiws=40
```
## Test Manuale
Puoi testare l'auto-discovery manualmente senza riavviare il container:
```bash
# Test base
docker exec -it voltronic-mqtt /opt/inverter-cli/bin/inverter_poller -a
# Test con debug
docker exec -it voltronic-mqtt /opt/inverter-cli/bin/inverter_poller -d -a
# Test singolo comando
docker exec -it voltronic-mqtt /opt/inverter-cli/bin/inverter_poller -r QPIGS
```
## Best Practices
1. **Primo Setup:** Lascia auto-discovery attivo (default)
2. **Produzione:** Dopo aver verificato che funzioni, considera `SKIP_DISCOVERY=true` per avvio rapido
3. **Multi-Inverter:** Usa container separati con `INVERTER_DEVICE` diversi
4. **Backup:** Salva `config/.discovery_done` dopo il primo successo
5. **Logging:** Monitora i log del primo avvio per verificare discovery:
```bash
docker logs voltronic-mqtt
```
## Esempio Completo docker-compose.yml
```yaml
version: '3'
services:
# Inverter primario su ttyUSB1
voltronic-mqtt-primary:
image: bushrangers/ha-voltronic-mqtt
container_name: voltronic-mqtt-primary
privileged: true
restart: always
environment:
- INVERTER_DEVICE=/dev/ttyUSB1
- FORCE_DISCOVERY=false
- SKIP_DISCOVERY=false
volumes:
- ./config-primary/:/etc/inverter/
devices:
- /dev/ttyUSB1:/dev/ttyUSB1:rwm
# Inverter secondario su ttyUSB0 (discovery skippato)
voltronic-mqtt-secondary:
image: bushrangers/ha-voltronic-mqtt
container_name: voltronic-mqtt-secondary
privileged: true
restart: always
environment:
- INVERTER_DEVICE=/dev/ttyUSB0
- SKIP_DISCOVERY=true # Parametri già noti
volumes:
- ./config-secondary/:/etc/inverter/
devices:
- /dev/ttyUSB0:/dev/ttyUSB0:rwm
```
## Migrazione da Versione Precedente
Se stai aggiornando da una versione senza auto-discovery:
1. **Backup configurazione esistente:**
```bash
cp config/inverter.conf config/inverter.conf.old
```
2. **Aggiungi variabili d'ambiente al docker-compose.yml:**
```yaml
environment:
- INVERTER_DEVICE=/dev/ttyUSB1 # Il tuo device attuale
```
3. **Primo avvio con auto-discovery:**
```bash
docker-compose down
docker-compose up -d
docker logs -f voltronic-mqtt
```
4. **Verifica risultati:**
```bash
cat config/.discovery_done
```
5. **Se tutto OK, abilita skip per avvio rapido:**
```yaml
environment:
- INVERTER_DEVICE=/dev/ttyUSB1
- SKIP_DISCOVERY=true # Usa parametri scoperti
```
## FAQ
**Q: Quanto tempo impiega l'auto-discovery?**
A: Circa 10-15 secondi al primo avvio. Gli avvii successivi sono istantanei.
**Q: Posso usare auto-discovery con più inverter?**
A: Sì! Usa container separati con `INVERTER_DEVICE` diversi e directory config separate.
**Q: Cosa succede se l'inverter è spento durante discovery?**
A: Il container fallisce gracefully e usa i parametri di default da `inverter.conf`.
**Q: Devo eliminare `.discovery_done` manualmente?**
A: No, il container lo fa automaticamente quando cambi `INVERTER_DEVICE` o usi `FORCE_DISCOVERY=true`.
**Q: Posso disabilitare completamente auto-discovery?**
A: Sì, usa `SKIP_DISCOVERY=true`.
**Q: I parametri scoperti sono persistenti?**
A: Sì, sono salvati nel volume `./config/` e sopravvivono ai restart.
documentation/CODE_ARCHITECTURE.md
+893
View File
@@ -0,0 +1,893 @@
# Architettura del Codice - Mappa Logica e Flusso di Esecuzione
## Panoramica Generale
Il progetto è composto da due componenti principali:
1. **inverter-cli** (C++): Applicazione che comunica con l'inverter via RS232/USB
2. **inverter-mqtt** (Bash): Script che gestiscono l'integrazione MQTT con Home Assistant
```
┌──────────────────────────────────────────────────────────────┐
│ CONTAINER DOCKER │
│ │
│ ┌────────────────────────────────────────────────────────┐ │
│ │ entrypoint.sh │ │
│ │ 1. Auto-Discovery (prima esecuzione) │ │
│ │ 2. Caricamento configurazione │ │
│ │ 3. Avvio servizi MQTT │ │
│ └──────┬─────────────┬─────────────┬─────────────────────┘ │
│ │ │ │ │
│ ┌────▼────┐ ┌────▼────┐ ┌────▼────────┐ │
│ │mqtt-init│ │mqtt-push│ │mqtt-subscriber│ │
│ │ .sh │ │ .sh │ │ .sh │ │
│ └────┬────┘ └────┬────┘ └────┬────────┘ │
│ │ │ │ │
│ │ ┌────▼─────────────▼────┐ │
│ │ │ inverter_poller │ │
│ │ │ (binario C++) │ │
│ │ └────┬──────────────────┘ │
│ │ │ │
│ └─────────────┴──────┐ │
│ │ │
│ ┌────▼────┐ │
│ │ MQTT │ │
│ │ Broker │ │
│ └─────────┘ │
└──────────────────────────────────────────────────────────────┘
│
┌─────▼──────┐
│ Home │
│ Assistant │
└────────────┘
```
---
## Componente 1: inverter-cli (C++)
### 1.1 Mappa delle Variabili Globali
#### File: main.cpp
```cpp
// Configurazione
string devicename = "/dev/ttyUSB0"; // Device seriale
float runinterval = 0; // Intervallo polling (120 = ogni 30s)
float ampfactor = 1; // Fattore correzione amperaggio
float wattfactor = 1; // Fattore correzione wattaggio
int qpiri = 0, qpiws = 0; // Buffer sizes comandi
int qmod = 0, qpigs = 0;
// Flag di controllo
bool debugFlag = false; // Debug mode
bool runOnce = false; // Esegui una volta e esci
// Flag atomici per sincronizzazione thread
atomic_bool ups_status_changed(false);
atomic_bool ups_qmod_changed(false); // Mode query completata
atomic_bool ups_qpiri_changed(false); // QPIRI query completata
atomic_bool ups_qpigs_changed(false); // QPIGS query completata
atomic_bool ups_qpiws_changed(false); // QPIWS query completata
// Oggetto inverter
cInverter *ups = nullptr;
```
### 1.2 Flusso di Esecuzione: main()
```
START main(argc, argv)
│
├─> Parse argomenti CLI (InputParser)
│ ├─> -d/--debug → debugFlag = true
│ ├─> -1/--run-once → runOnce = true
│ ├─> -r <command> → rawcmd = command
│ └─> -a/--auto-discover → modalità auto-discovery
│
├─> Carica configurazione
│ ├─> Cerca ./inverter.conf
│ └─> Altrimenti /etc/inverter/inverter.conf
│ ├─> devicename (es: /dev/ttyUSB1)
│ ├─> run_interval
│ ├─> amperage_factor, watt_factor
│ └─> qpiri, qpiws, qmod, qpigs (buffer sizes)
│
├─> Crea oggetto cInverter
│ ups = new cInverter(devicename, qpiri, qpiws, qmod, qpigs)
│
├─> BRANCH: Modalità auto-discovery?
│ YES ├─> ups->AutoDiscoverBufferSizes()
│ ├─> Stampa DISCOVERY_QMOD=X
│ ├─> Stampa DISCOVERY_QPIGS=X
│ ├─> Stampa DISCOVERY_QPIRI=X
│ ├─> Stampa DISCOVERY_QPIWS=X
│ ├─> Stampa DISCOVERY_SUCCESS=true/false
│ └─> exit(0)
│
├─> BRANCH: Comando raw specificato?
│ YES ├─> ups->ExecuteCmd(rawcmd)
│ ├─> Stampa risposta
│ └─> exit(0)
│
├─> Modalità polling normale
│ ├─> ups->runMultiThread()
│ │ └─> Avvia thread: poll()
│ │
│ └─> LOOP PRINCIPALE while(true)
│ │
│ ├─> WAIT: ups_qmod_changed && ups_qpiri_changed &&
│ │ ups_qpigs_changed && ups_qpiws_changed
│ │
│ ├─> Quando tutti i flag sono true:
│ │ ├─> Reset flag a false
│ │ ├─> Leggi dati con GetQpigsStatus(), GetQpiriStatus()
│ │ ├─> Parse valori con sscanf()
│ │ ├─> Calcola PV watts, watthour
│ │ ├─> Stampa JSON completo su stdout
│ │ └─> IF runOnce: exit(0)
│ │
│ └─> sleep(1) e ripeti
│
└─> END
```
### 1.3 Classe cInverter
#### Variabili Membro (inverter.h)
```cpp
class cInverter {
private:
// Configurazione
int fd; // File descriptor device seriale
string device; // Path device (es: /dev/ttyUSB1)
int buf_qpiri, buf_qpiws; // Buffer sizes configurati
int buf_qmod, buf_qpigs;
// Mutex per thread-safety
mutex m;
// Dati letti dall'inverter
char status1[512]; // Risposta QPIGS
char status2[512]; // Risposta QPIRI
char warnings[512]; // Risposta QPIWS
int mode; // Mode corrente (1-6)
// Buffer comunicazione seriale
uint8_t buf[2048];
public:
// Costruttore
cInverter(string devicename, int qpiri, int qpiws, int qmod, int qpigs);
// Metodi polling
void poll(); // Thread principale polling
void runMultiThread(); // Avvia poll() in thread separato
// Metodi query
bool query(const char *cmd, int replysize);
int query_auto(const char *cmd, int max_size);
// Getter
string *GetQpigsStatus();
string *GetQpiriStatus();
string *GetWarnings();
int GetMode();
// Utility
void ExecuteCmd(const string cmd);
void AutoDiscoverBufferSizes();
};
```
#### Flusso di Esecuzione: poll() Thread
```
START poll() [Thread separato]
│
├─> fprintf: "Thread started, runOnce=X"
│
└─> LOOP while(true)
│
├─> IF !ups_qmod_changed
│ ├─> query("QMOD", buf_qmod)
│ │ ├─> Costruisci comando con CRC
│ │ ├─> write() su device seriale
│ │ ├─> read() risposta
│ │ ├─> Verifica CRC
│ │ └─> return true se OK
│ ├─> SetMode(buf[1])
│ └─> ups_qmod_changed = true
│
├─> IF !ups_qpigs_changed
│ ├─> query("QPIGS", buf_qpigs)
│ ├─> Copia in status1
│ └─> ups_qpigs_changed = true
│
├─> IF !ups_qpiri_changed
│ ├─> query("QPIRI", buf_qpiri)
│ ├─> Copia in status2
│ └─> ups_qpiri_changed = true
│
├─> IF !ups_qpiws_changed
│ ├─> query("QPIWS", buf_qpiws)
│ ├─> Copia in warnings
│ └─> ups_qpiws_changed = true
│
├─> IF runOnce && tutti_i_flag_true
│ ├─> fprintf: "All data collected"
│ └─> return (termina thread)
│
├─> fprintf: "Flags: QMOD=X QPIGS=X ..."
│
└─> sleep(2) e ripeti
```
#### Flusso di Esecuzione: query()
```
START query(cmd, replysize)
│
├─> Apri device se non già aperto
│ ├─> open(device, O_RDWR | O_NOCTTY | O_NDELAY)
│ ├─> Configura termios (2400 baud, 8N1)
│ └─> tcsetattr()
│
├─> Flush buffer I/O
│ ├─> tcflush(fd, TCIOFLUSH)
│ └─> usleep(100000) // 100ms delay
│
├─> Costruisci comando con CRC
│ ├─> Comando base (es: "QPIGS")
│ ├─> Calcola CRC con cal_crc_half()
│ ├─> Aggiungi CRC bytes
│ └─> Aggiungi CR (\r)
│
├─> Invia comando
│ └─> write(fd, comando, lunghezza)
│
├─> Leggi risposta (loop incrementale)
│ ├─> FOR i=0 to replysize
│ │ ├─> read(fd, buf+i, replysize-i)
│ │ ├─> IF byte letto == CR: break
│ │ └─> continue
│ │
│ ├─> IF debug: stampa hex dump
│ │
│ └─> Verifica formato risposta
│ ├─> Primo byte deve essere '('
│ ├─> Ultimo byte deve essere CR
│ └─> Verifica CRC
│
└─> RETURN true se OK, false se errore
```
#### Flusso di Esecuzione: AutoDiscoverBufferSizes()
```
START AutoDiscoverBufferSizes()
│
├─> Stampa intestazione "AUTO-DISCOVERY MODE"
│
├─> Test QMOD (5-100 bytes)
│ ├─> query_auto("QMOD", 100)
│ │ ├─> Invia comando
│ │ ├─> Leggi byte fino a CR
│ │ └─> return numero_bytes
│ └─> Stampa "✓ QMOD buffer size: X"
│
├─> Test QPIGS (5-200 bytes)
│ ├─> query_auto("QPIGS", 200)
│ └─> Stampa "✓ QPIGS buffer size: X"
│
├─> Test QPIRI (5-200 bytes)
│ ├─> query_auto("QPIRI", 200)
│ └─> Stampa "✓ QPIRI buffer size: X"
│
├─> Test QPIWS (5-100 bytes)
│ ├─> query_auto("QPIWS", 100)
│ └─> Stampa "✓ QPIWS buffer size: X"
│
└─> Output risultati (parsabile)
├─> DISCOVERY_QMOD=X
├─> DISCOVERY_QPIGS=X
├─> DISCOVERY_QPIRI=X
├─> DISCOVERY_QPIWS=X
└─> DISCOVERY_SUCCESS=true
```
### 1.4 Funzioni di Utilità
#### getSettingsFile()
```
Legge /etc/inverter/inverter.conf
├─> Parse linee formato: chiave=valore
├─> Ignora righe con # (commenti)
└─> Popola variabili globali:
├─> devicename
├─> runinterval
├─> amperage_factor, watt_factor
└─> qpiri, qpiws, qmod, qpigs
```
#### attemptAddSettingInt() / attemptAddSetting()
```
Parse stringhe in int/float
├─> stoi() per interi (qpiri, qpiws, qmod, qpigs)
└─> stof() per float (amperage_factor, watt_factor)
```
#### cal_crc_half()
```
Calcola CRC-16 custom per protocollo inverter
├─> Input: buffer, lunghezza
├─> Algoritmo polinomiale custom
└─> Return: uint16_t CRC
```
---
## Componente 2: inverter-mqtt (Bash Scripts)
### 2.1 entrypoint.sh - Orchestrator Principale
```
START Container
│
├─> Carica variabili d'ambiente
│ ├─> INVERTER_DEVICE (default: /dev/ttyUSB0)
│ ├─> FORCE_DISCOVERY (default: false)
│ └─> SKIP_DISCOVERY (default: false)
│
├─> DECISIONE: Eseguire auto-discovery?
│ │
│ ├─> IF FORCE_DISCOVERY=true
│ │ ├─> rm .discovery_done
│ │ └─> NEED_DISCOVERY=true
│ │
│ ├─> ELSE IF SKIP_DISCOVERY=true
│ │ ├─> Aggiorna solo device in config
│ │ └─> NEED_DISCOVERY=false
│ │
│ ├─> ELSE IF .discovery_done non esiste
│ │ └─> NEED_DISCOVERY=true
│ │
│ └─> ELSE
│ ├─> Leggi device salvato
│ ├─> IF device cambiato
│ │ └─> NEED_DISCOVERY=true
│ └─> ELSE
│ ├─> Carica parametri salvati
│ └─> NEED_DISCOVERY=false
│
├─> IF NEED_DISCOVERY
│ └─> run_discovery()
│ ├─> Esegue: inverter_poller -d -a
│ ├─> Parse output DISCOVERY_*
│ ├─> IF SUCCESS=true
│ │ ├─> update_config_with_discovery()
│ │ │ ├─> sed device, qmod, qpigs, qpiri, qpiws
│ │ │ └─> cp inverter.conf.backup
│ │ └─> Salva in .discovery_done
│ └─> ELSE
│ └─> Usa config di default
│
├─> Avvia servizi MQTT
│ │
│ ├─> BACKGROUND: watch -n 300 mqtt-init.sh
│ │ └─> Ogni 5 minuti: re-init sensori HA
│ │
│ ├─> BACKGROUND: mqtt-subscriber.sh
│ │ └─> Ascolta comandi da Home Assistant
│ │
│ └─> FOREGROUND: watch -n 30 mqtt-push.sh
│ └─> Ogni 30s: push dati MQTT
│
└─> END (rimane in loop con mqtt-push.sh)
```
### 2.2 mqtt-push.sh - Pubblicazione Dati
```
START mqtt-push.sh
│
├─> Carica configurazione MQTT
│ └─> cat mqtt.json | jq
│ ├─> MQTT_SERVER
│ ├─> MQTT_PORT
│ ├─> MQTT_TOPIC (base)
│ ├─> DEVICENAME
│ └─> Credenziali
│
├─> Esegui polling inverter
│ └─> inverter_poller -1 > output.json
│
├─> Parse JSON e pubblica ogni metrica
│ └─> FOR each campo in JSON
│ ├─> Estrai valore con jq
│ └─> mosquitto_pub
│ ├─> Topic: homeassistant/sensor/${DEVICENAME}_${metric}
│ ├─> Payload: valore
│ └─> Retain: true
│
├─> OPZIONALE: Push su InfluxDB
│ └─> IF influx.enabled=true
│ └─> curl POST a InfluxDB API
│
└─> END
```
### 2.3 mqtt-subscriber.sh - Ricezione Comandi
```
START mqtt-subscriber.sh (loop infinito)
│
├─> Subscribe a topic comandi
│ └─> mosquitto_sub -t homeassistant/sensor/${DEVICENAME}/command
│
└─> LOOP: Per ogni messaggio ricevuto
│
├─> Valida comando con regex
│ └─> Match contro lista comandi validi
│ ├─> POP0[0-2]
│ ├─> PCP0[0-3]
│ ├─> PBDV*, PBCV*, PBFT*, PCVV*
│ └─> PE*/PD* (enable/disable)
│
├─> IF comando valido
│ ├─> Esegui: inverter_poller -r COMANDO
│ └─> Log risultato
│
└─> ELSE
└─> Log: comando non valido
```
### 2.4 mqtt-init.sh - Auto-Discovery Home Assistant
```
START mqtt-init.sh
│
├─> Carica config MQTT
│
└─> FOR each sensor (mode, voltage, current, watt, etc)
│
├─> Costruisci JSON config
│ ├─> name: "Voltronic Battery Voltage"
│ ├─> state_topic: homeassistant/sensor/voltronic_Battery_voltage
│ ├─> unit_of_measurement: "V"
│ ├─> device_class: "voltage"
│ └─> unique_id, icon, ecc.
│
└─> Pubblica su config topic
└─> mosquitto_pub -t homeassistant/sensor/${DEVICENAME}_${sensor}/config
└─> Payload: JSON config
└─> Retain: true
└─> END (Home Assistant auto-scopre tutti i sensori)
```
---
## Mappa Concettuale del Sistema
```
┌─────────────────────────────────────────────────────────────────┐
│ LIVELLO FISICO │
│ ┌──────────────┐ │
│ │ Inverter │ ←──── RS232/USB (2400 baud, 8N1) │
│ │ Hardware │ │
│ └──────┬───────┘ │
└─────────┼─────────────────────────────────────────────────────┬─┘
│ │
┌─────────▼─────────────────────────────────────────────────────▼─┐
│ LIVELLO COMUNICAZIONE │
│ │
│ ┌────────────────────────────────────────────────────────┐ │
│ │ cInverter::query() / query_auto() │ │
│ │ • Costruzione comandi con CRC │ │
│ │ • Gestione protocollo RS232 │ │
│ │ • Parsing risposte │ │
│ │ • Validazione CRC │ │
│ └────────┬───────────────────────────────────────────────┘ │
└───────────┼──────────────────────────────────────────────────┬─┘
│ │
┌───────────▼──────────────────────────────────────────────────▼─┐
│ LIVELLO APPLICAZIONE │
│ │
│ ┌──────────────────┐ ┌─────────────────────┐ │
│ │ cInverter::poll │◄───────┤ Thread Polling │ │
│ │ (Thread) │ │ • QMOD │ │
│ │ │ │ • QPIGS │ │
│ │ Ciclo continuo │ │ • QPIRI │ │
│ │ lettura dati │ │ • QPIWS │ │
│ └────────┬─────────┘ └─────────────────────┘ │
│ │ │
│ │ Atomic flags │
│ │ (ups_qmod_changed, ups_qpigs_changed, ...) │
│ │ │
│ ┌────────▼─────────┐ │
│ │ main() loop │ │
│ │ • Attende flag │ │
│ │ • Parse dati │ │
│ │ • Output JSON │ │
│ └────────┬─────────┘ │
└───────────┼──────────────────────────────────────────────────┬─┘
│ │
│ JSON stdout │
│ │
┌───────────▼──────────────────────────────────────────────────▼─┐
│ LIVELLO INTEGRAZIONE │
│ │
│ ┌──────────────────┐ ┌──────────────────┐ ┌──────────────┐ │
│ │ mqtt-push.sh │ │mqtt-subscriber.sh│ │ mqtt-init.sh │ │
│ │ • Esegue poller │ │ • Riceve comandi │ │ • Auto- │ │
│ │ • Parse JSON │ │ • Valida │ │ discovery │ │
│ │ • Pubblica MQTT │ │ • Esegue │ │ • Config HA │ │
│ └────────┬─────────┘ └────────┬─────────┘ └──────┬───────┘ │
└───────────┼──────────────────────┼────────────────────┼───────┬─┘
│ │ │ │
│ MQTT Protocol │ │ │
│ │ │ │
┌───────────▼──────────────────────▼────────────────────▼───────▼─┐
│ LIVELLO PRESENTAZIONE │
│ │
│ ┌───────────────────────────────────────────────────────────┐ │
│ │ MQTT Broker │ │
│ │ Topics: │ │
│ │ • homeassistant/sensor/voltronic_Battery_voltage │ │
│ │ • homeassistant/sensor/voltronic_PV_in_watts │ │
│ │ • homeassistant/sensor/voltronic_Load_watt │ │
│ │ • ... │ │
│ │ • homeassistant/sensor/voltronic/command (subscribe) │ │
│ └─────────────────────────────┬─────────────────────────────┘ │
└────────────────────────────────┼───────────────────────────────┘
│
┌──────────▼──────────┐
│ Home Assistant │
│ • Sensori │
│ • Grafici │
│ • Automazioni │
│ • Comandi │
└─────────────────────┘
```
---
## Sincronizzazione Multi-Thread
### Schema di Comunicazione Thread
```
┌─────────────────────────────────────────────────────────────┐
│ THREAD PRINCIPALE │
│ main() │
│ │
│ while(true) { │
│ ┌────────────────────────────────────────────────┐ │
│ │ WAIT per flag atomici: │ │
│ │ ups_qmod_changed == true ◄────┐ │ │
│ │ ups_qpigs_changed == true ◄────┤ │ │
│ │ ups_qpiri_changed == true ◄────┤ │ │
│ │ ups_qpiws_changed == true ◄────┤ │ │
│ └────────────────────────────────────┼───────────┘ │
│ │ │
│ Quando TUTTI true: │ │
│ ├─> Reset flag a false │ │
│ ├─> GetQpigsStatus() ────────────────┼──────┐ │
│ ├─> GetQpiriStatus() ────────────────┼──┐ │ │
│ ├─> GetWarnings() ────────────────┼┐ │ │ │
│ ├─> Parse e calcolo ││ │ │ │
│ ├─> Output JSON ││ │ │ │
│ └─> IF runOnce: exit(0) ││ │ │ │
│ ││ │ │ │
│ sleep(1) ││ │ │ │
│ } ││ │ │ │
└──────────────────────────────────────────┼┼─┼───┼──────────┘
││ │ │
Mutex protected ────────┼┼─┼───┼──────────┐
││ │ │ │
┌──────────────────────────────────────────▼▼─▼───▼──────────▼─┐
│ THREAD POLL │
│ cInverter::poll() │
│ │
│ while(true) { │
│ IF !ups_qmod_changed { │
│ query("QMOD") ──> status1[512] │
│ ups_qmod_changed = true ─────────────────┐ │
│ } │ │
│ │ │
│ IF !ups_qpigs_changed { │ │
│ query("QPIGS") ─┬─> LOCK(mutex) │ │
│ └─> status1 = buf │ │
│ ups_qpigs_changed = true ────────────────┤ │
│ } │ │
│ │ │
│ IF !ups_qpiri_changed { │ │
│ query("QPIRI") ─┬─> LOCK(mutex) │ │
│ └─> status2 = buf │ │
│ ups_qpiri_changed = true ────────────────┤ │
│ } │ │
│ │ │
│ IF !ups_qpiws_changed { │ │
│ query("QPIWS") ─┬─> LOCK(mutex) │ │
│ └─> warnings = buf │ │
│ ups_qpiws_changed = true ────────────────┘ │
│ } │
│ │
│ IF runOnce && all_flags_true { │
│ return; // Termina thread │
│ } │
│ │
│ sleep(2) │
│ } │
└───────────────────────────────────────────────────────────────┘
```
### Protezione Dati Condivisi
```cpp
// Dati protetti da mutex
mutex m;
// Scrittura (thread poll)
m.lock();
strcpy(status1, buffer);
m.unlock();
// Lettura (thread main)
string *GetQpigsStatus() {
m.lock();
string *result = new string(status1);
m.unlock();
return result;
}
// Flag atomici (non necessitano mutex)
atomic_bool ups_qmod_changed; // Lettura/scrittura atomica garantita
```
---
## Gestione Errori e Retry
### Strategia di Resilienza
```
query() failure
│
├─> CRC error
│ ├─> Log errore
│ ├─> Return false
│ └─> Thread poll riprova al ciclo successivo (2s)
│
├─> Device non aperto
│ ├─> Tentativo apertura device
│ ├─> IF fallisce: sleep(1) e retry
│ └─> MAX 3 tentativi prima di abort
│
├─> Timeout lettura
│ ├─> read() con timeout implicito
│ ├─> Return false
│ └─> Retry al prossimo ciclo
│
└─> Formato risposta errato
├─> Log hex dump (se debug)
├─> Return false
└─> Retry al prossimo ciclo
```
### Auto-Recovery Container
```
entrypoint.sh
│
├─> IF discovery fallisce
│ ├─> Log errore
│ ├─> Usa config di default
│ └─> Continua con servizi MQTT
│
└─> IF inverter_poller crash
└─> watch riavvia automaticamente ogni 30s
```
---
## Ottimizzazioni Prestazioni
### Frequency di Polling
```
Configurabile via run_interval:
├─> 120 = ogni 30 secondi (default)
├─> 60 = ogni minuto
└─> 30 = ogni 2 minuti
Thread poll interno:
├─> Query sequenziali (non parallele)
├─> Sleep 2s tra cicli
└─> Immediate exit se runOnce mode
```
### Buffer Management
```
Buffer sizes ottimizzati per ogni comando:
├─> QMOD: 5 bytes (fisso)
├─> QPIGS: 110 bytes (varia per modello)
├─> QPIRI: 103 bytes (varia per modello)
└─> QPIWS: 40 bytes (varia per modello)
Auto-discovery determina sizes esatti:
└─> Evita letture incomplete o overhead
```
### Caching MQTT
```
entrypoint.sh:
├─> .discovery_done persiste parametri
├─> Evita re-discovery ad ogni restart
└─> Re-discovery solo se:
├─> FORCE_DISCOVERY=true
├─> Device cambiato
└─> File cache non esiste
```
---
## Debugging e Logging
### Livelli di Debug
```
inverter_poller -d:
├─> Abilita lprintf() output
├─> Stampa parametri configurazione
├─> Hex dump buffer seriali
├─> Log apertura/chiusura device
└─> Timestamps su ogni operazione
entrypoint.sh:
├─> Echo ogni step esecuzione
├─> Simboli visual: ✓ ✗ ⚠ ℹ
└─> Log risultati discovery
mqtt-push.sh:
└─> Silenzioso (output su /dev/null)
```
### File di Log
```
/var/log/inverter.log:
└─> lprintf() scrive qui (se debugFlag=true)
Container logs:
└─> docker logs voltronic-mqtt
├─> Output entrypoint.sh
├─> Errori servizi MQTT
└─> Messaggi discovery
```
---
## Variabili d'Ambiente Docker
```
INVERTER_DEVICE:
├─> Default: /dev/ttyUSB0
├─> Usato da: entrypoint.sh
└─> Scritto in: /etc/inverter/inverter.conf
FORCE_DISCOVERY:
├─> Default: false
├─> Se true: rm .discovery_done e riesegui
└─> Usato da: entrypoint.sh
SKIP_DISCOVERY:
├─> Default: false
├─> Se true: usa solo inverter.conf
└─> Usato da: entrypoint.sh
```
---
## Sequence Diagram: Primo Avvio Container
```
Container Start
│
├─> entrypoint.sh
│ │
│ ├─> Check .discovery_done: NOT FOUND
│ │
│ ├─> run_discovery()
│ │ │
│ │ ├─> inverter_poller -d -a
│ │ │ │
│ │ │ ├─> cInverter::AutoDiscoverBufferSizes()
│ │ │ │ ├─> query_auto("QMOD")
│ │ │ │ │ └─> Serial: QMOD + CRC
│ │ │ │ │ Inverter ──> (L<CR>
│ │ │ │ │ └─> Return: 5
│ │ │ │ │
│ │ │ │ ├─> query_auto("QPIGS")
│ │ │ │ │ └─> Return: 110
│ │ │ │ │
│ │ │ │ ├─> query_auto("QPIRI")
│ │ │ │ │ └─> Return: 103
│ │ │ │ │
│ │ │ │ └─> query_auto("QPIWS")
│ │ │ │ └─> Return: 40
│ │ │ │
│ │ │ └─> Output:
│ │ │ DISCOVERY_QMOD=5
│ │ │ DISCOVERY_QPIGS=110
│ │ │ DISCOVERY_QPIRI=103
│ │ │ DISCOVERY_QPIWS=40
│ │ │ DISCOVERY_SUCCESS=true
│ │ │
│ │ ├─> Parse output (grep + cut)
│ │ │
│ │ ├─> update_config_with_discovery()
│ │ │ ├─> sed -i "s/^qmod=.*/qmod=5/"
│ │ │ ├─> sed -i "s/^qpigs=.*/qpigs=110/"
│ │ │ ├─> sed -i "s/^qpiri=.*/qpiri=103/"
│ │ │ └─> sed -i "s/^qpiws=.*/qpiws=40/"
│ │ │
│ │ └─> echo "device=..." > .discovery_done
│ │
│ ├─> Start MQTT services
│ │ │
│ │ ├─> watch -n 300 mqtt-init.sh &
│ │ │ └─> Auto-discovery HA sensors
│ │ │
│ │ ├─> mqtt-subscriber.sh &
│ │ │ └─> mosquitto_sub -t .../command
│ │ │
│ │ └─> watch -n 30 mqtt-push.sh (foreground)
│ │ │
│ │ └─> LOOP ogni 30s:
│ │ ├─> inverter_poller -1
│ │ │ │
│ │ │ ├─> Thread poll()
│ │ │ ├─> Wait flags
│ │ │ └─> Output JSON
│ │ │
│ │ └─> mosquitto_pub (ogni metrica)
│ │
│ └─> Container running...
│
└─> Home Assistant riceve dati MQTT
```
---
## Summary: Punti Chiave dell'Architettura
### 1. Separazione Responsabilità
- **C++**: Comunicazione hardware, parsing protocollo, performance
- **Bash**: Orchestrazione, integrazione MQTT, configurazione
### 2. Thread Safety
- Atomic flags per sincronizzazione
- Mutex per protezione dati condivisi
- Pattern producer-consumer (poll → main)
### 3. Resilienza
- Auto-discovery automatica
- Retry automatico su errori
- Graceful degradation (fallback a config default)
- Container auto-restart
### 4. Configurabilità
- Buffer sizes auto-detected
- Device configurabile via ENV
- Fattori correzione calibrabili
- Intervallo polling personalizzabile
### 5. Estensibilità
- Facile aggiungere nuovi comandi inverter
- Template MQTT per nuovi sensori
- Supporto multi-inverter (container separati)
- Plugin InfluxDB opzionale
documentation/DEBUG.md
+367
View File
@@ -0,0 +1,367 @@
# Debug Configuration - inverter-cli
Questa directory contiene le configurazioni per il debug dell'applicazione `inverter-cli` in VS Code.
## Prerequisiti
### Software Richiesto
```bash
# Installa gli strumenti di build e debug
sudo apt-get update
sudo apt-get install -y build-essential cmake gdb
# Verifica installazione
gdb --version
cmake --version
g++ --version
```
### Estensioni VS Code Consigliate
- **C/C++** (ms-vscode.cpptools) - IntelliSense, debugging, browsing
- **CMake** (twxs.cmake) - Syntax highlighting per CMakeLists.txt
- **CMake Tools** (ms-vscode.cmake-tools) - Integrazione CMake avanzata
## Configurazioni di Debug Disponibili
### 1. Debug inverter_poller (Release Build)
**Nome:** `(gdb) Debug inverter_poller`
- Build in modalità Release con ottimizzazioni
- Esegue con flag `-d -1` (debug + run-once)
- Utile per debug rapido senza simboli completi
### 2. Debug inverter_poller - Run Once with Debug
**Nome:** `(gdb) Debug inverter_poller - Run Once with Debug`
- Build in modalità Debug con simboli completi
- Esegue con flag `-d -1`
- Include tutti i simboli di debug per analisi dettagliata
- **Consigliato per debug approfondito**
### 3. Debug inverter_poller - Loop Mode
**Nome:** `(gdb) Debug inverter_poller - Loop Mode`
- Build in modalità Debug
- Esegue in modalità loop continuo con debug `-d`
- Utile per debug di problemi intermittenti o di threading
### 4. Debug inverter_poller - Raw Command
**Nome:** `(gdb) Debug inverter_poller - Raw Command`
- Build in modalità Debug
- Esegue comando raw specifico: `-r QPIGS`
- Modifica l'argomento in launch.json per testare altri comandi
### 5. Attach to running inverter_poller
**Nome:** `(gdb) Attach to running inverter_poller`
- Attach a processo già in esecuzione
- Utile per debug di container o processi daemon
- Richiede permessi adeguati (potrebbe richiedere sudo)
## Tasks di Build
### Build Tasks
#### build-inverter-cli (Default)
```bash
Ctrl+Shift+B
```
Build in modalità Release con ottimizzazioni (-O2).
#### build-inverter-cli-debug
Build in modalità Debug con simboli completi (-O0 -g).
#### clean-inverter-cli
Pulisce tutti i file di build generati.
#### rebuild-inverter-cli
Pulisce e ricompila completamente il progetto.
### Run Tasks
#### run-inverter-cli-once
```bash
Tasks: Run Task → run-inverter-cli-once
```
Compila ed esegue il poller una volta con debug abilitato.
#### run-inverter-cli-loop
Compila ed esegue il poller in modalità loop continuo.
### Docker Tasks
#### docker-build
Build dell'immagine Docker locale per development.
#### docker-run
Avvia il container con docker-compose.
#### docker-logs
Mostra i log del container in tempo reale.
#### docker-stop
Ferma il container docker-compose.
## Workflow di Debug Tipici
### Debug Locale (senza device fisico)
Il programma proverà ad aprire il device seriale. Se non è disponibile, otterrai errori ma puoi comunque:
1. **Debug della logica di parsing:**
```bash
# Modifica temporaneamente main.cpp per usare dati mock
# Oppure esegui con un device virtuale
```
2. **Debug con socat (porta seriale virtuale):**
```bash
# Installa socat
sudo apt-get install socat
# Crea coppia di porte virtuali
socat -d -d pty,raw,echo=0 pty,raw,echo=0
# Output: PTY is /dev/pts/2 e /dev/pts/3
# Modifica config/inverter.conf
device=/dev/pts/2
# In un altro terminale, simula risposte inverter su /dev/pts/3
```
### Debug con Device Reale
1. **Identifica il device:**
```bash
ls -la /dev/ttyUSB* /dev/ttyS* /dev/hidraw*
dmesg | grep tty # Per vedere device USB
```
2. **Verifica permessi:**
```bash
sudo chmod 666 /dev/ttyUSB0 # O il tuo device
# OPPURE aggiungi utente al gruppo
sudo usermod -a -G dialout $USER
# Logout e login necessari
```
3. **Aggiorna configurazione:**
```bash
# Modifica config/inverter.conf
device=/dev/ttyUSB0
```
4. **Avvia debug:**
- Imposta breakpoint dove necessario
- Premi F5 o seleziona configurazione dal menu Debug
- Step through con F10 (step over), F11 (step into)
### Debug Problemi Comuni
#### CRC Errors
**Breakpoint:** `inverter.cpp` → funzione `CheckCRC()`
- Verifica calcolo CRC
- Controlla dati ricevuti in `buf[]`
#### Device Communication Issues
**Breakpoint:** `inverter.cpp` → funzione `query()`
- Verifica apertura device (errno)
- Controlla configurazione seriale (baud rate, etc.)
- Monitora `write()` e `read()` operations
#### Threading Issues
**Breakpoint:** `inverter.cpp` → `poll()` e `main.cpp` → main loop
- Verifica sincronizzazione mutex
- Controlla `atomic_bool` flags
- Watch variables: `ups_status_changed`, ecc.
#### JSON Parsing Issues
**Breakpoint:** `main.cpp` → dopo `sscanf()` calls
- Verifica parsing corretto delle risposte
- Controlla valori delle variabili dopo sscanf
- Debug calcoli (ampfactor, wattfactor)
## Debugging con Watchpoints
### Variabili Chiave da Monitorare
In VS Code Debug View → Watch, aggiungi:
```
voltage_grid
voltage_batt
pv_input_watts
mode
ups_qpigs_changed
device_status
```
### GDB Commands Utili
Nel Debug Console (Ctrl+Shift+Y):
```gdb
# Print strutture dati
-exec p voltage_grid
-exec p device_status
# Backtrace
-exec bt
# Info threads
-exec info threads
# Print tutti i local vars
-exec info locals
# Watch memory
-exec x/100c buf
```
## Configurazione IntelliSense
Il file `.vscode/c_cpp_properties.json` viene auto-generato. Se necessario, puoi personalizzarlo:
```json
{
"configurations": [
{
"name": "Linux",
"includePath": [
"${workspaceFolder}/**",
"/usr/include"
],
"defines": [],
"compilerPath": "/usr/bin/g++",
"cStandard": "c11",
"cppStandard": "c++11",
"intelliSenseMode": "linux-gcc-arm"
}
],
"version": 4
}
```
## Debug Container Docker
### Attach a Container in Esecuzione
```bash
# Trova il processo nel container
docker exec -it voltronic-mqtt ps aux | grep inverter
# Installa gdbserver nel container (se necessario)
docker exec -it voltronic-mqtt apt-get install -y gdbserver
# Avvia gdbserver nel container
docker exec -it voltronic-mqtt gdbserver :2345 /opt/inverter-cli/bin/inverter_poller -d -1
# Nella configurazione launch.json, aggiungi:
{
"name": "(gdb) Remote Debug",
"type": "cppdbg",
"request": "launch",
"program": "${workspaceFolder}/sources/inverter-cli/bin/inverter_poller",
"miDebuggerServerAddress": "localhost:2345",
"miDebuggerPath": "/usr/bin/gdb",
"MIMode": "gdb"
}
```
### Debug Logs
```bash
# Tail logs in tempo reale
docker logs -f voltronic-mqtt
# Exec nel container per debug manuale
docker exec -it voltronic-mqtt bash
cd /opt/inverter-cli/bin
./inverter_poller -d -1
```
## Performance Profiling
### Con valgrind
```bash
# Installa valgrind
sudo apt-get install valgrind
# Memory leak detection
valgrind --leak-check=full --show-leak-kinds=all \
./sources/inverter-cli/bin/inverter_poller -1
# Profiling
valgrind --tool=callgrind ./sources/inverter-cli/bin/inverter_poller -1
```
### Con gprof
```bash
# Compila con profiling
cd sources/inverter-cli
cmake -DCMAKE_CXX_FLAGS="-pg" .
make
# Esegui
./bin/inverter_poller -1
# Analizza
gprof bin/inverter_poller gmon.out > analysis.txt
```
## Tips & Tricks
1. **Conditional Breakpoints:**
- Click destro su breakpoint → Edit Breakpoint
- Aggiungi condizione, es: `voltage_batt < 24.0`
2. **Logpoints:**
- Invece di breakpoint, logpoint stampa senza fermare
- Click destro → Add Logpoint
- Esempio: `Voltage: {voltage_grid}V`
3. **Debug con file di log:**
- Il programma scrive su `/tmp/inverter.log` (vedi LOG_FILE in tools.h)
- Usa `tail -f /tmp/inverter.log` in terminale separato
4. **Quick Debug:**
```bash
# Build e run rapido senza VS Code
cd sources/inverter-cli
cmake -DCMAKE_BUILD_TYPE=Debug . && make && gdb --args bin/inverter_poller -d -1
```
## Troubleshooting Debug Setup
### GDB non trova simboli
```bash
# Verifica che binary abbia simboli debug
file sources/inverter-cli/bin/inverter_poller
# Output dovrebbe contenere: "not stripped"
# Se stripped, rebuilda in debug mode
cd sources/inverter-cli && cmake -DCMAKE_BUILD_TYPE=Debug . && make
```
### Permission denied su /dev/ttyUSB0
```bash
sudo chmod 666 /dev/ttyUSB0
# O permanentemente:
sudo usermod -a -G dialout $USER
```
### VS Code non trova GDB
```bash
# Installa gdb
sudo apt-get install gdb
# Verifica path in launch.json
which gdb # Usa questo path in miDebuggerPath
```
## Risorse Aggiuntive
- [VS Code C++ Debugging](https://code.visualstudio.com/docs/cpp/cpp-debug)
- [GDB Documentation](https://sourceware.org/gdb/documentation/)
- [CMake Tutorial](https://cmake.org/cmake/help/latest/guide/tutorial/)
- [Protocol Manual](../../manual/) - Documentazione protocollo inverter
documentation/IMPLEMENTATION.md
+374
View File
@@ -0,0 +1,374 @@
# 🎉 Auto-Discovery Implementation Complete!
## ✅ What's Been Added
### 1. Auto-Discovery Feature in C++ Binary
**File:** [sources/inverter-cli/inverter.cpp](sources/inverter-cli/inverter.cpp)
- New method `query_auto()` - Reads serial data until CR terminator, auto-detects buffer size
- New method `AutoDiscoverBufferSizes()` - Tests all 4 commands (QMOD, QPIGS, QPIRI, QPIWS)
- Machine-readable output format:
```
DISCOVERY_QMOD=5
DISCOVERY_QPIGS=110
DISCOVERY_QPIRI=103
DISCOVERY_QPIWS=40
DISCOVERY_SUCCESS=true
```
**CLI Flag:** `-a` or `--auto-discover`
```bash
./inverter_poller -a # Run auto-discovery
./inverter_poller -d -a # Run with debug output
```
### 2. Smart Container Entrypoint
**File:** [sources/inverter-mqtt/entrypoint.sh](sources/inverter-mqtt/entrypoint.sh)
**Features:**
- ✅ Automatic buffer size detection at first startup
- ✅ Persistent cache in `/etc/inverter/.discovery_done`
- ✅ Re-runs discovery when device changes
- ✅ Environment variable configuration
- ✅ Force/Skip discovery options
- ✅ Graceful fallback on failure
- ✅ Detailed logging with icons (✓, ✗, ⚠, ℹ)
**Workflow:**
```
Container Start
↓
Check FORCE_DISCOVERY=true?
Yes → Run Discovery
No ↓
Check SKIP_DISCOVERY=true?
Yes → Use inverter.conf
No ↓
Check .discovery_done exists?
No → Run Discovery
Yes ↓
Check device changed?
Yes → Run Discovery
No → Use cached results
↓
Start MQTT Services
```
### 3. Docker Compose Configuration
**File:** [docker-compose.yml](docker-compose.yml)
**Added Environment Variables:**
```yaml
environment:
- INVERTER_DEVICE=/dev/ttyUSB1 # Your serial device
- FORCE_DISCOVERY=false # Re-run every time
- SKIP_DISCOVERY=false # Never run discovery
```
### 4. Comprehensive Documentation
**Files Created:**
- **[AUTO_DISCOVERY.md](AUTO_DISCOVERY.md)** - Complete user guide
- How auto-discovery works
- Environment variable reference
- Usage scenarios (5 examples)
- Troubleshooting guide
- Migration instructions
- Multi-inverter setup examples
- FAQ section
- **[test-autodiscovery.sh](test-autodiscovery.sh)** - Local test script
- Tests auto-discovery without Docker
- Validates discovered values
- Tests data reading with new parameters
- Creates temporary test environment
### 5. Updated README
**File:** [README.md](README.md)
Added section:
- 🆕 Auto-Discovery Feature (v2.0+)
- Link to detailed documentation
- Environment variable examples
---
## 🚀 How to Use
### Quick Start (Default Setup)
1. **Edit docker-compose.yml** - Set your device:
```yaml
environment:
- INVERTER_DEVICE=/dev/ttyUSB1
```
2. **Start container:**
```bash
docker-compose up -d
```
3. **Watch logs:**
```bash
docker logs -f voltronic-mqtt
```
**Expected Output:**
```
=== Voltronic MQTT Bridge Starting ===
Version: 2.0 with Auto-Discovery
Configuration:
Device: /dev/ttyUSB1
Force Discovery: false
Skip Discovery: false
ℹ No previous discovery found, will run auto-discovery
=== Running Auto-Discovery ===
This will take about 10-15 seconds...
✓ QMOD buffer size: 5
✓ QPIGS buffer size: 110
✓ QPIRI buffer size: 103
✓ QPIWS buffer size: 40
✓ Auto-discovery completed successfully!
device=/dev/ttyUSB1
qmod=5
qpigs=110
qpiri=103
qpiws=40
=== Starting MQTT Bridge Services ===
✓ All services started successfully!
```
### Test Before Docker (Optional)
```bash
# Build the binary
cd sources/inverter-cli
make
# Run local test
cd ../..
bash test-autodiscovery.sh
```
---
## 📊 Test Results
**Hardware Tested:**
- Device: `/dev/ttyUSB1`
- Inverter: Voltronic/Axpert compatible
**Discovered Values:**
```
QMOD = 5 bytes ✓
QPIGS = 110 bytes ✓
QPIRI = 103 bytes ✓ (was 98, corrected)
QPIWS = 40 bytes ✓ (was 36, corrected)
```
**Success Rate:** 100% on tested hardware
---
## 🔧 Advanced Usage
### Scenario 1: Multiple Inverters
```yaml
services:
inverter-1:
image: bushrangers/ha-voltronic-mqtt
environment:
- INVERTER_DEVICE=/dev/ttyUSB0
volumes:
- ./config-inverter1/:/etc/inverter/
devices:
- /dev/ttyUSB0:/dev/ttyUSB0:rwm
inverter-2:
image: bushrangers/ha-voltronic-mqtt
environment:
- INVERTER_DEVICE=/dev/ttyUSB1
volumes:
- ./config-inverter2/:/etc/inverter/
devices:
- /dev/ttyUSB1:/dev/ttyUSB1:rwm
```
### Scenario 2: Force Re-Discovery
```bash
# Temporary (until restart)
docker exec voltronic-mqtt rm /etc/inverter/.discovery_done
docker restart voltronic-mqtt
# Permanent
docker-compose down
# Edit docker-compose.yml: FORCE_DISCOVERY=true
docker-compose up -d
```
### Scenario 3: Skip Discovery (Production)
```yaml
environment:
- INVERTER_DEVICE=/dev/ttyUSB1
- SKIP_DISCOVERY=true # Use values from inverter.conf
```
---
## 🐛 Troubleshooting
### Discovery Fails
**Symptoms:**
```
✗ Auto-discovery failed!
Falling back to default configuration...
```
**Solutions:**
1. Check inverter is powered on
2. Verify cable connection
3. Test device manually:
```bash
ls -la /dev/ttyUSB*
docker exec voltronic-mqtt /opt/inverter-cli/bin/inverter_poller -r QPIGS
```
### Wrong Device
**Symptoms:**
```
Unable to open device file
```
**Solution:**
```yaml
# Check available devices on host
ls -la /dev/tty*
# Update docker-compose.yml
environment:
- INVERTER_DEVICE=/dev/ttyUSB0 # Change to correct device
# Ensure device is mapped
devices:
- /dev/ttyUSB0:/dev/ttyUSB0:rwm
```
### Discovery Takes Too Long
**Normal:** ~10-15 seconds
**If > 30 seconds:** Check for interference, try different USB port
---
## 📝 Files Modified
| File | Status | Description |
|------|--------|-------------|
| `sources/inverter-cli/inverter.h` | ✅ Modified | Added AutoDiscoverBufferSizes() |
| `sources/inverter-cli/inverter.cpp` | ✅ Modified | Implemented query_auto() and discovery |
| `sources/inverter-cli/main.cpp` | ✅ Modified | Added `-a` flag |
| `sources/inverter-cli/tools.cpp` | ✅ Modified | Updated help text |
| `sources/inverter-mqtt/entrypoint.sh` | ✅ Rewritten | Smart discovery logic |
| `docker-compose.yml` | ✅ Modified | Added ENV vars |
| `README.md` | ✅ Modified | Added auto-discovery section |
| `AUTO_DISCOVERY.md` | ✅ Created | Complete documentation |
| `test-autodiscovery.sh` | ✅ Created | Local test script |
| `IMPLEMENTATION.md` | ✅ Created | This file |
---
## 🎯 Next Steps
### For Development:
1. ✅ Compile: `cd sources/inverter-cli && make`
2. ✅ Test locally: `bash test-autodiscovery.sh`
3. ✅ Verify values: Check `/tmp/inverter-test-*/` output
### For Production:
1. **Build Docker image:**
```bash
docker build -f Dockerfile.multiarch -t voltronic-mqtt:latest .
```
2. **Update docker-compose.yml:**
```yaml
image: voltronic-mqtt:latest # Use local image
# OR
image: bushrangers/ha-voltronic-mqtt:latest # Use from hub
```
3. **Deploy:**
```bash
docker-compose down
docker-compose up -d
docker logs -f voltronic-mqtt
```
4. **Verify MQTT:**
```bash
mosquitto_sub -h <mqtt-server> -t "homeassistant/#" -v
```
### For Multi-Arch Build:
```bash
# Push to Gitea - triggers automatic multi-arch build
git add .
git commit -m "feat: Add auto-discovery feature v2.0"
git tag v2.0.0
git push origin main --tags
```
---
## 💡 Key Benefits
✅ **Plug & Play** - No manual buffer size configuration
✅ **Hardware Agnostic** - Works with different inverter models
✅ **Persistent** - Discovery runs once, cached forever
✅ **Flexible** - Force/skip options for all scenarios
✅ **Multi-Inverter** - Each container discovers independently
✅ **Robust** - Graceful fallback on failure
✅ **Developer Friendly** - Detailed logs and test script
---
## 📚 Related Documentation
- [AUTO_DISCOVERY.md](AUTO_DISCOVERY.md) - Complete user guide
- [.vscode/DEBUG.md](.vscode/DEBUG.md) - Development debugging guide
- [.github/copilot-instructions.md](.github/copilot-instructions.md) - AI coding guidelines
- [README.md](README.md) - Main project documentation
---
## 🏆 Version History
**v2.0 (Current)**
- ✅ Auto-discovery feature
- ✅ Smart container entrypoint
- ✅ Environment variable configuration
- ✅ Persistent caching
- ✅ Comprehensive documentation
**v1.x**
- Basic Voltronic MQTT bridge
- Manual buffer size configuration
- Static inverter.conf
---
**Implementation Date:** January 25, 2026
**Author:** GitHub Copilot + User
**Status:** ✅ Complete & Tested
documentation/QUICKSTART.md
+363
View File
@@ -0,0 +1,363 @@
# Quick Start Guide - Development & Debug
Questa guida fornisce un rapido riferimento per iniziare a sviluppare e debuggare il progetto.
## Setup Iniziale
### 1. Requisiti Sistema
```bash
# Aggiorna sistema
sudo apt-get update
# Installa dipendenze build
sudo apt-get install -y build-essential cmake gdb git
# Installa dipendenze runtime
sudo apt-get install -y mosquitto-clients jq
# Aggiungi utente al gruppo per accesso seriale (opzionale)
sudo usermod -a -G dialout $USER
# Logout e login necessari per applicare
```
### 2. Setup VS Code
```bash
# Apri progetto
code /home/pi/Progetti
# Installa estensioni raccomandate quando richiesto
# Oppure manualmente: Ctrl+Shift+P → "Extensions: Show Recommended Extensions"
```
### 3. Prima Build
```bash
# Opzione A: Da VS Code
# Premi Ctrl+Shift+B → Seleziona "build-inverter-cli"
# Opzione B: Da terminale
cd /home/pi/Progetti/sources/inverter-cli
mkdir -p bin
cmake .
make
```
### 4. Verifica Build
```bash
# Test esecuzione (senza device fisico, darà errore ma verifica che compili)
./sources/inverter-cli/bin/inverter_poller --help
```
## Workflow di Sviluppo
### Scenario 1: Modificare e Testare Codice
```bash
1. Apri file da modificare (es. sources/inverter-cli/main.cpp)
2. Fai modifiche al codice
3. Build: Ctrl+Shift+B (oppure F5 per build+debug)
4. Test: Tasks → "run-inverter-cli-once"
5. Verifica output JSON
```
### Scenario 2: Debug di un Bug
```bash
1. Riproduci il bug manualmente
2. Identifica file sorgente coinvolto
3. Apri file e imposta breakpoint (F9)
4. Premi F5 → Seleziona "(gdb) Debug inverter_poller - Run Once with Debug"
5. Usa Debug toolbar:
- F10: Step Over (prossima riga)
- F11: Step Into (entra in funzione)
- Shift+F11: Step Out (esci da funzione)
6. Ispeziona variabili nel pannello Variables/Watch
7. Continua (F5) o Stop (Shift+F5)
```
### Scenario 3: Aggiungere Nuovo Comando Inverter
```bash
1. Apri sources/inverter-cli/main.cpp
2. Aggiungi parsing nella sezione sscanf
3. Aggiungi output nella sezione printf JSON
4. Build e test: Ctrl+Shift+B
5. Verifica JSON output
6. Aggiorna sources/inverter-mqtt/mqtt-push.sh per pushare nuovo valore
7. Aggiorna sources/inverter-mqtt/mqtt-init.sh per auto-discovery
```
### Scenario 4: Debug con Device Reale
```bash
1. Connetti inverter via USB/RS232
2. Identifica device:
ls -la /dev/ttyUSB* # o ttyS*, hidraw*
3. Configura device:
# Modifica config/inverter.conf
device=/dev/ttyUSB0
4. Verifica permessi:
sudo chmod 666 /dev/ttyUSB0
5. Debug normale:
F5 → Seleziona configurazione debug
6. Imposta breakpoint in inverter.cpp → query()
7. Osserva comunicazione seriale in tempo reale
```
### Scenario 5: Test Docker Locale
```bash
# Opzione A: Da VS Code Tasks
1. Tasks → "docker-build"
2. Tasks → "docker-run"
3. Tasks → "docker-logs" (monitora output)
4. Quando finito: Tasks → "docker-stop"
# Opzione B: Da terminale
cd /home/pi/Progetti
docker-compose up --build
# Test manuale nel container
docker exec -it voltronic-mqtt bash
/opt/inverter-cli/bin/inverter_poller -d -1
```
## Comandi Utili
### Build e Run
```bash
# Build Release
cd sources/inverter-cli && cmake . && make
# Build Debug (con simboli)
cd sources/inverter-cli && cmake -DCMAKE_BUILD_TYPE=Debug . && make
# Clean build
cd sources/inverter-cli && rm -rf bin CMakeFiles CMakeCache.txt cmake_install.cmake Makefile
# Run con debug flag
./sources/inverter-cli/bin/inverter_poller -d -1
# Run comando raw
./sources/inverter-cli/bin/inverter_poller -r QPIGS
# Run in loop
./sources/inverter-cli/bin/inverter_poller -d
```
### Test Device
```bash
# Verifica device disponibili
ls -la /dev/tty* /dev/hidraw*
# Test read da device (richiede screen o minicom)
sudo apt-get install screen
sudo screen /dev/ttyUSB0 2400
# Verifica permessi
sudo chmod 666 /dev/ttyUSB0
# O permanente:
sudo usermod -a -G dialout $USER && newgrp dialout
```
### Debug GDB Manuale
```bash
# Build con debug symbols
cd sources/inverter-cli
cmake -DCMAKE_BUILD_TYPE=Debug . && make
# Avvia in GDB
gdb --args bin/inverter_poller -d -1
# Comandi GDB utili:
(gdb) break main.cpp:150 # Breakpoint a linea
(gdb) break cInverter::query # Breakpoint a funzione
(gdb) run # Avvia
(gdb) next # Step over (n)
(gdb) step # Step into (s)
(gdb) continue # Continua (c)
(gdb) print voltage_grid # Stampa variabile (p)
(gdb) info locals # Mostra tutte variabili locali
(gdb) backtrace # Stack trace (bt)
(gdb) quit # Esci (q)
```
### Docker
```bash
# Build locale
docker build -f Dockerfile.dev -t voltronic-mqtt:dev .
# Run
docker-compose up -d
# Logs
docker logs -f voltronic-mqtt
# Exec nel container
docker exec -it voltronic-mqtt bash
# Debug nel container
docker exec -it voltronic-mqtt /opt/inverter-cli/bin/inverter_poller -d -1
# Stop
docker-compose down
```
### Git Workflow
```bash
# Prima di modifiche
git checkout -b feature/nuova-funzionalita
# Durante sviluppo
git add sources/inverter-cli/main.cpp
git commit -m "Add: nuova metrica XYZ"
# Push
git push origin feature/nuova-funzionalita
# Gitea Actions builderà automaticamente su push
```
## Configurazioni Debug VS Code
### Configurazioni Disponibili (F5)
| Nome | Uso | Quando Usare |
|------|-----|--------------|
| Debug inverter_poller | Build Release | Debug rapido, problemi performance |
| Run Once with Debug | Build completa | Debug approfondito, simboli completi |
| Loop Mode | Loop continuo | Debug threading, problemi intermittenti |
| Raw Command | Comando specifico | Test singolo comando inverter |
| Attach to running | Attach esterno | Debug container o daemon |
### Tasks Disponibili (Ctrl+Shift+P → Tasks: Run Task)
| Task | Descrizione |
|------|-------------|
| build-inverter-cli | Build Release (default: Ctrl+Shift+B) |
| build-inverter-cli-debug | Build con simboli debug |
| clean-inverter-cli | Pulizia file build |
| rebuild-inverter-cli | Clean + Build |
| run-inverter-cli-once | Build e esegui una volta |
| run-inverter-cli-loop | Build e esegui in loop |
| docker-build | Build immagine Docker |
| docker-run | Avvia container |
| docker-logs | Visualizza log |
| docker-stop | Ferma container |
## Shortcuts VS Code
| Shortcut | Azione |
|----------|--------|
| `Ctrl+Shift+B` | Build (default task) |
| `F5` | Start Debugging |
| `Ctrl+F5` | Run Without Debugging |
| `F9` | Toggle Breakpoint |
| `F10` | Step Over |
| `F11` | Step Into |
| `Shift+F11` | Step Out |
| `Shift+F5` | Stop Debugging |
| `Ctrl+Shift+F5` | Restart Debugging |
| `Ctrl+` ` | Toggle Terminal |
| `Ctrl+Shift+P` | Command Palette |
| `Ctrl+P` | Quick Open File |
## Testing
### Unit Test Locale
```bash
# Test parsing dati
./sources/inverter-cli/bin/inverter_poller -d -1 | jq .
# Test comando specifico
./sources/inverter-cli/bin/inverter_poller -r QPIGS
# Test con output su file
./sources/inverter-cli/bin/inverter_poller -d -1 > /tmp/test_output.json
cat /tmp/test_output.json | jq .
```
### Integration Test MQTT
```bash
# Terminal 1: Subscribe a topic
mosquitto_sub -h localhost -t "homeassistant/#" -v
# Terminal 2: Esegui poller e push
cd sources/inverter-mqtt
./mqtt-push.sh
# Verifica messaggi ricevuti in Terminal 1
```
### Test Docker End-to-End
```bash
# 1. Build
docker-compose build
# 2. Run
docker-compose up -d
# 3. Verifica logs
docker logs -f voltronic-mqtt
# 4. Test MQTT output
mosquitto_sub -h [MQTT_SERVER] -t "homeassistant/sensor/voltronic/#" -v
# 5. Test comando
mosquitto_pub -h [MQTT_SERVER] \
-t "homeassistant/sensor/voltronic/command" \
-m "QPIGS"
```
## Troubleshooting Rapido
| Problema | Soluzione |
|----------|-----------|
| "Unable to open device" | Verifica device in config/inverter.conf e permessi |
| "CRC error" | Controlla cablaggio RS232 e buffer size in config |
| GDB non trova simboli | Build con: `cmake -DCMAKE_BUILD_TYPE=Debug .` |
| IntelliSense non funziona | Reload Window (Ctrl+Shift+P → "Reload Window") |
| Build fallisce | Clean: `rm -rf CMakeFiles CMakeCache.txt` poi rebuild |
| Permission denied device | `sudo chmod 666 /dev/ttyUSB0` o aggiungi a gruppo dialout |
## Risorse
- **[.vscode/DEBUG.md]** - Guida debug completa
- **[.vscode/README.md]** - Documentazione configurazioni VS Code
- **[.github/copilot-instructions.md]** - Documentazione completa progetto
- **[README.md]** - Documentazione principale
- **[manual/]** - Manuali protocollo inverter
## Prossimi Passi
1. ✅ Setup ambiente completato
2. 📖 Leggi documentazione protocollo in `/manual/`
3. 🔧 Prova modifiche semplici (es. aggiungi log)
4. 🐛 Usa debug per capire flusso programma
5. 🚀 Contribuisci: aggiungi nuove metriche o comandi
6. 🐳 Testa in Docker prima di production
## Support
- Issues: [GitHub/Gitea Issues]
- Docs: File README.md e .vscode/DEBUG.md
- Forum: AEVA Forum (link in README.md principale)
---
**Happy Coding! 🚀**
documentation/README.md
+164
View File
@@ -0,0 +1,164 @@
# VS Code Configuration
Questa directory contiene le configurazioni per sviluppo e debug del progetto in VS Code.
## File di Configurazione
### launch.json
Configurazioni di debug per inverter-cli con GDB:
- Debug con build Release
- Debug con build completa (simboli debug)
- Debug in modalità loop
- Debug comandi raw
- Attach a processo esistente
### tasks.json
Task automatizzati per:
- Build (Release/Debug)
- Clean e Rebuild
- Esecuzione diretta
- Gestione container Docker
### c_cpp_properties.json
Configurazione IntelliSense per C/C++:
- Include paths
- Standard C++11
- Compiler settings
### settings.json
Impostazioni workspace:
- Configurazione CMake
- File associations
- Esclusioni ricerca e explorer
### extensions.json
Estensioni raccomandate per il progetto:
- C/C++ tools
- CMake tools
- Docker
- ShellCheck
- YAML support
## Quick Start
### Prima Build
1. Apri il progetto in VS Code:
```bash
code /home/pi/Progetti
```
2. Installa estensioni raccomandate (popup VS Code)
3. Build del progetto:
- Premi `Ctrl+Shift+B` per build default
- Oppure `Tasks: Run Task` → `build-inverter-cli-debug`
### Debug Rapido
1. Apri `sources/inverter-cli/main.cpp`
2. Imposta breakpoint (F9 su riga)
3. Premi `F5` e seleziona configurazione debug
4. Usa `F10` (step over) e `F11` (step into)
### Testare Modifiche
1. Modifica codice in `sources/inverter-cli/`
2. Build: `Ctrl+Shift+B`
3. Run: Tasks → `run-inverter-cli-once`
4. Verifica output JSON
## Documentazione Dettagliata
Vedi [DEBUG.md](DEBUG.md) per guida completa al debug e troubleshooting.
## Configurazioni Disponibili
### Debug Configurations (F5)
- **(gdb) Debug inverter_poller** - Debug rapido con Release build
- **(gdb) Debug inverter_poller - Run Once with Debug** - Debug completo, esecuzione singola
- **(gdb) Debug inverter_poller - Loop Mode** - Debug in modalità continua
- **(gdb) Debug inverter_poller - Raw Command** - Debug comandi specifici
- **(gdb) Attach to running inverter_poller** - Attach a processo esistente
### Build Tasks (Ctrl+Shift+B)
- **build-inverter-cli** (default) - Build Release ottimizzato
- **build-inverter-cli-debug** - Build con simboli debug
- **clean-inverter-cli** - Pulizia file di build
- **rebuild-inverter-cli** - Clean + Build
### Run Tasks
- **run-inverter-cli-once** - Esegui una volta
- **run-inverter-cli-loop** - Esegui in loop
- **docker-build** - Build immagine Docker
- **docker-run** - Avvia container
- **docker-logs** - Visualizza log container
- **docker-stop** - Ferma container
## Shortcuts Utili
| Shortcut | Azione |
|----------|--------|
| `F5` | Start Debugging |
| `Ctrl+F5` | Run Without Debugging |
| `F9` | Toggle Breakpoint |
| `F10` | Step Over |
| `F11` | Step Into |
| `Shift+F11` | Step Out |
| `Ctrl+Shift+B` | Run Build Task |
| `Ctrl+Shift+P` | Command Palette |
| `Ctrl+` ` | Toggle Terminal |
## Estensioni Consigliate
### Essenziali
- **C/C++** - IntelliSense, debugging, browsing
- **CMake Tools** - Integrazione CMake
### Utili
- **Docker** - Gestione container
- **ShellCheck** - Linting script bash
- **YAML** - Syntax per configurazioni
### Opzionali
- **GitHub Copilot** - AI code assistant
- **GitLens** - Git supercharged
## Troubleshooting
### IntelliSense non funziona
1. Ricarica window: `Ctrl+Shift+P` → "Reload Window"
2. Verifica estensione C/C++ installata
3. Build il progetto almeno una volta
### GDB non trovato
```bash
sudo apt-get install gdb
```
### Permission denied su device
```bash
sudo usermod -a -G dialout $USER
# Logout e login necessari
```
### Task build fallisce
```bash
cd sources/inverter-cli
rm -rf CMakeFiles CMakeCache.txt
cmake . && make
```
## Tips
1. **Multiple Debug Windows**: Puoi avere più configurazioni debug attive contemporaneamente
2. **Watch Variables**: Usa il pannello Watch per monitorare variabili durante debug
3. **Debug Console**: Esegui comandi GDB direttamente nel Debug Console
4. **Logpoints**: Usa logpoints invece di printf per non modificare codice
## Risorse
- [VS Code C++ Docs](https://code.visualstudio.com/docs/cpp/cpp-debug)
- [CMake Tools Extension](https://github.com/microsoft/vscode-cmake-tools)
- [GDB Documentation](https://sourceware.org/gdb/documentation/)
- [DEBUG.md](DEBUG.md) - Guida debug completa del progetto
sources/inverter-cli/CMakeLists.txt
+17 -1
View File
@@ -1,8 +1,24 @@
CMAKE_MINIMUM_REQUIRED(VERSION 2.6) CMAKE_MINIMUM_REQUIRED(VERSION 2.6)
PROJECT("inverter_poller") PROJECT("inverter_poller")
set (CMAKE_CXX_FLAGS "-O2 --std=c++0x ${CMAKE_CXX_FLAGS}") # Set default build type to Release if not specified
if(NOT CMAKE_BUILD_TYPE)
set(CMAKE_BUILD_TYPE Release CACHE STRING "Choose the type of build (Debug or Release)" FORCE)
endif()
# Compiler flags for different build types
set(CMAKE_CXX_FLAGS "--std=c++0x ${CMAKE_CXX_FLAGS}")
set(CMAKE_CXX_FLAGS_RELEASE "-O2 -DNDEBUG")
set(CMAKE_CXX_FLAGS_DEBUG "-O0 -g -DDEBUG -Wall -Wextra")
# Print build type
message(STATUS "Build type: ${CMAKE_BUILD_TYPE}")
file(GLOB SOURCES *.cpp) file(GLOB SOURCES *.cpp)
ADD_EXECUTABLE(inverter_poller ${SOURCES}) ADD_EXECUTABLE(inverter_poller ${SOURCES})
target_link_libraries(inverter_poller -lpthread) target_link_libraries(inverter_poller -lpthread)
# Set output directory for binary
set_target_properties(inverter_poller PROPERTIES
RUNTIME_OUTPUT_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}/bin"
)
sources/inverter-cli/inverter.conf
-25
View File
@@ -1,25 +0,0 @@
# Basic configuration options for the actual inverter polling process...
# The device to read from...
# Use: /dev/ttyS0 if you have a serial device,
# /dev/ttyUSB0 if a USB<>Serial,
# /dev/hidraw0 if you're connecting via the USB port on the inverter.
device=/dev/ttyUSB0
# How many times per hour is the program going to run...
# This is used to calculate the PV & Load Watt Hours between runs...
# If unsure, leave as default - it will run every minute...
# (120 = every 30 seconds)...
run_interval=120
# This allows you to modify the amperage in case the inverter is giving an incorrect
# reading compared to measurement tools. Normally this will remain '1'
amperage_factor=1.0
# This allos you to modify the wattage in case the inverter is giving an incorrect
# reading compared to measurement tools. Normally this will remain '1'
watt_factor=1.01
qpiri=97
sources/inverter-cli/inverter.cpp
+235 -20
View File
@@ -1,6 +1,7 @@
#include <fcntl.h> #include <fcntl.h>
#include <stdio.h> #include <stdio.h>
#include <string.h> #include <string.h>
#include <string>
#include <unistd.h> #include <unistd.h>
#include "inverter.h" #include "inverter.h"
#include "tools.h" #include "tools.h"
@@ -15,10 +16,12 @@ cInverter::cInverter(std::string devicename, int qpiri, int qpiws, int qmod, int
status2[0] = 0; status2[0] = 0;
warnings[0] = 0; warnings[0] = 0;
mode = 0; mode = 0;
qpiri = qpiri; buf_qpiri = qpiri;
qpiws = qpiws; buf_qpiws = qpiws;
qmod = qmod; buf_qmod = qmod;
qpigs = qpigs; buf_qpigs = qpigs;
lprintf("INVERTER: Initialized with buffer sizes - QPIRI:%d QPIWS:%d QMOD:%d QPIGS:%d",
buf_qpiri, buf_qpiws, buf_qmod, buf_qpigs);
} }
string *cInverter::GetQpigsStatus() { string *cInverter::GetQpigsStatus() {
@@ -89,6 +92,7 @@ bool cInverter::query(const char *cmd, int replysize) {
tcgetattr(fd, &settings); tcgetattr(fd, &settings);
cfsetospeed(&settings, baud); // baud rate cfsetospeed(&settings, baud); // baud rate
cfsetispeed(&settings, baud); // input baud rate
settings.c_cflag &= ~PARENB; // no parity settings.c_cflag &= ~PARENB; // no parity
settings.c_cflag &= ~CSTOPB; // 1 stop bit settings.c_cflag &= ~CSTOPB; // 1 stop bit
settings.c_cflag &= ~CSIZE; settings.c_cflag &= ~CSIZE;
@@ -97,7 +101,15 @@ bool cInverter::query(const char *cmd, int replysize) {
settings.c_oflag &= ~OPOST; // raw output settings.c_oflag &= ~OPOST; // raw output
tcsetattr(fd, TCSANOW, &settings); // apply the settings tcsetattr(fd, TCSANOW, &settings); // apply the settings
tcflush(fd, TCOFLUSH);
// CRITICAL: Flush both input and output buffers to clear any residual data
tcflush(fd, TCIOFLUSH);
// Wait a bit for the device to settle after flush
usleep(100000); // 100ms delay
// Clear internal buffer
memset(buf, 0, sizeof(buf));
// --------------------------------------------------------------- // ---------------------------------------------------------------
@@ -112,7 +124,18 @@ bool cInverter::query(const char *cmd, int replysize) {
buf[n++] = 0x0d; buf[n++] = 0x0d;
//send a command //send a command
write(fd, &buf, n); int written = write(fd, &buf, n);
if (written != n) {
lprintf("INVERTER: %s write failed (wrote %d of %d bytes)", cmd, written, n);
close(fd);
return false;
}
// Flush output to ensure command is sent
tcdrain(fd);
// Clear buffer again before reading
memset(buf, 0, sizeof(buf));
time(&started); time(&started);
do { do {
@@ -122,25 +145,49 @@ bool cInverter::query(const char *cmd, int replysize) {
lprintf("INVERTER: %s read timeout", cmd); lprintf("INVERTER: %s read timeout", cmd);
break; break;
} else { } else {
usleep(10); usleep(10000); // 10ms
continue; continue;
} }
} }
if (n > 0) {
i += n; i += n;
} while (i<replysize); // Check if we've received the terminator
if (i > 0 && buf[i-1] == 0x0d) {
lprintf("INVERTER: %s received terminator at byte %d", cmd, i);
break;
}
}
} while (i<replysize && (time(NULL) - started < 3));
close(fd); close(fd);
if (i==replysize) { if (i > 0) {
lprintf("INVERTER: %s reply size (%d bytes)", cmd, i); lprintf("INVERTER: %s reply size (%d bytes, expected %d)", cmd, i, replysize);
if (buf[0]!='(' || buf[replysize-1]!=0x0d) { // Dump raw buffer for debugging
lprintf("INVERTER: %s: incorrect start/stop bytes. Buffer: %s", cmd, buf); if (debugFlag) {
lprintf("INVERTER: Raw buffer hex dump (first 50 bytes):");
for(int x = 0; x < (i < 50 ? i : 50); x++) {
fprintf(stderr, "%02X ", buf[x]);
if ((x+1) % 16 == 0) fprintf(stderr, "\n");
}
fprintf(stderr, "\n");
}
if (buf[0]!='(' ) {
lprintf("INVERTER: %s: incorrect start byte (got 0x%02X, expected '('). Buffer: %s", cmd, buf[0], buf);
return false; return false;
} }
if (!(CheckCRC(buf, replysize))) {
lprintf("INVERTER: %s: CRC Failed! Reply size: %d Buffer: %s", cmd, replysize, buf); if (buf[i-1]!=0x0d) {
lprintf("INVERTER: %s: incorrect stop byte (got 0x%02X at pos %d, expected CR). Buffer: %s", cmd, buf[i-1], i-1, buf);
return false;
}
if (!(CheckCRC(buf, i))) {
lprintf("INVERTER: %s: CRC Failed! Reply size: %d Buffer: %s", cmd, i, buf);
return false; return false;
} }
@@ -148,6 +195,13 @@ bool cInverter::query(const char *cmd, int replysize) {
lprintf("INVERTER: %s: %d bytes read: %s", cmd, i, buf); lprintf("INVERTER: %s: %d bytes read: %s", cmd, i, buf);
lprintf("INVERTER: %s query finished", cmd); lprintf("INVERTER: %s query finished", cmd);
// If expected size doesn't match actual size, log it
if (i != replysize) {
lprintf("INVERTER: WARNING - %s actual size (%d) differs from configured size (%d)", cmd, i, replysize);
lprintf("INVERTER: SUGGESTION - Update inverter.conf to set the buffer size to %d", i);
}
return true; return true;
} else { } else {
lprintf("INVERTER: %s reply too short (%d bytes)", cmd, i); lprintf("INVERTER: %s reply too short (%d bytes)", cmd, i);
@@ -157,49 +211,68 @@ bool cInverter::query(const char *cmd, int replysize) {
void cInverter::poll() { void cInverter::poll() {
int n,j; int n,j;
extern const int qpiri, qpiws, qmod, qpigs;
fprintf(stderr, "[POLL] Thread started, runOnce=%s\n", runOnce ? "true" : "false");
while (true) { while (true) {
// Reading mode // Reading mode
if (!ups_qmod_changed) { if (!ups_qmod_changed) {
if (query("QMOD", qmod)) { fprintf(stderr, "[POLL] Reading QMOD...\n");
if (query("QMOD", buf_qmod)) {
SetMode(buf[1]); SetMode(buf[1]);
ups_qmod_changed = true; ups_qmod_changed = true;
fprintf(stderr, "[POLL] QMOD completed\n");
} }
} }
// reading status (QPIGS) // reading status (QPIGS)
if (!ups_qpigs_changed) { if (!ups_qpigs_changed) {
if (query("QPIGS", qpigs)) { fprintf(stderr, "[POLL] Reading QPIGS...\n");
if (query("QPIGS", buf_qpigs)) {
m.lock(); m.lock();
strcpy(status1, (const char*)buf+1); strcpy(status1, (const char*)buf+1);
m.unlock(); m.unlock();
ups_qpigs_changed = true; ups_qpigs_changed = true;
fprintf(stderr, "[POLL] QPIGS completed\n");
} }
} }
// Reading QPIRI status // Reading QPIRI status
if (!ups_qpiri_changed) { if (!ups_qpiri_changed) {
if (query("QPIRI", qpiri)) { fprintf(stderr, "[POLL] Reading QPIRI...\n");
if (query("QPIRI", buf_qpiri)) {
m.lock(); m.lock();
strcpy(status2, (const char*)buf+1); strcpy(status2, (const char*)buf+1);
m.unlock(); m.unlock();
ups_qpiri_changed = true; ups_qpiri_changed = true;
fprintf(stderr, "[POLL] QPIRI completed\n");
} }
} }
// Get any device warnings... // Get any device warnings...
if (!ups_qpiws_changed) { if (!ups_qpiws_changed) {
if (query("QPIWS", qpiws)) { fprintf(stderr, "[POLL] Reading QPIWS...\n");
if (query("QPIWS", buf_qpiws)) {
m.lock(); m.lock();
strcpy(warnings, (const char*)buf+1); strcpy(warnings, (const char*)buf+1);
m.unlock(); m.unlock();
ups_qpiws_changed = true; ups_qpiws_changed = true;
fprintf(stderr, "[POLL] QPIWS completed\n");
} }
} }
sleep(5); // If runOnce mode and all data collected, exit the thread
if (runOnce && ups_qmod_changed && ups_qpigs_changed && ups_qpiri_changed && ups_qpiws_changed) {
fprintf(stderr, "[POLL] All data collected, exiting (run-once mode)\n");
return;
}
fprintf(stderr, "[POLL] Flags: QMOD=%d QPIGS=%d QPIRI=%d QPIWS=%d, sleeping...\n",
ups_qmod_changed.load(), ups_qpigs_changed.load(),
ups_qpiri_changed.load(), ups_qpiws_changed.load());
sleep(2);
} }
} }
@@ -255,3 +328,145 @@ bool cInverter::CheckCRC(unsigned char *data, int len) {
uint16_t crc = cal_crc_half(data, len-3); uint16_t crc = cal_crc_half(data, len-3);
return data[len-3]==(crc>>8) && data[len-2]==(crc&0xff); return data[len-3]==(crc>>8) && data[len-2]==(crc&0xff);
} }
// Auto-discover the correct buffer size for a command by reading until CR
int cInverter::query_auto(const char *cmd, int max_size) {
time_t started;
int fd;
int i=0, n;
unsigned char temp_buf[1024];
memset(temp_buf, 0, sizeof(temp_buf));
fd = open(this->device.data(), O_RDWR | O_NONBLOCK);
if (fd == -1) {
lprintf("INVERTER: Unable to open device file for auto-discovery");
return -1;
}
// Configure serial port
speed_t baud = B2400;
struct termios settings;
tcgetattr(fd, &settings);
cfsetospeed(&settings, baud);
cfsetispeed(&settings, baud);
settings.c_cflag &= ~PARENB;
settings.c_cflag &= ~CSTOPB;
settings.c_cflag &= ~CSIZE;
settings.c_cflag |= CS8 | CLOCAL;
settings.c_oflag &= ~OPOST;
tcsetattr(fd, TCSANOW, &settings);
// Flush all buffers
tcflush(fd, TCIOFLUSH);
usleep(200000); // 200ms delay to ensure clean state
// Generate and send command with CRC
uint16_t crc = cal_crc_half((uint8_t*)cmd, strlen(cmd));
n = strlen(cmd);
memcpy(&temp_buf, cmd, n);
temp_buf[n++] = crc >> 8;
temp_buf[n++] = crc & 0xff;
temp_buf[n++] = 0x0d;
write(fd, &temp_buf, n);
tcdrain(fd);
// Clear buffer for reading
memset(temp_buf, 0, sizeof(temp_buf));
time(&started);
// Read until we find CR (0x0d) or timeout
while (i < max_size && (time(NULL) - started < 5)) {
n = read(fd, temp_buf+i, 1); // Read one byte at a time
if (n > 0) {
i += n;
// Found the terminator
if (temp_buf[i-1] == 0x0d) {
lprintf("INVERTER: Auto-discovery for %s: found CR at byte %d", cmd, i);
break;
}
} else {
usleep(10000); // 10ms between reads
}
}
close(fd);
// Validate the response
if (i > 0 && temp_buf[0] == '(' && temp_buf[i-1] == 0x0d) {
lprintf("INVERTER: Auto-discovery for %s successful: %d bytes", cmd, i);
return i;
} else {
lprintf("INVERTER: Auto-discovery for %s failed (read %d bytes)", cmd, i);
// Dump what we received for debugging
if (i > 0) {
lprintf("INVERTER: Received data (hex):");
for(int x = 0; x < i; x++) {
fprintf(stderr, "%02X ", temp_buf[x]);
}
fprintf(stderr, "\n");
lprintf("INVERTER: Received data (ascii):");
for(int x = 0; x < i; x++) {
fprintf(stderr, "%c", (temp_buf[x] >= 32 && temp_buf[x] < 127) ? temp_buf[x] : '.');
}
fprintf(stderr, "\n");
}
return -1;
}
}
// Auto-discover buffer sizes for all commands
void cInverter::AutoDiscoverBufferSizes() {
printf("\n=== AUTO-DISCOVERY MODE ===\n");
printf("Testing inverter to find correct buffer sizes...\n\n");
int qmod_size = query_auto("QMOD", 20);
if (qmod_size > 0) {
printf("✓ QMOD buffer size: %d\n", qmod_size);
} else {
printf("✗ QMOD auto-discovery failed\n");
}
sleep(1);
int qpigs_size = query_auto("QPIGS", 150);
if (qpigs_size > 0) {
printf("✓ QPIGS buffer size: %d\n", qpigs_size);
} else {
printf("✗ QPIGS auto-discovery failed\n");
}
sleep(1);
int qpiri_size = query_auto("QPIRI", 150);
if (qpiri_size > 0) {
printf("✓ QPIRI buffer size: %d\n", qpiri_size);
} else {
printf("✗ QPIRI auto-discovery failed\n");
}
sleep(1);
int qpiws_size = query_auto("QPIWS", 100);
if (qpiws_size > 0) {
printf("✓ QPIWS buffer size: %d\n", qpiws_size);
} else {
printf("✗ QPIWS auto-discovery failed\n");
}
printf("\n=== SUGGESTED CONFIGURATION ===\n");
printf("Update your /etc/inverter/inverter.conf with these values:\n\n");
if (qmod_size > 0) printf("qmod=%d\n", qmod_size);
if (qpigs_size > 0) printf("qpigs=%d\n", qpigs_size);
if (qpiri_size > 0) printf("qpiri=%d\n", qpiri_size);
if (qpiws_size > 0) printf("qpiws=%d\n", qpiws_size);
printf("\n");
// Output in parsable format for scripts
printf("DISCOVERY_QMOD=%d\n", qmod_size > 0 ? qmod_size : 5);
printf("DISCOVERY_QPIGS=%d\n", qpigs_size > 0 ? qpigs_size : 110);
printf("DISCOVERY_QPIRI=%d\n", qpiri_size > 0 ? qpiri_size : 98);
printf("DISCOVERY_QPIWS=%d\n", qpiws_size > 0 ? qpiws_size : 36);
printf("DISCOVERY_SUCCESS=%s\n", (qmod_size > 0 && qpigs_size > 0 && qpiri_size > 0 && qpiws_size > 0) ? "true" : "false");
}
sources/inverter-cli/inverter.h
+9
View File
@@ -1,6 +1,7 @@
#ifndef ___INVERTER_H #ifndef ___INVERTER_H
#define ___INVERTER_H #define ___INVERTER_H
#include <string>
#include <thread> #include <thread>
#include <mutex> #include <mutex>
@@ -17,9 +18,16 @@ class cInverter {
std::string device; std::string device;
std::mutex m; std::mutex m;
// Buffer sizes for different commands
int buf_qpiri;
int buf_qpiws;
int buf_qmod;
int buf_qpigs;
void SetMode(char newmode); void SetMode(char newmode);
bool CheckCRC(unsigned char *buff, int len); bool CheckCRC(unsigned char *buff, int len);
bool query(const char *cmd, int replysize); bool query(const char *cmd, int replysize);
int query_auto(const char *cmd, int max_size);
uint16_t cal_crc_half(uint8_t *pin, uint8_t len); uint16_t cal_crc_half(uint8_t *pin, uint8_t len);
public: public:
@@ -36,6 +44,7 @@ class cInverter {
int GetMode(); int GetMode();
void ExecuteCmd(const std::string cmd); void ExecuteCmd(const std::string cmd);
void AutoDiscoverBufferSizes();
}; };
#endif // ___INVERTER_H #endif // ___INVERTER_H
sources/inverter-cli/main.cpp
+33 -9
View File
@@ -65,6 +65,15 @@ void attemptAddSetting(float *addTo, string addFrom) {
} }
} }
void attemptAddSettingInt(int *addTo, string addFrom) {
try {
*addTo = stoi(addFrom);
} catch (exception e) {
cout << e.what() << '\n';
cout << "There's probably a string in the settings file where an int should be.\n";
}
}
void getSettingsFile(string filename) { void getSettingsFile(string filename) {
try { try {
@@ -89,14 +98,22 @@ void getSettingsFile(string filename) {
attemptAddSetting(&ampfactor, linepart2); attemptAddSetting(&ampfactor, linepart2);
else if(linepart1 == "watt_factor") else if(linepart1 == "watt_factor")
attemptAddSetting(&wattfactor, linepart2); attemptAddSetting(&wattfactor, linepart2);
else if(linepart1 == "qpiri") else if(linepart1 == "qpiri") {
attemptAddSetting(&qpiri, linepart2); attemptAddSettingInt(&qpiri, linepart2);
else if(linepart1 == "qpiws") if(debugFlag) printf("Parsed qpiri=%d from '%s'\n", qpiri, linepart2.c_str());
attemptAddSetting(&qpiws, linepart2); }
else if(linepart1 == "qmod") else if(linepart1 == "qpiws") {
attemptAddSetting(&qmod, linepart2); attemptAddSettingInt(&qpiws, linepart2);
else if(linepart1 == "qpigs") if(debugFlag) printf("Parsed qpiws=%d from '%s'\n", qpiws, linepart2.c_str());
attemptAddSetting(&qpigs, linepart2); }
else if(linepart1 == "qmod") {
attemptAddSettingInt(&qmod, linepart2);
if(debugFlag) printf("Parsed qmod=%d from '%s'\n", qmod, linepart2.c_str());
}
else if(linepart1 == "qpigs") {
attemptAddSettingInt(&qpigs, linepart2);
if(debugFlag) printf("Parsed qpigs=%d from '%s'\n", qpigs, linepart2.c_str());
}
else else
continue; continue;
} }
@@ -180,6 +197,12 @@ int main(int argc, char* argv[]) {
bool ups_status_changed(false); bool ups_status_changed(false);
ups = new cInverter(devicename,qpiri,qpiws,qmod,qpigs); ups = new cInverter(devicename,qpiri,qpiws,qmod,qpigs);
// Auto-discovery mode to find correct buffer sizes
if(cmdArgs.cmdOptionExists("-a") || cmdArgs.cmdOptionExists("--auto-discover")) {
ups->AutoDiscoverBufferSizes();
exit(0);
}
// Logic to send 'raw commands' to the inverter.. // Logic to send 'raw commands' to the inverter..
if (!rawcmd.empty()) { if (!rawcmd.empty()) {
ups->ExecuteCmd(rawcmd); ups->ExecuteCmd(rawcmd);
@@ -200,11 +223,12 @@ int main(int argc, char* argv[]) {
ups_status_changed = false; ups_status_changed = false;
} }
if (ups_qmod_changed && ups_qpiri_changed && ups_qpigs_changed) { if (ups_qmod_changed && ups_qpiri_changed && ups_qpigs_changed && ups_qpiws_changed) {
ups_qmod_changed = false; ups_qmod_changed = false;
ups_qpiri_changed = false; ups_qpiri_changed = false;
ups_qpigs_changed = false; ups_qpigs_changed = false;
ups_qpiws_changed = false;
int mode = ups->GetMode(); int mode = ups->GetMode();
string *reply1 = ups->GetQpigsStatus(); string *reply1 = ups->GetQpigsStatus();
sources/inverter-cli/main.h
+1
View File
@@ -5,6 +5,7 @@
#include "inverter.h" #include "inverter.h"
extern bool debugFlag; extern bool debugFlag;
extern bool runOnce;
extern atomic_bool ups_data_changed; extern atomic_bool ups_data_changed;
extern atomic_bool ups_status_changed; extern atomic_bool ups_status_changed;
sources/inverter-cli/test-device.sh
Executable
+133
View File
@@ -0,0 +1,133 @@
#!/bin/bash
# Script per testare comunicazione diretta con inverter
# Usa questo per verificare se il device risponde correttamente
DEVICE="${1:-/dev/ttyUSB0}"
echo "=== Test Comunicazione Inverter su $DEVICE ==="
echo ""
# Verifica device esiste
if [ ! -e "$DEVICE" ]; then
echo "ERROR: Device $DEVICE non trovato!"
exit 1
fi
# Verifica permessi
if [ ! -r "$DEVICE" ] || [ ! -w "$DEVICE" ]; then
echo "ERROR: Permessi insufficienti su $DEVICE"
echo "Esegui: sudo chmod 666 $DEVICE"
exit 1
fi
echo "1. Configurazione device seriale..."
stty -F $DEVICE 2400 cs8 -cstopb -parenb -echo raw
echo "2. Test con cat (premi Ctrl+C dopo 5 secondi)..."
echo " Questo mostrerà eventuali dati inviati dall'inverter..."
timeout 5 cat $DEVICE | od -A x -t x1z -v | head -20
echo ""
echo "3. Invio comando raw QMOD all'inverter..."
# Crea script Python per inviare comando con CRC corretto
python3 << 'PYTHON_EOF'
import sys
import serial
import time
def calc_crc(data):
"""Calcola CRC secondo protocollo Voltronic"""
crc_ta = [
0x0000,0x1021,0x2042,0x3063,0x4084,0x50a5,0x60c6,0x70e7,
0x8108,0x9129,0xa14a,0xb16b,0xc18c,0xd1ad,0xe1ce,0xf1ef
]
crc = 0
for byte in data:
da = ((crc >> 8) >> 4)
crc = (crc << 4) & 0xFFFF
crc ^= crc_ta[da ^ (byte >> 4)]
da = ((crc >> 8) >> 4)
crc = (crc << 4) & 0xFFFF
crc ^= crc_ta[da ^ (byte & 0x0f)]
crc_high = (crc >> 8) & 0xFF
crc_low = crc & 0xFF
# Adjust for special bytes
if crc_low in [0x28, 0x0d, 0x0a]:
crc_low += 1
if crc_high in [0x28, 0x0d, 0x0a]:
crc_high += 1
return bytes([crc_high, crc_low])
try:
ser = serial.Serial(
port=sys.argv[1] if len(sys.argv) > 1 else '/dev/ttyUSB0',
baudrate=2400,
bytesize=serial.EIGHTBITS,
parity=serial.PARITY_NONE,
stopbits=serial.STOPBITS_ONE,
timeout=3
)
# Flush buffers
ser.reset_input_buffer()
ser.reset_output_buffer()
time.sleep(0.2)
# Test comandi
commands = ['QMOD', 'QPIGS', 'QPIRI', 'QPIWS']
for cmd in commands:
print(f"\n--- Testing {cmd} ---")
# Prepare command
cmd_bytes = cmd.encode('ascii')
crc = calc_crc(cmd_bytes)
full_cmd = cmd_bytes + crc + b'\r'
print(f"Sending: {full_cmd.hex()}")
# Send
ser.write(full_cmd)
ser.flush()
time.sleep(0.3)
# Read response
response = ser.read(200)
if len(response) > 0:
print(f"Received {len(response)} bytes")
print(f"Hex: {response.hex()}")
try:
print(f"ASCII: {response.decode('ascii', errors='replace')}")
except:
print(f"ASCII: {response}")
if response[0:1] == b'(':
print(f"[OK] Valid start byte")
if response[-1:] == b'\r':
print(f"[OK] Valid end byte")
print(f">>> Buffer size for {cmd}: {len(response)}")
else:
print(f"[ERROR] Invalid end byte: {response[-1]:02x}")
else:
print(f"[ERROR] Invalid start byte: {response[0]:02x}")
else:
print("✗ No response received")
time.sleep(1)
ser.close()
except Exception as e:
print(f"Error: {e}")
sys.exit(1)
PYTHON_EOF
echo ""
echo "=== Test completato ===="
sources/inverter-cli/tools.cpp
+2 -1
View File
@@ -54,7 +54,8 @@ int print_help() {
printf(" -r <raw-command> TX 'raw' command to the inverter\n"); printf(" -r <raw-command> TX 'raw' command to the inverter\n");
printf(" -h | --help This Help Message\n"); printf(" -h | --help This Help Message\n");
printf(" -1 | --run-once Runs one iteration on the inverter, and then exits\n"); printf(" -1 | --run-once Runs one iteration on the inverter, and then exits\n");
printf(" -d Additional debugging\n\n"); printf(" -d Additional debugging\n");
printf(" -a | --auto-discover Auto-detect correct buffer sizes for your inverter\n\n");
printf("RAW COMMAND EXAMPLES (see protocol manual for complete list):\n"); printf("RAW COMMAND EXAMPLES (see protocol manual for complete list):\n");
printf("Set output source priority POP00 (Utility first)\n"); printf("Set output source priority POP00 (Utility first)\n");
sources/inverter-mqtt/entrypoint.sh
+161 -2
View File
@@ -1,15 +1,174 @@
#!/bin/bash #!/bin/bash
export TERM=xterm export TERM=xterm
# stty -F /dev/ttyUSB0 2400 raw echo "=== Voltronic MQTT Bridge Starting ==="
echo "Version: 2.0 with Auto-Discovery"
echo ""
# Configuration paths
CONF_FILE="/etc/inverter/inverter.conf"
DISCOVERY_FLAG="/etc/inverter/.discovery_done"
TEMP_CONF="/tmp/inverter_discovered.conf"
# Environment variables with defaults
INVERTER_DEVICE="${INVERTER_DEVICE:-/dev/ttyUSB0}"
FORCE_DISCOVERY="${FORCE_DISCOVERY:-false}"
SKIP_DISCOVERY="${SKIP_DISCOVERY:-false}"
echo "Configuration:"
echo " Device: $INVERTER_DEVICE"
echo " Force Discovery: $FORCE_DISCOVERY"
echo " Skip Discovery: $SKIP_DISCOVERY"
echo ""
# Function to update config file with discovered values
update_config_with_discovery() {
local qmod=$1
local qpigs=$2
local qpiri=$3
local qpiws=$4
echo "Updating configuration with discovered values..."
# Backup original config
cp $CONF_FILE ${CONF_FILE}.backup
# Update device
sed -i "s|^device=.*|device=$INVERTER_DEVICE|g" $CONF_FILE
# Update buffer sizes
sed -i "s/^qmod=.*/qmod=$qmod/g" $CONF_FILE
sed -i "s/^qpigs=.*/qpigs=$qpigs/g" $CONF_FILE
sed -i "s/^qpiri=.*/qpiri=$qpiri/g" $CONF_FILE
sed -i "s/^qpiws=.*/qpiws=$qpiws/g" $CONF_FILE
echo "✓ Configuration updated successfully"
echo ""
grep -E "^(device|qmod|qpigs|qpiri|qpiws)=" $CONF_FILE
}
# Function to run auto-discovery
run_discovery() {
echo "=== Running Auto-Discovery ==="
echo "This will take about 10-15 seconds..."
echo ""
# Temporarily set device in config for discovery
cp $CONF_FILE $TEMP_CONF
sed -i "s|^device=.*|device=$INVERTER_DEVICE|g" $TEMP_CONF
cp $TEMP_CONF $CONF_FILE
# Run discovery and capture output
DISCOVERY_OUTPUT=$(/opt/inverter-cli/bin/inverter_poller -d -a 2>&1)
echo "$DISCOVERY_OUTPUT"
echo ""
# Parse discovery output
QMOD=$(echo "$DISCOVERY_OUTPUT" | grep "DISCOVERY_QMOD=" | cut -d= -f2)
QPIGS=$(echo "$DISCOVERY_OUTPUT" | grep "DISCOVERY_QPIGS=" | cut -d= -f2)
QPIRI=$(echo "$DISCOVERY_OUTPUT" | grep "DISCOVERY_QPIRI=" | cut -d= -f2)
QPIWS=$(echo "$DISCOVERY_OUTPUT" | grep "DISCOVERY_QPIWS=" | cut -d= -f2)
SUCCESS=$(echo "$DISCOVERY_OUTPUT" | grep "DISCOVERY_SUCCESS=" | cut -d= -f2)
if [ "$SUCCESS" = "true" ]; then
echo "✓ Auto-discovery completed successfully!"
update_config_with_discovery $QMOD $QPIGS $QPIRI $QPIWS
# Mark discovery as done
echo "device=$INVERTER_DEVICE" > $DISCOVERY_FLAG
echo "qmod=$QMOD" >> $DISCOVERY_FLAG
echo "qpigs=$QPIGS" >> $DISCOVERY_FLAG
echo "qpiri=$QPIRI" >> $DISCOVERY_FLAG
echo "qpiws=$QPIWS" >> $DISCOVERY_FLAG
echo "timestamp=$(date -Iseconds)" >> $DISCOVERY_FLAG
echo "✓ Discovery results saved to $DISCOVERY_FLAG"
return 0
else
echo "✗ Auto-discovery failed!"
echo "Please check:"
echo " 1. Inverter is powered on"
echo " 2. Cable is properly connected"
echo " 3. Device path is correct: $INVERTER_DEVICE"
echo ""
echo "Falling back to default configuration..."
# Update device but keep default buffer sizes
sed -i "s|^device=.*|device=$INVERTER_DEVICE|g" $CONF_FILE
return 1
fi
}
# Check if we need to run discovery
NEED_DISCOVERY=false
if [ "$FORCE_DISCOVERY" = "true" ]; then
echo "⚠ Force discovery requested via environment variable"
rm -f $DISCOVERY_FLAG
NEED_DISCOVERY=true
elif [ "$SKIP_DISCOVERY" = "true" ]; then
echo "⚠ Discovery skipped via environment variable"
# Just update device in config
sed -i "s|^device=.*|device=$INVERTER_DEVICE|g" $CONF_FILE
NEED_DISCOVERY=false
elif [ ! -f "$DISCOVERY_FLAG" ]; then
echo "ℹ No previous discovery found, will run auto-discovery"
NEED_DISCOVERY=true
else
# Check if device changed
SAVED_DEVICE=$(grep "^device=" $DISCOVERY_FLAG 2>/dev/null | cut -d= -f2)
if [ "$SAVED_DEVICE" != "$INVERTER_DEVICE" ]; then
echo "⚠ Device changed from $SAVED_DEVICE to $INVERTER_DEVICE"
echo " Running new discovery..."
rm -f $DISCOVERY_FLAG
NEED_DISCOVERY=true
else
echo "✓ Using previous discovery results from $DISCOVERY_FLAG"
# Restore saved config
while IFS= read -r line; do
if [[ $line =~ ^(device|qmod|qpigs|qpiri|qpiws)= ]]; then
key=$(echo "$line" | cut -d= -f1)
value=$(echo "$line" | cut -d= -f2)
sed -i "s/^$key=.*/$key=$value/g" $CONF_FILE
fi
done < "$DISCOVERY_FLAG"
echo "Current configuration:"
grep -E "^(device|qmod|qpigs|qpiri|qpiws)=" $CONF_FILE
fi
fi
# Run discovery if needed
if [ "$NEED_DISCOVERY" = "true" ]; then
if ! run_discovery; then
echo "⚠ Continuing with default configuration..."
echo " You can manually run discovery later with:"
echo " docker exec -it <container> /opt/inverter-cli/bin/inverter_poller -a"
fi
fi
echo ""
echo "=== Starting MQTT Bridge Services ==="
echo ""
# Wait a bit for the device to be ready
sleep 2
# Init the mqtt server for the first time, then every 5 minutes # Init the mqtt server for the first time, then every 5 minutes
# This will re-create the auto-created topics in the MQTT server if HA is restarted... # This will re-create the auto-created topics in the MQTT server if HA is restarted...
echo "Starting MQTT initialization service..."
watch -n 300 /opt/inverter-mqtt/mqtt-init.sh > /dev/null 2>&1 & watch -n 300 /opt/inverter-mqtt/mqtt-init.sh > /dev/null 2>&1 &
# Run the MQTT Subscriber process in the background (so that way we can change the configuration on the inverter from home assistant) # Run the MQTT Subscriber process in the background (so that way we can change the configuration on the inverter from home assistant)
echo "Starting MQTT subscriber for commands..."
/opt/inverter-mqtt/mqtt-subscriber.sh & /opt/inverter-mqtt/mqtt-subscriber.sh &
# execute exactly every 30 seconds... # execute exactly every 30 seconds...
echo "Starting MQTT data push service (every 30 seconds)..."
echo ""
echo "✓ All services started successfully!"
echo " Logs will appear below..."
echo ""
watch -n 30 /opt/inverter-mqtt/mqtt-push.sh > /dev/null 2>&1 watch -n 30 /opt/inverter-mqtt/mqtt-push.sh > /dev/null 2>&1
test-autodiscovery.sh
Executable
+147
View File
@@ -0,0 +1,147 @@
#!/bin/bash
# Test script per verificare auto-discovery in locale
# Simula il comportamento del container
echo "=== Test Auto-Discovery Locale ==="
echo ""
# Configura le variabili come farebbe il container
export INVERTER_DEVICE="${INVERTER_DEVICE:-/dev/ttyUSB1}"
export FORCE_DISCOVERY="${FORCE_DISCOVERY:-false}"
export SKIP_DISCOVERY="${SKIP_DISCOVERY:-false}"
CONF_FILE="/etc/inverter/inverter.conf"
DISCOVERY_FLAG="/etc/inverter/.discovery_done"
INVERTER_BIN="./sources/inverter-cli/bin/inverter_poller"
echo "Configurazione:"
echo " Device: $INVERTER_DEVICE"
echo " Binary: $INVERTER_BIN"
echo " Force Discovery: $FORCE_DISCOVERY"
echo " Skip Discovery: $SKIP_DISCOVERY"
echo ""
# Verifica che il binario esista
if [ ! -f "$INVERTER_BIN" ]; then
echo "✗ Errore: $INVERTER_BIN non trovato!"
echo " Compila prima con: cd sources/inverter-cli && make"
exit 1
fi
# Verifica che il device esista
if [ ! -e "$INVERTER_DEVICE" ]; then
echo "✗ Errore: Device $INVERTER_DEVICE non trovato!"
echo " Devices disponibili:"
ls -la /dev/tty* 2>/dev/null | grep -E "USB|ttyS"
exit 1
fi
# Crea directory temporanea per il test
TEST_DIR="/tmp/inverter-test-$$"
mkdir -p "$TEST_DIR"
echo "Directory test: $TEST_DIR"
# Copia config originale
if [ -f "./config/inverter.conf" ]; then
cp ./config/inverter.conf "$TEST_DIR/inverter.conf"
CONF_FILE="$TEST_DIR/inverter.conf"
DISCOVERY_FLAG="$TEST_DIR/.discovery_done"
echo "✓ Config copiata in $CONF_FILE"
else
echo "✗ Errore: config/inverter.conf non trovato!"
exit 1
fi
# Aggiorna device nella config temporanea
sed -i "s|^device=.*|device=$INVERTER_DEVICE|g" "$CONF_FILE"
echo ""
echo "=== Esecuzione Auto-Discovery ==="
echo "Questo prenderà circa 10-15 secondi..."
echo ""
# Esegui discovery
DISCOVERY_OUTPUT=$("$INVERTER_BIN" -d -a 2>&1)
echo "$DISCOVERY_OUTPUT"
echo ""
# Parse output
QMOD=$(echo "$DISCOVERY_OUTPUT" | grep "DISCOVERY_QMOD=" | cut -d= -f2)
QPIGS=$(echo "$DISCOVERY_OUTPUT" | grep "DISCOVERY_QPIGS=" | cut -d= -f2)
QPIRI=$(echo "$DISCOVERY_OUTPUT" | grep "DISCOVERY_QPIRI=" | cut -d= -f2)
QPIWS=$(echo "$DISCOVERY_OUTPUT" | grep "DISCOVERY_QPIWS=" | cut -d= -f2)
SUCCESS=$(echo "$DISCOVERY_OUTPUT" | grep "DISCOVERY_SUCCESS=" | cut -d= -f2)
echo "=== Risultati Discovery ==="
if [ "$SUCCESS" = "true" ]; then
echo "✓ SUCCESS!"
echo ""
echo "Valori scoperti:"
echo " QMOD = $QMOD"
echo " QPIGS = $QPIGS"
echo " QPIRI = $QPIRI"
echo " QPIWS = $QPIWS"
echo ""
# Salva risultati
echo "device=$INVERTER_DEVICE" > "$DISCOVERY_FLAG"
echo "qmod=$QMOD" >> "$DISCOVERY_FLAG"
echo "qpigs=$QPIGS" >> "$DISCOVERY_FLAG"
echo "qpiri=$QPIRI" >> "$DISCOVERY_FLAG"
echo "qpiws=$QPIWS" >> "$DISCOVERY_FLAG"
echo "timestamp=$(date -Iseconds)" >> "$DISCOVERY_FLAG"
echo "Salvati in: $DISCOVERY_FLAG"
echo ""
cat "$DISCOVERY_FLAG"
# Aggiorna config
sed -i "s/^qmod=.*/qmod=$QMOD/g" "$CONF_FILE"
sed -i "s/^qpigs=.*/qpigs=$QPIGS/g" "$CONF_FILE"
sed -i "s/^qpiri=.*/qpiri=$QPIRI/g" "$CONF_FILE"
sed -i "s/^qpiws=.*/qpiws=$QPIWS/g" "$CONF_FILE"
echo ""
echo "Config aggiornata:"
grep -E "^(device|qmod|qpigs|qpiri|qpiws)=" "$CONF_FILE"
echo ""
echo "✓ Test completato con successo!"
echo ""
echo "Per applicare questi valori al tuo config/inverter.conf:"
echo " cp $CONF_FILE ./config/inverter.conf"
else
echo "✗ FAILED!"
echo ""
echo "Controlla:"
echo " 1. Inverter acceso"
echo " 2. Cavo collegato correttamente"
echo " 3. Device corretto: $INVERTER_DEVICE"
echo " 4. Permessi device: ls -la $INVERTER_DEVICE"
exit 1
fi
echo ""
echo "=== Test Lettura Dati ==="
echo "Testo la lettura con i nuovi parametri..."
echo ""
# Test con -1 (run-once)
TEST_OUTPUT=$("$INVERTER_BIN" -1 2>&1)
echo "$TEST_OUTPUT"
if echo "$TEST_OUTPUT" | grep -q '"mode":'; then
echo ""
echo "✓ Lettura dati OK! Output JSON valido."
else
echo ""
echo "⚠ Attenzione: Output non sembra JSON valido"
fi
echo ""
echo "=== Cleanup ==="
echo "Directory test: $TEST_DIR"
echo "Per rimuoverla: rm -rf $TEST_DIR"