示例#1
0
    def pre_start(self):
        """\
            Do initial base class set up required before start, such as
            initialize self._xbee_manager and self._extended_address
        """
        
        if self._xbee_manager is None:
            # then initialize things
            
            self._tracer.calls("XBeeBase.pre_start()")

            # Fetch the XBee Manager name from the Settings Manager:
            dm = self._core.get_service("device_driver_manager")
            self._xbee_manager = dm.instance_get(
                    SettingsBase.get_setting(self, "xbee_device_manager"))

            # Register ourselves with the XBee Device Manager instance:
            self._xbee_manager.xbee_device_register(self)

            # Get the extended address of the device:
            self._extended_address = SettingsBase.get_setting(self, "extended_address")

            # Create a callback specification that calls back this driver when
            # our device has left the configuring state and has transitioned
            # to the running state:
            xbdm_running_event_spec = XBeeDeviceManagerRunningEventSpec()
            xbdm_running_event_spec.cb_set(self.running_indication)
            self._xbee_manager.xbee_device_event_spec_add(self,
                                                    xbdm_running_event_spec)

        # else do nothing
        
        return
    def make_request(self):
        success = True
        self._tracer.debug("make_request")

        extended_address = SettingsBase.get_setting(self, "extended_address")

        try:
            sample = self.__xbee_manager.xbee_device_ddo_get_param(extended_address, '1S')
            self.__decode_sample(sample)
            self._tracer.debug("Successfully retrieved and decoded sample.")
        except TypeError:
            success = False
            self._tracer.error("Device driver does not match with connected hardware.")
            pass
        except:
            success = False
            self._tracer.warning("Xmission failure, will retry.")
            pass

        # Schedule another heart beat poll, but only if we aren't in sleep mode.
        will_sleep = SettingsBase.get_setting(self, "sleep")
        if will_sleep != True:
            self.__schedule_request()
            self.__reschedule_retry_watchdog()

        return success
    def apply_settings(self):
        
        SettingsBase.merge_settings(self)
        accepted, rejected, not_found = SettingsBase.verify_settings(self)

        if len(rejected) or len(not_found):
            # There were problems with settings, terminate early:
            print "idigi_db (%s): Settings rejected/not found: %s %s" % \
                (self.__name, rejected, not_found)
            return (accepted, rejected, not_found)

        # Verify that if we are on the Digi ConnectPort X3, that the user
        # doesn't have the secure option set to True.
        # If they do, we MUST bail here and also warn the user that the
        # Digi ConnectPort X3 cannot do secure/encrypted idigi connections.
        if accepted['secure'] == True and get_platform_name() == 'digix3':
            print "idigi_db (%s): The Digi ConnectPort X3 product cannot " \
                  "do secure/encrypted connections to the iDigi Server.  " \
                  "Please set the 'secure' option to False!" % \
                                (self.__name)

            rejected['secure'] = accepted['secure']
            del accepted['secure']
            return (accepted, rejected, not_found)

        SettingsBase.commit_settings(self, accepted)
        
       # xbee_manager_name = SettingsBase.get_setting(self, "xbee_device_manager")
        dm = self.__core.get_service("device_driver_manager")
        self.__xbee_manager = dm.instance_get("xbee_device_manager")
        
        self.__last_upload_time = 0
        
        self.repeat()
        return (accepted, rejected, not_found)
    def run(self):
        
        #Get the device properties
        time_sleep = SettingsBase.get_setting(self,"update_rate")

        self.input_gpios = SettingsBase.get_setting(self,"input_gpios")
        self.output_gpios = SettingsBase.get_setting(self,"output_gpios")
        
        #Call the GPIOs initializer method
        self.initialize_gpios()
        
        #Start the refresh thread
        while 1:
            if self.__stopevent.isSet():
                self.__stopevent.clear()
                break

            try:
                while self.setting_gpio:
                    pass
                self.get_GPIOs()
            except Exception, e:
                self.__tracer.error("Unable to update values: %s", str(e))
            
            #Sleep the time configured in settings (in seconds)
            digitime.sleep(time_sleep)
    def run(self):
                
        while self.started_flag:
            msg = self.queue.get()
            
            if not self.started_flag:
                return

            host = SettingsBase.get_setting(self, 'server_address')
            port = SettingsBase.get_setting(self, 'port')
            frm    = SettingsBase.get_setting(self, 'from_address')
            to     = SettingsBase.get_setting(self, 'to_address')
            
            try:
                s = smtplib.SMTP(host, port)
            except Exception, e:
                self.__tracer.error("Failed to connect to SMTP server")
                self.__tracer.warning("If using a DNS name, " + \
                        "make sure the Digi device is configured" + \
                        " to use the correct DNS server")
                
            try:
                error_list = s.sendmail(frm, to, msg)
            except:
                self.__tracer.error("Failed to send messages, please double check server/port")
            else:
                for err in error_list:
                    self.__tracer.error("Failed to send message to %s address", err)
            s.quit()
示例#6
0
    def apply_settings(self):

        SettingsBase.merge_settings(self)
        accepted, rejected, not_found = SettingsBase.verify_settings(self)

        if len(rejected) or len(not_found):
            # there were problems with settings, terminate early:
            self.__tracer.error("Settings rejected/not found: %s %s",
                                rejected, not_found)
            
            return (accepted, rejected, not_found)

        # Verify that the sample predelay time when added to the awake time
        # is not over 0xffff.
        if accepted['sample_predelay'] + accepted['awake_time_ms'] > 0xffff:
            self.__tracer.error("The awake_time_ms value (%d) " +
                                "and sample_predelay value (%d) " +
                                "when added together cannot exceed 65535.",
                                self.__name, accepted['sample_predelay'],
                                accepted['awake_time_ms'])

            rejected['awake_time_ms'] = accepted['awake_time_ms']
            del accepted['awake_time_ms']
            rejected['sample_predelay'] = accepted['sample_predelay']
            del accepted['sample_predelay']
            return (accepted, rejected, not_found)

        SettingsBase.commit_settings(self, accepted)

        return (accepted, rejected, not_found)
    def conditional_settings_serializer_load(self,
            settings_filename="", suffix=""):
        """
        Infer which serializer should be loaded and used.

        Parameters:

        * `settings_filename` - Filename to use to determine
          serializer
        * `suffix` - Suffix of filename used to determine serializer

        Only one of `settings_filename` or `suffix` need be specified
        """

        if len(settings_filename):
            suffix = os.path.splitext(settings_filename)[1][1:]
        elif not len(suffix):
            raise CoreSettingsInvalidSerializer

        if suffix in [ 'yml', 'yaml' ]:
            from settings.settings_serializer_yaml import SettingsSerializerYaml
            SettingsBase.register_serializer(self, "yaml",
                                             SettingsSerializerYaml())
            self.__serializer_ext_map["yaml"] = "yml"
            return 'yaml'
        if suffix == 'pyr':
            from settings.settings_serializer_py import SettingsSerializerPy
            SettingsBase.register_serializer(self, 'pyr',
                                             SettingsSerializerPy())
            self.__serializer_ext_map['pyr'] = 'pyr'
            return 'pyr'
        else:
            raise CoreSettingsInvalidSerializer(
                "unsupported serializer '%s'" % suffix )
示例#8
0
    def start(self):

        # If the use_default_httpserver setting is specified,
        # the presentation will  start own http server on the specified port.
        isDefault = SettingsBase.get_setting(self, 'use_default_httpserver')
        if not globals().has_key('Callback'):
            isDefault = False

        if isDefault:
            self._cb_handle = Callback(self.cb)
            self.__tracer.info("using web page %s and"
                   " using digiweb", self.get_page())
        else:
            self._cb_handle = self.get_channels
            try:
                port = SettingsBase.get_setting(self, 'port')
                self.__tracer.info("using port %d and BaseHTTPServer", port)

                HTTPServer.__init__(self, ('', port), WebRequestHandler)
            except Exception:
                self.__tracer.debug(traceback.format_exc())
                self.socket.close()
            # Only start a thread if the Python web-server is
            # used:
            threading.Thread.start(self)
示例#9
0
    def running_indication(self):
        # request initial status here.
        self.__tracer.info("Running indication")
        extended_address = SettingsBase.get_setting(self, "extended_address")
        humidity_present = SettingsBase.get_setting(self, "humidity_present")

        # this is a flawed design - if the gateway has just rebooted,
        # and the Xbee sensor sleeps (which it should), then an actual
        # GET_DDO will be issued, which causes Dia to freeze here and
        # almost certainly throw exception and put the device off line.
        try:
            dd_value = self.__xbee_manager.xbee_device_ddo_get_param(
                    extended_address, 'DD', use_cache=True)
        except:
            self.__tracer.warning('Using default DD')
            dd_value = 0x0003000E

        module_id, product_id = parse_dd(dd_value)
        self.__tracer.info('DD info (module_id, product_id) = ' +
                           '(0x%04x, 0x%04x)"', module_id, product_id)

        if product_id == PROD_DIGI_XB_SENSOR_LTH or humidity_present == True:
            self.__tracer.info("Sensor is a '%s' adding humidity channel",
                               product_name(product_id))

            self.add_property(
                ChannelSourceDeviceProperty(name="humidity", type=float,
                    initial=Sample(timestamp=0, value=0.0, unit="%"),
                    perms_mask=DPROP_PERM_GET, options=DPROP_OPT_AUTOTIMESTAMP)) 
        else:
            self.__tracer.info("Sensor is a '%s' no humidity capability.",
                               product_name(product_id))
    def apply_settings(self):

        SettingsBase.merge_settings(self)
        accepted, rejected, not_found = SettingsBase.verify_settings(self)

        if len(rejected) or len(not_found):
            # there were problems with settings, terminate early:
            self.__tracer.error("Settings rejected/not found: %s %s",
                                rejected, not_found)
            return (accepted, rejected, not_found)

        # Walk each setting, and verify the physical channel type
        # is the same type the user specified in their config.
        for setting in accepted.copy():
            if setting[0:7] == "channel":
                try:
                    channel = setting[7]
                    operation = setting[9:]
                    type = digihw.get_channel_type(int(channel) - 1)
                    if type == self.IO_TYPE_ANALOG:
                        if operation != "mode":
                           raise ValueError, "Channel mode is not correct"
                    elif type == self.IO_TYPE_DIGITAL:
                        if operation != "dir" and operation != "source":
                           raise ValueError, "Channel mode is not correct"
                    else:
                           raise ValueError, "Channel mode is not correct"
                except Exception, e:
                    self.__tracer.error("Unable to parse settings: %s", e)
                    rejected[setting] = accepted[setting]
                    del accepted[setting]
 def run(self):
     """run when our device driver thread is started"""
     
     ip = SettingsBase.get_setting(self, "server_ip")
     port = int(SettingsBase.get_setting(self, "server_port"))
     server = 'wsgiref'
     run_itty(server, ip, port)
    def run(self):
        type = SettingsBase.get_setting(self, "type")
        if type == "serial":
            from presentations.console.console_serial_server import \
                 ConsoleSerialServer
            server = ConsoleSerialServer(
                                    SettingsBase.get_setting(self, "device"),
                                    SettingsBase.get_setting(self, "baudrate"),
                                    self.__core,
                                    self.__stopevent
                )
        else:
            server = ConsoleTcpServer(('', 
                                    SettingsBase.get_setting(self, "port")),
                                    ConsoleTcpRequestHandler, self.__core,
                                    self.__stopevent)
        while 1:
            if self.__stopevent.isSet():
                break

            if isinstance(server, ConsoleTcpServer):
                r, w, e = select([server.socket], [], [], 1.0)
            else:
                r = True # Serial ports are always ready

            if r:
                # Spawns a thread for TCP, blocks for Serial
                server.handle_request()

        while hasattr(server, "handlers") and len(server.handlers):
            # Wait for handlers to exit
            time.sleep(1.0)
示例#13
0
    def apply_settings(self):
        """\
        Called when new configuration settings are available.

        Must return tuple of three dictionaries: a dictionary of
        accepted settings, a dictionary of rejected settings,
        and a dictionary of required settings that were not
        found.
        """
        try:
            if not threading.Thread.isAlive(self):
                return
        except:
            return

        if 'update_rate' in accepted and \
               accepted['update_rate'] > SHUTDOWN_WAIT:
            self.__tracer.warning('Long update_rate setting may ' +
                                  'interfere with shutdown of Dia.')


        SettingsBase.merge_settings(self)
        accepted, rejected, not_found = SettingsBase.verify_settings(self)

        SettingsBase.commit_settings(self, accepted)

        return (accepted, rejected, not_found)
示例#14
0
    def start_post(self):

        self._tracer.debug("RobustXBee:Start_Post")

        hb = SettingsBase.get_setting(self, "heart_beat_sec")
        if (hb is not None) and (hb > 0):
            # then enable the periodic intake of data productions
            self.__xbee_manager.register_sample_listener(self,
                self.get_extended_address(), self._heart_beat_indication)

            hb = SettingsBase.get_setting(self, "heart_beat_io")
            if (hb is not None) and (len(hb) > 0):
                # then set a dummy IO to input, but only if HeartBeat active
                cfg = self.get_ddo_block()
                cfg.add_parameter(hb, 3)
                self.get_xbee_manager().xbee_device_config_block_add(
                        self, cfg)

        else: # no heart_beat
            try:
                # remove the availability channel
                self.remove_one_property(self.RXBEE_DEF_AVAIL_CHAN)
                # remove the online channel
                self.remove_one_property(self.HB_STATUS_CHAN)
            except:
                pass

        # Indicate that we have no more configuration to add:
        self.get_xbee_manager().xbee_device_configure(self)

        return RobustBase.start_post(self)
    def start(self):
        """Start the device driver.  Returns bool."""

        cm = self.__core.get_service("channel_manager")
        cp = cm.channel_publisher_get()
        cdb = cm.channel_database_get()

        left_channel_name = SettingsBase.get_setting(self, LEFT_VOLUME_CHANNEL)
        left_channel = cdb.channel_get(left_channel_name)
        right_channel_name = SettingsBase.get_setting(self, RIGHT_VOLUME_CHANNEL)
        right_channel = cdb.channel_get(right_channel_name)

        # Determine initial state:
        if left_channel.get().value >= right_channel.get().value:
            print "INIT LEFT: volume is %f" % (left_channel.get().value)
            self.__state = STATE_PUMP_OUT_LEFT
            self.property_set("left_pump_on",
                Sample(0, Boolean(True, STYLE_ONOFF)))
        else:
            print "INIT RIGHT: volume is %f" % (right_channel.get().value)
            self.__state = STATE_PUMP_OUT_RIGHT
            self.property_set("right_pump_on",
                Sample(0, Boolean(True, STYLE_ONOFF)))

        # Perform channel subscriptions:
        cp.subscribe(left_channel_name,
            lambda chan: self.tank_volume_update(chan, LEFT_VOLUME_CHANNEL))
        cp.subscribe(right_channel_name,
            lambda chan: self.tank_volume_update(chan, RIGHT_VOLUME_CHANNEL))


        return True
示例#16
0
    def __init__(self, name, core_services, settings, properties):
        self._name = name
        self._core = core_services
        self._tracer = get_tracer(name)

        # Initialize settings:
        ## Settings Table Definition:
        settings_list = [
            Setting(
                name='trace', type=str, required=False,
                default_value=self.DEF_TRACE),
        ]
        # Add our settings_list entries into the settings passed to us.
        settings = self.merge_settings(settings, settings_list)

        self.__settings = settings
        SettingsBase.__init__(self, binding=("devices", (name,), "settings"),
                                    setting_defs=settings)

        # Initialize properties:
        self.__properties = { }
        for property in properties:
            self.add_property(property)

        # pre_start - check if special trace level requested
        trace = SettingsBase.get_setting(self, "trace")
        try:
            self._tracer.set_level(trace)
        except:
            self._tracer.warning("Ignoring bad trace level \'%s\' for this device", trace)

        self._tracer.calls("DeviceBase.__init__()")
    def start(self):
        """Start the device driver.  Returns bool."""

        RobustBase.start_pre(self)

        # copy the Modbus Unit ID (slave id) to our Veris H8036 object
        x = SettingsBase.get_setting(self, "unit_id")
        self._my_tracer.debug("Setting Modbus Unit-ID:%d ", x)
        self._H8036.set_ModbusAddress(x)
        
        # create the Dia channels
        x = SettingsBase.get_setting(self, "channels")
        self._my_tracer.debug("Setting H8036 Mode:%s ", x)
        self._H8036.enable_channels(x)

        nam_list = self._H8036.get_channel_name_list()

        for nam in nam_list:
            self._my_tracer.debug("Adding Channel:%s ", nam)
            self.add_property(
                ChannelSourceDeviceProperty(name=nam,
                    type=float, initial=Sample(0, 0.0, 'not init'),
                    perms_mask=DPROP_PERM_GET, options=DPROP_OPT_AUTOTIMESTAMP))

        RobustBase.start_post(self)

        return True
示例#18
0
    def __init__(self, settings_flo, settings_filename):
        # Provides self.settings and serialization:
        settings_list = [
            Setting(
                name='devices', type=list, required=False, default_value=[]),
            Setting(
                name='loggers', type=list, required=False, default_value=[]),
            Setting(
                name='presentations', type=list, required=False,
                default_value=[]),
            Setting(
                name='services', type=list, required=False, default_value=[]),
            Setting(
                name='tracing', type=list, required=False, default_value=[]),
        ]
        SettingsBase.__init__(self, binding=(), setting_defs=settings_list)

        self.__settings_filename = settings_filename
        self.__service_map = {}
        self.__serializer_ext_map = {}
        self.__sleep_req = None  # STUB: seconds to wait before power-off
        self.__shutdown_event = threading.Event()

        # TODO: core may become a thread so we can monitor services and
        #       attempt to restart them when they fail.
        try:
            self.epoch(settings_flo)
        except KeyboardInterrupt:  # pragma: no cover
            raise KeyboardInterrupt
        except CoreSettingsException:
            print "Core: Initial settings invalid, aborting start up..."
            sys.exit()
        except:
            print "Core: Fatal exception caught!  Halting execution."
            self.request_shutdown()
    def start(self):

        # Fetch the XBee Manager name from the Settings Manager:
        xbee_manager_name = SettingsBase.get_setting(self, "xbee_device_manager")
        dm = self.__core.get_service("device_driver_manager")
        self.__xbee_manager = dm.instance_get(xbee_manager_name)

        # Register ourselves with the XBee Device Manager instance:
        self.__xbee_manager.xbee_device_register(self)

        # Get the extended address of the device:
        extended_address = SettingsBase.get_setting(self, "extended_address")

        #register a callback for when the config is done
        xb_rdy_state_spec = XBeeDeviceManagerRunningEventSpec()
        xb_rdy_state_spec.cb_set(self._config_done_cb)
        self.__xbee_manager.xbee_device_event_spec_add(self, xb_rdy_state_spec)
        
        # Create a DDO configuration block for this device:
        xbee_ddo_cfg = XBeeConfigBlockDDO(extended_address)

        # Call the XBeeSerial function to add the initial set up of our device.
        # This will set up the destination address of the devidce, and also set
        # the default baud rate, parity, stop bits and flow control.
        XBeeSerial.initialize_xbee_serial(self, xbee_ddo_cfg)

        # Register this configuration block with the XBee Device Manager:
        self.__xbee_manager.xbee_device_config_block_add(self, xbee_ddo_cfg)

        # Indicate that we have no more configuration to add:
        self.__xbee_manager.xbee_device_configure(self)

        return True
示例#20
0
    def __send_to_idigi(self, data):
        """
        Sends data to iDigi

        Keyword arguments:

        data - the XML string to send
        """

        filename = SettingsBase.get_setting(self, "filename")
        filename_format = SettingsBase.get_setting(self, "filename_format")
        filename = filename_format % (filename, self.__current_file_number)
        collection = SettingsBase.get_setting(self, "collection")
        secure = SettingsBase.get_setting(self, "secure")

        print "idigi_upload: Uploading %s to iDigi" % filename

        success, err, errmsg = idigi_data.send_idigi_data(data, filename, collection, secure)
        if not success:
            # if successful, delete upload list else try again next time
            print "idigi_db: Uploading ERROR %s (%s)" % (err,errmsg)

        self.__current_file_number += 1

        max_files = SettingsBase.get_setting(self, "file_count")

        if self.__current_file_number >= max_files + 1:
            self.__current_file_number = 1

        return success
示例#21
0
    def receive(self, channel):
        """
        Called whenever there is a new sample

        Keyword arguments:

        channel -- the channel with the new sample
        """

        # we always cache
        if SettingsBase.get_setting(self, "compact_xml"):
            sam = self.__make_compact_xml(channel.name(),channel.get())
        else:
            sam = self.__make_xml(channel.name(),channel.get())
        self.__cache.append(sam)

        self.__sample_count += 1
        print '%s:%d cache:%s' % (self.__name, self.__sample_count, sam)

        # If we have exceeded the sample threshold, notify the thread
        # responsible for pushing up data
        if self.__sample_count >= SettingsBase.get_setting(self, "sample_threshold"):
#             print "idigi_db: Reached threshold of %i, setting event flag" % sample_threshold
            self.__threshold_event.set()

        return
示例#22
0
    def load_settings(self, settings_filename, settings_flo=None):
        """
Load settings from `settings_filename`.

If the optional parameter `setting_flo` is specified, that file-like object
will be used as the source of settings data.  `settings_filename` is always
used in order to infer the settings serializer used to interpret the
settings as given by a extension-to-type mapping table defined as a constant
in the core service.
        """

        serializer_name = self.conditional_settings_serializer_load(
                            settings_filename=settings_filename)

        if not settings_flo:
            if not os.path.exists(settings_filename):
                raise CoreSettingsFileNotFound

            try:
                settings_flo = open(settings_filename, 'r')
            except:
                raise CoreSettingsFileNotFound

        try:
            SettingsBase.load(self, settings_flo, serializer_name)
        except Exception, e:
            try:
                print "Core: Unable to load settings: %s" % (str(e))
            except:
                print "Core: Unable to load settings: reason unavailable"
            raise CoreSettingsException
示例#23
0
    def run(self):
        """Worker thread for the TCPCSV client.""" 

        state = STATE_NOTCONNECTED
        sd = None

        while not self.__stopevent.isSet():
            if state == STATE_NOTCONNECTED:
                server = SettingsBase.get_setting(self, "server")
                port = SettingsBase.get_setting(self, "port")
                sd = socket(AF_INET, SOCK_STREAM)
                try:
                    sd.connect((server, port))
                except Exception, e:
                    print "TCPCSV(%s): error connecting to %s:%d: %s" % \
                        (self.__name, server, port, str(e))
                    time.sleep(RECONNECT_DELAY)
                    continue
                state = STATE_CONNECTED

            if state == STATE_CONNECTED:
                sio = StringIO()
                self._write_channels(sio)
                try:
                        sd.sendall(sio.getvalue())
                except:
                        try:
                                sd.close()
                        except:
                                pass
                        state = STATE_NOTCONNECTED
                        continue
                del(sio)
                time.sleep(SettingsBase.get_setting(self, "interval"))
示例#24
0
    def start(self):
        """Start the device driver.  Returns bool."""

        ECM1240_Xbee.start(self)

        if self._import_settings():
            self.apply_settings()

        logger_id = SettingsBase.get_setting(self, 'sunspec_lid')
        if (logger_id is None) or (logger_id.lower == 'none'):
            self._ecm._lid = None
            self._lid_ns = None
        #elif logger_id.lower is in ['mac', 'auto']:
        #    self._ecm._lid = None
        #    self._lid_ns = 'mac'
        else:
            self._ecm._lid = logger_id
            self._lid_ns = 'mac'

        format = SettingsBase.get_setting(self, 'sunspec_format').lower()
        if format in ECM1240_SunSpec.XML_FORM_LIST:
            self._ecm._xml_form = format
            self.__tracer.debug('%s: Selecting XML format "%s".', self.__showname, format)
        else:
            self.__tracer.error('%s: Unknown XML format "%s".', self.__showname, format)

        self._ecm._single_channel = SettingsBase.get_setting(self, 'single_channel')
        if self._ecm._single_channel:
            self.__tracer.debug('%s: Forcing Single Channel Mode', self.__showname)

        return True
示例#25
0
    def start(self):
        """Start the device driver.  Returns bool."""

        self.__tracer.info("Starting device")

        # force desired fixed parameters into our base/parent devices
        RobustXSerial.start_pre(self)

        # match our private tracer to Robust_Base's family one
        self.__tracer.level = self._tracer.level

        ## Remove the statistic channels if NOT desired
        # why add, then remove?  Otherwise they don't exist at
        # start-up for subscription by other devices/presentations
        if not SettingsBase.get_setting(self, "add_statistics"):
            self.__tracer.info("Statistic Channels are disabled.")
            self.remove_list_of_properties(
                    ["co2_stats", "hum_stats", "tmp_stats"])
            self.__co2_stats = None
            self.__hum_stats = None
            self.__tmp_stats = None

        ## Force a default IA Modbus config if none
        # 'enabling' really only enables this config check
        if SettingsBase.get_setting(self, "enable_modbus"):
            try:
                if rci_modbus.rci_test_for_ia_table():
                    self.__tracer.info("Detected existing Modbus IA Config.")
                else:
                    if rci_modbus.rci_create_ia_table_mbdia():
                        self.__tracer.info("Created new Modbus IA Config.")
                    else:
                        self.__tracer.error("Modbus IA Config creation FAILED.")

            except:
                self.__tracer.debug(traceback.format_exc())
                self.__tracer.error('Modbus IA Config creation FAILED!')

        self.__three_command = SettingsBase.get_setting(self, "three_commands")

        # Create a DDO configuration block for this device:
        xbee_ddo_cfg = self.get_ddo_block()

        # enable/disable the LED statistics channels
        if SettingsBase.get_setting(self, "disable_led"):
            # disable by setting DIO-10 (p0) to 5/dig-out high
            xbee_ddo_cfg.add_parameter('P0', 5)
        else:
            # enable by setting DIO-10 (p0) to 1/RSSI/PWM
            xbee_ddo_cfg.add_parameter('P0', 1)

        # Register configuration blocks with the XBee Device Manager:
        self.get_xbee_manager().xbee_device_config_block_add(self, xbee_ddo_cfg)

        RobustXSerial.start_post(self)

        # force garbage collection in case we deleted big things
        gc.collect()

        return True
示例#26
0
    def apply_settings(self):
        """\
            Called when new configuration settings are available.
       
            Must return tuple of three dictionaries: a dictionary of
            accepted settings, a dictionary of rejected settings,
            and a dictionary of required settings that were not
            found.
        """
        
        SettingsBase.merge_settings(self)
        accepted, rejected, not_found = SettingsBase.verify_settings(self)
        if len(rejected) or len(not_found):
            print "TimingService(%s) Settings rejected/not found: %s %s" % (
                self.__name, rejected, not_found)

        SettingsBase.commit_settings(self, accepted)

        # Tear down and rebuild annotation system, this does mean that
        # reconfiguration will cause a window where stale data will
        # not be reported at the time where it technically becomes
        # stale under either configuration necessarily.
        self._destroy_timers()
        self._create_timers()
        self._enroll_channel_sources()

        return (accepted, rejected, not_found)
 def repeat(self):
     
     if self.started == False:
         time.sleep(60)
         
     
     interval = SettingsBase.get_setting(self, "interval")
     
     
     if self.__event_timer is not None:
         try:
             self.__xbee_manager.xbee_device_schedule_cancel(
                 self.__event_timer)
         except:
             pass
         
     self.__event_timer = self.__xbee_manager.xbee_device_schedule_after(
             SettingsBase.get_setting(self, "interval"),
             self.repeat)
     
     
     
     
     
     
     try:
         self.__upload_data()
         self.connected = 0
     except:
         self.connected += 1
         print "error in sending from repeat function"
    def apply_settings(self):

        SettingsBase.merge_settings(self)
        accepted, rejected, not_found = SettingsBase.verify_settings(self)

        # verify exclusive issues
        if(accepted['poll_clean_minutes'] > 0):
            # then we have exclusive issues to settle
            if(accepted['sleep']):
                # cannot sleep with clean_minutes active
                print "XBeeWatchport: 'sleep' cannot be True if poll_clean_minutes is used."
                rejected['sleep'] = accepted['sleep']
                del accepted['sleep']

            # over-ride / force sample_rate to match clean_minutes
            accepted['sample_rate_ms'] = \
                    accepted['poll_clean_minutes'] * 60000

        if len(rejected) or len(not_found):
            # there were problems with settings, terminate early:
            print "Settings rejected/not found: %s %s" % (rejected, not_found)
            return (accepted, rejected, not_found)

        SettingsBase.commit_settings(self, accepted)

        return (accepted, rejected, not_found)
示例#29
0
    def start_pre(self):
        """\
            Start the device driver.
        """

        self._tracer.debug("RobustXBee:Start_Pre")

        # suppress the Robust_Device start of polling until XBee config is done
        self._start_polling = False
        RobustBase.start_pre(self)

        # Fetch the XBee Manager name from the Settings Manager:
        xbee_manager_name = SettingsBase.get_setting(self, "xbee_device_manager")
        dm = self.get_core().get_service("device_driver_manager")
        self.__xbee_manager = dm.instance_get(xbee_manager_name)

        # Register ourselves with the XBee Device Manager instance:
        self.__xbee_manager.xbee_device_register(self)

        # Get the extended address of the device:
        self.__extended_address = SettingsBase.get_setting(self, "extended_address")

        # Create a callback to tell this driver when our device has left the
        # configuring state, transitioning to the running state
        x = XBeeDeviceManagerRunningEventSpec()
        x.cb_set(self.running_indication)
        self.__xbee_manager.xbee_device_event_spec_add(self, x)

        self.initialize_robust_xbee()

        return True
 def run(self):
     """run when our device driver thread is started"""
     self.sd = None
     '''/
     import serial
     self.sd = serial.Serial(
        0,                            #port number
        baudrate=115200,              #baudrate
        bytesize=serial.EIGHTBITS,    #number of databits
        parity=serial.PARITY_NONE,    #enable parity checking
        stopbits=serial.STOPBITS_ONE, #number of stopbits
        timeout=3,                    #set a timeout value
        xonxoff=0,                    #enable software flow control
        rtscts=0,                     #enable RTS/CTS flow control
     )
     '''
     
     try:
         fd = None
         fd = open(path + 'id_secret_token.txt', 'r+')
         id = fd.readline()
         secret = fd.readline()
         token = fd.readline()
         fd.close()
         self.hvconn = HealthVaultConn(path, id, secret, token)
     except:
         traceback.print_exc()
         if fd != None: fd.close()
         self.hvconn = None
     
     ip = SettingsBase.get_setting(self, "server_ip")
     port = int(SettingsBase.get_setting(self, "server_port"))
     server = 'wsgiref'
     run_itty(server, ip, port)
示例#31
0
    def apply_settings(self):
        """
            Called when new configuration settings are available.
       
            Must return tuple of three dictionaries: a dictionary of
            accepted settings, a dictionary of rejected settings,
            and a dictionary of required settings that were not
            found.
        """

        SettingsBase.merge_settings(self)
        accepted, rejected, not_found = SettingsBase.verify_settings(self)
        if len(rejected) or len(not_found):
            self._tracer.error("Settings rejected/not found: %s %s", rejected,
                               not_found)

        SettingsBase.commit_settings(self, accepted)

        return (accepted, rejected, not_found)
示例#32
0
    def __init__(self, core, settings_binding, additional_settings=None):
        """
        Creates a new :class:`AbstractServiceManager` instance.

        `core` must be a reference to the core service manager
        (see :mod:`~src.core.core_services`).

        `settings_binding` must be a valid settings binding tuple.  This
        determines at what point in the settings registry the service
        will locate and receive its settings.  If we wished to create a
        service manager which received its settings in a binding off the
        registry root called "devices" the `settings_binding` would be
        given as a one element tuple ('devices',).

        `additional_settings` is a list of :class:`Setting` objects
        which define additional settings, aside from the implied instance
        list that all :class:`AbstractServiceManager` instances have.
        """
        if additional_settings == None:
            additional_settings = []

        # Core reference:
        self._core = core
        # Maps instance name (str) -> service instance (object)
        self._name_instance_map = {}
        # Maps service name (str) -> service instance (object)
        self._loaded_services = {}

        from core.tracing import get_tracer
        self.__tracer = get_tracer('AbstractServiceManager')

        # Initialize settings infrastructure:
        settings_list = [
            Setting(name='instance_list',
                    type=list,
                    required=False,
                    default_value=[]),
        ]
        settings_list.extend(additional_settings)

        SettingsBase.__init__(self,
                              binding=settings_binding,
                              setting_defs=settings_list)
示例#33
0
    def apply_settings(self):
        """
        Apply new settings on this abstract service manager instance.

        This function is called by the settings sub-system when there are
        new settings available.  This method may be overridden.  The
        default implementation accepts all settings and then calls the
        local private function self._reenumerate_services() in order to
        start new services.  Changes in settings are then committed
        to the settings running registry.
        """
        SettingsBase.merge_settings(self)
        accepted, rejected, not_found = SettingsBase.verify_settings(self)

        self._reenumerate_services()

        SettingsBase.commit_settings(self, accepted)

        return (accepted, rejected, not_found)
    def create_filter_channel(self, source_channel, filter_channel):
        """\
            Required override of the base channel's call of the same name.

            This allows us create/build a custom class to control the filter.

            Keyword arguments:

            source_channel -- the channel we are shadowing

            filter_channel -- the shadow/filter channel
        """
        threshold = SettingsBase.get_setting(self, "threshold")
        readings = SettingsBase.get_setting(self, "readings")
        continuous = SettingsBase.get_setting(self, "continuous")

        return ThresholdBoolAlarm(self._name, self._core, source_channel,
                                  filter_channel, threshold, readings,
                                  continuous)
示例#35
0
 def log_page(self, type, path, headers, args):
     """Prepares the HTML log page.
     """
     refresh_rate = SettingsBase.get_setting(self, 'refresh_rate')
     log = self.format_log()
     my_html = """<HTML><HEAD><TITLE>Gateway Log File</TITLE><META http-equiv="refresh" content="%d">
 <STYLE TYPE="text/css">div.DEBUG{color:C0C0C0}div.INFO{color:0000FF}div.WARNING{color:FFFF00}
 div.ERROR{color:FFA500}div.CRITICAL{color:FF0000}</STYLE></HEAD>
 <BODY><H1>Log Info</H1><P>%s</P></BODY></HTML>""" % (refresh_rate, log)
     return (digiweb.TextHtml, my_html)
示例#36
0
    def get_eoln(self):
        eoln = SettingsBase.get_setting(self, "eoln")
        if eoln is None:
            return None

        if eoln != self.__eoln_save:
            # cache result to avoid repeat processing of escapes
            self.__eoln_save = eoln
            self._eoln = strip_escapes(eoln)
        return self._eoln
示例#37
0
    def next_poll_cycle(self):

        self.__poll_event = None

        manual = SettingsBase.get_setting(self, "manual_trigger")

        for sensor in self.__sensor_list:
            # repeat for each ID tag (or node)
            id = sensor.get_id_tag()

            self._tracer.debug("%s: poll sensor ID tag %d", self.showname, id)

            if manual:
                # then issue the manual software poll
                req = sensor.req_software_trigger_1()

                try:
                    self.write(req)
                    if SHOW_COMM:
                        print "M300: send MANUAL READ, len=%d, " % len(req),
                        for by in req:
                            print '%02X ' % ord(by),
                        print
                    # there is NO response to this poll,
                    #   but we need to wait some delay
                    time.sleep(self.MANUAL_DELAY_SEC)

                except:
                    traceback.print_exc()
                    self._tracer.error("manual poll xmission failure, abort cycle.")
                    break

            # poll the status
            req = sensor.req_status_3()

            if SHOW_COMM:
                print "M300: send STATUS, len=%d, " % len(req),
                for by in req:
                    print '%02X ' % ord(by),
                print

            try:
                self.write(req)
                data = self.read(self.READ_SIZE)
                self.flushInput()
                self.message_indication(sensor, data)

            except:
                traceback.print_exc()
                self._tracer.error("status xmission failure, will retry.")
                break

        self.__schedule_poll_cycle()
        # self.__reschedule_retry_watchdog()
        return
示例#38
0
    def make_request(self):
        self._tracer.calls("XBeeAIO.make_request()")

        will_sleep = SettingsBase.get_setting(self, "sleep")
        sample_rate_ms = SettingsBase.get_setting(self, "sample_rate_ms")

        if not will_sleep:
            try:
                io_sample = self.ddo_get_param('IS')
                self.sample_indication(io_sample, self._extended_address)
            except:
                self._tracer.warning("Xmission failure, will retry.")
                pass

        # Scheduling first request and watchdog heart beat poll,
        # but only if we aren't in sleep mode and .

        if will_sleep != True and sample_rate_ms > 0xffff:
            self.__schedule_request()
            self.__reschedule_retry_watchdog()
示例#39
0
 def __write_dict_to_xml_output(self, data_dict, output_object):
     '''
     Write all the samples in the data_dict to the output_object.
     '''
     compat = SettingsBase.get_setting(self, 'compatibility')
     for name, vals in data_dict.iteritems():
         sample_type = vals[0]
         for sample in vals[1]:
             output_object.write(self.methods[compat](name, sample,
                                                      sample_type))
             output_object.write('\n')
示例#40
0
    def start(self):
        transforms = SettingsBase.get_setting(self, "instance_list")

        for t in transforms:
            try:
                self.tlist.append(Transform(self, self.__core, **t))
            except:
                self.__tracer.error("%s", sys.exc_info()[1])
                self.__tracer.error("Transform was %s", pformat(t))

        return True
示例#41
0
    def apply_settings(self):
        """\
            Called when new configuration settings are available.

            Must return tuple of three dictionaries: a dictionary of
            accepted settings, a dictionary of rejected settings,
            and a dictionary of required settings that were not found.
        """

        self._tracer.calls("DeviceBase.apply_settings()")
        SettingsBase.merge_settings(self)
        accepted, rejected, not_found = SettingsBase.verify_settings(self)

        if len(rejected) or len(not_found):
            # there were problems with settings, terminate early:
            return (accepted, rejected, not_found)

        SettingsBase.commit_settings(self, accepted)

        return (accepted, rejected, not_found)
示例#42
0
    def subscribe_write_channels(self):

        # 'sio' is a file-like object which reads/writes to a string
        # buffer, as seen in StringIO.py.

        cm = self.__core.get_service("channel_manager")
        cp = cm.channel_publisher_get()
        channel0 = SettingsBase.get_setting(self, "channel0")

        cp.subscribe(channel0, self.cb_data_available)
        return
示例#43
0
    def request_info(self):
        """Request cluster info: single byte of 0x00"""
        self.send_to_cluster('\x00', XBEE_GPIO_CLUST_INFO)
        self.__tracer.info("XBeeGPIOClient: Discovery request sent: %s",
                           digitime.time())
        # Schedule a timeout
        self.info_timer = self.schedule_after(
            self.request_info, self.timeout * self.info_timeout_scale)
        if self.info_timeout_scale < 8:
            self.info_timeout_scale = self.info_timeout_scale * 2

        self.poll_secs = SettingsBase.get_setting(self, "poll_rate")
示例#44
0
    def stop(self):
        """Stop listening for messages"""

        if not RCI_NONBLOCKING:
            target_name = SettingsBase.get_setting(self, 'target_name')
            rci.stop_rci_callback(target_name)
        else:
            if self._handle:
                del self._handle
                self._handle = None

        return True
示例#45
0
    def running_indication(self):
        self._tracer.calls("XBeeDIO.running_indication()")

        if not SettingsBase.get_setting(self, "sleep"):
            # Our device is now running, load our initial state.
            # It is okay if we take an Exception here, as the device
            # might have already gone to sleep.
            try:
                io_sample = self.ddo_get_param('IS')
                self.sample_indication(io_sample, self._extended_address)
            except:
                pass
示例#46
0
    def apply_settings(self):
        """\
            Called when new configuration settings are available.

            Must return tuple of three dictionaries: a dictionary of
            accepted settings, a dictionary of rejected settings,
            and a dictionary of required settings that were not
            found.
        """

        SettingsBase.merge_settings(self)
        accepted, rejected, not_found = SettingsBase.verify_settings(self)

        if len(rejected) or len(not_found):
            # there were problems with settings, terminate early:
            self.__tracer.warning("There was an error with the settings. " +
                                  "Attempting to continue.")

        SettingsBase.commit_settings(self, accepted)

        return (accepted, rejected, not_found)
示例#47
0
    def apply_settings(self):
        """\
            Called when new configuration settings are available.

            Must return tuple of three dictionaries: a dictionary of
            accepted settings, a dictionary of rejected settings, and a
            dictionary of required settings that were not found.
        """

        SettingsBase.merge_settings(self)
        accepted, rejected, not_found = SettingsBase.verify_settings(self)

        #if len(rejected) or len(not_found):
        if len(not_found):
            # Ignore extra settings, but reject if required settings are
            # not found
            return (accepted, rejected, not_found)

        SettingsBase.commit_settings(self, accepted)

        return (accepted, rejected, not_found)
示例#48
0
    def _add_filter_channel(self, channel_name, retry=3):
        cm = self._core.get_service("channel_manager")
        cdb = cm.channel_database_get()
        channel = cdb.channel_get(channel_name)

        cm = self._core.get_service("channel_manager")
        cdb = cm.channel_database_get()
        dm = self._core.get_service("device_driver_manager")
        target_device_name = channel.name().split('.')[0]

        # If the user has specified an override name for the channel name
        # that we will make, use it by adding an underscore in front of it.
        channel_name_override = SettingsBase.get_setting(
            self, "channel_name_override")
        if channel_name_override != None and self._name != "":
            filter_channel_name = "_%s" % (channel_name_override)
        # Otherwise, append the name to the filter channel name with an underscore
        else:
            filter_channel_name = "_%s_%s" % (channel.name().split('.')[1],
                                              self._name)

        #check if we already added filter channel
        if cdb.channel_exists("%s.%s" %
                              (target_device_name, filter_channel_name)):
            self._tracer.error("Trying to add duplicate filter channel")
            return

        #find the target device driver
        try:
            target_device = dm.instance_get(target_device_name)
        except ASMInstanceNotFound:
            if retry > 0:
                self._tracer.error(
                    "%s not started, rescheduling filter channel creation, retry %d",
                    target_device_name, retry)
                self._scheduler.schedule_after(30, self._add_filter_channel,
                                               channel_name, retry - 1)
            else:
                self._tracer.error(
                    "%s is not starting, filter channel creation giving up",
                    target_device_name)
            return

        #create the filter property we are going to add
        filter_channel = self.physically_create_filter_channel(
            channel, filter_channel_name)

        target_device.add_property(filter_channel)

        #create the filter channel object and hook up to target channel
        filter_channel_object = self.create_filter_channel(
            channel, filter_channel)
        self._filter_objects.append(filter_channel_object)
示例#49
0
    def _match_filter(self, channel_name):
        filter_string = SettingsBase.get_setting(self, "target_channel_filter")
        device_filter = '*'
        property_filter = '*'
        if filter_string.find('.') != -1:
            (device_filter, property_filter) = filter_string.split('.')

        (device_name, property_name) = channel_name.split('.')
        if (self._match_substrings(device_name, device_filter) and
                self._match_substrings(property_name, property_filter, True)):
            return True
        return False
示例#50
0
    def apply_settings(self):
        """Called when new configuration settings are available.
       
        Must return tuple of three dictionaries: a dictionary of
        accepted settings, a dictionary of rejected settings,
        and a dictionary of required settings that were not
        found.
        """
        SettingsBase.merge_settings(self)
        accepted, rejected, not_found = SettingsBase.verify_settings(self)
        if len(rejected) or len(not_found):
            self.logger.warn(
                "%s(%s): settings rejected/not found: %s/%s" %
                (self.__class__.__name__, self.__name, rejected, not_found))

        SettingsBase.commit_settings(self, accepted)

        new_level_string = SettingsBase.get_setting(self, 'log_level')
        try:
            # The syntax of the setting has already been verified
            new_level = eval('logging.' + new_level_string)
            self.logger.setLevel(new_level)
        except Exception:
            # new_level_string is not an attribube of the logging package
            self.logger.error(
                'Setting change error for log_level: should be DEBUG, ERROR, ...'
            )

        return (accepted, rejected, not_found)
示例#51
0
    def start(self):

        # Verify that the user has a reasonable Device Cloud host set on their device.
        if hasattr(idigi_data, 'get_idigi_values'):
            host, token, path, port, secureport = idigi_data.get_idigi_values()
            if host == None or host == "" or host == " ":
                self.__tracer.error(
                    "Host '%s' is not a valid value. " +
                    "Please check your device and set the Host value " +
                    "appropriately", host)
                raise ValueError("name must be a non-empty string")

        # Start by appending 1 to filename of pushed data
        self.__current_file_number = 1

        # Event to use for notification of meeting the sample threshold
        self.__threshold_event = threading.Event()

        # Count of samples since last data push
        self.__sample_count = 0

        # Here we grab the channel publisher
        channels = SettingsBase.get_setting(self, "channels")
        cm = self.__core.get_service("channel_manager")
        cp = cm.channel_publisher_get()

        # And subscribe to receive notification about new samples
        # as long as sample_threshold is not 0
        sample_threshold = SettingsBase.get_setting(self, "sample_threshold")
        if sample_threshold:
            if len(channels) > 0:
                for channel in channels:
                    cp.subscribe(channel, self.receive)
            else:
                cp.subscribe_to_all(self.receive)

        threading.Thread.start(self)
        self.apply_settings()
        return True
示例#52
0
    def run(self):
        cm = self.__core.get_service("channel_manager")
        cp = cm.channel_publisher_get()
        channel_src = [
            'channel1_source', 'channel2_source', 'channel3_source',
            'channel4_source'
        ]
        src_path = [
            SettingsBase.get_setting(self, channel) for channel in channel_src
        ]

        pos_index = 0

        for ch_name in src_path:
            if ch_name != None:
                channel_to = "channel%d_output" % (pos_index + 1)
                cp.subscribe(ch_name,
                             lambda src_ch, dest_name=channel_to: self.sub_cb(
                                 src_ch, dest_name))
            pos_index += 1

        while 1:
            if self.__stopevent.isSet():
                self.__stopevent.clear()
                break

            current_channel1_input_status = bool(digihw.get_din(IN_PORT))
            # current_temperature = digihw.temperature()
            # current_voltage = digihw.voltage_monitor()

            #While thread is running, set those channels' value concurrently
            # self.property_set("temperature",
            #                   Sample(0, int(current_temperature)))
            # self.property_set("voltage", Sample(0, current_voltage))
            self.property_set("channel1_input",
                              Sample(0, current_channel1_input_status))

            digitime.sleep(
                SettingsBase.get_setting(self, "sample_rate_ms") / 1000)
示例#53
0
    def schedule_request(self):
        """\
            Schedule a request to acquire samples for all our channels.
        """
        # Cancel any/all pending requests.
        self.cancel_all_pending_requests()

        # Request a new event at our poll rate in the future.
        sample_rate_ms = SettingsBase.get_setting(self.__parent, "sample_rate_ms")
        event = self.__xbee_manager.xbee_device_schedule_after(
            sample_rate_ms / 1000, self.make_request)
        if event != None:
            self.__request_events.append(event)
示例#54
0
    def start(self):

        self._logger.info('Start')

        while 1:

            interface = SettingsBase.get_setting(self, 'interface')

            if self.__stopevent.isSet():
                self.__stopevent.clear()
                break
            if on_digi_board() and (not SettingsBase.get_setting(
                    self, "no_digicli")):
                current_ip_address = self._get_ip_address_with_digicli()
            else:
                current_ip_address = self._get_ip_address_with_socket()
            if current_ip_address:
                # we got a valid address
                if current_ip_address != self._published_ip_address:
                    # address has changed => update it
                    self._logger.debug('Got new IP address for interface: %s' %
                                       interface)
                    if self._update_dtdns():
                        self._published_ip_address = current_ip_address
                else:
                    self._logger.debug('IP address unchanged')
                # wait and check for new address change
                digitime.sleep(
                    SettingsBase.get_setting(self, 'address_update_rate'))
            else:
                self._logger.debug('No valid IP address for interface: %s' %
                                   interface)
                # wait and check for new address availability
                digitime.sleep(
                    SettingsBase.get_setting(self,
                                             'check_for_valid_address_rate'))

        self._logger.info('Terminating')
        return True
示例#55
0
    def __reschedule_retry_watchdog(self):
        self.__tracer.debug("__reschedule_retry_watchdog")
        sample_rate_ms = SettingsBase.get_setting(self, "sample_rate_ms")
        try:
            if self.__retry_event:
                self.__xbee_manager.xbee_device_schedule_cancel(
                    self.__retry_event)
        except:
            pass

        self.__retry_event = \
            self.__xbee_manager.xbee_device_schedule_after(
                sample_rate_ms * 1000 * 1.5, self.retry_request)
    def start(self):

        cm = self.__core.get_service("channel_manager")

        # subscribe to all the channels that drive our logic
        cp = cm.channel_publisher_get()
        channel_name = SettingsBase.get_setting(self, 'command_channel')
        self.__logger.info("Subscribing to command channel: %s" % channel_name)
        cp.subscribe(channel_name, self.__new_ecocity_command)

        threading.Thread.start(self)

        return True
    def run(self):
        cm = self.__core.get_service("channel_manager")
        cp = cm.channel_publisher_get()
        cdb = cm.channel_database_get()     

        #threshold = SettingsBase.get_setting(self, 'acc_threshold')
        sample_rate_ms = SettingsBase.get_setting(self, 'sample_rate_ms')

        #self._tracer.info("Threshold set to %.3fG" %threshold)

        if digihw.NB_GPIO != len(channel_type):
                self._tracer.info('Invalid number of channels')

        while 1:
            if self.__stopevent.isSet():
                self.__stopevent.clear()
                break

            # acceleration_value = self.update_accelerometer_info()
            # self.property_set("acceleration", Sample(0, acceleration_value))
            
            for index, ch_type in enumerate(channel_type):
                if ch_type == 'in':
                    current_status = bool(digihw.gpio_get_value(index))
                    digihw.gpio_set_input(index)
                    self.property_set('channel%d_input' %(index+1), \
                        Sample(0, current_status))
                elif ch_type == 'out':
                    status = self.property_get('channel%d_output' %(index+1)).value
                    digihw.gpio_set_value(index, status)

            try:
                self._tracer.info("Reading GPS data.....")
                gps_data = digihw.gps_location()
            
                #Retrieve information from gps_location
                name = ['latitude', 'longitude', 'altitude', 'current_time']
                for index in range(len(name)):
                    self.property_set(name[index], 
                                      Sample(0, value = gps_data[index]))

            except:
                import traceback
                traceback.print_exc()
                self._tracer.info("Unable to get a GPS signal.")
                self._tracer.info("Please place the GPS antenna in another place.")

            status = digihw.ignition_sense()
            self.property_set("ignition_status", Sample(0, status))

            digitime.sleep(sample_rate_ms / 1000)
示例#58
0
    def run(self):
        state = STATE_NOTCONNECTED
        sd = None

        last_write = 0
        while not self.__stopevent.isSet():
            if state == STATE_NOTCONNECTED:
                server = SettingsBase.get_setting(self, "server")
                port = SettingsBase.get_setting(self, "port")
                sd = socket(AF_INET, SOCK_STREAM)
                try:
                    sd.connect((server, port))
                except Exception, e:
                    self.__tracer.error("error connecting to %s:%d: %s", \
                        server, port, str(e))
                    digitime.sleep(RECONNECT_DELAY)
                    continue
                state = STATE_CONNECTED

            interval = SettingsBase.get_setting(self, "interval")
            if state == STATE_CONNECTED \
                   and digitime.real_clock() > last_write + interval:

                sio = StringIO()
                self._write_channels(sio)
                try:
                    sd.sendall(sio.getvalue())
                    last_write = digitime.real_clock()
                except:
                    try:
                        sd.close()
                    except:
                        pass
                    state = STATE_NOTCONNECTED
                    continue
                del (sio)

            digitime.sleep(min(SHUTDOWN_WAIT, interval))
示例#59
0
    def __adjust_sample_rate_sec(self, val=None):

        if val is None:
            # then use existing setting, which shall be string
            val = SettingsBase.get_setting(self, "sample_rate_sec")

        elif isinstance(val, types.IntType):
            # else make int as seconds into string
            val = str(val)

        # else assume is string

        # Parse out the sample rate string, set self.__rate to seconds
        self.__rate = int(parse_time_duration( val, in_type='sec', out_type='sec'))
        #if self.trace_debug_events():
        #    print '%s: import sample rate (%s) as %d sec' % \
        #          (self.showname, val, self.__rate)

        val = SettingsBase.get_setting(self, "sample_rate_sec")
        if val != str(self.__rate):
            # then we changed the value
            try:
                SettingsBase.set_pending_setting(self, \
                        "sample_rate_sec", str(self.__rate))

                # push the new settings into running system
                self.apply_settings()

            except:
                traceback.print_exc()

        if (self.__rate % 60) == 0:
            # then we'll do the 'clean minutes' function
            self.__clean_minutes = 0
        else:
            self.__clean_minutes = None

        return
示例#60
0
    def run(self):
        """run when our device driver thread is started"""

        self.apply_settings()

        addr = SettingsBase.get_setting(self, 'extended_address')
        xbee_manager = SettingsBase.get_setting(self, 'xbee_device_manager')
        dm = self.__core.get_service("device_driver_manager")
        xbee_manager = dm.instance_get(xbee_manager)
        self.__autotap = AutoTapStreamer(xbee_manager, addr)

        while 1:
            if self.__stopevent.isSet():
                self.__stopevent.clear()
                break

            if self.property_get("ready_for_communication").value == 0:
                if self.__autotap.readyForCommunication():
                    vin = self.__autotap.getVIN()
                    supported_parameters = []
                    for pid in self.__autotap.getSupportedParameters():
                        supported_parameters.append(
                            AutoTapStreamer.PID_NAME_MAP[pid])

                    self.property_set("ready_for_communication", Sample(0, 1))
                    self.property_set("vin", Sample(0, vin))
                    self.property_set("supported_parameters",
                                      Sample(0, str(supported_parameters)))

            if self.property_get("ready_for_communication").value == 1:
                for pid in self.__autotap.getSupportedParameters():
                    val = self.__autotap.getParameterValues([pid])
                    pidValue = self.__autotap.\
                               convertValueToReadableFormat(pid, val[pid])
                    self.property_set(PID_NAME_MAP[pid],
                                  Sample(0, PID_TYPE_MAP[pid](pidValue)))

            time.sleep(SettingsBase.get_setting(self, "update_rate"))