'''Sets up the comms'''

def __init__(self, mfrid= Devices.MFRID_ENERGENIE,

productid= Devices.PRODUCTID_R1_MONITOR_AND_CONTROL,

sensorid= 0):

self.logger = logging.getLogger('root')

self.directory = {}

self.msg_join_ack = MESSAGE_JOIN_ACK

self.msg_join_ack['header']['mfrid'] = mfrid

self.msg_join_ack['header']['productid'] = productid

self.msg_join_ack['header']['sensorid'] = sensorid

self.msg_switch = MESSAGE_SWITCH

self.msg_switch['header']['sensorid'] = sensorid

radio.init()

OpenHEMS.init(Devices.CRYPT_PID)

#---------------------------------------------------------------------------

# Create short message

#---------------------------------------------------------------------------

def clean(self, msg):

'''Takes message returned from radio and returns a dictionary with

only essential values'''

data = {'timestamp': 'U',

'mfrid': 'U',

'productid': 'U',

'sensorid': 'U',

'switch': 'U',

'voltage': 'U',

'freq': 'U',

'reactive': 'U',

'real': 'U' }

# get the header

header = msg['header']

data['timestamp'] = int(time.time())

data['mfrid'] = header['mfrid']

data['productid'] = header['productid']

data['sensorid'] = header['sensorid']

# capture any data that we want

for rec in msg['recs']:

paramid = rec['paramid']

try:

value = rec['value']

except:

value = None

if paramid == OpenHEMS.PARAM_SWITCH_STATE:

data['switch'] = value

elif paramid == OpenHEMS.PARAM_VOLTAGE:

data['voltage'] = value

elif paramid == OpenHEMS.PARAM_FREQUENCY:

data['freq'] = value

elif paramid == OpenHEMS.PARAM_REACTIVE_POWER:

data['reactive'] = value

elif paramid == OpenHEMS.PARAM_REAL_POWER:

data['real'] = value

return data

#---------------------------------------------------------------------------

# Write data to CSV file

#---------------------------------------------------------------------------

def updateCSV (self, msg, log_filename='energenie.csv'):

'''Writes message data to CSV file'''

HEADINGS = 'timestamp,mfrid,prodid,sensorid,flags,switch,voltage,freq,reactive,real'

log_file = None

if 'header' in msg:

msg = self.clean(msg)

if log_file == None:

if not os.path.isfile(log_filename):

log_file = open(log_filename, 'w')

log_file.write(HEADINGS + '\n')

else:

log_file = open(log_filename, 'a') # append

flags= [1,1,1,1,1]

if msg['switch'] == 'U':

flags[0] = 0

if msg['voltage'] == 'U':

flags[1] = 0

if msg['freq'] == 'U':

flags[2] = 0

if msg['reactive'] == 'U':

flags[3] = 0

if msg['real'] == 'U':

flags[4] = 0

csv = '{timestamp}, {mfrid}, {productid}, {sensorid}, {flags}, {switch}, {voltage}, {freq}, {reactive}, {real}'.format(

timestamp= msg['timestamp'],

mfrid= msg['mfrid'],

productid= msg['productid'],

sensorid= msg['sensorid'],

flags= "".join([str(a) for a in flags]),

switch= msg['switch'],

voltage= msg['voltage'],

freq= msg['freq'],

reactive= msg['reactive'],

real= msg['real'])

log_file.write(csv + '\n')

log_file.flush()

self.logger.info(csv) # testing

#---------------------------------------------------------------------------

#

#---------------------------------------------------------------------------

def allkeys(self, d):

result = ""

for k in d:

if len(result) != 0:

result += ','

result += str(k)

return result

#---------------------------------------------------------------------------

# Update Directory

#---------------------------------------------------------------------------

def updateDirectory(self, message):

'''Update the local directory with information about this device'''

now = time.time()

header = message["header"]

sensorId = header["sensorid"]

if not self.directory.has_key(sensorId):

# new device discovered

desc = Devices.getDescription(header["mfrid"], header["productid"])

self.logger.info("ADD device:%s %s" % (hex(sensorId), desc))

self.directory[sensorId] = {"header": message["header"]}

self.logger.info(self.allkeys(self.directory))

self.directory[sensorId]["time"] = now

#TODO would be good to keep recs, but need to iterate through all and key by paramid,

#not as a list index, else merging will be hard.

#---------------------------------------------------------------------------

# Grab data

#---------------------------------------------------------------------------

def get_data(self, monitor_mode= False, short_msg= True):

'''Send discovery and monitor messages, and capture any responses.

monitor_mode True: will loop continously

False: will stop script once first succesful data

packet is received (default)

short_msg True: returns long detailed message

False: returns short message (default)'''

# Define the schedule of message polling

radio.receiver()

decoded = None

message_not_received = True

while message_not_received:

# See if there is a payload, and if there is, process it

if radio.isReceiveWaiting():

self.logger.info("receiving payload")

payload = radio.receive()

if monitor_mode == False:

message_not_received = False

try:

decoded = OpenHEMS.decode(payload)

except OpenHEMS.OpenHEMSException as e:

self.logger.error("Can't decode payload:" + str(e))

message_not_received = True

continue

self.updateDirectory(decoded)

if self.msg_join_ack['header']['sensorid'] == 0 or self.msg_switch['header']['sensorid'] == 0:

self.msg_join_ack['header']['sensorid'] = decoded["header"]["sensorid"]

self.msg_switch['header']['sensorid'] = decoded["header"]["sensorid"]

#TODO: Should remember report time of each device,

#and reschedule command messages to avoid their transmit slot

#making it less likely to miss an incoming message due to

#the radio being in transmit mode

# assume only 1 rec in a join, for now

if len(decoded["recs"])>0 and decoded["recs"][0]["paramid"] == OpenHEMS.PARAM_JOIN:

#TODO: write OpenHEMS.getFromMessage("header_mfrid")

response = OpenHEMS.alterMessage(self.msg_join_ack,

header_mfrid=decoded["header"]["mfrid"],

header_productid=decoded["header"]["productid"],

header_sensorid=decoded["header"]["sensorid"])

p = OpenHEMS.encode(response)

radio.transmitter()

radio.transmit(p)

radio.receiver()

if short_msg:

decoded = self.clean(decoded)

return decoded

#---------------------------------------------------------------------------

# Send data to switch

#---------------------------------------------------------------------------

def send_data(self, switch_state):

'''Send data to switch'''

request = OpenHEMS.alterMessage(self.msg_switch, recs_0_value=switch_state)

p = OpenHEMS.encode(request)

radio.transmitter()

radio.transmit(p)

radio.receiver()

#---------------------------------------------------------------------------

# Finish comms

#---------------------------------------------------------------------------

def close(self):

'''Closes connection'''

'''Entry point for script'''

script_name = os.path.basename(sys.argv[0])

#---------------------------------------------------------------------------

# Set up logger

#---------------------------------------------------------------------------

formatter = logging.Formatter(

fmt='%(asctime)s [%(levelname)-8s] %(module)-15s : %(message)s')

logging.Formatter.converter = time.gmtime

fh = logging.handlers.TimedRotatingFileHandler(filename='{script}.log'.format(

script= script_name[:-3]),

when='midnight',

backupCount=7,

utc=True)

fh.setLevel(logging.DEBUG)

fh.setFormatter(formatter)

ch = logging.StreamHandler()

ch.setLevel(logging.DEBUG)

ch.setFormatter(formatter)

logger = logging.getLogger('root')

logger.setLevel(logging.DEBUG)

logger.addHandler(fh)

logger.addHandler(ch)

logger.info('')

logger.info('--- Script {script} Started ---'.format(script= script_name))

#---------------------------------------------------------------------------

# Set up radio and capture data

#---------------------------------------------------------------------------

plug = MiPlug()

try:

data = plug.get_data()

plug.updateCSV(data)

plug.send_data(True)

finally: