コード例 #1
0
ファイル: scottecom.py プロジェクト: lassepc/PellMon
    def activate(self, conf, glob):
        protocols.activate(self, conf, glob)
        self.logger = logging.getLogger('pellMon')
        self.dbvalues = {}

        # Initialize protocol and setup the database according to version_string
        try:
            try:
                self.protocol = Protocol(self.conf['serialport'],
                                         self.conf['chipversion'])
            except:
                # Create testprotocol if conf is missing
                self.protocol = Protocol(None, '')
            self.allparameters = self.protocol.getDataBase()

            # Create and start settings_pollthread to log settings changed locally
            settings = menus.getDbWithTags(('Settings', ))
            ht = threading.Timer(3,
                                 self.settings_pollthread,
                                 args=(settings, ))
            ht.setDaemon(True)
            ht.start()

            # Create and start alarm_pollthread to log settings changed locally
            ht = threading.Timer(5,
                                 self.alarm_pollthread,
                                 args=(('mode', 'alarm'), ))
            ht.setDaemon(True)
            ht.start()

            self.dataDescriptions = dataDescriptions
        except:
            self.logger.info('scottecom protocol setup failed')
コード例 #2
0
ファイル: scottecom.py プロジェクト: apakhomov/PellMon
    def activate(self, conf, glob):
        protocols.activate(self, conf, glob)
        self.logger = logging.getLogger('pellMon')
        self.dbvalues={}

        # Initialize protocol and setup the database according to version_string
        try:
            try:
                self.protocol = Protocol(self.conf['serialport'], self.conf['chipversion'])
            except:
                # Create testprotocol if conf is missing
                self.protocol = Protocol(None, '')
            self.allparameters = self.protocol.getDataBase()

            # Create and start settings_pollthread to log settings changed locally
            settings = menus.getDbWithTags(('Settings',))
            ht = threading.Timer(3, self.settings_pollthread, args=(settings,))
            ht.setDaemon(True)
            ht.start()

            # Create and start alarm_pollthread to log settings changed locally
            ht = threading.Timer(5, self.alarm_pollthread, args=(('mode', 'alarm'),))
            ht.setDaemon(True)
            ht.start()

            self.dataDescriptions = dataDescriptions
        except:
            self.logger.info('scottecom protocol setup failed')
コード例 #3
0
ファイル: scottecom.py プロジェクト: syastrov/PellMon
    def activate(self, conf, glob, db, *args, **kwargs):
        protocols.activate(self, conf, glob, db, *args, **kwargs)
        self.logger = logging.getLogger('pellMon')
        self.dbvalues = {}
        self.itemrefs = []

        # Initialize protocol and setup the database according to version_string
        try:
            try:
                self.protocol = Protocol(self.conf['serialport'],
                                         self.conf['chipversion'])
            except:
                # Create testprotocol if conf is missing
                self.protocol = Protocol(None, '')
            self.allparameters = self.protocol.getDataBase()
            """Get list of all data/parameter/command items"""
            params = self.protocol.getDataBase()
            for item in params:
                dbitem = Getsetitem(item, None, lambda i: self.getItem(i),
                                    lambda i, v: self.setItem(i, v))
                if hasattr(params[item], 'max'):
                    dbitem.max = str(params[item].max)
                if hasattr(params[item], 'min'):
                    dbitem.min = str(params[item].min)
                if hasattr(params[item], 'frame'):
                    if hasattr(params[item], 'address'):
                        dbitem.type = 'R/W'
                    else:
                        dbitem.type = 'R'
                else:
                    dbitem.type = 'W'
                dbitem.longname = dataDescriptions[item][0]
                dbitem.unit = dataDescriptions[item][1]
                dbitem.description = dataDescriptions[item][2]
                dbitem.tags = menus.itemtags(item)
                self.db.insert(dbitem)
                self.itemrefs.append(dbitem)

            # Create and start settings_pollthread to log settings changed locally
            settings = [
                item for item in params if 'Settings' in menus.itemtags(item)
            ]
            ht = threading.Timer(3,
                                 self.settings_pollthread,
                                 args=(settings, ))
            ht.setDaemon(True)
            ht.start()

            # Create and start alarm_pollthread to log settings changed locally
            ht = threading.Timer(5,
                                 self.alarm_pollthread,
                                 args=(('mode', 'alarm'), ))
            ht.setDaemon(True)
            ht.start()

            self.dataDescriptions = dataDescriptions
        except:
            self.logger.info('scottecom protocol setup failed')
コード例 #4
0
ファイル: scottecom.py プロジェクト: motoz/PellMon
    def activate(self, conf, glob, db, *args, **kwargs):
        protocols.activate(self, conf, glob, db, *args, **kwargs)
        self.logger = logging.getLogger('pellMon')
        self.dbvalues={}
        self.itemrefs = []

        # Initialize protocol and setup the database according to version_string
        try:
            try:
                self.protocol = Protocol(self.conf['serialport'], self.conf['chipversion'])
            except:
                # Create testprotocol if conf is missing
                self.protocol = Protocol(None, '')
            self.allparameters = self.protocol.getDataBase()

            """Get list of all data/parameter/command items"""
            params = self.protocol.getDataBase()
            for item in params:
                dbitem = Getsetitem(item, None, lambda i:self.getItem(i), lambda i,v:self.setItem(i,v))
                if hasattr(params[item], 'max'): 
                    dbitem.max = str(params[item].max)
                if hasattr(params[item], 'min'): 
                    dbitem.min = str(params[item].min)
                if hasattr(params[item], 'frame'): 
                    if hasattr(params[item], 'address'): 
                        dbitem.type = 'R/W'
                    else:
                        dbitem.type = 'R'
                else:
                    dbitem.type = 'W'
                dbitem.longname = dataDescriptions[item][0]
                dbitem.unit = dataDescriptions[item][1]
                dbitem.description = dataDescriptions[item][2]
                dbitem.tags = menus.itemtags(item)
                self.db.insert(dbitem)
                self.itemrefs.append(dbitem)

            # Create and start settings_pollthread to log settings changed locally
            settings = [item for item in params if 'Settings' in menus.itemtags(item)]
            ht = threading.Timer(3, self.settings_pollthread, args=(settings,))
            ht.setDaemon(True)
            ht.start()

            # Create and start alarm_pollthread to log settings changed locally
            ht = threading.Timer(5, self.alarm_pollthread, args=(('mode', 'alarm'),))
            ht.setDaemon(True)
            ht.start()

            self.dataDescriptions = dataDescriptions
        except:
            self.logger.info('scottecom protocol setup failed')
コード例 #5
0
ファイル: scottecom.py プロジェクト: apakhomov/PellMon
class scottecom(protocols):
    def __init__(self):
        protocols.__init__(self)

    def activate(self, conf, glob):
        protocols.activate(self, conf, glob)
        self.logger = logging.getLogger('pellMon')
        self.dbvalues={}

        # Initialize protocol and setup the database according to version_string
        try:
            try:
                self.protocol = Protocol(self.conf['serialport'], self.conf['chipversion'])
            except:
                # Create testprotocol if conf is missing
                self.protocol = Protocol(None, '')
            self.allparameters = self.protocol.getDataBase()

            # Create and start settings_pollthread to log settings changed locally
            settings = menus.getDbWithTags(('Settings',))
            ht = threading.Timer(3, self.settings_pollthread, args=(settings,))
            ht.setDaemon(True)
            ht.start()

            # Create and start alarm_pollthread to log settings changed locally
            ht = threading.Timer(5, self.alarm_pollthread, args=(('mode', 'alarm'),))
            ht.setDaemon(True)
            ht.start()

            self.dataDescriptions = dataDescriptions
        except:
            self.logger.info('scottecom protocol setup failed')

    def getItem(self, item):
        return self.protocol.getItem(item)

    def setItem(self, item, value):
        return self.protocol.setItem(item, value)

    def getDataBase(self):
        db = self.protocol.getDataBase()
        return db.keys()

    def getDbWithTags(self, tags):
        """Get the menutags for param"""
        allparameters = self.getDataBase()
        filteredParams = menus.getDbWithTags(tags)            
        params = []
        for param in filteredParams:
            if param in allparameters:
                params.append(param)
        params.sort()
        return params

    def getMenutags(self):
        return menus.getMenutags()

    def GetFullDB(self, tags):
        """Get list of all data/parameter/command items"""
        l=[]
        allparameters = self.protocol.getDataBase()
        filteredParams = self.getDbWithTags(tags)
        params = []
        for param in filteredParams:
            if param in allparameters:
                params.append(param)
        params.sort()
        for item in params:
            data={}
            data['name']=item
            if hasattr(allparameters[item], 'max'): 
                data['max']=(allparameters[item].max)
            if hasattr(allparameters[item], 'min'): 
                data['min']=(allparameters[item].min)
            if hasattr(allparameters[item], 'frame'): 
                if hasattr(allparameters[item], 'address'): 
                    data['type']=('R/W')
                else:
                    data['type']=('R')
            else:
                data['type']=('W')
            data['longname'] = dataDescriptions[item][0]
            data['unit'] = dataDescriptions[item][1]
            data['description'] = dataDescriptions[item][2]
            l.append(data)
        return l

    def settings_pollthread(self, settings):
        """Loop through all items tagged as 'Settings' and write a message to the log when their values have changed"""
        for item in settings:
            try:
                param = self.allparameters[item]
                value = self.protocol.getItem(item)
                if item in self.dbvalues:
                    if not value==self.dbvalues[item]:
                        log_change = True
                        # These are settings but their values are changed by the firmware also, 
                        # so small changes are suppressed from the log
                        selfmodifying_params = {'feeder_capacity': 25, 'feeder_low': 0.5, 'feeder_high': 0.8, 'time_minutes': 2, 'magazine_content': 1}
                        try:
                            change = abs(float(value) - float(self.dbvalues[item]))
                            squelch = selfmodifying_params[item]
                            # These items change by themselves, log change only when squelch is exceeded
                            if change <= squelch:
                                log_change = False
                        except:
                            pass
                        # Don't log clock turn around
                        if (item == 'time_minutes' and change == 1439): 
                            log_change = False
                        if log_change:
                            self.settings_changed(item, self.dbvalues[item], value)
                self.dbvalues[item]=value
            except:
                pass
        # run this thread again after 30 seconds
        ht = threading.Timer(30, self.settings_pollthread, args=(settings,))
        ht.setDaemon(True)
        ht.start()

    def alarm_pollthread(self, alarms):
        # Log changes to 'mode' and 'alarm'
        for param in alarms:
            value = self.protocol.getItem(param)
            if param in self.dbvalues:
                if not value==self.dbvalues[param]:
                    self.settings_changed(param, self.dbvalues[param], value, param)
            self.dbvalues[param] = value
        # run this thread again after 30 seconds
        ht = threading.Timer(30, self.alarm_pollthread, args=(alarms,))
        ht.setDaemon(True)
        ht.start()
コード例 #6
0
ファイル: scottecom.py プロジェクト: lassepc/PellMon
class scottecom(protocols):
    def __init__(self):
        protocols.__init__(self)

    def activate(self, conf, glob):
        protocols.activate(self, conf, glob)
        self.logger = logging.getLogger('pellMon')
        self.dbvalues = {}

        # Initialize protocol and setup the database according to version_string
        try:
            try:
                self.protocol = Protocol(self.conf['serialport'],
                                         self.conf['chipversion'])
            except:
                # Create testprotocol if conf is missing
                self.protocol = Protocol(None, '')
            self.allparameters = self.protocol.getDataBase()

            # Create and start settings_pollthread to log settings changed locally
            settings = menus.getDbWithTags(('Settings', ))
            ht = threading.Timer(3,
                                 self.settings_pollthread,
                                 args=(settings, ))
            ht.setDaemon(True)
            ht.start()

            # Create and start alarm_pollthread to log settings changed locally
            ht = threading.Timer(5,
                                 self.alarm_pollthread,
                                 args=(('mode', 'alarm'), ))
            ht.setDaemon(True)
            ht.start()

            self.dataDescriptions = dataDescriptions
        except:
            self.logger.info('scottecom protocol setup failed')

    def getItem(self, item, raw=False):
        return self.protocol.getItem(item, raw)

    def setItem(self, item, value, raw=False):
        return self.protocol.setItem(item, value, raw)

    def getDataBase(self):
        db = self.protocol.getDataBase()
        return db.keys()

    def getDbWithTags(self, tags):
        """Get the menutags for param"""
        allparameters = self.getDataBase()
        filteredParams = menus.getDbWithTags(tags)
        params = []
        for param in filteredParams:
            if param in allparameters:
                params.append(param)
        params.sort()
        return params

    def getMenutags(self):
        return menus.getMenutags()

    def GetFullDB(self, tags):
        """Get list of all data/parameter/command items"""
        l = []
        allparameters = self.protocol.getDataBase()
        filteredParams = self.getDbWithTags(tags)
        params = []
        for param in filteredParams:
            if param in allparameters:
                params.append(param)
        params.sort()
        for item in params:
            data = {}
            data['name'] = item
            if hasattr(allparameters[item], 'max'):
                data['max'] = (allparameters[item].max)
            if hasattr(allparameters[item], 'min'):
                data['min'] = (allparameters[item].min)
            if hasattr(allparameters[item], 'frame'):
                if hasattr(allparameters[item], 'address'):
                    data['type'] = ('R/W')
                else:
                    data['type'] = ('R')
            else:
                data['type'] = ('W')
            data['longname'] = dataDescriptions[item][0]
            data['unit'] = dataDescriptions[item][1]
            data['description'] = dataDescriptions[item][2]
            l.append(data)
        return l

    def settings_pollthread(self, settings):
        """Loop through all items tagged as 'Settings' and write a message to the log when their values have changed"""
        for item in settings:
            try:
                param = self.allparameters[item]
                value = self.protocol.getItem(item, raw=True)
                if item in self.dbvalues:
                    if not value == self.dbvalues[item]:
                        log_change = True
                        # These are settings but their values are changed by the firmware also,
                        # so small changes are suppressed from the log
                        selfmodifying_params = {
                            'feeder_capacity': 25,
                            'feeder_low': 0.5,
                            'feeder_high': 0.8,
                            'time_minutes': 3,
                            'magazine_content': 1
                        }
                        try:
                            change = abs(
                                float(value) - float(self.dbvalues[item]))
                            squelch = selfmodifying_params[item]
                            # These items change by themselves, log change only when squelch is exceeded
                            if change <= squelch:
                                log_change = False
                        except:
                            pass
                        # Don't log clock turn around
                        if (item == 'time_minutes' and change == 1439):
                            log_change = False
                        if log_change:
                            self.settings_changed(item, self.dbvalues[item],
                                                  value)
                self.dbvalues[item] = value
            except:
                pass
        # run this thread again after 30 seconds
        ht = threading.Timer(30, self.settings_pollthread, args=(settings, ))
        ht.setDaemon(True)
        ht.start()

    def alarm_pollthread(self, alarms):
        # Log changes to 'mode' and 'alarm'
        try:
            for param in alarms:
                value = self.protocol.getItem(param)
                if param in self.dbvalues:
                    if not value == self.dbvalues[param]:
                        self.settings_changed(param, self.dbvalues[param],
                                              value, param)
                self.dbvalues[param] = value
        except:
            pass
        # run this thread again after 30 seconds
        ht = threading.Timer(30, self.alarm_pollthread, args=(alarms, ))
        ht.setDaemon(True)
        ht.start()
コード例 #7
0
ファイル: scottecom.py プロジェクト: motoz/PellMon
class scottecom(protocols):
    def __init__(self):
        protocols.__init__(self)

    def activate(self, conf, glob, db, *args, **kwargs):
        protocols.activate(self, conf, glob, db, *args, **kwargs)
        self.logger = logging.getLogger('pellMon')
        self.dbvalues={}
        self.itemrefs = []

        # Initialize protocol and setup the database according to version_string
        try:
            try:
                self.protocol = Protocol(self.conf['serialport'], self.conf['chipversion'])
            except:
                # Create testprotocol if conf is missing
                self.protocol = Protocol(None, '')
            self.allparameters = self.protocol.getDataBase()

            """Get list of all data/parameter/command items"""
            params = self.protocol.getDataBase()
            for item in params:
                dbitem = Getsetitem(item, None, lambda i:self.getItem(i), lambda i,v:self.setItem(i,v))
                if hasattr(params[item], 'max'): 
                    dbitem.max = str(params[item].max)
                if hasattr(params[item], 'min'): 
                    dbitem.min = str(params[item].min)
                if hasattr(params[item], 'frame'): 
                    if hasattr(params[item], 'address'): 
                        dbitem.type = 'R/W'
                    else:
                        dbitem.type = 'R'
                else:
                    dbitem.type = 'W'
                dbitem.longname = dataDescriptions[item][0]
                dbitem.unit = dataDescriptions[item][1]
                dbitem.description = dataDescriptions[item][2]
                dbitem.tags = menus.itemtags(item)
                self.db.insert(dbitem)
                self.itemrefs.append(dbitem)

            # Create and start settings_pollthread to log settings changed locally
            settings = [item for item in params if 'Settings' in menus.itemtags(item)]
            ht = threading.Timer(3, self.settings_pollthread, args=(settings,))
            ht.setDaemon(True)
            ht.start()

            # Create and start alarm_pollthread to log settings changed locally
            ht = threading.Timer(5, self.alarm_pollthread, args=(('mode', 'alarm'),))
            ht.setDaemon(True)
            ht.start()

            self.dataDescriptions = dataDescriptions
        except:
            self.logger.info('scottecom protocol setup failed')

    def getItem(self, item, raw=False):
        return self.protocol.getItem(item, raw)

    def setItem(self, item, value, raw=False):
        return self.protocol.setItem(item, value, raw)

    def getDataBase(self):
        db = self.protocol.getDataBase()
        return db.keys()

    def settings_pollthread(self, settings):
        """Loop through all items tagged as 'Settings' and write a message to the log when their values have changed"""
        for item in settings:
            try:
                param = self.allparameters[item]
                value = self.protocol.getItem(item, raw=True)
                if item in self.dbvalues:
                    if not value==self.dbvalues[item]:
                        log_change = True
                        # These are settings but their values are changed by the firmware also, 
                        # so small changes are suppressed from the log
                        selfmodifying_params = {'feeder_capacity': 25, 'feeder_low': 0.5, 'feeder_high': 0.8, 'time_minutes': 3, 'magazine_content': 1}
                        try:
                            change = abs(float(value) - float(self.dbvalues[item]))
                            squelch = selfmodifying_params[item]
                            # These items change by themselves, log change only when squelch is exceeded
                            if change <= squelch:
                                log_change = False
                        except:
                            pass
                        # Don't log clock turn around
                        if (item == 'time_minutes' and change == 1439): 
                            log_change = False
                        if log_change:
                            self.settings_changed(item, self.dbvalues[item], value)
                self.dbvalues[item]=value
            except:
                pass
        # run this thread again after 30 seconds
        ht = threading.Timer(30, self.settings_pollthread, args=(settings,))
        ht.setDaemon(True)
        ht.start()

    def alarm_pollthread(self, alarms):
        # Log changes to 'mode' and 'alarm'
        try:
            for param in alarms:
                value = self.protocol.getItem(param)
                if param in self.dbvalues:
                    if not value==self.dbvalues[param]:
                        self.settings_changed(param, self.dbvalues[param], value, param)
                self.dbvalues[param] = value
        except:
            pass
        # run this thread again after 30 seconds
        ht = threading.Timer(30, self.alarm_pollthread, args=(alarms,))
        ht.setDaemon(True)
        ht.start()