def __init__(self, name, core_services): self.__name = name self.__core = core_services self._logger = init_module_logger(name) ## Local State Variables: self.__lora_manager = None self._extended_address_setting = None # Settings # # xbee_device_manager: must be set to the name of an XBeeDeviceManager # instance. # extended_address: the extended address of the XBee Sensor device you # would like to monitor. # # Advanced settings: # # None settings_list = [ Setting( name='lora_device_manager', type=str, required=True), Setting( name='extended_address', type=str, required=True), Setting( name='log_level', type=str, required=False, default_value='DEBUG', verify_function=check_debug_level_setting), ] ## Channel Properties Definition: property_list = [ # getable properties ChannelSourceDeviceProperty(name='software_version', type=str, initial=Sample(timestamp=digitime.time(), value=VERSION_NUMBER), perms_mask= DPROP_PERM_GET, options=DPROP_OPT_AUTOTIMESTAMP), # setable properties ChannelSourceDeviceProperty(name='simulate_xbee_frame', type=str, initial=Sample(timestamp=0, value=''), perms_mask= DPROP_PERM_SET, options=DPROP_OPT_AUTOTIMESTAMP, set_cb=self._simulate_xbee_frame_cb), ChannelSourceDeviceProperty(name='command', type=str, initial=Sample(timestamp=0, value=''), perms_mask= DPROP_PERM_SET, options=DPROP_OPT_AUTOTIMESTAMP, set_cb=self._send_command_to_sensor_cb), ] ## Initialize the DeviceBase interface: DeviceBase.__init__(self, self.__name, self.__core, settings_list, property_list)
def __init__(self, name, core_services): ## Initialize and declare class variables self.__name = name self.__core = core_services self.__logger = init_module_logger(name) ## Settings Table Definition: settings_list = [ Setting(name='baudrate', type=int, required=False, default_value=38400, verify_function=lambda x: x > 0), Setting(name='port', type=str, required=False, default_value='11'), Setting(name='mainloop_serial_read_timeout', type=int, required=False, default_value=30), Setting(name='log_level', type=str, required=False, default_value='DEBUG', verify_function=check_debug_level_setting), ] ## Channel Properties Definition: property_list = [ ChannelSourceDeviceProperty(name='software_version', type=str, initial=Sample( timestamp=digitime.time(), value=VERSION_NUMBER), perms_mask=DPROP_PERM_GET, options=DPROP_OPT_AUTOTIMESTAMP), ChannelSourceDeviceProperty(name="LoRaPlugAndSenseFrame", type=str, initial=Sample(timestamp=0, value=''), perms_mask=DPROP_PERM_GET, options=DPROP_OPT_AUTOTIMESTAMP), ] ## Initialize the DeviceBase interface: DeviceBase.__init__(self, self.__name, self.__core, settings_list, property_list) ## Thread initialization: self.__stopevent = threading.Event() threading.Thread.__init__(self, name=name) threading.Thread.setDaemon(self, True)
def __init__(self, name, core_services): self.__name = name self.__core = core_services self.__logger = init_module_logger(name) ## Settings Table Definition: settings_list = [ Setting(name='log_level', type=str, required=False, default_value='DEBUG', verify_function=check_debug_level_setting), ] ## Channel Properties Definition: property_list = [ # gettable properties ChannelSourceDeviceProperty(name="raw_out", type=str, initial=Sample(timestamp=0, value=""), perms_mask=DPROP_PERM_GET, options=DPROP_OPT_AUTOTIMESTAMP), # settable properties ChannelSourceDeviceProperty(name="raw_in", type=str, initial=Sample( timestamp=0, value='__INITIAL_SAMPLE__'), perms_mask=DPROP_PERM_SET, set_cb=self.__prop_set_raw_in), ChannelSourceDeviceProperty(name='software_version', type=str, initial=Sample(timestamp=0, value=_VERSION_NUMBER), perms_mask=DPROP_PERM_GET, options=DPROP_OPT_AUTOTIMESTAMP), ] ## Initialize the DeviceBase interface: DeviceBase.__init__(self, self.__name, self.__core, settings_list, property_list) ## Thread initialization: self.__stopevent = threading.Event() threading.Thread.__init__(self, name=name) threading.Thread.setDaemon(self, True)
def __init__(self, name, core_services): settings_list = [ Setting(name='debug_sleep_time', type=int, required=False, default_value=50, verify_function=lambda x: 10 <= x <= 14400000), Setting(name='debug_wake_time', type=int, required=False, default_value=20000, verify_function=lambda x: 69 <= x <= 3600000), ] property_list = [ ChannelSourceDeviceProperty(name='debug_mode', 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=self.__handle_debug), ] # network debug mode flag self.__debug = False self.__debug_lock = threading.RLock() DigiMeshDeviceManager.__init__(self, name, core_services, settings_list, property_list)
def _send_data_to_dia_channel(self, frame, addr): self._last_timestamp = digitime.time() io_sample=parser(decode_waspmote_frame(frame)) self._logger.debug ('Found following information: %s' % str(io_sample)) # route each information to its corresponding channel for key in io_sample.keys(): if libelium_to_dia_map.has_key(key): channel_name, type_name, channel_unit = libelium_to_dia_map[key] else: # add this key to existing map for next loop # use default values => # ... the new channel has the information name channel_name = libelium_key_to_dia_channel_name (key) # ... type will be default type_name = str # ... unit will be none channel_unit = '' # extend the map (initialized in utils) with this new key libelium_to_dia_map[key] = (channel_name, type_name, channel_unit) #verify the type of the value if type_name=='float': sample_value=Convert_Str_Float(io_sample[key]) elif type_name=='int': sample_value=Convert_Str_Integer(io_sample[key]) else: sample_value=io_sample[key] sample = Sample(self._last_timestamp, sample_value, channel_unit) #verify if the channel already exists. I not, create it. if not self.property_exists(channel_name): # create the new channel self.add_property( ChannelSourceDeviceProperty(channel_name, type=type(sample_value), initial=sample, perms_mask=DPROP_PERM_GET, options=DPROP_OPT_AUTOTIMESTAMP)) self._logger.info ("Created channel \"%s\" for key \"%s\"" % (channel_name, key)) # send the new sample self._logger.debug ('Put %s data to dia channel: %s' % (key, channel_name)) self.property_set(channel_name, sample)
def physically_create_filter_channel(self, original_channel, filter_channel_name): #create the filter property we are going to add # perm_mask draws the refresh setting from the channel we are following. # If it is refreshable, then our channel will be refreshable as well. is_refreshable = bool(original_channel.perm_mask() & DPROP_PERM_REFRESH) if is_refreshable: perms_mask = DPROP_PERM_GET | DPROP_PERM_SET | DPROP_PERM_REFRESH else: perms_mask = DPROP_PERM_GET | DPROP_PERM_SET filter_channel = ChannelSourceDeviceProperty( name=filter_channel_name, type=original_channel.type(), initial=Sample(timestamp=0, value=original_channel.type()()), perms_mask=perms_mask, refresh_cb=self._refresh, options=DPROP_OPT_AUTOTIMESTAMP) return filter_channel
def physically_create_filter_channel(self, original_channel, filter_channel_name): """\ Optional override of the base channel's call of the same name. This allows us to create a new channel, and define its type, based on whatever type we desire it to be. Keyword arguments: original_channel -- the shadowed channel filter_channel_name -- the name of the channel we should create """ filter_channel = ChannelSourceDeviceProperty( name=filter_channel_name, type=bool, initial=Sample(timestamp=0, value=bool()), perms_mask=DPROP_PERM_GET | DPROP_PERM_SET, options=DPROP_OPT_AUTOTIMESTAMP) return filter_channel
def __init__(self, name, core_services): ## Initialize and declare class variables self.__name = name self.__core = core_services self.__cm = self.__core.get_service("channel_manager") self.__cp = self.__cm.channel_publisher_get() self.__cdb = self.__cm.channel_database_get() self._ec_key_to_dia_command_channel_name_cache = {} self._logger = init_module_logger(name) self._subscribed_channels = [] self._ec_access_point_pub_key_setting = None self._dia_module_name_to_ec_device_public_key_setting_map = None self._sensor_channel_list_to_subscribe_to_setting = None self._incoming_command_channel_setting = None # semaphores and synchronization variables self._receive_sensor_data_callback_lock = threading.Lock() # will be appended to a DIA module name to get the name of the # channel to be used to send received commands self._sensor_channel_name_where_to_forward_commands = "command" settings_list = [ Setting(name='ec_access_point_pub_key', type=str, required=False), Setting(name='channels', type=list, required=True, default_value=[]), Setting(name='exclude', type=list, required=False, default_value=[]), Setting(name='dia_channel_to_ec_sensor', type=dict, required=False, default_value={}), Setting(name='dia_module_to_ec_pub_key', type=dict, required=False, default_value={}), Setting(name='incoming_command_channel', type=str, required=False, default_value=''), Setting(name='log_level', type=str, required=False, default_value='DEBUG', verify_function=check_debug_level_setting), ] # Channel Properties Definition: property_list = [ # properties ChannelSourceDeviceProperty(name='json_data', type=str, initial=Sample(timestamp=digitime.time(), value=""), perms_mask= DPROP_PERM_GET, options=DPROP_OPT_AUTOTIMESTAMP), ChannelSourceDeviceProperty(name='software_version', type=str, initial=Sample(timestamp=digitime.time(), value=VERSION_NUMBER), perms_mask= DPROP_PERM_GET, options=DPROP_OPT_AUTOTIMESTAMP), ] ## Initialize the DeviceBase interface: DeviceBase.__init__(self, self.__name, self.__core, settings_list, property_list) self.__stopevent = threading.Event() threading.Thread.__init__(self, name=name) threading.Thread.setDaemon(self, True)
def __init__(self, name, core_services, settings_list=None, property_list=None): if settings_list == None: settings_list = [] if property_list == None: property_list = [] # over-ride base-class defaults - YML still over-rides these over-rides # digimesh requires DH/DL to match the coordinator self.DH_DL_FORCE_DEFAULT = 'coordinator' # this is in minutes - default to once every 3 hours/180 minutes self.DH_DL_REFRESH_DEFAULT = 180 # existing default of 00:00:00:00:00:00:FF:FF! is okay for DigiMesh # self.MESH_BROADCAST settings_list.extend([ Setting(name='sleep_time', type=int, required=False, default_value=self.DMMAN_DEF_SLEEP_TIME, verify_function=lambda x: (x == 0) or (10 <= x <= 14400000)), Setting(name='wake_time', type=int, required=False, default_value=self.DMMAN_DEF_WAKE_TIME, verify_function=lambda x: 69 <= x <= 3600000), # if True try setting IR/IF as required otherwise leave alone # and assume the user has managed all of this Setting(name='set_if', type=bool, required=False, default_value=self.DMMAN_DEF_SET_IF), ]) property_list.extend([ ChannelSourceDeviceProperty(name='wake_time', type=int, initial=Sample(timestamp=0, value=-1, unit='ms'), perms_mask=DPROP_PERM_GET, options=DPROP_OPT_AUTOTIMESTAMP), ChannelSourceDeviceProperty(name='sleep_time', type=int, initial=Sample(timestamp=0, value=-1, unit='ms'), perms_mask=DPROP_PERM_GET, options=DPROP_OPT_AUTOTIMESTAMP), ]) XBeeDeviceManager.__init__(self, name, core_services, settings_list, property_list) # will be initialized during run() startup self.__dh_dl_refresh_sec = self.DH_DL_REFRESH_NOT_SET self.listener = SleepChecker(self)