ems/CAN/Filter.py

#!/usr/bin/env python
# -*- coding: utf8 -*-
'''
Created on 13.11.2013

@author: Philipp Rauch
@version: 0.1
'''
from PCan import PcanAdapter
from Sym2Lib import Add2Adapter, _get_easy_Dict_, readSym
from datetime import datetime
from time import sleep
from threading import Thread
from pandas import DataFrame
from profile.database import Database

debug = True

intervall = 100

def CAN_start(conf):
    print 'starte CAN mit Baud von', conf['can_baudrate']
    can = CANFilter(conf)
    can.start()

def get_DataFrameDict(symfile):
    mes = readSym(symfile)
    symDict = _get_easy_Dict_(mes)
    dfDict = {}
    for i in symDict.keys():
        dfDict.update( { i : DataFrame(columns = symDict[i]) } )
    return dfDict

class CANFilter(Thread):

    ### Lookup für CAN --> DB ###
    lookup = {
              'U_IST_WERT' : 'GRIDManager_U_IST',
              'I_IST_WERT' : 'GRIDManager_I_IST',
              'TEMPEARTUR' : 'GRIDManager_Temperatur',
              'STATUS_FPGA' : 'GRIDManager_Status',
              'I_PH_WERT' : 'GRIDManager_I_PH'
              }

    def __init__(self, conf):
        Thread.__init__(self)
        self.conf = conf

        ### init DB ###
        self.db = Database()
        self.db.loadDatabase(strHost = self.conf['mySQL_server'],
                     intPort = int(self.conf['mySQL_port']),
                     strUser = self.conf['mySQL_user'],
                     strPasswd = self.conf['mySQL_pass'],
                     strDatabase = self.conf['mySQL_database'],
                     strTable = None)

        self.symList = []

        ### init PCAN ###
        self.pcan = PcanAdapter(PcanAdapter.Baudrate[self.conf['can_baudrate']],
                               debug = self.conf['config_debug'])
        self.pcan.initialize()
        if isinstance(self.conf['can_symfile'], str):
            sym = '%s/%s' % (self.conf['config_dictionary'],
                             self.conf['can_symfile'])
            self.symList.append(get_DataFrameDict(sym))
            Add2Adapter(self.pcan, sym)
        elif isinstance(self.conf['can_symfile'], list):
            for element in self.conf['can_symfile']:
                sym = '%s/%s' % (self.conf['config_dictionary'], element)
                self.symList.append(get_DataFrameDict(sym))
                Add2Adapter(self.pcan, sym)

    def run(self):
        while True:
            receiveMessageName = self.pcan.receiveMessage(block = True)

            try:
                tablename = self.lookup[receiveMessageName]
            except:
                tablename = receiveMessageName

#            if receiveMessageName is None or self.pcan.Messages[receiveMessageName].getFlag('RECEIVE'):
#                continue

            #print "%s - %s" % (datetime.now(), tablename)

            for sym in self.symList:
                if receiveMessageName in sym.keys():
                    tmp = {}
                    for sig in list(sym[receiveMessageName].columns):
                        data = self.pcan.Messages[receiveMessageName].Signals[sig].GetData()
                        if self.pcan.Messages[receiveMessageName].Signals[sig].Enum is not None:
                            data = self.pcan.Messages[receiveMessageName].Signals[sig].Enum[data]
                        tmp[sig] = data

                    sym[receiveMessageName] = sym[receiveMessageName].append(tmp, ignore_index=True)

                    if len(sym[receiveMessageName].index) == int(1/(0.001 * intervall)):
                        #res = DataFrame(sym[receiveMessageName].mean(axis=0)).T
                        res =  sym[receiveMessageName][-1:]
                        res = res.reset_index(drop = True)

                        #res.drop('isMaster', axis = 1, inplace = True)
                        #res.drop('isCharging', axis = 1, inplace = True)
                        res['DateTime'] = datetime.now()

                        #self.db.writeDatabase(self.lookup[receiveMessageName], res)
                        self.db.writeDatabase(strTable=tablename, dfData=res, bClear=False)
                        sym[receiveMessageName] = sym[receiveMessageName].drop(sym[receiveMessageName].index[:])
                        print "%s - Write to DB - %s" % (res['DateTime'][0], tablename)

            #sleep(0.01)