Pi Developer
655 lines
28 KiB
Bash
Executable File
655 lines
28 KiB
Bash
Executable File
#!/bin/bash
|
|
# MQTT Push for Parallel Inverters
|
|
# Discovers parallel inverters and publishes data for each one separately
|
|
|
|
# Detect environment (container vs development)
|
|
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"
|
|
MQTT_FALLBACK="/opt/inverter-mqtt/mqtt-push.sh"
|
|
INVERTER_CONF="/etc/inverter/inverter.conf"
|
|
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"
|
|
MQTT_FALLBACK="/home/pi/Progetti/sources/inverter-mqtt/mqtt-push.sh"
|
|
INVERTER_CONF="/home/pi/Progetti/config/inverter.conf"
|
|
CONTAINER_MODE=false
|
|
fi
|
|
|
|
echo "Mode: $([ "$CONTAINER_MODE" = true ] && echo "Container" || echo "Development")"
|
|
echo "Using binary: $INVERTER_BIN"
|
|
|
|
# Check if jq is installed
|
|
if ! command -v jq &> /dev/null; then
|
|
echo "ERROR: jq is not installed. Install it with: sudo apt-get install jq"
|
|
exit 1
|
|
fi
|
|
|
|
MQTT_SERVER=`cat $MQTT_CONFIG | jq '.server' -r`
|
|
MQTT_PORT=`cat $MQTT_CONFIG | jq '.port' -r`
|
|
MQTT_TOPIC=`cat $MQTT_CONFIG | jq '.topic' -r`
|
|
MQTT_DEVICENAME=`cat $MQTT_CONFIG | jq '.devicename' -r`
|
|
MQTT_USERNAME=`cat $MQTT_CONFIG | jq '.username' -r`
|
|
MQTT_PASSWORD=`cat $MQTT_CONFIG | jq '.password' -r`
|
|
MQTT_CLIENTID=`cat $MQTT_CONFIG | jq '.clientid' -r`
|
|
INFLUX_ENABLED=`cat $MQTT_CONFIG | jq '.influx.enabled' -r`
|
|
|
|
pushMQTTData () {
|
|
# $1 = inverter_id, $2 = metric, $3 = value
|
|
local inverter_id=$1
|
|
local metric=$2
|
|
local value=$3
|
|
|
|
mosquitto_pub \
|
|
-h $MQTT_SERVER \
|
|
-p $MQTT_PORT \
|
|
-u "$MQTT_USERNAME" \
|
|
-P "$MQTT_PASSWORD" \
|
|
-i $MQTT_CLIENTID \
|
|
-r \
|
|
-t "$MQTT_TOPIC/sensor/${MQTT_DEVICENAME}_inv${inverter_id}_${metric}" \
|
|
-m "$value"
|
|
|
|
if [[ $INFLUX_ENABLED == "true" ]] ; then
|
|
pushInfluxData $inverter_id $metric $value
|
|
fi
|
|
}
|
|
|
|
pushInfluxData () {
|
|
INFLUX_HOST=`cat $MQTT_CONFIG | jq '.influx.host' -r`
|
|
INFLUX_USERNAME=`cat $MQTT_CONFIG | jq '.influx.username' -r`
|
|
INFLUX_PASSWORD=`cat $MQTT_CONFIG | jq '.influx.password' -r`
|
|
INFLUX_DEVICE=`cat $MQTT_CONFIG | jq '.influx.device' -r`
|
|
INFLUX_PREFIX=`cat $MQTT_CONFIG | jq '.influx.prefix' -r`
|
|
INFLUX_DATABASE=`cat $MQTT_CONFIG | jq '.influx.database' -r`
|
|
INFLUX_MEASUREMENT_NAME=`cat $MQTT_CONFIG | jq '.influx.namingMap.'$2'' -r`
|
|
|
|
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
|
|
SUDO_CMD="sudo"
|
|
fi
|
|
|
|
# Multi-device mode: if INVERTER_DEVICES is set, poll each device separately
|
|
if [ -n "$INVERTER_DEVICES" ]; then
|
|
IFS=':' read -ra DEVICE_ARRAY <<< "$INVERTER_DEVICES"
|
|
if [ ${#DEVICE_ARRAY[@]} -gt 0 ]; then
|
|
echo "Multi-device mode enabled (${#DEVICE_ARRAY[@]} devices)"
|
|
for idx in "${!DEVICE_ARRAY[@]}"; do
|
|
inv_id=$((idx + 1))
|
|
device_path="${DEVICE_ARRAY[$idx]}"
|
|
temp_dir=$(mktemp -d)
|
|
cp "$INVERTER_CONF" "$temp_dir/inverter.conf" 2>/dev/null
|
|
sed -i "s|^device=.*|device=$device_path|g" "$temp_dir/inverter.conf"
|
|
|
|
INVERTER_DATA=$(cd "$temp_dir" && $SUDO_CMD "$INVERTER_BIN" -1 2>/dev/null | tr -d '\r')
|
|
rm -rf "$temp_dir"
|
|
|
|
if [ -z "$INVERTER_DATA" ] || ! echo "$INVERTER_DATA" | jq -e . >/dev/null 2>&1; then
|
|
echo "⚠ No valid JSON from $device_path (inv$inv_id)"
|
|
continue
|
|
fi
|
|
|
|
extractAndPublishAllData "$inv_id" "$INVERTER_DATA"
|
|
done
|
|
|
|
echo "Multi-device MQTT push completed"
|
|
exit 0
|
|
fi
|
|
fi
|
|
|
|
# Try parallel discovery with retry
|
|
MAX_RETRIES=3
|
|
RETRY_DELAY=2
|
|
PARALLEL_COUNT=0
|
|
|
|
for attempt in $(seq 1 $MAX_RETRIES); do
|
|
echo "Parallel discovery attempt $attempt/$MAX_RETRIES..."
|
|
PARALLEL_DISCOVERY=`$SUDO_CMD "$INVERTER_BIN" -p 2>&1`
|
|
PARALLEL_COUNT=`echo "$PARALLEL_DISCOVERY" | grep "PARALLEL_COUNT=" | cut -d= -f2`
|
|
|
|
if [ ! -z "$PARALLEL_COUNT" ] && [ "$PARALLEL_COUNT" -gt 0 ]; then
|
|
echo "✓ Found $PARALLEL_COUNT inverters"
|
|
break
|
|
else
|
|
echo "⚠ Discovery failed (count=$PARALLEL_COUNT)"
|
|
if [ $attempt -lt $MAX_RETRIES ]; then
|
|
echo " Waiting ${RETRY_DELAY}s before retry..."
|
|
sleep $RETRY_DELAY
|
|
fi
|
|
fi
|
|
done
|
|
|
|
# If still no count or discovery failed, try direct QPGS commands
|
|
if [ -z "$PARALLEL_COUNT" ] || [ "$PARALLEL_COUNT" -eq 0 ]; then
|
|
echo "⚠ Discovery reports 0 inverters, trying direct QPGS0/QPGS1 commands..."
|
|
|
|
for attempt in 1 2 3; do
|
|
# 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"
|
|
break
|
|
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"
|
|
break
|
|
else
|
|
echo "⚠ QPGS commands failed (attempt $attempt/3)"
|
|
sleep 1
|
|
fi
|
|
done
|
|
|
|
if [ "$PARALLEL_COUNT" -eq 0 ]; then
|
|
echo "✗ QPGS commands also failed"
|
|
fi
|
|
fi
|
|
|
|
DISCOVERY_SERIALS=()
|
|
DISCOVERY_QPGS=()
|
|
MAX_QPGS_IDX=-1
|
|
|
|
for i in $(seq 1 $PARALLEL_COUNT); do
|
|
serial=$(echo "$PARALLEL_DISCOVERY" | grep "INVERTER_${i}_SERIAL=" | cut -d= -f2)
|
|
qpgs_idx=$(echo "$PARALLEL_DISCOVERY" | grep "INVERTER_${i}_QPGS=" | cut -d= -f2)
|
|
|
|
if [ -z "$serial" ] || [ "$serial" = "0.0" ]; then
|
|
continue
|
|
fi
|
|
if echo "$serial" | grep -qE '^0+$'; then
|
|
continue
|
|
fi
|
|
if [ -z "$qpgs_idx" ]; then
|
|
continue
|
|
fi
|
|
|
|
DISCOVERY_SERIALS+=("$serial")
|
|
DISCOVERY_QPGS+=("$qpgs_idx")
|
|
|
|
if [ "$qpgs_idx" -gt "$MAX_QPGS_IDX" ]; then
|
|
MAX_QPGS_IDX=$qpgs_idx
|
|
fi
|
|
done
|
|
|
|
# Get QPIRI data once (shared configuration for all inverters in cascade)
|
|
echo ""
|
|
echo "Getting shared configuration (QPIRI)..."
|
|
QPIRI_RAW=""
|
|
for attempt in 1 2 3 4 5; do
|
|
QPIRI_RAW=`$SUDO_CMD "$INVERTER_BIN" -r "QPIRI" 2>&1 | grep "Reply:" | cut -d: -f2- | xargs`
|
|
if [ ! -z "$QPIRI_RAW" ] && [ "$QPIRI_RAW" != "NAK" ]; then
|
|
break
|
|
fi
|
|
sleep 1
|
|
done
|
|
|
|
QPIRI_SUCCESS=false
|
|
if [ ! -z "$QPIRI_RAW" ] && [ "$QPIRI_RAW" != "NAK" ]; then
|
|
echo "✓ QPIRI retrieved successfully"
|
|
QPIRI_SUCCESS=true
|
|
# 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 (single session)
|
|
PARALLEL_SUCCESS=false
|
|
|
|
PARALLEL_QPGS_COUNT=$PARALLEL_COUNT
|
|
if [ "$PARALLEL_QPGS_COUNT" -lt 2 ]; then
|
|
PARALLEL_QPGS_COUNT=2
|
|
fi
|
|
if [ "$MAX_QPGS_IDX" -ge 0 ] && [ $((MAX_QPGS_IDX + 1)) -gt "$PARALLEL_QPGS_COUNT" ]; then
|
|
PARALLEL_QPGS_COUNT=$((MAX_QPGS_IDX + 1))
|
|
fi
|
|
|
|
PARALLEL_QPGS_OUTPUT=`$SUDO_CMD "$INVERTER_BIN" -P "$PARALLEL_QPGS_COUNT" 2>/dev/null`
|
|
HAS_PARALLEL_QPGS=false
|
|
if echo "$PARALLEL_QPGS_OUTPUT" | grep -q "^QPGS[0-9]_REPLY="; then
|
|
HAS_PARALLEL_QPGS=true
|
|
PARALLEL_QPGS_OUTPUT=`$SUDO_CMD "$INVERTER_BIN" -P "$PARALLEL_QPGS_COUNT" 2>/dev/null`
|
|
fi
|
|
|
|
VALID_SERIALS=()
|
|
VALID_QPGS=()
|
|
|
|
DIRECT_SERIALS=()
|
|
DIRECT_QPGS=()
|
|
if [ "$PARALLEL_COUNT" -lt 2 ]; then
|
|
for idx in 0 1; do
|
|
reply_value=`$SUDO_CMD "$INVERTER_BIN" -r "QPGS$idx" 2>&1 | grep "Reply:" | cut -d: -f2- | xargs`
|
|
if [ -z "$reply_value" ]; then
|
|
continue
|
|
fi
|
|
serial_from_reply=`echo "$reply_value" | awk '{print $2}'`
|
|
if [ -z "$serial_from_reply" ] || [ "$serial_from_reply" = "0.0" ]; then
|
|
continue
|
|
fi
|
|
if echo "$serial_from_reply" | grep -qE '^0+$'; then
|
|
continue
|
|
fi
|
|
if ! echo "$serial_from_reply" | grep -qE '^[0-9]{10,}$'; then
|
|
continue
|
|
fi
|
|
duplicate=false
|
|
for existing in "${DIRECT_SERIALS[@]}"; do
|
|
if [ "$existing" = "$serial_from_reply" ]; then
|
|
duplicate=true
|
|
break
|
|
fi
|
|
done
|
|
if [ "$duplicate" = true ]; then
|
|
continue
|
|
fi
|
|
DIRECT_SERIALS+=("$serial_from_reply")
|
|
DIRECT_QPGS+=("$idx")
|
|
done
|
|
fi
|
|
|
|
if [ ${#DIRECT_SERIALS[@]} -gt 0 ]; then
|
|
VALID_SERIALS=("${DIRECT_SERIALS[@]}")
|
|
VALID_QPGS=("${DIRECT_QPGS[@]}")
|
|
fi
|
|
|
|
if [ ${#VALID_SERIALS[@]} -eq 0 ] && [ "$HAS_PARALLEL_QPGS" = true ]; then
|
|
for attempt in 1 2 3; do
|
|
VALID_SERIALS=()
|
|
VALID_QPGS=()
|
|
|
|
for idx in $(seq 0 $((PARALLEL_QPGS_COUNT - 1))); do
|
|
reply_line=`echo "$PARALLEL_QPGS_OUTPUT" | grep "^QPGS${idx}_REPLY="`
|
|
reply_value=`echo "$reply_line" | cut -d= -f2- | xargs`
|
|
if [ -z "$reply_value" ]; then
|
|
continue
|
|
fi
|
|
|
|
serial_from_reply=`echo "$reply_value" | awk '{print $2}'`
|
|
if [ -z "$serial_from_reply" ] || [ "$serial_from_reply" = "0.0" ]; then
|
|
continue
|
|
fi
|
|
if echo "$serial_from_reply" | grep -qE '^0+$'; then
|
|
continue
|
|
fi
|
|
if ! echo "$serial_from_reply" | grep -qE '^[0-9]{10,}$'; then
|
|
continue
|
|
fi
|
|
|
|
duplicate=false
|
|
for existing in "${VALID_SERIALS[@]}"; do
|
|
if [ "$existing" = "$serial_from_reply" ]; then
|
|
duplicate=true
|
|
break
|
|
fi
|
|
done
|
|
if [ "$duplicate" = true ]; then
|
|
continue
|
|
fi
|
|
|
|
VALID_SERIALS+=("$serial_from_reply")
|
|
VALID_QPGS+=("$idx")
|
|
done
|
|
|
|
if [ ${#VALID_SERIALS[@]} -ge 2 ]; then
|
|
break
|
|
fi
|
|
|
|
PARALLEL_QPGS_OUTPUT=`$SUDO_CMD "$INVERTER_BIN" -P "$PARALLEL_QPGS_COUNT" 2>/dev/null`
|
|
sleep 1
|
|
done
|
|
fi
|
|
|
|
if [ ${#VALID_SERIALS[@]} -eq 0 ]; then
|
|
VALID_SERIALS=("${DISCOVERY_SERIALS[@]}")
|
|
VALID_QPGS=("${DISCOVERY_QPGS[@]}")
|
|
fi
|
|
|
|
VALID_COUNT=${#VALID_SERIALS[@]}
|
|
|
|
SUCCESS_INV_IDS=()
|
|
|
|
if [ "$VALID_COUNT" -eq 0 ]; then
|
|
echo "⚠ No valid inverter serials found (excluding 0.0/all-zero)"
|
|
else
|
|
echo "Processing $VALID_COUNT valid parallel inverters"
|
|
fi
|
|
|
|
# Publish discovery info (valid inverters only)
|
|
pushMQTTData "system" "parallel_count" "$VALID_COUNT"
|
|
|
|
for idx in "${!VALID_SERIALS[@]}"; do
|
|
inv_id=$((idx + 1))
|
|
QPGS_IDX="${VALID_QPGS[$idx]}"
|
|
SERIAL="${VALID_SERIALS[$idx]}"
|
|
|
|
echo ""
|
|
echo "Processing Inverter #$inv_id (Serial: $SERIAL, QPGS$QPGS_IDX)"
|
|
|
|
# Get QPGS data from single-session output, fallback to direct query
|
|
if [ "$HAS_PARALLEL_QPGS" = true ]; then
|
|
QPGS_RAW=`echo "$PARALLEL_QPGS_OUTPUT" | grep "^QPGS${QPGS_IDX}_REPLY=" | cut -d= -f2- | xargs`
|
|
fi
|
|
if [ -z "$QPGS_RAW" ]; then
|
|
QPGS_RAW=`$SUDO_CMD "$INVERTER_BIN" -r "QPGS$QPGS_IDX" 2>&1 | grep "Reply:" | cut -d: -f2- | xargs`
|
|
fi
|
|
|
|
if [ ! -z "$QPGS_RAW" ] && [ "$QPGS_RAW" != "NAK" ]; then
|
|
echo " ✓ QPGS$QPGS_IDX successful"
|
|
PARALLEL_SUCCESS=true
|
|
|
|
# Parse QPGS response
|
|
IFS=' ' read -ra DATA <<< "$QPGS_RAW"
|
|
|
|
# Field mapping per protocol (QPGSn):
|
|
# 0=Exists, 1=Serial, 2=Mode, 3=Fault, 4=GridV, 5=GridF, 6=OutV, 7=OutF
|
|
# 8=OutVA, 9=OutW, 10=LoadPct, 11=BattV, 12=BattChgA, 13=BattCap
|
|
# 14=PVV, 15=TotalChgA, 16=TotalOutVA, 17=TotalOutW, 18=TotalOutPct
|
|
# 19=StatusByte, 20=OutMode, 21=ChgSourcePriority, 22=MaxChgA
|
|
# 23=MaxChgRange, 24=MaxAcChgA, 25=PV_in_current, 26=Batt_discharge_current
|
|
|
|
# Prefer serial from QPGS payload if valid
|
|
serial_from_data="${DATA[1]}"
|
|
if echo "$serial_from_data" | grep -qE '^[0-9]{10,}$'; then
|
|
SERIAL="$serial_from_data"
|
|
fi
|
|
|
|
# Publish serial
|
|
pushMQTTData "$inv_id" "serial" "$SERIAL"
|
|
|
|
# Runtime data from QPGS (19 parameters)
|
|
[ "${DATA[2]}" ] && pushMQTTData "$inv_id" "Inverter_mode" "${DATA[2]}"
|
|
[ "${DATA[4]}" ] && pushMQTTData "$inv_id" "AC_grid_voltage" "${DATA[4]}"
|
|
[ "${DATA[5]}" ] && pushMQTTData "$inv_id" "AC_grid_frequency" "${DATA[5]}"
|
|
[ "${DATA[6]}" ] && pushMQTTData "$inv_id" "AC_out_voltage" "${DATA[6]}"
|
|
[ "${DATA[7]}" ] && pushMQTTData "$inv_id" "AC_out_frequency" "${DATA[7]}"
|
|
[ "${DATA[8]}" ] && pushMQTTData "$inv_id" "Load_va" "${DATA[8]}"
|
|
[ "${DATA[9]}" ] && pushMQTTData "$inv_id" "Load_watt" "${DATA[9]}"
|
|
[ "${DATA[10]}" ] && pushMQTTData "$inv_id" "Load_pct" "${DATA[10]}"
|
|
[ "${DATA[11]}" ] && pushMQTTData "$inv_id" "Battery_voltage" "${DATA[11]}"
|
|
[ "${DATA[12]}" ] && pushMQTTData "$inv_id" "Battery_charge_current" "${DATA[12]}"
|
|
[ "${DATA[13]}" ] && pushMQTTData "$inv_id" "Battery_capacity" "${DATA[13]}"
|
|
[ "${DATA[14]}" ] && pushMQTTData "$inv_id" "PV_in_voltage" "${DATA[14]}"
|
|
[ "${DATA[25]}" ] && pushMQTTData "$inv_id" "PV_in_current" "${DATA[25]}"
|
|
|
|
# Calculate PV watts (V * A)
|
|
if [ ! -z "${DATA[14]}" ] && [ ! -z "${DATA[25]}" ]; then
|
|
PV_WATTS=`echo "${DATA[14]} ${DATA[25]}" | awk '{printf "%.1f", $1 * $2}'`
|
|
pushMQTTData "$inv_id" "PV_in_watts" "$PV_WATTS"
|
|
fi
|
|
|
|
[ "${DATA[26]}" ] && pushMQTTData "$inv_id" "Battery_discharge_current" "${DATA[26]}"
|
|
|
|
# Status flags (parse from field 18 bitmap if available)
|
|
[ "${DATA[18]}" ] && {
|
|
BITMAP="${DATA[18]}"
|
|
if [[ "$BITMAP" =~ ^[0-9]+$ ]]; then
|
|
BITMAP=$((10#$BITMAP))
|
|
# 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 "$inv_id" "Load_status_on" "$LOAD_ON"
|
|
pushMQTTData "$inv_id" "SCC_charge_on" "$SCC_ON"
|
|
pushMQTTData "$inv_id" "AC_charge_on" "$AC_CHG_ON"
|
|
fi
|
|
}
|
|
|
|
echo " ✓ Published 17 runtime parameters for inverter #$inv_id"
|
|
echo " (QPGS data + calculated PV_watts + status flags)"
|
|
echo " ⚠ Missing 5 params: PV_watthour, Load_watthour, Bus_voltage, Heatsink_temp, Warnings"
|
|
|
|
SUCCESS_INV_IDS+=("$inv_id")
|
|
|
|
else
|
|
echo " ✗ QPGS$QPGS_IDX failed (NAK or empty)"
|
|
fi
|
|
done
|
|
|
|
# Publish shared configuration parameters for ALL inverters (replicate QPIRI data)
|
|
if [ "$QPIRI_SUCCESS" = true ] && [ ${#SUCCESS_INV_IDS[@]} -gt 0 ]; then
|
|
echo ""
|
|
echo "Publishing shared configuration to all inverters..."
|
|
|
|
for inv_id in "${SUCCESS_INV_IDS[@]}"; do
|
|
echo " Replicating QPIRI config to inverter #$inv_id..."
|
|
|
|
[ ! -z "$BATT_RECHARGE" ] && pushMQTTData "$inv_id" "Battery_recharge_voltage" "$BATT_RECHARGE"
|
|
[ ! -z "$BATT_UNDER" ] && pushMQTTData "$inv_id" "Battery_under_voltage" "$BATT_UNDER"
|
|
[ ! -z "$BATT_BULK" ] && pushMQTTData "$inv_id" "Battery_bulk_voltage" "$BATT_BULK"
|
|
[ ! -z "$BATT_FLOAT" ] && pushMQTTData "$inv_id" "Battery_float_voltage" "$BATT_FLOAT"
|
|
[ ! -z "$MAX_CHARGE_CURRENT" ] && pushMQTTData "$inv_id" "Max_charge_current" "$MAX_CHARGE_CURRENT"
|
|
[ ! -z "$MAX_GRID_CHARGE" ] && pushMQTTData "$inv_id" "Max_grid_charge_current" "$MAX_GRID_CHARGE"
|
|
[ ! -z "$OUT_SOURCE_PRIORITY" ] && pushMQTTData "$inv_id" "Out_source_priority" "$OUT_SOURCE_PRIORITY"
|
|
[ ! -z "$CHARGER_SOURCE_PRIORITY" ] && pushMQTTData "$inv_id" "Charger_source_priority" "$CHARGER_SOURCE_PRIORITY"
|
|
[ ! -z "$BATT_REDISCHARGE" ] && pushMQTTData "$inv_id" "Battery_redischarge_voltage" "$BATT_REDISCHARGE"
|
|
|
|
echo " ✓ Published 9 shared config parameters to inv$inv_id"
|
|
done
|
|
fi
|
|
|
|
# Retry shared config once after QPGS if needed
|
|
if [ "$QPIRI_SUCCESS" = false ] && [ ${#SUCCESS_INV_IDS[@]} -gt 0 ]; then
|
|
echo ""
|
|
echo "Retrying shared configuration (QPIRI) after QPGS..."
|
|
for attempt in 1 2 3; do
|
|
QPIRI_RAW=`$SUDO_CMD "$INVERTER_BIN" -r "QPIRI" 2>&1 | grep "Reply:" | cut -d: -f2- | xargs`
|
|
if [ ! -z "$QPIRI_RAW" ] && [ "$QPIRI_RAW" != "NAK" ]; then
|
|
QPIRI_SUCCESS=true
|
|
break
|
|
fi
|
|
sleep 1
|
|
done
|
|
|
|
if [ "$QPIRI_SUCCESS" = true ]; then
|
|
IFS=' ' read -ra QPIRI <<< "$QPIRI_RAW"
|
|
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]}"
|
|
|
|
echo "Publishing shared configuration to all inverters..."
|
|
for inv_id in "${SUCCESS_INV_IDS[@]}"; do
|
|
echo " Replicating QPIRI config to inverter #$inv_id..."
|
|
[ ! -z "$BATT_RECHARGE" ] && pushMQTTData "$inv_id" "Battery_recharge_voltage" "$BATT_RECHARGE"
|
|
[ ! -z "$BATT_UNDER" ] && pushMQTTData "$inv_id" "Battery_under_voltage" "$BATT_UNDER"
|
|
[ ! -z "$BATT_BULK" ] && pushMQTTData "$inv_id" "Battery_bulk_voltage" "$BATT_BULK"
|
|
[ ! -z "$BATT_FLOAT" ] && pushMQTTData "$inv_id" "Battery_float_voltage" "$BATT_FLOAT"
|
|
[ ! -z "$MAX_CHARGE_CURRENT" ] && pushMQTTData "$inv_id" "Max_charge_current" "$MAX_CHARGE_CURRENT"
|
|
[ ! -z "$MAX_GRID_CHARGE" ] && pushMQTTData "$inv_id" "Max_grid_charge_current" "$MAX_GRID_CHARGE"
|
|
[ ! -z "$OUT_SOURCE_PRIORITY" ] && pushMQTTData "$inv_id" "Out_source_priority" "$OUT_SOURCE_PRIORITY"
|
|
[ ! -z "$CHARGER_SOURCE_PRIORITY" ] && pushMQTTData "$inv_id" "Charger_source_priority" "$CHARGER_SOURCE_PRIORITY"
|
|
[ ! -z "$BATT_REDISCHARGE" ] && pushMQTTData "$inv_id" "Battery_redischarge_voltage" "$BATT_REDISCHARGE"
|
|
echo " ✓ Published 9 shared config parameters to inv$inv_id"
|
|
done
|
|
else
|
|
echo "⚠ QPIRI retry failed, shared configuration not published"
|
|
fi
|
|
fi
|
|
|
|
# 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"
|