def start(self): self._tracer.calls("XBeeXBIB.start()") # init self._xbee_manager and self._extended_address # then register ourself with our Xbee manager XBeeBase.pre_start(self) # Create a callback specification for our device address, endpoint # Digi XBee profile and sample cluster id: self._xbee_manager.register_sample_listener(self, self._extended_address, self.sample_indication) # Configure node sleep behavior: sleep_ms = SettingsBase.get_setting(self, "sleep_ms") awake_time_ms = SettingsBase.get_setting(self, "awake_time_ms") # The original sample rate is used as the sleep rate: xbee_sleep_cfg = self._xbee_manager.get_sleep_block( self._extended_address, sleep=sleep_ms > 0, sleep_rate_ms=sleep_ms, awake_time_ms=awake_time_ms) self._xbee_manager.xbee_device_config_block_add(self, xbee_sleep_cfg) # Create a DDO configuration block for this device: xbee_ddo_cfg = XBeeConfigBlockDDO(self._extended_address) # Configure pins DIO0 .. DIO3 for digital input: for io_pin in ['D0', 'D1', 'D2', 'D3']: xbee_ddo_cfg.add_parameter(io_pin, 3) # Turn off LEDs: for led in LED_IO_MAP: xbee_ddo_cfg.add_parameter(LED_IO_MAP[led], 0) # Assert that all pin pull-ups are enabled: xbee_ddo_cfg.add_parameter('PR', 0x1fff) # Enable I/O line monitoring on pins DIO0 .. DIO3: xbee_ddo_cfg.add_parameter('IC', 0xf) # Register this configuration block with the XBee Device Manager: self._xbee_manager.xbee_device_config_block_add(self, xbee_ddo_cfg) # Handle channels subscribed to output their data to our led # properties: cm = self._core.get_service("channel_manager") cp = cm.channel_publisher_get() for i in range(1, 4): setting_name = "led%d_source" % i channel_name = SettingsBase.get_setting(self, setting_name) if channel_name is not None: cp.subscribe(channel_name, (lambda prop: lambda cn: self.update_property(prop, cn))( "led%d" % i)) # we've no more to config, indicate we're ready to configure. return XBeeBase.start(self)
def start(self): self._tracer.calls("XBeeRPM.start()") # init self._xbee_manager and self._extended_address # register ourself with our Xbee manager # create the self.running_indication callback XBeeBase.pre_start(self) # Create a callback specification for our device address, endpoint # Digi XBee profile and sample cluster id: self._xbee_manager.register_sample_listener(self, self._extended_address, self.sample_indication) # Create a DDO configuration block for this device: xbee_ddo_cfg = XBeeConfigBlockDDO(self._extended_address) # Configure pins DI1 .. DI3 for analog input: for io_pin in ['D1', 'D2', 'D3']: xbee_ddo_cfg.add_parameter(io_pin, 2) # Get the extended address of the device: default_state = SettingsBase.get_setting(self, 'default_state') if default_state != 'same': # Configure pin DI4 for digital output, default state setting: self.prop_set_power_control( Sample(0, str(Boolean(default_state, STYLE_ONOFF)))) else: self.property_set('power_on', Sample(0, UNKNOWN_POWER_STATE)) # Configure the IO Sample Rate: sample_rate = SettingsBase.get_setting(self, 'sample_rate_ms') xbee_ddo_cfg.add_parameter('IR', sample_rate) # new method for mesh health monitoring self.set_data_update_rate_seconds(sample_rate / 1000) # Handle subscribing the devices output to a named channel, # if configured to do so: power_on_source = SettingsBase.get_setting(self, 'power_on_source') if power_on_source is not None: cm = self._core.get_service('channel_manager') cp = cm.channel_publisher_get() cp.subscribe(power_on_source, self.update_power_state) # Register this configuration block with the XBee Device Manager: self._xbee_manager.xbee_device_config_block_add(self, xbee_ddo_cfg) # we've no more to config, indicate we're ready to configure. return XBeeBase.start(self)
def start(self): """Start the device driver. Returns bool.""" self._tracer.calls("XBeeSerial.start()") # init self._xbee_manager and self._extended_address # register ourself with our Xbee manager # create the self.running_indication callback XBeeBase.pre_start(self) self.initialize_xbee_serial() # we've no more to config, indicate we're ready to configure. return XBeeBase.start(self)
def start(self): """Start the device driver. Returns bool.""" self._tracer.calls("XBeeSerial.start()") # init self._xbee_manager and self._extended_address # register ourself with our Xbee manager # create the self.running_indication callback XBeeBase.pre_start(self) self.initialize_xbee_serial() # we've no more to config, indicate we're ready to configure. return XBeeBase.start(self)
def start(self): self._tracer.calls("XBeeXBR.start()") # init self._xbee_manager and self._extended_address # register ourself with our Xbee manager # create the self.running_indication callback XBeeBase.pre_start(self) # Create a callback specification for our device address, endpoint # Digi XBee profile and sample cluster id: self._xbee_manager.register_sample_listener(self, self._extended_address, self._sample_indication) # Create a DDO configuration block for this device: xbee_ddo_cfg = XBeeConfigBlockDDO(self._extended_address) # Configure pins DI1 & DI2 for analog input: for io_pin in ['D1', 'D2']: xbee_ddo_cfg.add_parameter(io_pin, 2) # Register this configuration block with the XBee Device Manager: self._xbee_manager.xbee_device_config_block_add(self, xbee_ddo_cfg) # Configure the IO Sample Rate: sample_rate = SettingsBase.get_setting(self, "sample_rate_ms") # DigiMesh requires at least 'Sleep Compatibility' # this call will also set IR to sample_rate xbee_sleep_cfg = self._xbee_manager.get_sleep_block( self._extended_address, sleep=False, sleep_rate_ms=sample_rate, awake_time_ms=0) self._xbee_manager.xbee_device_config_block_add(self, xbee_sleep_cfg) # we've no more to config, indicate we're ready to configure. return XBeeBase.start(self)
def start(self): self._tracer.calls("XBeeXBR.start()") # init self._xbee_manager and self._extended_address # register ourself with our Xbee manager # create the self.running_indication callback XBeeBase.pre_start(self) # Create a callback specification for our device address, endpoint # Digi XBee profile and sample cluster id: self._xbee_manager.register_sample_listener(self, self._extended_address, self._sample_indication) # Create a DDO configuration block for this device: xbee_ddo_cfg = XBeeConfigBlockDDO(self._extended_address) # Configure pins DI1 & DI2 for analog input: for io_pin in ['D1', 'D2']: xbee_ddo_cfg.add_parameter(io_pin, 2) # Register this configuration block with the XBee Device Manager: self._xbee_manager.xbee_device_config_block_add(self, xbee_ddo_cfg) # Configure the IO Sample Rate: sample_rate = SettingsBase.get_setting(self, "sample_rate_ms") # DigiMesh requires at least 'Sleep Compatibility' # this call will also set IR to sample_rate xbee_sleep_cfg = self._xbee_manager.get_sleep_block( self._extended_address, sleep=False, sleep_rate_ms=sample_rate, awake_time_ms=0) self._xbee_manager.xbee_device_config_block_add(self, xbee_sleep_cfg) # we've no more to config, indicate we're ready to configure. return XBeeBase.start(self)
def start(self): self._tracer.calls("XBeeAIO.start()") # init self._xbee_manager and self._extended_address # then register ourself with our Xbee manager XBeeBase.pre_start(self) # Create a callback specification for our device address, endpoint # Digi XBee profile and sample cluster id: self._xbee_manager.register_sample_listener(self, self._extended_address, self.sample_indication) # XBeeBase.pre_start(self) enables self.running_indication # Create a DDO configuration block for this device: xbee_ddo_cfg = XBeeConfigBlockDDO(self._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, self.CHN_MODE_NAME[io_pin]) mode = AIO_MODE_MAP[mode.lower()] if io_pin % 2 == 1: last_mode = SettingsBase.\ get_setting(self, 'channel%d_mode' % (io_pin)) last_mode = AIO_MODE_MAP[last_mode.lower()] if mode == AIO_MODE_DIFFERENTIAL: if last_mode != AIO_MODE_DIFFERENTIAL: raise ValueError("Differential mode may only "\ "be set on odd channels.") elif last_mode == AIO_MODE_DIFFERENTIAL: # Nothing to do for this paired channel. continue elif mode != AIO_MODE_DIFFERENTIAL and \ last_mode == AIO_MODE_DIFFERENTIAL: raise ValueError("Unable to change mode, paired " \ "channel is configured for "\ "Differential operation.") if mode == AIO_MODE_CURRENTLOOP: xbee_ddo_cfg.add_parameter( AIO_CONTROL_LINES[io_pin][AIO_LINE_A], 4) xbee_ddo_cfg.add_parameter( AIO_CONTROL_LINES[io_pin][AIO_LINE_B], 4) elif mode == AIO_MODE_TENV: xbee_ddo_cfg.add_parameter( AIO_CONTROL_LINES[io_pin][AIO_LINE_A], 5) xbee_ddo_cfg.add_parameter( AIO_CONTROL_LINES[io_pin][AIO_LINE_B], 4) elif mode == AIO_MODE_DIFFERENTIAL: xbee_ddo_cfg.add_parameter( AIO_CONTROL_LINES[io_pin][AIO_LINE_A], 4) xbee_ddo_cfg.add_parameter( AIO_CONTROL_LINES[io_pin][AIO_LINE_B], 5) xbee_ddo_cfg.add_parameter( AIO_CONTROL_LINES[io_pin + 1][AIO_LINE_A], 4) # else: for OFF, do nothing # TODO: in the future when we support changing the settings # for this adapter on the fly we would need to do: #if previous_mode == Differential and new_mode != Differential: # xbee_ddo_cfg.add_paramseter( # (AIO_CONTROL_LINES[io_pin+1][AIO_LINE_A], 5)) # # TODO: Set setting for io_pin+1 to TenV Mode # if adapter is using internal batteries, then configure # battery-monitor pin and add low_battery channel if SettingsBase.get_setting(self, "enable_low_battery"): # configure battery-monitor pin DIO11/P1 for digital input xbee_ddo_cfg.add_parameter('P1', 3) # add low_battery channel self._tracer.info("adapter is using internal batteries... " + "adding low battery channel") self.add_property( ChannelSourceDeviceProperty(name="low_battery", type=bool, initial=Sample(timestamp=0, value=False), perms_mask=DPROP_PERM_GET, \ options=DPROP_OPT_AUTOTIMESTAMP)) else: self._tracer.info("adapter is not using internal batteries.") # disable the triggered low-battery alarm since it causes problems # we see the value every time new values are sent anyway ic = 0 xbee_ddo_cfg.add_parameter('IC', ic) # Assert input pull-ups xbee_ddo_cfg.add_parameter('PR', 0x1fff) # Is the unit meant to sleep or not? will_sleep = SettingsBase.get_setting(self, "sleep") # Configure the IO Sample Rate. # # This gets a little trickier in cases where the unit is NOT # in sleep mode, yet the sampling rate is over a minute. # # (The max value for IR is 64K and is in milliseconds. # This ends up being a tad over a minute. # # So if we are NOT in sleep mode, and our sample rate # is over 1 minute, 5 seconds (64K), we will set IR to 0, # and set up DIA (in the make_request call), to call us back # when our poll rate is about to trigger. # self._xbee_manager.get_sleep_block() manages 'IR' # Enable/disable power output on terminal 6: power = SettingsBase.get_setting(self, "power") if power: xbee_ddo_cfg.add_parameter('p3', 5) else: xbee_ddo_cfg.add_parameter('p3', 4) # Register this configuration block with the XBee Device Manager: self._xbee_manager.xbee_device_config_block_add(self, xbee_ddo_cfg) # Setup the sleep parameters on this device: will_sleep = SettingsBase.get_setting(self, "sleep") sample_predelay = SettingsBase.get_setting(self, "sample_predelay") awake_time_ms = (SettingsBase.get_setting(self, "awake_time_ms") + sample_predelay) # The original sample rate is used as the sleep rate: sleep_rate_ms = SettingsBase.get_setting(self, "sample_rate_ms") xbee_sleep_cfg = self._xbee_manager.get_sleep_block( self._extended_address, sleep=will_sleep, sample_predelay=sample_predelay, awake_time_ms=awake_time_ms, sleep_rate_ms=sleep_rate_ms) self._xbee_manager.xbee_device_config_block_add(self, xbee_sleep_cfg) # we've no more to config, indicate we're ready to configure. return XBeeBase.start(self)
def start(self): """Start the device driver. Returns bool.""" self._tracer.calls('WirelessSensor start') # init self._xbee_manager and self._extended_address # register ourself with our Xbee manager # create the self.running_indication callback XBeeBase.pre_start(self) # Get the extended address of the device: self._addr = (self._extended_address, 0xe8, 0xc105, 0x11) # Retrieve the flag which tells us if we should sleep: # 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( (self._extended_address, 0xe8, 0xc105, 0x11), (True, True, True, True)) self._xbee_manager.xbee_device_event_spec_add(self, xbdm_rx_event_spec) # 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) # Define a Network Sleep block. # This block will NOT send any sleep parameters to the device, # but instead, will provide a hint to the DIA about how long # we expect our device to sleep for. # This is required for long sleeping nodes, as the coordinator # and all routers on the network need to know these values. xbee_sleep_cfg = XBeeConfigNetworkSleep(self._extended_address) sleep_rate = SettingsBase.get_setting(self, self.KEY_SAMPLE_RATE) self._tracer.debug('pushing sleep config for %d seconds', sleep_rate) sleep_rate *= 1000 xbee_sleep_cfg.sleep_cycle_set(1, sleep_rate) self._xbee_manager.xbee_device_config_block_add(self, xbee_sleep_cfg) # see if there are sensor configurations self._tracer.debug('loading configuration changes') #generate configurations as a dictionary of dictionaries, one for global and #one for each serial number as appropriate self.configurations = {} self.addConfiguration( self.parser.KEY_XMIT_PERIOD, SettingsBase.get_setting(self, self.parser.KEY_XMIT_PERIOD)) self.addConfiguration( self.parser.KEY_ALARM_EXIT, SettingsBase.get_setting(self, self.parser.KEY_ALARM_EXIT)) self.addConfiguration( self.parser.KEY_TRIES, SettingsBase.get_setting(self, self.parser.KEY_TRIES)) self.addConfiguration( self.parser.KEY_HYSTERISIS, SettingsBase.get_setting(self, self.parser.KEY_HYSTERISIS)) self.addConfiguration( self.parser.KEY_LOG_PERIOD, SettingsBase.get_setting(self, self.parser.KEY_LOG_PERIOD)) self.addConfiguration( self.parser.KEY_HI_VAL1, SettingsBase.get_setting(self, self.parser.KEY_HI_VAL1)) self.addConfiguration( self.parser.KEY_HI_TIME1, SettingsBase.get_setting(self, self.parser.KEY_HI_TIME1)) self.addConfiguration( self.parser.KEY_LO_VAL1, SettingsBase.get_setting(self, self.parser.KEY_LO_VAL1)) self.addConfiguration( self.parser.KEY_LO_TIME1, SettingsBase.get_setting(self, self.parser.KEY_LO_TIME1)) self.addConfiguration( self.parser.KEY_HI_VAL2, SettingsBase.get_setting(self, self.parser.KEY_HI_VAL2)) self.addConfiguration( self.parser.KEY_HI_TIME2, SettingsBase.get_setting(self, self.parser.KEY_HI_TIME2)) self.addConfiguration( self.parser.KEY_LO_VAL2, SettingsBase.get_setting(self, self.parser.KEY_LO_VAL2)) self.addConfiguration( self.parser.KEY_LO_TIME2, SettingsBase.get_setting(self, self.parser.KEY_LO_TIME2)) # Indicate that we have no more configuration to add: self._tracer.debug('completing configuration') # we've no more to config, indicate we're ready to configure. return XBeeBase.start(self)
def start(self): self._tracer.calls("XBeeXBIB.start()") # init self._xbee_manager and self._extended_address # then register ourself with our Xbee manager XBeeBase.pre_start(self) # Create a callback specification for our device address, endpoint # Digi XBee profile and sample cluster id: self._xbee_manager.register_sample_listener(self, self._extended_address, self.sample_indication) # Configure node sleep behavior: sleep_ms = SettingsBase.get_setting(self, "sleep_ms") awake_time_ms = SettingsBase.get_setting(self, "awake_time_ms") # The original sample rate is used as the sleep rate: xbee_sleep_cfg = self._xbee_manager.get_sleep_block( self._extended_address, sleep=sleep_ms > 0, sleep_rate_ms=sleep_ms, awake_time_ms=awake_time_ms) self._xbee_manager.xbee_device_config_block_add(self, xbee_sleep_cfg) # Create a DDO configuration block for this device: xbee_ddo_cfg = XBeeConfigBlockDDO(self._extended_address) # Configure pins DIO0 .. DIO3 for digital input: for io_pin in ['D0', 'D1', 'D2', 'D3']: xbee_ddo_cfg.add_parameter(io_pin, 3) # Turn off LEDs: for led in LED_IO_MAP: xbee_ddo_cfg.add_parameter(LED_IO_MAP[led], 0) # Assert that all pin pull-ups are enabled: xbee_ddo_cfg.add_parameter('PR', 0x1fff) # Enable I/O line monitoring on pins DIO0 .. DIO3: xbee_ddo_cfg.add_parameter('IC', 0xf) # Register this configuration block with the XBee Device Manager: self._xbee_manager.xbee_device_config_block_add(self, xbee_ddo_cfg) # Handle channels subscribed to output their data to our led # properties: cm = self._core.get_service("channel_manager") cp = cm.channel_publisher_get() for i in range(1, 4): setting_name = "led%d_source" % i channel_name = SettingsBase.get_setting(self, setting_name) if channel_name is not None: cp.subscribe( channel_name, (lambda prop: lambda cn: self.update_property(prop, cn))( "led%d" % i)) # we've no more to config, indicate we're ready to configure. return XBeeBase.start(self)
def start(self): self._tracer.calls("XBeeDIO.start()") # init self._xbee_manager and self._extended_address # then register ourself with our Xbee manager XBeeBase.pre_start(self) cm = self._core.get_service("channel_manager") cp = cm.channel_publisher_get() self._xbee_manager.register_sample_listener(self, self._extended_address, self.sample_indication) # XbeeBase enables self.running_indication # Create a DDO configuration block for this device: xbee_ddo_cfg = XBeeConfigBlockDDO(self._extended_address) # Configure pins DIO0 .. DIO3 for digital input: pr = 0xe1 # DIO0-3 pullups off, all else on ic = 0 for io_pin in range(4): dir = SettingsBase.get_setting(self, 'channel%d_dir' % \ (io_pin + 1)) dir = dir.lower() # Enable input on all pins: xbee_ddo_cfg.add_parameter(CONTROL_LINES[io_pin][IN], 3) # Build our change detection mask for all io pins: ic |= 1 << INPUT_CHANNEL_TO_PIN[io_pin] if dir == 'in': # Disable sinking driver output: xbee_ddo_cfg.add_parameter(CONTROL_LINES[io_pin][OUT], 4) elif dir == 'out': # Create the output channel for this IO pin: self.add_property( ChannelSourceDeviceProperty( name=self.CHN_OUTPUT_NAME[io_pin], type=Boolean, initial=Sample(timestamp=0, value=Boolean(False), unit='bool'), perms_mask=(DPROP_PERM_GET | DPROP_PERM_SET), options=DPROP_OPT_AUTOTIMESTAMP, set_cb=lambda sample, io=io_pin: \ self.set_output(sample, io))) # If set, subscribe to the channel that drives our # output logic: source = SettingsBase.get_setting(self, 'channel%d_source' % (io_pin + 1)) if len(source): cp.subscribe(source, lambda chan, io=io_pin: \ self.update(chan, io)) self._tracer.debug("Linking DOUT %d to channel %s", io_pin+1, source) # If not set, attempt to grab the default output setting, # and use that instead. else: out = SettingsBase.get_setting(self, 'channel%d_default' % (io_pin + 1)) if out == True: self._tracer.debug("Setting default output to High") xbee_ddo_cfg.add_parameter(CONTROL_LINES[io_pin][OUT], 5) elif out == False: self._tracer.debug("Setting default output to Low") xbee_ddo_cfg.add_parameter(CONTROL_LINES[io_pin][OUT], 4) else: self._tracer.debug("Not setting default output value") # if adapter is using internal batteries, then configure # battery-monitor pin and add low_battery channel if SettingsBase.get_setting(self, "enable_low_battery"): # configure battery-monitor pin DIO11/P1 for digital input xbee_ddo_cfg.add_parameter('P1', 3) # add low_battery channel self._tracer.debug("Adapter is using internal batteries... " + "adding low_battery channel") self.add_property( ChannelSourceDeviceProperty(name="low_battery", type=bool, initial=Sample(timestamp=0, value=False), perms_mask=DPROP_PERM_GET, options=DPROP_OPT_AUTOTIMESTAMP)) else: self._tracer.debug("Adapter is not using internal batteries.") # 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) # Assert input pull-ups xbee_ddo_cfg.add_parameter('PR', 0x1fff) # self._xbee_manager.get_sleep_block() manages 'IR' # Enable/disable power output on terminal 6: power = SettingsBase.get_setting(self, "power") if power: xbee_ddo_cfg.add_parameter('p3', 5) else: xbee_ddo_cfg.add_parameter('p3', 4) # Register this configuration block with the XBee Device Manager: self._xbee_manager.xbee_device_config_block_add(self, xbee_ddo_cfg) # Setup the sleep parameters on this device: will_sleep = SettingsBase.get_setting(self, "sleep") sample_predelay = SettingsBase.get_setting(self, "sample_predelay") awake_time_ms = (SettingsBase.get_setting(self, "awake_time_ms") + sample_predelay) # The original sample rate is used as the sleep rate: sleep_rate_ms = SettingsBase.get_setting(self, "sample_rate_ms") if sleep_rate_ms == 0 and will_sleep: # bounding sleep rate in when sampling is disabled and # sleeping is enabled sleep_rate_ms = CYCLIC_SLEEP_MIN_MS xbee_sleep_cfg = self._xbee_manager.get_sleep_block(\ self._extended_address, sleep=will_sleep, sample_predelay=sample_predelay, awake_time_ms=awake_time_ms, sleep_rate_ms=sleep_rate_ms) self._xbee_manager.xbee_device_config_block_add(self, xbee_sleep_cfg) self._xbee_manager.xbee_device_configure(self) return True
def start(self): self._tracer.calls("XBeeSensor.start()") # init self._xbee_manager and self._extended_address # register ourself with our Xbee manager # create the self.running_indication callback XBeeBase.pre_start(self) # Retrieve the flag which tells us if we should sleep: # Create a callback specification for our device address self._xbee_manager.register_sample_listener(self, self._extended_address, self.sample_indication) # Create a DDO configuration block for this device: xbee_ddo_cfg = XBeeConfigBlockDDO(self._extended_address) # Configure pins DI1 .. DI3 for analog input: for io_pin in ['D1', 'D2', 'D3']: xbee_ddo_cfg.add_parameter(io_pin, 2) # Configure battery-monitor pin DIO11/P1 for digital input: xbee_ddo_cfg.add_parameter('P1', 3) # 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', 0x800) if SettingsBase.get_setting(self, "humidity_present"): # Get gateway module_id, universal to all nodes on the network: gw_dd = self._xbee_manager.xbee_device_ddo_get_param( None, 'DD', use_cache=True) module_id, product_id = parse_dd(gw_dd) # Re-program DD value to set sensor type to /L/T/H: device_dd = format_dd(module_id, PROD_DIGI_XB_SENSOR_LTH) xbee_ddo_cfg.add_parameter('DD', device_dd) # Configure the IO Sample Rate: # Clip sample_rate_ms to the max value of IR: sample_rate_ms = SettingsBase.get_setting(self, "sample_rate_ms") sample_rate_ms = min(sample_rate_ms, 0xffff) xbee_ddo_cfg.add_parameter('IR', sample_rate_ms) # Register this configuration block with the XBee Device Manager: self._xbee_manager.xbee_device_config_block_add(self, xbee_ddo_cfg) # Setup the sleep parameters on this device: will_sleep = SettingsBase.get_setting(self, "sleep") sample_predelay = SettingsBase.get_setting(self, "sample_predelay") awake_time_ms = (SettingsBase.get_setting(self, "awake_time_ms") + sample_predelay) if will_sleep: # Sample time pre-delay, allow the circuitry to power up and # settle before we allow the XBee to send us a sample: xbee_ddo_wh_block = XBeeConfigBlockDDO(self._extended_address) xbee_ddo_wh_block.apply_only_to_modules(( MOD_XB_ZB, MOD_XB_S2C_ZB, )) xbee_ddo_wh_block.add_parameter('WH', sample_predelay) self._xbee_manager.xbee_device_config_block_add( self, xbee_ddo_wh_block) # The original sample rate is used as the sleep rate: sleep_rate_ms = SettingsBase.get_setting(self, "sample_rate_ms") # new method for mesh health monitoring self.set_data_update_rate_seconds(sleep_rate_ms / 1000) # not including sample_predelay here... specially configured above xbee_sleep_cfg = self._xbee_manager.get_sleep_block( self._extended_address, sleep=will_sleep, sleep_rate_ms=sleep_rate_ms, awake_time_ms=awake_time_ms) self._xbee_manager.xbee_device_config_block_add(self, xbee_sleep_cfg) # we've no more to config, indicate we're ready to configure. return XBeeBase.start(self)