Ciao a tutti
Volevo condividere con voi quanto ho sviluppato per tenere sotto controllo il mio 4848MS

Il software in dotazione con l'inverter WatchPower è terribile e dopo qualche settimana di utilizzo ho deciso di investire un po di tempo e integrare il monitoraggio dell'inverter in Zabbix.
Zabbix è un software OpenSource ideato per il monitoraggio dei data center e ne ho implementati parecchi nel corso degli anni, diciamo che non è pensato per monitorare gli inverter ma funziona egregiamente.

Colgo l'occasione per ringraziare tutti gli abitanti del forum che hanno partecipato al reverse engineering del protocollo di comunicazione seriale, il vostro lavoro mi ha risparmiato un sacco di tempo, grazie anche a chi ha implementato il CRC in Python.
Basandomi sul vostro lavoro ho scritto il Wrapper che permette di far comunicare Zabbix con il PIP4048.

Ho importato nel sistema tutti i valori utili e da quelli riesco a derivarne altri vedi foto.

Immagine Allegata: Items.JPG
 

Complimentissimi per il lavoro svolto....
Appena posso gli butto un occhio meglio. Zabbix ho visto che è multipiattaforma
Gira sotto win? Ce la fa raspberry con una piattaforma raspian?
Grazie


Luca

Grandissima realizzazione, complimenti veramente.

Grazie, in realtà è più semplice di quello che sembra.

Fantastico Ize, complimenti.

Se siete interessati posso prendermi carico di scrivere un manualino su come installare il sistema e configurare il tutto.
Il mio è basato su Ubuntu e gira su di un mini pc da pochissimi Watt con un po di martellate credo possa girare anche su raspberry.

CITAZIONE (ize, 17/10/2015 21:41:45 )

Ciao Ize, non posso far altro che unirmi alla schiera di complimenti che ti sei giustamente meritato.

Anche se per te è stato semplice perché lavori nel settore resta comunque un'integrazione di alto livello.

È da un po' che cerco un sistema (per il forum) per monitorare gli impianti semplice, flessibe, open, scalabile e alla portata di tutti e sicuramente il tuo progetto si inserisce nella lista dei candidati... Appena ho 2 minuti provo ad installare il software su una VM per vedere come funziona.

Posso chiederti di spendere 2 righe che descrivano la catena di comunicazione ? Cioè il 4848 è collegato con la seriale al PC, i dati vengono acquisiti dal tuo Wrapper (perché lo chiami così ? Di cosa si tratta di un demone che trasferisce i dati dalla seriale a Zabbix ?) che li invia a Zabbix il quale li elabora secondo le nostre impostazioni, giusto ?

Grazie in anticipo, Elix

Ciao BellaEli

I dati vengono letti dalla seriele tramite uno script in python che di fatto è un demone unix, in sostaza lo script fa una lettura di tutti i parametri ogni X secondi e li scrive in un file di stato, dopo di che Zabbix per ogni valore ha un tempo di pooling differente (per salvare spazio sul databese, non ha senso leggere ogni 5 secondi valori che non graficherò mai, come la freq della linea elettrica).
Ogni volta che Zabbix deve leggere un valore che arriva dall'inverter utilizza uno script che se lo va a cercare nel file che ha generato lo script in python.
Una volta che il valore è stato letto da zabbix finisce in un database mysql dove il sistema attinge quando deve generare i grafici.
Il sistema controlla anche i valori e se escono da certi limiti configuati è in grado di mandare mail di allarme.

Lo script gestisce anche il LOCK della seriale per permettere ad altri script di utilizzarla quando non la usa il Wrapper, ho un paio di script che commutano le modalità dell'inverter da remoto, SBU, SOL, UEI.

Modificando il codice python sarebbe possibile avere il supporto per più modelli di inverter basta avere i vari protocolli di comunicazione per far si che lo script sia in grado di scrivere i valori nel file.

questo è il codice del Wrapper:

import serial, time
import struct, string
import shutil	
import os
from ctypes import c_ubyte, c_ushort

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()

		except Exception, e:
		    print "error open serial port: " + str(e)
		    exit()

		if self.ser.isOpen():
			try:
				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, e1:
				print "error communicating...: " + str(e1)
		else:
			print "cannot open serial port "

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

	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])
		CMD = self.QueryCMD("QMOD")
		if (CMD == -1):
			return -1
		mode = CMD[1:]
		self.isLineMode = 0
		if ( mode == "L" ):
			self.isLineMode = 1
		self.isBatteryMode = 0
		if ( mode == "B" ):
			self.isBatteryMode = 1
		CMD = self.QueryCMD("QPIWS")
		if (CMD == -1):
			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("/dev/ttyUSB0")	
while True:
	lock_file = open("/tmp/SERIALLOCK","w")
	lock_file.write("1")	
	if (sp5000.Update() == 0):
		out_file = open("/tmp/sp5000out_B","w")
		out_file.write("grid_voltage:"+str(sp5000.grid_voltage)+"\n")
		out_file.write("grid_frequency:"+str(sp5000.grid_frequency)+"\n")
		out_file.write("ac_output_voltage:"+str(sp5000.ac_output_voltage)+"\n")
	        out_file.write("ac_output_frequency:"+str(sp5000.ac_output_frequency)+"\n")
		out_file.write("ac_output_apparent_power:"+str(sp5000.ac_output_apparent_power)+"\n")
		out_file.write("ac_output_active_power:"+str(sp5000.ac_output_active_power)+"\n")
		out_file.write("output_load_percent:"+str(sp5000.output_load_percent)+"\n")
		out_file.write("bus_voltage:"+str(sp5000.bus_voltage)+"\n")
		out_file.write("battery_voltage:"+str(sp5000.battery_voltage)+"\n")
		out_file.write("battery_charging_current:"+str(sp5000.battery_charging_current)+"\n")
		out_file.write("battery_capacity:"+str(sp5000.battery_capacity)+"\n")
		out_file.write("heatsink_temperature:"+str(sp5000.heatsink_temperature)+"\n")
		out_file.write("pv_current:"+str(sp5000.pv_current)+"\n")
		out_file.write("pv_voltage:"+str(sp5000.pv_voltage)+"\n")
		out_file.write("battery_voltage_scc:"+str(sp5000.battery_voltage_scc)+"\n")
		out_file.write("battery_discharge_current:"+str(sp5000.battery_discharge_current)+"\n")
		out_file.write("isLineMode:"+str(sp5000.isLineMode)+"\n")
		out_file.write("isBatteryMode:"+str(sp5000.isBatteryMode)+"\n")
		out_file.write("inverter_fault:"+str(sp5000.inverter_fault)+"\n")
		out_file.write("BusOvervolt:"+str(sp5000.BusOvervolt)+"\n")
		out_file.write("BusUndervolt:"+str(sp5000.BusUndervolt)+"\n")
		out_file.write("SoftStartFail:"+str(sp5000.SoftStartFail)+"\n")
		out_file.write("LineFail:"+str(sp5000.LineFail)+"\n")
		out_file.write("PvShort:"+str(sp5000.PvShort)+"\n")
		out_file.write("InvVoltLow:"+str(sp5000.InvVoltLow)+"\n")
		out_file.write("InvVolrHigh:"+str(sp5000.InvVolrHigh)+"\n")
		out_file.write("OverTemp:"+str(sp5000.OverTemp)+"\n")
		out_file.write("BatteryVoltHigh:"+str(sp5000.BatteryVoltHigh)+"\n")
		out_file.write("BatteryVoltLow:"+str(sp5000.BatteryVoltLow)+"\n")
		out_file.close()
		shutil.move("/tmp/sp5000out_B","/tmp/sp5000out")
	lock_file.close()
	os.remove("/tmp/SERIALLOCK")
	time.sleep(3)

#!/bin/bash
grep $1: /tmp/sp5000out |awk -F ":" '{print $2}'

Ciao ize
Complimenti per il tuo lavoro .
È' un po' che cerco su internet qualcosa del genere ma ho trovato solo qualche discussione in un forum australiano .
È' vero che il software molto carino e' quello di jarod ma sotto Windows dopo 2 giorni si è piantato !
Credo che sotto ubuntu sia molto più stabile .
Avendo il clone del pip4048 cioè il genius50 il problema come quello di tutti sarebbe il discorso dell'equalizzazione perché oltre al fatto che il regolatore interno non ci arriva a farla anche se là si fa con un regolatore esterno va spento perché a più 60V va in blocco e si spegne .
Cercavo qualcosa che legga oltre ai dati dell' inverter anche dei 3 regolatori .
Con lo stesso programma dell' inverter riesco a leggere i parametri del regolatore advance SC3KM clone del pcm6048 .
Ciò che alla fine vorrei realizzare e' una pagina web che possa darmi i dati di 2 inverter e 4 regolatori .
So che è complicato e lungo ma se si potesse avere lo script Python per la comunicazione sarebbe già molto .
Grazie
Buona giornata

CITAZIONE (emanuele78, 18/10/2015 08:30:15 )

Ciao si perfetto ma già tutto il discorso dei grafici sarebbe troppo .... Basterebbe solo poter leggere i valori e magari fare qualche somma .

Sono solo quei pochi comandi per interrogare l'inverter ?
Grazie

CITAZIONE (emanuele78, 18/10/2015 12:36:31 )

Ciao,
Mio figlio mi ha svegliato alle 4AM e quindi ho iniziato a scrivere due righe.

Per ora quanto riguarda l'installazione del sistema e la configurazione ho messo dei link ad altre guide online.

Mi sono concentrato sulla parte custom.
E' ancora tutto molto grezzo, pieno di errori, ma rende l'idea.

Per ora ho spiegato come installare gli script e come prelevare i dati con zabbix.
Mancano ancora, calcoli complessi, grafici, allarmi.

Allego tutti gli script in un unico archivio indicati nel manuale:
http://www.energialternativa.info/public/newforum/ForumEA/G/Forum.zip

Ciao

CITAZIONE (ize, 19/10/2015 07:06:55 )