def run(self): while 1: if self.__stopevent.isSet(): self.__stopevent.clear() break try: device_stats = query_state("device_stats") for stat in [ 'uptime', 'cpu', 'freemem', 'usedmem', 'totalmem' ]: for item in device_stats: data = item.find(stat) if data != None: data = data.text break else: continue if stat == 'uptime': self.property_set( "uptime", Sample(0, int(float(data)), unit="sec")) elif stat == 'cpu': self.property_set("cpu_utilization", Sample(0, int(data), unit="%")) elif stat == 'freemem': self.property_set("free_memory", Sample(0, int(data), unit="bytes")) elif stat == 'usedmem': self.property_set("used_memory", Sample(0, int(data), unit="bytes")) elif stat == 'totalmem': self.property_set("total_memory", Sample(0, int(data), unit="bytes")) except Exception, e: self.__tracer.error("Unable to update stat: %s", str(e)) digitime.sleep(SettingsBase.get_setting(self, "update_rate"))
def run(self): while 1: if self.__stopevent.isSet(): self.__stopevent.clear() break try: device_stats = query_state("device_stats") for stat in ['uptime', 'cpu', 'freemem', 'usedmem', 'totalmem']: for item in device_stats: data = item.find(stat) if data != None: data = data.text break else: continue if stat == 'uptime': self.property_set("uptime", Sample(0, int(data), unit="sec")) elif stat == 'cpu': self.property_set("cpu_utilization", Sample(0, int(data), unit="%")) elif stat == 'freemem': self.property_set("free_memory", Sample(0, int(data), unit="bytes")) elif stat == 'usedmem': self.property_set("used_memory", Sample(0, int(data), unit="bytes")) elif stat == 'totalmem': self.property_set("total_memory", Sample(0, int(data), unit="bytes")) except Exception, e: self.__tracer.error("Unable to update stat: %s", str(e)) time.sleep(SettingsBase.get_setting(self,"update_rate"))
def start(self): """Start the device driver. Returns bool.""" # Attempt to detect if we are on older units that require a different # algorithm for determine calibration. try: device_info = query_state("device_info") for item in device_info: hardware_strapping = item.find('hardwarestrapping') if hardware_strapping != None: hardware_strapping = hardware_strapping.text break else: hardware_strapping = '' if hardware_strapping == self.OLD_HARDWARE_STRAPPING_A or hardware_strapping == self.OLD_HARDWARE_STRAPPING_B: self.__tracer.info("Old hardware detected. " + "Turning on old support flag.") self.__OLD_HARDWARE = True except: pass # Grab the calibration rate setting, and store it self.__calibration_interval = SettingsBase.get_setting(self.__parent, "calibration_rate_ms") self.__calibration_interval /= 1000.0 # Force a calibration the first time getting samples. self.__calibration_time = -self.__calibration_interval # Fetch the XBee Manager name from the Settings Manager: xbee_manager_name = SettingsBase.get_setting(self.__parent, "xbee_device_manager") dm = self.__core.get_service("device_driver_manager") self.__xbee_manager = dm.instance_get(xbee_manager_name) # Walk through the channels, allocating required channel types # and creating each channels respective channel properties. for channel in self.__aio_channels: channel_name = "channel%d" % (channel + 1) mode = SettingsBase.get_setting(self.__parent, 'channel%d_mode' % (channel + 1)) aio_chan = XBeeLocalAIO(channel_name, self, channel, mode.lower()) self.__aio_channel_structures.append(aio_chan) for channel in self.__dio_channels: channel_name = "channel%d" % (channel + 1) direction = SettingsBase.get_setting(self.__parent, 'channel%d_dir' % (channel + 1)) direction = direction.lower() source = SettingsBase.get_setting(self.__parent, 'channel%d_source' % (channel + 1)) source = source.lower() dio_chan = XBeeLocalDIO(channel_name, self, channel, direction.lower(), source) self.__dio_channel_structures.append(dio_chan) # Register ourselves with the XBee Device Manager instance: self.__xbee_manager.xbee_device_register(self) # 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) # Create a callback specification for our device address, endpoint # Digi XBee profile and sample cluster id: xbdm_rx_event_spec = XBeeDeviceManagerRxEventSpec() xbdm_rx_event_spec.cb_set(self.sample_indication) # xbdm_rx_event_spec.match_spec_set((None, xbdm_rx_event_spec.match_spec_set((gw_extended_address(), 0xe8, 0xc105, 0x92), (True, True, True, True)) self.__xbee_manager.xbee_device_event_spec_add(self, xbdm_rx_event_spec) # Create a DDO configuration block for this device. # None indicates that we will be using the local radio. xbee_ddo_cfg = XBeeConfigBlockDDO(None) # Get the gateway's extended address: gw_xbee_sh, gw_xbee_sl = gw_extended_address_tuple() # Set the destination for I/O samples to be the gateway: xbee_ddo_cfg.add_parameter('DH', gw_xbee_sh) xbee_ddo_cfg.add_parameter('DL', gw_xbee_sl) # For the X3, aux power can be turned on/off. # For all other platforms, it is always on, and cannot be turned off. if get_platform_name() == 'digix3': power = SettingsBase.get_setting(self.__parent, "power") if power == Boolean(True, style = STYLE_ONOFF): xbee_ddo_cfg.add_parameter('d4', 5) elif power == Boolean(False, style=STYLE_ONOFF): xbee_ddo_cfg.add_parameter('d4', 4) # Call each channels start function to configure itself and start. # It will append any needed DDO commands to the 'xbee_ddo_cfg' block # we pass in. for channel in self.__aio_channel_structures: channel.start(xbee_ddo_cfg) for channel in self.__dio_channel_structures: channel.start(xbee_ddo_cfg) # Walk the digital channels again, if any are set to input, # we need to have the pin monitored. ic = 0 for channel in self.__dio_channel_structures: if channel.mode() == "in": ic |= 1 << channel.channel() # Enable I/O line monitoring on pins DIO0 .. DIO3 & # enable change detection on DIO11: # # 0x 8 0 0 # 1000 0000 0000 (b) # DDDD DDDD DDDD # IIII IIII IIII # OOOO OOOO OOOO # 1198 7654 3210 # 10 # xbee_ddo_cfg.add_parameter('IC', ic) # Disable any periodic I/O sampling: xbee_ddo_cfg.add_parameter('IR', 0) # 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
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) # Attempt to detect if we are on older units that require a different # algorithm for determine calibration. try: device_info = query_state("device_info") for item in device_info: hardware_strapping = item.find('hardwarestrapping') if hardware_strapping != None: hardware_strapping = hardware_strapping.text break else: hardware_strapping = '' if hardware_strapping == self.LOCAL_AIO_R1_STRAPPING_A or hardware_strapping == self.LOCAL_AIO_R1_STRAPPING_B: self.__tracer.info("Old hardware detected. Turning on old support flag.") self.__OLD_HARDWARE = True except: pass # Register ourselves with the XBee Device Manager instance: self.__xbee_manager.xbee_device_register(self) # 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) extended_address = None # Create a DDO configuration block for this device: xbee_ddo_cfg = XBeeConfigBlockDDO(extended_address) for io_pin in range(4): # I/O pin for analog input: xbee_ddo_cfg.add_parameter('D%d' % (io_pin), 2) mode = SettingsBase.get_setting(self, 'channel%d_mode' % (io_pin+1) ) mode = self.LOCAL_AIO_MODE_MAP[mode.lower()] if mode == self.LOCAL_AIO_MODE_CURRENTLOOP: digihw.configure_channel(io_pin, 1) xbee_ddo_cfg.add_parameter(self.LOCAL_AIO_CONTROL_LINES[io_pin], 2) elif mode == self.LOCAL_AIO_MODE_TENV: digihw.configure_channel(io_pin, 2) xbee_ddo_cfg.add_parameter(self.LOCAL_AIO_CONTROL_LINES[io_pin], 2) # 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
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) # Attempt to detect if we are on older units that require a different # algorithm for determine calibration. try: device_info = query_state("device_info") for item in device_info: hardware_strapping = item.find('hardwarestrapping') if hardware_strapping != None: hardware_strapping = hardware_strapping.text break else: hardware_strapping = '' if hardware_strapping == self.LOCAL_AIO_R1_STRAPPING_A or hardware_strapping == self.LOCAL_AIO_R1_STRAPPING_B: self.__tracer.info( "Old hardware detected. Turning on old support flag.") self.__OLD_HARDWARE = True except: pass # Register ourselves with the XBee Device Manager instance: self.__xbee_manager.xbee_device_register(self) # 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) extended_address = None # Create a DDO configuration block for this device: xbee_ddo_cfg = XBeeConfigBlockDDO(extended_address) for io_pin in range(4): # I/O pin for analog input: xbee_ddo_cfg.add_parameter('D%d' % (io_pin), 2) mode = SettingsBase.get_setting(self, 'channel%d_mode' % (io_pin + 1)) mode = self.LOCAL_AIO_MODE_MAP[mode.lower()] if mode == self.LOCAL_AIO_MODE_CURRENTLOOP: digihw.configure_channel(io_pin, 1) xbee_ddo_cfg.add_parameter( self.LOCAL_AIO_CONTROL_LINES[io_pin], 2) elif mode == self.LOCAL_AIO_MODE_TENV: digihw.configure_channel(io_pin, 2) xbee_ddo_cfg.add_parameter( self.LOCAL_AIO_CONTROL_LINES[io_pin], 2) # 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