ricevuto il file grazie.

ma "dialoga" in modbus o in seriale?

grazie

a me arriva all invio di QPIGS e ritorna un -1

non capisco quale sia il problema (provato su 2 inverter sirio diversi)

Ti dovrebbe rispondere.

QPIGS
230.1 50.0 230.4 50.0 1474 1444 036 395 50.20 000 080 0038 0007 081.0 50.34 00025 00010110 00 00 00357 010

che é il dato che mi aspettavo



invece butta meno uno.

qualcuno vuole fare una prova?

python3 e la seriale (e il modulo sserial su python)sono sufficienti.l idea é per ora di salvare su CSV e poi evolvere

A me funziona, l'unica cosa è che se lo lanci manualmente devi lanciarlo due o tre volte perchè a le prime richieste non so per quale motivo ma rivece dei NAK. Facendo partire lo scritp in /etc/rc.local in automatico ad ogni avvio come demone lo script parte senza alcun problema (in automatico controlla se non è in esecuzione lo lancia se si interrompe lo rilancia.
io ce l'ho in esecuzione su raspberry zero W da ormai 4gg e i dati vengono memorizzati in influxdb e visualizzati in grafana senza alcun problema.

emuland se posso darti un consiglio prova a fare cosi,
modifica lo script in questo modo:

def Update(self):
		CMD = self.QueryCMD("QPIGS")
		if(CMD == -1):
			return -1
		all = string.split(CMD[1:])
		self.grid_voltage = float(all[0])
		self.grid_frequency = float(all[1])
		self.ac_output_voltage = float(all[2])
		self.ac_output_frequency = float(all[3])
		self.ac_output_apparent_power = int(all[4])
		self.ac_output_active_power = int(all[5])
		self.output_load_percent = int(all[6])
		self.bus_voltage = float(all[7])
		self.battery_voltage = float(all[8])
		self.battery_charging_current = int(all[9])
		self.battery_capacity = int(all[10])
		self.heatsink_temperature = int(all[11])
		self.pv_current = int(all[12])
		self.pv_voltage = float(all[13])
		self.battery_voltage_scc = float(all[14])
		self.battery_discharge_current = int(all[15])
		self.pv_power = int(all[19])
		self.line_power = self.ac_output_active_power
                global ricezione
                ricezione = CMD
                

sp5000 = Inverter("/dev/ttyUSB0")	

while True:
	if (sp5000.Update() == 0):
            print ricezione
        time.sleep(5)

io sto facendo dei test su Windows.....e python3(ho riscritto qualcosa del codice)

LL apertura della seriale arriva , fa send qpigs e poi risponde -1


farò il tuo temtativo

emuland, domanda forse stupida se sei sotto win hai cambiato la riga

sp5000 = Inverter("/dev/ttyUSB0")

sisi, tranquillo.

diciamo che l'informatica in generale è il mio mestiere.

mi sono scritto il datalogger del Epsolar tracer su modbus, per cui una vaga idea la ho.

del PIP non avevo trovato nulla di "pronto" da adattare per cui non mi ero avventurato (anche perchè non ho un PIP)

però ho accesso a 2-3 immediato e potenzialmente altri 40/60 per cui mi sarebbe comodo avere anche questo logging personalizzato

appena posso riposto il codice con le modifiche per salvare su CSV.devo solo appena ho tempo trovare la funzione python3 sostitutiva di split.


(per python é roba nuova)

la risposta che ottengo stampando a video dopo la query QPIGS è : NONE

import serial, time
import struct, string
import shutil   
import os
import csv
from ctypes import c_ubyte, c_ushort
from pathlib import Path
from serial import Serial

#from influxdb import InfluxDBClient
percorso=Path('./DATA.txt')
def CalcoloCRC( str ):

    crc_ta = [ 0x0000, 0x1021, 0x2042, 0x3063, 0x4084, 0x50a5, 0x60c6, 0x70e7, \
                     0x8108, 0x9129, 0xa14a, 0xb16b, 0xc18c, 0xd1ad, 0xe1ce, 0xf1ef ]

    lunghezza = len(str)

    Calcolo = list(str)

    crc = 0

    for idx in range(0,lunghezza):
        da=c_ubyte((c_ubyte(crc>>8).value)>>4).value
        crc = c_ushort(crc << 4).value
        crc = c_ushort(crc ^ crc_ta[da^c_ubyte(c_ubyte(ord(Calcolo[idx])).value >> 4).value]).value
        da = (c_ubyte(crc>>8).value) >> 4 
        crc <<= 4
        crc = c_ushort(crc ^ crc_ta[ da ^ ( ord(Calcolo[idx]) & 0x0f )]).value

    bCRCLow = c_ubyte(crc).value
    bCRCHign = c_ubyte(crc>>8).value

    if ( bCRCLow==0x28 or bCRCLow==0x0d or bCRCLow==0x0a ):
        bCRCLow += 1

    if ( bCRCHign==0x28 or bCRCHign==0x0d or bCRCHign==0x0a ):
        bCRCHign += 1

    crc = c_ushort(bCRCHign).value << 8
    crc += bCRCLow;
    return crc

class Inverter:
    def __init__(self,serialport):

        self.ser = serial.Serial()
        self.ser.port = serialport
        self.ser.baudrate = 2400
        self.ser.bytesize = serial.EIGHTBITS    #number of bits per bytes
        self.ser.parity = serial.PARITY_NONE    #set parity check: no parity
        self.ser.stopbits = serial.STOPBITS_ONE #number of stop bits
        self.ser.timeout = 1                    #non-block read
        self.ser.xonxoff = False                #disable software flow control
        self.ser.rtscts = False                 #disable hardware (RTS/CTS) flow control
        self.ser.dsrdtr = False                 #disable hardware (DSR/DTR) flow control
        self.ser.writeTimeout = 2               #timeout for write

        try: 
            self.ser.open()
            print("connesso")
        except Exception as e:
            print ("error open serial port: " + str(e))
            exit()

        if self.ser.isOpen():
            try:
                print("pulisco input e output")
                self.ser.flushInput()   #flush input buffer, discarding all its contents
                self.ser.flushOutput()  #flush output buffer, aborting current output 
                            #and discard all that is in buffer
            except Exception as e1:
                               # print ("error communicating...: " )
                print ("error communicating...: " + str(e1))
        else:
            print ("cannot open serial port ")

    def QueryCMD(self,CMD):
        try:
            print ("invio comandi")
            print (CMD)
            self.ser.write(CMD + struct.pack('!H',CalcoloCRC(CMD)) + '\x0D')
            time.sleep(1)  #give the serial port sometime to receive the data
            self.response = self.ser.readline()
            print ("response" + str (self.response))
            self.CRCSENT = ord(self.response[-3]) * 256 + ord(self.response[-2])
            if ( CalcoloCRC(self.response[:-3]) == self.CRCSENT ):
                return self.response[:-3]
                print ("crc passato")
            else:
                return -1
                print ("crc errato")
        except:
            print ("eccezione!!!")
         #   return -1

    def Update(self):
        print ("aggiorno")
        CMD = self.QueryCMD("QPIGS")
        print("cmd ricevuto: ")
        CMD="230.1 50.0 230.4 50.0 1474 1444 036 395 50.20 000 080 0038 0007 081.0 50.34 00025 00010110 00 00 00357 010"
        print (CMD)
        
        if(CMD == -1):
            
            print("errorer lettura dati gpigs")
            return -1
        print ("qpigs ok")
        CMD="230.1 50.0 230.4 50.0 1474 1444 036 395 50.20 000 080 0038 0007 081.0 50.34 00025 00010110 00 00 00357 010"
        all = str.split(CMD[1:])
        self.grid_voltage = float(all[0])
        self.grid_frequency = float(all[1])
        self.ac_output_voltage = float(all[2])
        self.ac_output_frequency = float(all[3])
        self.ac_output_apparent_power = int(all[4])
        self.ac_output_active_power = int(all[5])
        self.output_load_percent = int(all[6])
        self.bus_voltage = float(all[7])
        self.battery_voltage = float(all[8])
        self.battery_charging_current = int(all[9])
        self.battery_capacity = int(all[10])
        self.heatsink_temperature = int(all[11])
        self.pv_current = int(all[12])
        self.pv_voltage = float(all[13])
        self.battery_voltage_scc = float(all[14])
        self.battery_discharge_current = int(all[15])
        self.pv_power = int(all[19])
        self.line_power = self.ac_output_active_power - self.pv_power
        CMD = self.QueryCMD("QMOD")
        if (CMD == -1):
            print ("qmod errato")
            return -1
        CMD="230.1 50.0 230.4 50.0 1474 1444 036 395 50.20 000 080 0038 0007 081.0 50.34 00025 00010110 00 00 00357 010"
        mode = CMD[1:]
        self.isLineMode = 0
        if ( mode == "L" ):
            print ("line mode")
            self.isLineMode = 1
        self.isBatteryMode = 0
        if ( mode == "B" ):
            print ("battery mode")
            self.isBatteryMode = 1
        CMD = self.QueryCMD("QPIWS")
        CMD= "230.1 50.0 230.4 50.0 1474 1444 036 395 50.20 000 080 0038 0007 081.0 50.34 00025 00010110 00 00 00357 010"
        if (CMD == -1):
                        print ("QPIWS")
                        return -1
        self.inverter_fault = CMD[1:2]
        self.BusOvervolt = CMD[2:3]
        self.BusUndervolt = CMD[3:4]
        self.SoftStartFail = CMD[4:5]
        self.LineFail = CMD[5:6]
        self.PvShort = CMD[6:7]
        self.InvVoltLow = CMD[7:8]
        self.InvVolrHigh = CMD[8:9]
        self.OverTemp = CMD[9:10]
        self.BatteryVoltHigh = CMD[10:11]
        self.BatteryVoltLow = CMD[11:12]
        
        return 0

#####################################################################
##                                                                 ##
##     MAIN                                                        ##
#####################################################################


sp5000 = Inverter("COM1")   
#client = InfluxDBClient('localhost', 񡌆', 'roor', '', 'fotovoltaico')

while True:
    if (sp5000.Update() == 0):
        with open('DATA.txt', mode='a') as csv_file:
                    fieldnames = ['grid_voltage','grid_frequency' ,'ac_output_voltage',  'ac_output_frequency', 'ac_output_frequency','ac_output_apparent_power',   'ac_output_active_power', 'output_load_percent','bus_voltage','battery_voltage','battery_charging_current','battery_capacity','heatsink_temperature','pv_current','pv_voltage','battery_voltage_scc','battery_discharge_current','isLineMode','isBatteryMod',       'inverter_fault','BusOvervolt','BusUndervolt','SoftStartFail','LineFail','PvShort','InvVoltLow','InvVolrHigh','OverTemp','BatteryVoltHigh','BatteryVoltLow','PvPower','LinePower']
           # fieldnames=[]
                    writer = csv.DictWriter(csv_file, fieldnames=fieldnames)
                    if percorso.is_file():
                        writer.writerow({"grid_voltage":str(sp5000.grid_voltage),"grid_frequency": str(sp5000.grid_frequency),"ac_output_voltage": str(sp5000.ac_output_voltage),"ac_output_frequency": str(sp5000.ac_output_frequency),"ac_output_apparent_power": str(sp5000.ac_output_apparent_power),          "ac_output_active_power": str(sp5000.ac_output_active_power), "output_load_percent": str(sp5000.output_load_percent),  "bus_voltage": str(sp5000.bus_voltage),  "battery_voltage": str(sp5000.battery_voltage),  "battery_charging_current": str(sp5000.battery_charging_current),    "battery_capacity": str(sp5000.battery_capacity),  "heatsink_temperature": str(sp5000.heatsink_temperature),"pv_current": str(sp5000.pv_current), "pv_voltage": str(sp5000.pv_voltage),   "battery_voltage_scc": str(sp5000.battery_voltage_scc),   "battery_discharge_current": str(sp5000.battery_discharge_current),  "isLineMode": str(sp5000.isLineMode),   "isBatteryMod": str(sp5000.isBatteryMode), "inverter_fault": str(sp5000.inverter_fault),"BusOvervolt": str(sp5000.BusOvervolt),"BusUndervolt": str(sp5000.BusUndervolt), "SoftStartFail": str(sp5000.SoftStartFail),"LineFail": str(sp5000.LineFail),"PvShort": str(sp5000.PvShort),  "InvVoltLow": str(sp5000.InvVoltLow),    "InvVolrHigh": str(sp5000.InvVolrHigh),  "OverTemp": str(sp5000.OverTemp),  "BatteryVoltHigh": str(sp5000.BatteryVoltHigh),   "BatteryVoltLow": str(sp5000.BatteryVoltLow),   "PvPower": str(sp5000.pv_power),   "LinePower": str(sp5000.line_power)
                         })
                        print ("sto salvando su file")
                    else: 
                        writer.writeheader()  # file doesn't exist yet, write a header
                        print ("non sto scrivendo su file")
            
            
            # str(sp5000.grid_voltage)
    else:
        print ("non ci siamo")
    #client.write_points(json_body)
    time.sleep(5)

ho provato anche questo

ser = serial.Serial(
    port='COM1',
    baudrate=9600,
    parity=serial.PARITY_NONE,
    stopbits=serial.STOPBITS_TWO,
    bytesize=serial.EIGHTBITS,
    timeout = 1,
    xonxoff = False,
    rtscts = False,
    dsrdtr = False,
    writeTimeout = 2  
)
QPIGS = "\x51\x50\x49\x47\x53\xB7\xA9\x0D"
ser.isOpen()
ser.write(QPIGS.encode())
time.sleep(1)
risposta=ser.readline()
print (risposta.decode())

La COM è solo 2400

Io uso un adattatore USB sul PC e sono connesso all'RJ45/COM dell'inverter.

Immagine Allegata: QPIGS.jpg
 

gli inverter di prova che sto usando sono dei Sirio.

e sniffando la loro comunicazione con.watch Power ho intercettato9600.


comunque non cambia nulla anche con 2400 non va


Claudio hai modo voglia di lanciarlo? serve python3 e la classe serial (oltre a commentare dove ho forzato la risposta )

emuland non ne so proprio nulla, non so cosa è python3.
So che watch Power fa le interrogazioni e forse è per questo che hai visto un 9600, ma ti assicuro che va solo in 2400.
Il problema sono i CRC abbiamo notato che in base alle marche e modelli cambiano, non parliamo poi della usb,