feat: Supporto completo estrazione 28 parametri da QPGS+QPIRI per inverter paralleli

- Aggiunta funzione extractAndPublishAllData() con tutti i 33 parametri
- Parsing QPGS (19 params runtime) + QPIRI (8 params config) + PV_watts calcolato
- Fallback automatico a modalità standard se QPGS non disponibile
- Retry ridotto a 1 tentativo (2s delay) per performance
- Gestione errori NAK con messaggi informativi per utente
- Supporto bitmap status flags da QPGS (Load_on, SCC_on, AC_charge_on)

Note: Test mostrano che inverter attualmente in modalità Battery (QMOD=B)
risponde NAK a tutti i comandi eccetto QMOD. Necessaria verifica stato
fisico inverter o attivazione modalità parallela nel firmware.

sources/inverter-mqtt/mqtt-push-parallel.sh

@@ -68,6 +68,112 @@ pushInfluxData () {
     curl -i -XPOST "$INFLUX_HOST/write?db=$INFLUX_DATABASE&precision=s" -u "$INFLUX_USERNAME:$INFLUX_PASSWORD" --data-binary "$INFLUX_PREFIX,device=${INFLUX_DEVICE}_inv${1} $INFLUX_MEASUREMENT_NAME=$3" > /dev/null 2>&1
 }
 
+# Extract all 33 parameters from JSON (like original mqtt-push.sh)
+extractAndPublishAllData () {
+    local inv_id=$1
+    local json_data=$2
+    
+    # Extract all 33 parameters exactly like original script
+    Inverter_mode=`echo "$json_data" | jq '.Inverter_mode' -r`
+    [ ! -z "$Inverter_mode" ] && [ "$Inverter_mode" != "null" ] && pushMQTTData "$inv_id" "Inverter_mode" "$Inverter_mode"
+    
+    AC_grid_voltage=`echo "$json_data" | jq '.AC_grid_voltage' -r`
+    [ ! -z "$AC_grid_voltage" ] && [ "$AC_grid_voltage" != "null" ] && pushMQTTData "$inv_id" "AC_grid_voltage" "$AC_grid_voltage"
+    
+    AC_grid_frequency=`echo "$json_data" | jq '.AC_grid_frequency' -r`
+    [ ! -z "$AC_grid_frequency" ] && [ "$AC_grid_frequency" != "null" ] && pushMQTTData "$inv_id" "AC_grid_frequency" "$AC_grid_frequency"
+    
+    AC_out_voltage=`echo "$json_data" | jq '.AC_out_voltage' -r`
+    [ ! -z "$AC_out_voltage" ] && [ "$AC_out_voltage" != "null" ] && pushMQTTData "$inv_id" "AC_out_voltage" "$AC_out_voltage"
+    
+    AC_out_frequency=`echo "$json_data" | jq '.AC_out_frequency' -r`
+    [ ! -z "$AC_out_frequency" ] && [ "$AC_out_frequency" != "null" ] && pushMQTTData "$inv_id" "AC_out_frequency" "$AC_out_frequency"
+    
+    PV_in_voltage=`echo "$json_data" | jq '.PV_in_voltage' -r`
+    [ ! -z "$PV_in_voltage" ] && [ "$PV_in_voltage" != "null" ] && pushMQTTData "$inv_id" "PV_in_voltage" "$PV_in_voltage"
+    
+    PV_in_current=`echo "$json_data" | jq '.PV_in_current' -r`
+    [ ! -z "$PV_in_current" ] && [ "$PV_in_current" != "null" ] && pushMQTTData "$inv_id" "PV_in_current" "$PV_in_current"
+    
+    PV_in_watts=`echo "$json_data" | jq '.PV_in_watts' -r`
+    [ ! -z "$PV_in_watts" ] && [ "$PV_in_watts" != "null" ] && pushMQTTData "$inv_id" "PV_in_watts" "$PV_in_watts"
+    
+    PV_in_watthour=`echo "$json_data" | jq '.PV_in_watthour' -r`
+    [ ! -z "$PV_in_watthour" ] && [ "$PV_in_watthour" != "null" ] && pushMQTTData "$inv_id" "PV_in_watthour" "$PV_in_watthour"
+    
+    SCC_voltage=`echo "$json_data" | jq '.SCC_voltage' -r`
+    [ ! -z "$SCC_voltage" ] && [ "$SCC_voltage" != "null" ] && pushMQTTData "$inv_id" "SCC_voltage" "$SCC_voltage"
+    
+    Load_pct=`echo "$json_data" | jq '.Load_pct' -r`
+    [ ! -z "$Load_pct" ] && [ "$Load_pct" != "null" ] && pushMQTTData "$inv_id" "Load_pct" "$Load_pct"
+    
+    Load_watt=`echo "$json_data" | jq '.Load_watt' -r`
+    [ ! -z "$Load_watt" ] && [ "$Load_watt" != "null" ] && pushMQTTData "$inv_id" "Load_watt" "$Load_watt"
+    
+    Load_watthour=`echo "$json_data" | jq '.Load_watthour' -r`
+    [ ! -z "$Load_watthour" ] && [ "$Load_watthour" != "null" ] && pushMQTTData "$inv_id" "Load_watthour" "$Load_watthour"
+    
+    Load_va=`echo "$json_data" | jq '.Load_va' -r`
+    [ ! -z "$Load_va" ] && [ "$Load_va" != "null" ] && pushMQTTData "$inv_id" "Load_va" "$Load_va"
+    
+    Bus_voltage=`echo "$json_data" | jq '.Bus_voltage' -r`
+    [ ! -z "$Bus_voltage" ] && [ "$Bus_voltage" != "null" ] && pushMQTTData "$inv_id" "Bus_voltage" "$Bus_voltage"
+    
+    Heatsink_temperature=`echo "$json_data" | jq '.Heatsink_temperature' -r`
+    [ ! -z "$Heatsink_temperature" ] && [ "$Heatsink_temperature" != "null" ] && pushMQTTData "$inv_id" "Heatsink_temperature" "$Heatsink_temperature"
+    
+    Battery_capacity=`echo "$json_data" | jq '.Battery_capacity' -r`
+    [ ! -z "$Battery_capacity" ] && [ "$Battery_capacity" != "null" ] && pushMQTTData "$inv_id" "Battery_capacity" "$Battery_capacity"
+    
+    Battery_voltage=`echo "$json_data" | jq '.Battery_voltage' -r`
+    [ ! -z "$Battery_voltage" ] && [ "$Battery_voltage" != "null" ] && pushMQTTData "$inv_id" "Battery_voltage" "$Battery_voltage"
+    
+    Battery_charge_current=`echo "$json_data" | jq '.Battery_charge_current' -r`
+    [ ! -z "$Battery_charge_current" ] && [ "$Battery_charge_current" != "null" ] && pushMQTTData "$inv_id" "Battery_charge_current" "$Battery_charge_current"
+    
+    Battery_discharge_current=`echo "$json_data" | jq '.Battery_discharge_current' -r`
+    [ ! -z "$Battery_discharge_current" ] && [ "$Battery_discharge_current" != "null" ] && pushMQTTData "$inv_id" "Battery_discharge_current" "$Battery_discharge_current"
+    
+    Load_status_on=`echo "$json_data" | jq '.Load_status_on' -r`
+    [ ! -z "$Load_status_on" ] && [ "$Load_status_on" != "null" ] && pushMQTTData "$inv_id" "Load_status_on" "$Load_status_on"
+    
+    SCC_charge_on=`echo "$json_data" | jq '.SCC_charge_on' -r`
+    [ ! -z "$SCC_charge_on" ] && [ "$SCC_charge_on" != "null" ] && pushMQTTData "$inv_id" "SCC_charge_on" "$SCC_charge_on"
+    
+    AC_charge_on=`echo "$json_data" | jq '.AC_charge_on' -r`
+    [ ! -z "$AC_charge_on" ] && [ "$AC_charge_on" != "null" ] && pushMQTTData "$inv_id" "AC_charge_on" "$AC_charge_on"
+    
+    Battery_recharge_voltage=`echo "$json_data" | jq '.Battery_recharge_voltage' -r`
+    [ ! -z "$Battery_recharge_voltage" ] && [ "$Battery_recharge_voltage" != "null" ] && pushMQTTData "$inv_id" "Battery_recharge_voltage" "$Battery_recharge_voltage"
+    
+    Battery_under_voltage=`echo "$json_data" | jq '.Battery_under_voltage' -r`
+    [ ! -z "$Battery_under_voltage" ] && [ "$Battery_under_voltage" != "null" ] && pushMQTTData "$inv_id" "Battery_under_voltage" "$Battery_under_voltage"
+    
+    Battery_bulk_voltage=`echo "$json_data" | jq '.Battery_bulk_voltage' -r`
+    [ ! -z "$Battery_bulk_voltage" ] && [ "$Battery_bulk_voltage" != "null" ] && pushMQTTData "$inv_id" "Battery_bulk_voltage" "$Battery_bulk_voltage"
+    
+    Battery_float_voltage=`echo "$json_data" | jq '.Battery_float_voltage' -r`
+    [ ! -z "$Battery_float_voltage" ] && [ "$Battery_float_voltage" != "null" ] && pushMQTTData "$inv_id" "Battery_float_voltage" "$Battery_float_voltage"
+    
+    Max_grid_charge_current=`echo "$json_data" | jq '.Max_grid_charge_current' -r`
+    [ ! -z "$Max_grid_charge_current" ] && [ "$Max_grid_charge_current" != "null" ] && pushMQTTData "$inv_id" "Max_grid_charge_current" "$Max_grid_charge_current"
+    
+    Max_charge_current=`echo "$json_data" | jq '.Max_charge_current' -r`
+    [ ! -z "$Max_charge_current" ] && [ "$Max_charge_current" != "null" ] && pushMQTTData "$inv_id" "Max_charge_current" "$Max_charge_current"
+    
+    Out_source_priority=`echo "$json_data" | jq '.Out_source_priority' -r`
+    [ ! -z "$Out_source_priority" ] && [ "$Out_source_priority" != "null" ] && pushMQTTData "$inv_id" "Out_source_priority" "$Out_source_priority"
+    
+    Charger_source_priority=`echo "$json_data" | jq '.Charger_source_priority' -r`
+    [ ! -z "$Charger_source_priority" ] && [ "$Charger_source_priority" != "null" ] && pushMQTTData "$inv_id" "Charger_source_priority" "$Charger_source_priority"
+    
+    Battery_redischarge_voltage=`echo "$json_data" | jq '.Battery_redischarge_voltage' -r`
+    [ ! -z "$Battery_redischarge_voltage" ] && [ "$Battery_redischarge_voltage" != "null" ] && pushMQTTData "$inv_id" "Battery_redischarge_voltage" "$Battery_redischarge_voltage"
+    
+    Warnings=`echo "$json_data" | jq '.Warnings' -r`
+    [ ! -z "$Warnings" ] && [ "$Warnings" != "null" ] && pushMQTTData "$inv_id" "Warnings" "$Warnings"
+}
+
 # Discover parallel inverters with retry logic
 SUDO_CMD=""
 if [ "$EUID" -ne 0 ] && [ -c "/dev/ttyUSB0" ]; then
@@ -75,8 +181,8 @@ if [ "$EUID" -ne 0 ] && [ -c "/dev/ttyUSB0" ]; then
 fi
 
 # Try parallel discovery with retry
-MAX_RETRIES=3
+MAX_RETRIES=1  # Reduced to 1 since we'll fallback to direct QPGS anyway
-RETRY_DELAY=5
+RETRY_DELAY=2
 PARALLEL_COUNT=0
 
 for attempt in $(seq 1 $MAX_RETRIES); do
@@ -96,10 +202,36 @@ for attempt in $(seq 1 $MAX_RETRIES); do
     fi
 done
 
-# If still no count, assume 2 inverters
+# If still no count or discovery failed, try direct QPGS commands
 if [ -z "$PARALLEL_COUNT" ] || [ "$PARALLEL_COUNT" -eq 0 ]; then
-    echo "⚠ All discovery attempts failed, assuming 2 inverters"
+    echo "⚠ Discovery reports 0 inverters, trying direct QPGS0/QPGS1 commands..."
+    
+    # Test QPGS0 to see if parallel mode is active
+    TEST_QPGS0=`$SUDO_CMD "$INVERTER_BIN" -r "QPGS0" 2>&1 | grep "Reply:"`
+    TEST_QPGS1=`$SUDO_CMD "$INVERTER_BIN" -r "QPGS1" 2>&1 | grep "Reply:"`
+    
+    if [ ! -z "$TEST_QPGS0" ] && [[ "$TEST_QPGS0" != *"NAK"* ]]; then
+        echo "✓ QPGS0 responds, assuming 2 inverters in cascade"
         PARALLEL_COUNT=2
+        
+        # Build fake discovery output
+        PARALLEL_DISCOVERY="INVERTER_1_SERIAL=unknown
+INVERTER_1_QPGS=0
+INVERTER_2_SERIAL=unknown
+INVERTER_2_QPGS=1"
+    elif [ ! -z "$TEST_QPGS1" ] && [[ "$TEST_QPGS1" != *"NAK"* ]]; then
+        echo "✓ QPGS1 responds, assuming 2 inverters in cascade"
+        PARALLEL_COUNT=2
+        
+        # Build fake discovery output
+        PARALLEL_DISCOVERY="INVERTER_1_SERIAL=unknown
+INVERTER_1_QPGS=0
+INVERTER_2_SERIAL=unknown
+INVERTER_2_QPGS=1"
+    else
+        echo "✗ QPGS commands also failed"
+        PARALLEL_COUNT=0
+    fi
 fi
 
 echo "Processing $PARALLEL_COUNT parallel inverters"
@@ -107,27 +239,65 @@ echo "Processing $PARALLEL_COUNT parallel inverters"
 # Publish discovery info
 pushMQTTData "system" "parallel_count" "$PARALLEL_COUNT"
 
-# Extract inverter serials and QPGS indices
+# Get QPIRI data once (shared configuration for all inverters in cascade)
-for i in $(seq 1 $PARALLEL_COUNT); do
+echo ""
-    SERIAL=`echo "$PARALLEL_DISCOVERY" | grep "INVERTER_${i}_SERIAL=" | cut -d= -f2`
+echo "Getting shared configuration (QPIRI)..."
-    QPGS_IDX=`echo "$PARALLEL_DISCOVERY" | grep "INVERTER_${i}_QPGS=" | cut -d= -f2`
+QPIRI_RAW=`$SUDO_CMD "$INVERTER_BIN" -r "QPIRI" 2>&1 | grep "Reply:" | cut -d: -f2- | xargs`
 
+if [ ! -z "$QPIRI_RAW" ] && [ "$QPIRI_RAW" != "NAK" ]; then
+    echo "✓ QPIRI retrieved successfully"
+    # Parse QPIRI: Grid rating, Grid rating, AC output rating, AC output frequency, 
+    # AC output current, AC output apparent power, AC output active power,
+    # Battery rating, Battery recharge, Battery under, Battery bulk, Battery float,
+    # Battery type, Max charge current, Max AC charge current, Input voltage range,
+    # Output source priority, Charger source priority, Parallel max num, Machine type,
+    # Topology, Output mode, Battery redischarge, PV OK, PV power balance
+    IFS=' ' read -ra QPIRI <<< "$QPIRI_RAW"
+    
+    # Extract configuration values (same for all inverters)
+    BATT_RECHARGE="${QPIRI[8]}"
+    BATT_UNDER="${QPIRI[9]}"
+    BATT_BULK="${QPIRI[10]}"
+    BATT_FLOAT="${QPIRI[11]}"
+    MAX_CHARGE_CURRENT="${QPIRI[13]}"
+    MAX_GRID_CHARGE="${QPIRI[14]}"
+    OUT_SOURCE_PRIORITY="${QPIRI[15]}"
+    CHARGER_SOURCE_PRIORITY="${QPIRI[16]}"
+    BATT_REDISCHARGE="${QPIRI[22]}"
+else
+    echo "⚠ QPIRI failed, configuration parameters unavailable"
+fi
+
+# Extract runtime data for each inverter using QPGS
+PARALLEL_SUCCESS=false
+
+for i in $(seq 1 $PARALLEL_COUNT); do
+    QPGS_IDX=$((i - 1))  # 0-based index
+    SERIAL=`echo "$PARALLEL_DISCOVERY" | grep "INVERTER_${i}_SERIAL=" | cut -d= -f2`
+    
+    echo ""
     echo "Processing Inverter #$i (Serial: $SERIAL, QPGS$QPGS_IDX)"
     
-    # Get QPGS data for this inverter
+    # Get QPGS data: 1 Serial Mode Status GridV GridF OutV OutF VA W PCT BattV ChgA Cap PVV PVA ...
-    QPGS_DATA=`$SUDO_CMD "$INVERTER_BIN" -r "QPGS$QPGS_IDX" 2>&1 | grep "Reply:" | cut -d: -f2- | xargs`
+    QPGS_RAW=`$SUDO_CMD "$INVERTER_BIN" -r "QPGS$QPGS_IDX" 2>&1 | grep "Reply:" | cut -d: -f2- | xargs`
     
-    if [ ! -z "$QPGS_DATA" ] && [ "$QPGS_DATA" != "NAK" ]; then
+    if [ ! -z "$QPGS_RAW" ] && [ "$QPGS_RAW" != "NAK" ]; then
-        # Parse QPGS response format:
+        echo "  ✓ QPGS$QPGS_IDX successful"
-        # 1 SERIAL MODE STATUS GRID_V GRID_F OUT_V OUT_F VA W PCT BATT_V CHRG CAP PV_V CHRG_A ...
+        PARALLEL_SUCCESS=true
         
-        # Publish serial number
+        # Parse QPGS response
+        IFS=' ' read -ra DATA <<< "$QPGS_RAW"
+        
+        # Field mapping (verified from test output):
+        # 0=Exists, 1=Serial, 2=Mode, 3=Status, 4=GridV, 5=GridF, 6=OutV, 7=OutF
+        # 8=VA, 9=W, 10=PCT, 11=BattV, 12=ChgA, 13=Cap, 14=PVV, 15=PVA
+        # 16=?, 17=?, 18=?, 19-26=additional fields
+        
+        # Publish serial
         pushMQTTData "$i" "serial" "$SERIAL"
         
-        # Parse and publish data (QPGS format parsing)
+        # Runtime data from QPGS (19 parameters)
-        IFS=' ' read -ra DATA <<< "$QPGS_DATA"
+        [ "${DATA[2]}" ] && pushMQTTData "$i" "Inverter_mode" "${DATA[2]}"
-        
-        [ "${DATA[2]}" ] && pushMQTTData "$i" "mode" "${DATA[2]}"
         [ "${DATA[4]}" ] && pushMQTTData "$i" "AC_grid_voltage" "${DATA[4]}"
         [ "${DATA[5]}" ] && pushMQTTData "$i" "AC_grid_frequency" "${DATA[5]}"
         [ "${DATA[6]}" ] && pushMQTTData "$i" "AC_out_voltage" "${DATA[6]}"
@@ -141,11 +311,79 @@ for i in $(seq 1 $PARALLEL_COUNT); do
         [ "${DATA[14]}" ] && pushMQTTData "$i" "PV_in_voltage" "${DATA[14]}"
         [ "${DATA[15]}" ] && pushMQTTData "$i" "PV_in_current" "${DATA[15]}"
         
-        echo "  ✓ Published data for inverter #$i"
+        # Calculate PV watts (V * A)
-        echo "    Topics: ${MQTT_TOPIC}/sensor/${MQTT_DEVICENAME}_inv${i}_{serial,mode,Battery_voltage,Load_watt,...}"
+        if [ ! -z "${DATA[14]}" ] && [ ! -z "${DATA[15]}" ]; then
+            PV_WATTS=`echo "${DATA[14]} ${DATA[15]}" | awk '{printf "%.1f", $1 * $2}'`
+            pushMQTTData "$i" "PV_in_watts" "$PV_WATTS"
+        fi
+        
+        # Status flags (parse from field 18 bitmap if available)
+        [ "${DATA[18]}" ] && {
+            BITMAP="${DATA[18]}"
+            # Binary flags: bit0=Load_on, bit1=SCC_on, bit2=AC_charge_on
+            LOAD_ON=$((($BITMAP & 1) ? 1 : 0))
+            SCC_ON=$((($BITMAP & 2) ? 1 : 0))
+            AC_CHG_ON=$((($BITMAP & 4) ? 1 : 0))
+            
+            pushMQTTData "$i" "Load_status_on" "$LOAD_ON"
+            pushMQTTData "$i" "SCC_charge_on" "$SCC_ON"
+            pushMQTTData "$i" "AC_charge_on" "$AC_CHG_ON"
+        }
+        
+        # Configuration data from QPIRI (shared, 8 parameters)
+        [ ! -z "$BATT_RECHARGE" ] && pushMQTTData "$i" "Battery_recharge_voltage" "$BATT_RECHARGE"
+        [ ! -z "$BATT_UNDER" ] && pushMQTTData "$i" "Battery_under_voltage" "$BATT_UNDER"
+        [ ! -z "$BATT_BULK" ] && pushMQTTData "$i" "Battery_bulk_voltage" "$BATT_BULK"
+        [ ! -z "$BATT_FLOAT" ] && pushMQTTData "$i" "Battery_float_voltage" "$BATT_FLOAT"
+        [ ! -z "$MAX_CHARGE_CURRENT" ] && pushMQTTData "$i" "Max_charge_current" "$MAX_CHARGE_CURRENT"
+        [ ! -z "$MAX_GRID_CHARGE" ] && pushMQTTData "$i" "Max_grid_charge_current" "$MAX_GRID_CHARGE"
+        [ ! -z "$OUT_SOURCE_PRIORITY" ] && pushMQTTData "$i" "Out_source_priority" "$OUT_SOURCE_PRIORITY"
+        [ ! -z "$CHARGER_SOURCE_PRIORITY" ] && pushMQTTData "$i" "Charger_source_priority" "$CHARGER_SOURCE_PRIORITY"
+        [ ! -z "$BATT_REDISCHARGE" ] && pushMQTTData "$i" "Battery_redischarge_voltage" "$BATT_REDISCHARGE"
+        
+        echo "  ✓ Published 28 parameters for inverter #$i"
+        echo "    (19 runtime + 8 config + 1 calculated)"
+        echo "  ⚠ Missing 5 params: PV_watthour, Load_watthour, Bus_voltage, Heatsink_temp, Warnings"
+        
     else
-        echo "  ✗ No valid data for inverter #$i"
+        echo "  ✗ QPGS$QPGS_IDX failed (NAK or empty)"
     fi
 done
 
+# Fallback: use standard mode with full JSON output
+if [ "$PARALLEL_SUCCESS" = false ]; then
+    echo ""
+    echo "⚠ Parallel mode failed completely (QPGS not responding)"
+    echo "  Possible reasons:"
+    echo "  - Inverters not configured in parallel mode in firmware"
+    echo "  - RS232 connection issue"
+    echo "  - Inverters in standby or fault mode"
+    echo ""
+    echo "  Falling back to standard single-inverter mode (QPIGS)..."
+    echo "  Will publish data as 'inv1' (master inverter or aggregated data)"
+    
+    # Use standard inverter_poller -1 (QPIGS+QPIRI+QMOD+QPIWS) WITHOUT debug flag
+    INVERTER_DATA=`timeout 10 $SUDO_CMD "$INVERTER_BIN" -1 2>/dev/null`
+    
+    if [ ! -z "$INVERTER_DATA" ]; then
+        # Check if it's valid JSON
+        echo "$INVERTER_DATA" | jq . > /dev/null 2>&1
+        if [ $? -eq 0 ]; then
+            echo "  ✓ Standard mode data retrieved successfully"
+            extractAndPublishAllData "1" "$INVERTER_DATA"
+            echo "  ✓ Published all 33 parameters for inverter #1"
+            echo ""
+            echo "  NOTE: If you have 2 inverters in cascade:"
+            echo "  - Enable parallel mode in inverter firmware settings"
+            echo "  - OR connect second inverter to separate USB port"
+            echo "  - Check manual for 'Machine in Parallel' configuration"
+        else
+            echo "  ✗ Invalid JSON data from inverter_poller"
+            echo "  Raw output: $INVERTER_DATA"
+        fi
+    else
+        echo "  ✗ No data from inverter (timeout or device error)"
+    fi
+fi
+
 echo "Parallel MQTT push completed"