docker-voltronic-homeassistant/sources/inverter-mqtt/test-loop-parallel.sh

#!/bin/bash
# Test Loop - Simula esecuzione container con parallel discovery e MQTT push
# Questo script simula il comportamento completo del container in produzione

set -e

# Colors for output
RED='\033[0;31m'
GREEN='\033[0;32m'
YELLOW='\033[1;33m'
BLUE='\033[0;34m'
NC='\033[0m' # No Color

# Detect environment
if [ -f "/etc/inverter/mqtt.json" ] && [ -x "/opt/inverter-cli/bin/inverter_poller" ]; then
    # Container mode
    MQTT_CONFIG="/etc/inverter/mqtt.json"
    INVERTER_BIN="/opt/inverter-cli/bin/inverter_poller"
    INVERTER_CONFIG="/etc/inverter/inverter.conf"
    MQTT_PUSH_SCRIPT="/opt/inverter-mqtt/mqtt-push-parallel.sh"
    CONTAINER_MODE=true
else
    # Development mode
    MQTT_CONFIG="/home/pi/Progetti/config/mqtt.json"
    INVERTER_BIN="/home/pi/Progetti/sources/inverter-cli/bin/inverter_poller"
    INVERTER_CONFIG="/home/pi/Progetti/config/inverter.conf"
    MQTT_PUSH_SCRIPT="/home/pi/Progetti/sources/inverter-mqtt/mqtt-push-parallel.sh"
    CONTAINER_MODE=false
fi

SUDO_CMD=""
if [ "$EUID" -ne 0 ]; then
    SUDO_CMD="sudo"
fi

# Configuration
LOOP_INTERVAL=${LOOP_INTERVAL:-30}  # Seconds between iterations
MAX_ITERATIONS=${MAX_ITERATIONS:-0}  # 0 = infinite

echo -e "${BLUE}╔════════════════════════════════════════════════════════════════╗${NC}"
echo -e "${BLUE}║     VOLTRONIC PARALLEL INVERTER - TEST LOOP                   ║${NC}"
echo -e "${BLUE}║     Simulates container execution with full discovery          ║${NC}"
echo -e "${BLUE}╚════════════════════════════════════════════════════════════════╝${NC}"
echo ""
echo -e "${YELLOW}Mode:${NC} $([ "$CONTAINER_MODE" = true ] && echo "Container" || echo "Development")"
echo -e "${YELLOW}Binary:${NC} $INVERTER_BIN"
echo -e "${YELLOW}MQTT Config:${NC} $MQTT_CONFIG"
echo -e "${YELLOW}Loop Interval:${NC} ${LOOP_INTERVAL}s"
echo -e "${YELLOW}Max Iterations:${NC} $([ $MAX_ITERATIONS -eq 0 ] && echo "∞ (infinite)" || echo "$MAX_ITERATIONS")"
echo ""

# Check device configuration
if [ -f "$INVERTER_CONFIG" ]; then
    USB_DEVICE=$(grep "^device=" "$INVERTER_CONFIG" | cut -d= -f2)
    echo -e "${YELLOW}USB Device:${NC} $USB_DEVICE"
    # Show USB info if available
    if [ -e "$USB_DEVICE" ]; then
        USB_SERIAL=$(udevadm info -q property -n "$USB_DEVICE" 2>/dev/null | grep "ID_SERIAL_SHORT=" | cut -d= -f2)
        [ ! -z "$USB_SERIAL" ] && echo -e "${YELLOW}USB Serial:${NC} $USB_SERIAL"
    fi
fi

# Check if MQTT server is configured
if [ -f "$MQTT_CONFIG" ]; then
    MQTT_SERVER=$(cat "$MQTT_CONFIG" | jq -r '.server' 2>/dev/null || echo "not configured")
    MQTT_PORT=$(cat "$MQTT_CONFIG" | jq -r '.port' 2>/dev/null || echo "1883")
    MQTT_TOPIC=$(cat "$MQTT_CONFIG" | jq -r '.topic' 2>/dev/null || echo "homeassistant")
    MQTT_DEVICE=$(cat "$MQTT_CONFIG" | jq -r '.devicename' 2>/dev/null || echo "voltronic")
    echo -e "${YELLOW}MQTT Server:${NC} $MQTT_SERVER:$MQTT_PORT"
    echo -e "${YELLOW}MQTT Base Topic:${NC} $MQTT_TOPIC/sensor/$MQTT_DEVICE"
else
    echo -e "${RED}✗ MQTT config not found: $MQTT_CONFIG${NC}"
    exit 1
fi

echo ""
read -p "Press ENTER to start test loop (Ctrl+C to stop)..."
echo ""

# Phase 1: Initial Discovery (run once at startup)
echo -e "${BLUE}╔════════════════════════════════════════════════════════════════╗${NC}"
echo -e "${BLUE}║ PHASE 1: INITIAL DISCOVERY                                    ║${NC}"
echo -e "${BLUE}╚════════════════════════════════════════════════════════════════╝${NC}"
echo ""

echo -e "${YELLOW}[1.1] Buffer Sizes Auto-Discovery${NC}"
DISCOVERY_OUTPUT=$($SUDO_CMD "$INVERTER_BIN" -a 2>&1)
DISCOVERY_SUCCESS=$(echo "$DISCOVERY_OUTPUT" | grep "DISCOVERY_SUCCESS=" | cut -d= -f2)

if [ "$DISCOVERY_SUCCESS" = "true" ]; then
    echo -e "${GREEN}✓ Buffer sizes discovered successfully${NC}"
    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)
    
    echo "  • QMOD:  $QMOD bytes"
    echo "  • QPIGS: $QPIGS bytes"
    echo "  • QPIRI: $QPIRI bytes"
    echo "  • QPIWS: $QPIWS bytes"
else
    echo -e "${RED}✗ Buffer discovery failed, using defaults${NC}"
fi
echo ""

echo -e "${YELLOW}[1.2] Parallel Inverters Discovery${NC}"
PARALLEL_OUTPUT=$($SUDO_CMD "$INVERTER_BIN" -p 2>&1)
PARALLEL_COUNT=$(echo "$PARALLEL_OUTPUT" | grep "PARALLEL_COUNT=" | cut -d= -f2)

if [ -z "$PARALLEL_COUNT" ]; then
    PARALLEL_COUNT=0
fi

if [ $PARALLEL_COUNT -gt 0 ]; then
    echo -e "${GREEN}✓ Found $PARALLEL_COUNT parallel inverter(s)${NC}"
    for i in $(seq 1 $PARALLEL_COUNT); do
        SERIAL=$(echo "$PARALLEL_OUTPUT" | grep "INVERTER_${i}_SERIAL=" | cut -d= -f2)
        QPGS_IDX=$(echo "$PARALLEL_OUTPUT" | grep "INVERTER_${i}_QPGS=" | cut -d= -f2)
        echo "  • Inverter #$i: Serial $SERIAL (QPGS$QPGS_IDX)"
    done
else
    echo -e "${YELLOW}⚠ No parallel inverters found, using single mode${NC}"
fi
echo ""

# Phase 2: Main Loop
echo -e "${BLUE}╔════════════════════════════════════════════════════════════════╗${NC}"
echo -e "${BLUE}║ PHASE 2: MAIN POLLING LOOP                                    ║${NC}"
echo -e "${BLUE}╚════════════════════════════════════════════════════════════════╝${NC}"
echo ""

iteration=0
while true; do
    iteration=$((iteration + 1))
    timestamp=$(date '+%Y-%m-%d %H:%M:%S')
    
    echo -e "${BLUE}═══════════════════════════════════════════════════════════════${NC}"
    echo -e "${BLUE}Iteration #$iteration - $timestamp${NC}"
    echo -e "${BLUE}═══════════════════════════════════════════════════════════════${NC}"
    
    # Test standard commands (local inverter)
    echo -e "${YELLOW}[2.1] Testing standard commands (local inverter)${NC}"
    for cmd in QPIGS QPIRI QMOD QPIWS; do
        result=$($SUDO_CMD "$INVERTER_BIN" -r $cmd 2>&1 | grep "Reply:" | cut -d: -f2- | xargs)
        if [ ! -z "$result" ] && [ "$result" != "NAK" ]; then
            echo -e "  ${GREEN}✓${NC} $cmd: OK (${#result} chars)"
        else
            echo -e "  ${RED}✗${NC} $cmd: FAIL ($result)"
        fi
    done
    echo ""
    
    # Get parallel data
    if [ $PARALLEL_COUNT -gt 0 ]; then
        echo -e "${YELLOW}[2.2] Reading parallel inverters data${NC}"
        for i in $(seq 1 $PARALLEL_COUNT); do
            SERIAL=$(echo "$PARALLEL_OUTPUT" | grep "INVERTER_${i}_SERIAL=" | cut -d= -f2)
            QPGS_IDX=$(echo "$PARALLEL_OUTPUT" | grep "INVERTER_${i}_QPGS=" | cut -d= -f2)
            
            QPGS_DATA=$($SUDO_CMD "$INVERTER_BIN" -r "QPGS$QPGS_IDX" 2>&1 | grep "Reply:" | cut -d: -f2- | xargs)
            
            if [ ! -z "$QPGS_DATA" ] && [ "$QPGS_DATA" != "NAK" ]; then
                # Parse key values
                IFS=' ' read -ra DATA <<< "$QPGS_DATA"
                MODE="${DATA[2]}"
                GRID_V="${DATA[4]}"
                BATT_V="${DATA[11]}"
                LOAD_W="${DATA[9]}"
                
                echo -e "  ${GREEN}✓${NC} Inverter #$i ($SERIAL): Mode=$MODE, Grid=${GRID_V}V, Battery=${BATT_V}V, Load=${LOAD_W}W"
            else
                echo -e "  ${RED}✗${NC} Inverter #$i ($SERIAL): No data"
            fi
        done
        echo ""
    fi
    
    # MQTT Push simulation
    echo -e "${YELLOW}[2.3] MQTT Push${NC}"
    if [ -x "$MQTT_PUSH_SCRIPT" ]; then
        echo "  Running: $MQTT_PUSH_SCRIPT"
        echo "  Publishing to: $MQTT_SERVER:$MQTT_PORT"
        MQTT_OUTPUT=$(bash "$MQTT_PUSH_SCRIPT" 2>&1 | tail -5)
        echo "$MQTT_OUTPUT" | sed 's/^/  /'
        
        # Show sample topics published
        if [ $PARALLEL_COUNT -gt 0 ]; then
            echo -e "  ${GREEN}Sample topics published:${NC}"
            for i in $(seq 1 $PARALLEL_COUNT); do
                echo "    • $MQTT_TOPIC/sensor/${MQTT_DEVICE}_inv${i}_serial"
                echo "    • $MQTT_TOPIC/sensor/${MQTT_DEVICE}_inv${i}_Battery_voltage"
                echo "    • $MQTT_TOPIC/sensor/${MQTT_DEVICE}_inv${i}_Load_watt"
                [ $i -eq 1 ] && echo "    • ... (and more)"
            done
        fi
        
        echo -e "${GREEN}✓ MQTT push completed${NC}"
    else
        echo -e "${YELLOW}⚠ MQTT script not executable: $MQTT_PUSH_SCRIPT${NC}"
        echo "  Simulating MQTT publish..."
        if [ $PARALLEL_COUNT -gt 0 ]; then
            echo "  • Published data for $PARALLEL_COUNT inverters"
        else
            echo "  • Published data for 1 inverter (single mode)"
        fi
    fi
    echo ""
    
    # Check iteration limit
    if [ $MAX_ITERATIONS -gt 0 ] && [ $iteration -ge $MAX_ITERATIONS ]; then
        echo -e "${GREEN}✓ Reached maximum iterations ($MAX_ITERATIONS)${NC}"
        break
    fi
    
    # Wait for next iteration
    echo -e "${BLUE}Waiting ${LOOP_INTERVAL}s until next iteration...${NC}"
    echo ""
    sleep $LOOP_INTERVAL
done

echo ""
echo -e "${GREEN}╔════════════════════════════════════════════════════════════════╗${NC}"
echo -e "${GREEN}║ TEST LOOP COMPLETED                                            ║${NC}"
echo -e "${GREEN}║ Total iterations: $iteration                                    ║${NC}"
echo -e "${GREEN}╚════════════════════════════════════════════════════════════════╝${NC}"