Exemplo n.º 1
0
 def initialize(self):
     self.log=LoggerFactory.get_file_logger(config.log_filename,"MPPTScannerThread",config.log_level)
     self.log.info("Initializing")
     self.mppt=EPSolarBSeries()
     self.mppt.set_real_time_clock()
     self.connection=pymysql.connect(host=config_private.db_host,port=config_private.db_port,user=config_private.db_user,passwd=config_private.db_password,db=config_private.db_name)
     self.cursor=self.connection.cursor()
     self.log.info("Successfully initialized")
Exemplo n.º 2
0
class MPPTScannerThread(LoopingThread):

    def initialize(self):
        self.log=LoggerFactory.get_file_logger(config.log_filename,"MPPTScannerThread",config.log_level)
        self.log.info("Initializing")
        self.mppt=EPSolarBSeries()
        self.mppt.set_real_time_clock()
        self.connection=pymysql.connect(host=config_private.db_host,port=config_private.db_port,user=config_private.db_user,passwd=config_private.db_password,db=config_private.db_name)
        self.cursor=self.connection.cursor()
        self.log.info("Successfully initialized")

    def call(self):
        self.log.info("Beginning a new run")
        try:
            self.log.info("Searching matching realtime weather timestamp")
            timestamp=datetime.datetime.utcnow()
            query="select timestamp from WEATHER_DATA_REALTIME where timestamp>subdate(utc_date(),1) and timestamp<=utc_timestamp() order by timestamp desc limit 1"
            self.log.debug(query)
            self.cursor.execute(query)
            weather_timestamp=self.cursor.fetchone()[0]
            ### Getting data from device ###
            self.log.info("Getting production data from device")
            pv_voltage=self.mppt.get_pv_voltage()
            pv_current=self.mppt.get_pv_current()
            pv_power=self.mppt.get_pv_power()
            battery_voltage=self.mppt.get_battery_voltage()
            battery_charging_current=self.mppt.get_battery_charging_current()
            battery_charging_power=self.mppt.get_battery_charging_power()
            load_voltage=self.mppt.get_load_voltage()
            load_current=self.mppt.get_load_current()
            load_power=self.mppt.get_load_power()
            mppt_charging_status=self.mppt.get_status_charging()
            mppt_temperature=self.mppt.get_case_temperature()
            battery_soc=self.mppt.get_battery_soc()
            battery_temperature=self.mppt.get_battery_temperature_sensor()
            m=MPPTData(timestamp,weather_timestamp,pv_voltage,pv_current,pv_power,battery_voltage,battery_charging_current,battery_charging_power,\
            load_voltage,load_current,load_power,mppt_charging_status,mppt_temperature,battery_soc,battery_temperature)
            self.log.debug("Data from device: "+str(m))
            # Battery efficiency checking
            self.log.debug("Checking last records of battery efficiency")
            query="select coulombic_efficiency,energy_efficiency from BATTERY_EFFICIENCY where timestamp=(select max(timestamp) from BATTERY_EFFICIENCY)"
            self.log.debug(query)
            self.cursor.execute(query)
            battery_coulombic_efficiency,battery_energy_efficiency=self.cursor.fetchone()
            self.log.debug('Last battery_coulombic_efficiency: '+str(battery_coulombic_efficiency))
            self.log.debug('Last battery_energy_efficiency: '+str(battery_energy_efficiency))
            # Current integrated and power integrated SoC calculation
            self.log.debug("Calculating battery current integrated SoC and power integrated SoC")
            query="select max(timestamp) from MPPT_DATA_PRODUCTION where timestamp>subdate(utc_date(),90) and mppt_status=1"
            self.log.debug(query)
            self.cursor.execute(query)
            lastfull_timestamp=self.cursor.fetchone()[0]
            self.log.debug("Last full timestamp: "+str(lastfull_timestamp))
            query="select battery_charging_current as prod_current, load_current as load_current, \
            battery_voltage*battery_charging_current as prod_power, battery_voltage*load_current as load_power \
            from MPPT_DATA_PRODUCTION where timestamp>'"+str(lastfull_timestamp)+"'"
            self.log.debug(query)
            self.cursor.execute(query)
            current_balance=0   # in Ah
            power_balance=0     # in Wh
            for row in self.cursor:
                prod_current,load_current,prod_power,load_power=row
                current_balance+=(prod_current*battery_coulombic_efficiency-load_current)/60
                power_balance+=(prod_power*battery_energy_efficiency-load_power)/60
            self.log.debug("Current balance from last full: "+str(current_balance)+" Ah")
            self.log.debug("Power balance from last full: "+str(power_balance)+" Wh")
            m.battery_soc_int_current=(config.batt_ah+current_balance)/config.batt_ah*100
            m.battery_soc_int_power=(config.batt_wh+power_balance)/config.batt_wh*100
            self.log.debug("Battery current integrated SoC: "+str(m.battery_soc_int_current))
            self.log.debug("Battery power integrated SoC: "+str(m.battery_soc_int_power))
            self.log.debug("Data from device with integrated SoC: "+str(m))
            # Saving data to database
            self.log.info("Saving production data to database")
            query="insert into MPPT_DATA_PRODUCTION (timestamp,weather_timestamp,pv_voltage,pv_current,pv_power,battery_voltage,battery_charging_current,battery_charging_power,\
            load_voltage,load_current,load_power,mppt_status,mppt_temperature,battery_soc,battery_temperature,battery_soc_int_current,battery_soc_int_power) values ("
            query+="'"+str(m.timestamp)+"',"
            query+="'"+str(m.weather_timestamp)+"',"
            query+=str(m.pv_voltage)+","
            query+=str(m.pv_current)+","
            query+=str(m.pv_power)+","
            query+=str(m.battery_voltage)+","
            query+=str(m.battery_charging_current)+","
            query+=str(m.battery_charging_power)+","
            query+=str(m.load_voltage)+","
            query+=str(m.load_current)+","
            query+=str(m.load_power)+","
            query+="'"+str(m.mppt_charging_status)+"',"
            query+=str(m.mppt_temperature)+","
            query+=str(m.battery_soc)+","
            query+=str(m.battery_temperature)+","
            query+=str(m.battery_soc_int_current)+","
            query+=str(m.battery_soc_int_power)+")"
            self.log.debug(query)
            self.cursor.execute(query)
            self.cursor.execute("commit")
            ### Getting status from device ###
            self.log.info("Getting status data from device")
            timestamp=datetime.datetime.utcnow()
            rtc=self.mppt.get_real_time_clock()
            fault=self.mppt.get_status_fault()
            running=self.mppt.get_status_running()
            case_temperature=self.mppt.get_status_case_temperature()
            pv_voltage=self.mppt.get_status_pv_voltage()
            pv_overcurrent=self.mppt.get_status_pv_overcurrent()
            load_overcurrent=self.mppt.get_status_load_overcurrent()
            battery_voltage=self.mppt.get_status_battery_voltage()
            battery_temperature=self.mppt.get_status_battery_temperature()
            battery_inner_resistance=self.mppt.get_status_battery_inner_resistance()
            battery_identification=self.mppt.get_status_battery_identification()
            short_pv=self.mppt.get_status_short_pv()
            short_load=self.mppt.get_status_short_load()
            short_charging_mosfet=self.mppt.get_status_short_charging_mosfet()
            short_load_mosfet=self.mppt.get_status_short_load_mosfet()
            short_antireverse_mosfet=self.mppt.get_status_short_antireverse_mosfet()
            short_any_mosfet=self.mppt.get_status_short_any_mosfet()
            s=MPPTStatusData(rtc,fault,running,case_temperature,pv_voltage,pv_overcurrent,load_overcurrent,battery_voltage,battery_temperature,\
            battery_inner_resistance,battery_identification,short_pv,short_load,short_charging_mosfet,short_load_mosfet,short_antireverse_mosfet,short_any_mosfet)
            self.log.debug("Status from device: "+str(s))
            # Saving data to database
            self.log.info("Saving status data to database")
            query="insert into MPPT_DATA_STATUS (timestamp,rtc,fault,running,case_temperature,pv_voltage,pv_overcurrent,load_overcurrent,battery_voltage,battery_temperature,\
            battery_inner_resistance,battery_identification,short_pv,short_load,short_charging_mosfet,short_load_mosfet,short_antireverse_mosfet,short_any_mosfet) values ("
            query+="'"+str(timestamp)+"',"
            query+="'"+str(rtc)+"',"
            query+=str(fault)+","
            query+=str(running)+","
            query+=str(case_temperature)+","
            query+=str(pv_voltage)+","
            query+=str(pv_overcurrent)+","
            query+=str(load_overcurrent)+","
            query+=str(battery_voltage)+","
            query+=str(battery_temperature)+","
            query+=str(battery_inner_resistance)+","
            query+=str(battery_identification)+","
            query+=str(short_pv)+","
            query+=str(short_load)+","
            query+=str(short_charging_mosfet)+","
            query+=str(short_load_mosfet)+","
            query+=str(short_antireverse_mosfet)+","
            query+=str(short_any_mosfet)+")"
            self.log.debug(query)
            self.cursor.execute(query)
            self.cursor.execute("commit")
            self.log.info("Done this run")
        except Exception as exc:
            exc_type, exc_obj, exc_tb = sys.exc_info()
            self.log.error("Unable to update MPPT data: "+str(exc)+" - TBINFO:"+str(traceback.extract_tb(exc_tb)))

    def cleanup(self):
        self.log.info("Cleaning up")
        self.cursor.close()
        self.connection.close()
        self.log.info("Successfully cleaned up")