def __init__(self, name, core_services): """\ Standard __init__ function. """ ## Settings Table Definition: settings_list = [ Setting(name='threshold', type=bool, required=True, verify_function=self.__verify_threshold), Setting(name='readings', type=int, required=False, default_value=1, verify_function=self.__verify_readings), Setting(name='continuous', type=bool, required=False, default_value=False, verify_function=self.__verify_continuous), ] ## Channel Properties Definition: property_list = [] ## Initialize the DeviceBase interface: FilterChannelFactoryBase.__init__(self, name, core_services, settings_list, property_list)
def __init__(self, name, core, settings, properties): self._name = name self._core = core self._scheduler = self._core.get_service("scheduler") self._tracer = get_tracer(name) self._filter_channel_object = None self._filter_objects = [] ## Settings Table Definition: settings_list = [ Setting(name='target_channel_filter', type=str, required=False, default_value='*.*'), Setting(name='channel_name_override', type=str, required=False, default_value=""), ] settings.extend(settings_list) property_list = [] properties.extend(property_list) ## Initialize the ServiceBase interface: DeviceBase.__init__(self, self._name, self._core, settings, properties)
def __init__(self, name, core_services): self.__name = name self.__core = core_services ## Settings Table Definition: settings_list = [ Setting( name='count_init', type=int, required=False, default_value=0, verify_function=lambda x: x >= 0), Setting( name='update_rate', type=float, required=False, default_value=1.0, verify_function=lambda x: x > 0.0), ] ## Channel Properties Definition: property_list = [ # gettable properties ChannelSourceDeviceProperty(name="counter", type=int, initial=Sample(timestamp=0, value=0), perms_mask=DPROP_PERM_GET|DPROP_PERM_REFRESH, options=DPROP_OPT_AUTOTIMESTAMP, refresh_cb = self.refresh_counter), ChannelSourceDeviceProperty(name="adder_total", type=float, initial=Sample(timestamp=0, value=0.0), perms_mask=DPROP_PERM_GET, options=DPROP_OPT_AUTOTIMESTAMP), # settable properties ChannelSourceDeviceProperty(name="counter_reset", type=int, perms_mask=DPROP_PERM_SET, set_cb=self.prop_set_counter_reset), ChannelSourceDeviceProperty(name="global_reset", type=int, perms_mask=DPROP_PERM_SET, set_cb=self.prop_set_global_reset), # gettable & settable properties ChannelSourceDeviceProperty(name="adder_reg1", type=float, initial=Sample(timestamp=0, value=0.0), perms_mask=(DPROP_PERM_GET|DPROP_PERM_SET), options=DPROP_OPT_AUTOTIMESTAMP, set_cb=lambda x: self.prop_set_adder("adder_reg1", x)), ChannelSourceDeviceProperty(name="adder_reg2", type=float, initial=Sample(timestamp=0, value=0.0), perms_mask=(DPROP_PERM_GET|DPROP_PERM_SET), options=DPROP_OPT_AUTOTIMESTAMP, set_cb=lambda x: self.prop_set_adder("adder_reg2", x)), ] ## 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 from core.tracing import get_tracer self.__tracer = get_tracer(name) # Settings: # # page: The path location to access this presentation. # exclude: List of strings. Channels matching the strings will not be # displayed. settings_list = [ Setting(name='page', type=str, required=False, default_value='/idigi_dia'), Setting(name='exclude', type=list, required=False, default_value=[]), ] ## Initialize settings: PresentationBase.__init__(self, name=name, settings_list=settings_list)
def __init__(self, name, core_services): self.__name = name self.__core = core_services self.__stopevent = threading.Event() from core.tracing import get_tracer self.__tracer = get_tracer(name) # Configuration Settings: # server: The IP address or hostname to connect to. # port: The TCP port number to connect to. # interval: How often (in seconds) to emit CSV data # (default: 60 seconds). # channels: A list of channels to include in the data set. If this # setting is not given, all channels will be included. settings_list = [ Setting(name="server", type=str, required=True), Setting(name="port", type=int, required=True), Setting(name='interval', type=int, required=False, default_value=60), Setting(name="channels", type=list, required=False, default_value=[]), ] PresentationBase.__init__(self, name=name, settings_list=settings_list) threading.Thread.__init__(self, name=name) threading.Thread.setDaemon(self, True)
def __init__(self, name, core_services): """ Standard device init function. """ from core.tracing import get_tracer self.__tracer = get_tracer("CSVDevice") self.__tracer.info("Initializing CSVDevice") self.name = name self.core = core_services self.tracer = get_tracer(name) self.tdict = {} self.prop_names = [] self.dm = self.core.get_service("device_driver_manager") self.channel_manager = self.core.get_service('channel_manager') self.channel_database = self.channel_manager.channel_database_get() settings_list = [ Setting(name='channel_pattern', type=str, required=True), Setting(name='delimiter', type=str, required=False, default_value=','), Setting(name='column_names', type=list, default_value=[], required=False), ] ##No properties defined at first property_list = [] ## Initialize the DeviceBase interface: DeviceBase.__init__(self, self.name, self.core, settings_list, property_list)
def __init__(self, name, core_services): self.__name = name self.__core = core_services self.wd = None self.restart_counter = 0 self.__tracer = get_tracer(name) # Settings # watchdog_interval: defines how often to stroke the watchdog in seconds # low_memory_threshold: reboot if below memory threshold (bytes) # auto_restart_interval: how long the device should run # before auto-restart in seconds. ## Settings Table Definition: settings_list = [ Setting(name='watchdog_interval', type=int, required=True, default_value=120, verify_function=lambda x: x >= 60 and x <= 3600), Setting(name='low_memory_threshold', type=long, required=False, verify_function=lambda x: x >= 40960), Setting(name='auto_restart_interval', type=long, required=False, verify_function=lambda x: x >= 600), ] ## Initialize the ServiceBase interface: ServiceBase.__init__(self, self.__name, settings_list)
def __init__(self, name, core_services): """Basic initialization of members in class""" self.__name = name self.__core = core_services self.cb_handle = None self.init_module_logger() ## Settings Table Definition: settings_list = [ Setting( name='reboot_msg', type=str, required=False, default_value='REBOOT54321', verify_function=lambda x: type(x) == str), Setting( name='log_level', type=str, required=False, default_value='DEBUG', verify_function=self.check_debug_level_setting), ] ## Channel Properties Definition: property_list = [] ## Initialize the DeviceBase interface: DeviceBase.__init__(self, self.__name, self.__core, settings_list, property_list) ## Thread initialization: self.__stopevent = threading.Event()
def __init__(self, name, core_services): self.__name = name self.__core = core_services self.__digiweb_cb_handle = None self.__digiweb_xmlrpc = None from core.tracing import get_tracer self.__tracer = get_tracer(name) settings_list = [ Setting(name='port', type=int, required=False, default_value=80), Setting(name='use_default_httpserver', type=bool, required=False, default_value=True), ] ## Initialize settings: PresentationBase.__init__(self, name=name, settings_list=settings_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, properties): # DeviceBase will create: # self._name, self._core, self._tracer, self._xbee_manager = None self._extended_address = None ## Settings Table Definition: settings_list = [ Setting( name='xbee_device_manager', type=str, required=True), Setting( name='extended_address', type=str, required=True), ] # Add our settings_list entries into the settings passed to us. settings = self.merge_settings(settings, settings_list) ## Channel Properties Definition: property_list = [ ] # Add our property_list entries into the properties passed to us. properties = self.merge_properties(properties, property_list) ## Initialize the DeviceBase interface: DeviceBase.__init__(self, name, core_services, settings, properties) self._tracer.calls("XBeeBase.__init__()")
def __init__(self, name, core_services): # Create protected dictionaries and lists self.name_to_signal = lockDict() self.name_to_type = lockDict() self.signal_to_name = lockDict() self.signal_to_units_range = lockDict() self.reads_reqd = lockList() self.signals_reqd = lockList() self.units_reqd = lockList() self.names_reqd = lockList() self.info_timeout_scale = 1 self.__name = name self.__core = core_services ## Local State Variables: self.__xbee_manager = None from core.tracing import get_tracer self.__tracer = get_tracer("XBeeGPIOClient") ## Settings Table Definition: settings_list = [ Setting(name='xbee_device_manager', type=str, required=True), Setting(name='extended_address', type=str, required=True), Setting(name='poll_rate', type=float, required=False), ] ## Channel Properties Definition is in start() below: property_list = [] ## Initialize the DeviceBase interface: DeviceBase.__init__(self, self.__name, self.__core, settings_list, property_list)
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 __init__(self, name, core_services, set_in=None, prop_in=None): """\ Initialize an XBee Wall Router instance. Parameters: * name - The name of the XBee Wall Router instance. * core - The Core services instance. * set_in - settings from a derived class * prop_in - properties from a derived class """ # DeviceBase will create: # self._name, self._core, self._tracer, # XBeeBase will create: # self._xbee_manager, self._extended_address ## XBeeBase manages these settings: # xbee_device_manager: the name of an XBeeDeviceManager instance. # extended_address: the extended address of the XBee device you # would like to monitor. # ## This driver maintains # sample_rate_ms: the sample rate in msec of the XBee Wall Router. # offset: a raw offset to add/subtract from resulting temperature # degf: T/F if degress Fahrenheit is desired instead of Celsius settings_list = [ Setting( name='sample_rate_ms', type=int, required=False, default_value=self.DEF_SAMPLE_MS, verify_function=lambda x: x > 0 and x < 0xffff), Setting( name='offset', type=float, required=False, default_value=self.DEF_OFFSET), Setting( name='degf', type=bool, required=False, default_value=self.DEF_DEGF), ] # Add our settings_list entries into the settings passed to us. set_in = self.merge_settings(set_in, settings_list) ## Channel Properties Definition: property_list = [ # gettable properties ChannelSourceDeviceProperty(name="light", type=float, initial=Sample(timestamp=0, unit="not init", value=0.0), perms_mask=DPROP_PERM_GET, options=DPROP_OPT_AUTOTIMESTAMP), ChannelSourceDeviceProperty(name="temperature", type=float, initial=Sample(timestamp=0, unit="not init", value=0.0), perms_mask=DPROP_PERM_GET, options=DPROP_OPT_AUTOTIMESTAMP), ] # Add our property_list entries into the properties passed to us. prop_in = self.merge_properties(prop_in, property_list) ## Initialize the XBeeBase interface: XBeeBase.__init__(self, name, core_services, set_in, prop_in) self._tracer.calls("XBeeXBR.__init__()")
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): self.__name = name self.__core = core_services ## Local State Variables: self.__response_buffer = "" self.__request_events = [] self.__request_retry_events = [] from core.tracing import get_tracer self.__tracer = get_tracer(name) ## Settings Table Definition: settings_list = [ Setting( name='poll_rate_sec', type=int, required=False, default_value=5, verify_function=lambda x: x >= 0), Setting( name='bus_id', type=int, required=False, default_value=0, verify_function=lambda x: x >= 0), ] ## Channel Properties Definition: property_list = [ # gettable properties ChannelSourceDeviceProperty(name="strength", type=int, initial=Sample(timestamp=0, value=0, unit="%"), perms_mask=DPROP_PERM_GET, options=DPROP_OPT_AUTOTIMESTAMP), ChannelSourceDeviceProperty(name="target_detected", type=Boolean, initial=Sample(timestamp=0, value=Boolean(False, style=STYLE_YESNO)), perms_mask=DPROP_PERM_GET, options=DPROP_OPT_AUTOTIMESTAMP), ChannelSourceDeviceProperty(name="error_flag", type=Boolean, initial=Sample(timestamp=0, value=Boolean(False, style=STYLE_YESNO)), perms_mask=DPROP_PERM_GET, options=DPROP_OPT_AUTOTIMESTAMP), ChannelSourceDeviceProperty(name="range", type=int, initial=Sample(timestamp=0, value=0, unit="in"), perms_mask=DPROP_PERM_GET, options=DPROP_OPT_AUTOTIMESTAMP), ChannelSourceDeviceProperty(name="temperature", type=float, initial=Sample(timestamp=0, value=0.0, unit="C"), perms_mask=DPROP_PERM_GET, options=DPROP_OPT_AUTOTIMESTAMP), ] ## Initialize the DeviceBase interface: DeviceBase.__init__(self, self.__name, self.__core, settings_list, property_list) ## Initialize the serial interface: Serial.__init__(self, 0, 19200, timeout = 0)
def __init__(self, name, core_services): self.__name = name self.__core = core_services from core.tracing import get_tracer self.__tracer = get_tracer(name) settings_list = [ Setting(name="SMS", type=dict, required=False, default_value={}, verify_function=self.__verify_SMS), Setting(name="Iridium", type=dict, required=False, default_value={}, verify_function=self.__verify_iridium), Setting(name="clients", type=dict, required=False, default_value={}, verify_function=self.__verify_clients), Setting(name="updates", type=dict, required=False, default_value={}, verify_function=self.__verify_updates), Setting(name="alarms", type=dict, required=False, default_value={}, verify_function=self.__verify_alarms), ] PresentationBase.__init__(self, name=name, settings_list=settings_list) # Our dictionary of Transport Managers. self.__transport_managers = {} # Our cached list of clients. self.client_list = [] # The list of DIA channels that have matched our filters and so we have # subscribed to getting channel updates from DIA as they come in. self.__channels_being_watched = [] # The following list will contain a list of messages that should # be sent out at the next interval time. self.__coalesce_list = [] self.__stopevent = threading.Event() threading.Thread.__init__(self, name=name) threading.Thread.setDaemon(self, True)
def __init__(self, name, core_services, property_list): self.__name = name self.__core = core_services self.__property_list = property_list from core.tracing import get_tracer self._tracer = get_tracer(name) ## Local State Variables: self.__xbee_manager = None self.sensor = None # Settings # # xbee_device_manager: must be set to the name of an XBeeDeviceManager # instance. # extended_address: the extended address of the XBee Watchport Sensor # device you would like to monitor. # sleep: True/False setting which determines if we should put the # device to sleep between samples. # sample_rate_ms: the sample rate of the XBee adapter. # enable_low_battery: Force an adapter to enable support for # battery-monitor pin. # It should be only enabled if adapter is using # internal batteries. Optional, Off by default. settings_list = [ Setting( name='sleep', type=bool, required=False, default_value=False), Setting( name='sample_rate_ms', type=int, required=True, default_value=60000, verify_function=lambda x: x >= 0 and x <= CYCLIC_SLEEP_EXT_MAX_MS), # This setting is provided for advanced users, it is not required: Setting( name='awake_time_ms', type=int, required=False, default_value=5000, verify_function=lambda x: x >= 0 and x <= 0xffff), Setting( name='enable_low_battery', type=Boolean, required=False, default_value=Boolean("Off", STYLE_ONOFF)), ] ## Channel Properties Definition: __property_list_internal = [ ] property_list.extend(__property_list_internal) ## Initialize the XBeeBase interface: XBeeBase.__init__(self, self.__name, self.__core, settings_list, property_list)
def __init__(self, name, core_services): self.__name = name self.__core = core_services from core.tracing import get_tracer self.__tracer = get_tracer(name) ## Local State Variables: self.__xbee_manager = None self.__settings_ctx = \ core_services.get_service("settings_base").get_context() self.__purgatory = [] self.__callbacks = [] ## Settings Table Definition: settings_list = [ Setting(name='xbee_device_manager', type=str, required=True), # Contains the device driver settings for every device # that is intended to be auto enumerated. # The 'name: tag' is used as part of the new device name Setting(name='devices', type=dict, required=True, default_value=[]), Setting(name='discover_rate', type=int, required=False, default_value=600, verify_function=lambda x: x >= 60 and x <= 86400), # Shortens the discovered device names, when NI is not used, # to only include the last two octets of the XBee MAC Address. # User must confirm uniqueness of these 2 octets. # Example: 'aio_[00:13:a2:00:40:52:e0:fc]!' # becomes just 'aio_E0_FC' Setting(name='short_names', type=bool, required=False, default_value=False), ] ## Channel Properties Definition: property_list = [] self.__add_device_queue = Queue.Queue() ## 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): """Performs startup initializations. It verifies and loads the settings list.""" self.logger = init_module_logger(name) self.__name = name self.__core = core_services self.gateway_id = None self.server_conn_handle = None self.keep_alive_timer = 0 self.waiting_for_reply = False self.ao_msg_size_on_7_bits = True self.write_channel_name = None self.write_channe = None self.read_channel_name = None # watchdogs self.mainloop_made_a_pause = None self.mainloop_made_one_loop = None settings_list = [ Setting(name='write_channel', type=str, required=True), Setting(name='read_channel', type=str, required=True), Setting(name='server_port', type=int, required=True, default_value=9990), Setting(name='server_address', type=str, required=True, default_value="localhost"), Setting(name='keep_alive_interval', type=int, required=False, default_value=10), Setting(name='gateway_id', type=str, required=True), Setting(name='ao_msg_size_on_7_bits', type=bool, required=False, default_value=False), Setting(name='activate_tcp_keepalive', type=bool, required=False, default_value=True), Setting(name='log_level', type=str, required=False, default_value='DEBUG', verify_function=check_debug_level_setting), ] ## Initialize settings: PresentationBase.__init__(self, name=name, settings_list=settings_list) ## Thread initialization: self.__stopevent = threading.Event() threading.Thread.__init__(self, name=name) threading.Thread.setDaemon(self, True)
def __init__(self, name, core_services, set_in=None, prop_in=None): # DeviceBase will create: # self._name, self._core, self._tracer, # XBeeBase will create: # self._xbee_manager, self._extended_address ## Local State Variables: ## Settings Table Definition: settings_list = [ Setting(name='baudrate', type=int, required=False, default_value=self.DEF_BAUDRATE, verify_function=self.__verify_baudrate), Setting(name='parity', type=str, required=False, default_value=self.DEF_PARITY, verify_function=self.__verify_parity), # NOTE: SB/Stop-bits is not available in all XBEE Setting(name='stopbits', type=int, required=False, default_value=self.DEF_STOPBITS, verify_function=self.__verify_stopbits), Setting(name='hardwareflowcontrol', type=str, required=False, default_value=self.DEF_HWFLOW, verify_function=self.__verify_hwflow), # These setting is for legacy compatibility & ignored. # Having it here is not appropriate given this driver is commonly # used with third party XBee products. Setting(name='enable_low_battery', type=Boolean, required=False, default_value=False), ] # Add our settings_list entries into the settings passed to us. set_in = self.merge_settings(set_in, settings_list) ## Channel Properties Definition: # property_list = [] # Add our property_list entries into the properties passed to us. # prop_in = self.merge_properties(prop_in, property_list) ## Initialize the XBeeBase interface: XBeeBase.__init__(self, name, core_services, set_in, prop_in) self._tracer.calls("XBeeSerial.__init__()")
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.web_cb_handle = None settings_list = [ Setting( name='log_url', type=str, required=False, default_value='logging'), Setting( name='refresh_rate', type=int, required=False, default_value=10), ] ## Initialize settings: PresentationBase.__init__(self, name=name, settings_list=settings_list)
def __init__(self, name, core_services): self.__name = name self.__core = core_services self.showname = 'M300(%s)' % name ## Local State Variables: self.__response_buffer = "" self.__poll_event = None self.__request_events = [] # will hold the list of sensor objects self.__sensor_list = [] self._tracer = get_tracer(name) ## Settings Table Definition: settings_list = [ Setting( name='sample_rate_sec', type=str, required=False, default_value='60'), Setting( name='bus_id_list', type=list, required=False, default_value=[1]), Setting( name='manual_trigger', type=bool, required=False, default_value=False), Setting(name='trace', type=str, required=False, default_value='fancy'), ] ## Channel Properties Definition: # are defined dynamically within self.start() property_list = [ ] ## Initialize the DeviceBase interface: DeviceBase.__init__(self, self.__name, self.__core, settings_list, property_list) ## Initialize the serial interface: # Set the baud rate to 19200,8,N,1 expect answer within 1 secs Serial.__init__(self, 0, baudrate=19200, parity='N', \ timeout=0.5) return
def __init__(self, name, core_services): # DeviceBase will create: # self._name, self._core, self._tracer, # Settings # # xbee_device_manager: must be set to the name of an XBeeDeviceManager # instance. settings_list = [ Setting(name='xbee_device_manager', type=str, required=True), ] ## Channel Properties Definition: property_list = [ # gettable properties ChannelSourceDeviceProperty(name="button", type=str, initial=Sample(timestamp=0, value=''), perms_mask=DPROP_PERM_GET, options=DPROP_OPT_AUTOTIMESTAMP), ChannelSourceDeviceProperty(name="cb_trigger", type=bool, initial=Sample(timestamp=0, value=False), perms_mask=DPROP_PERM_GET, options=DPROP_OPT_AUTOTIMESTAMP), ] ## Initialize the DeviceBase interface: DeviceBase.__init__(self, name, core_services, settings_list, property_list)
def __init__(self, name, core_services, settings=None): """ Create an instance of the RCIHandler. If the target_name is not specified, it will default to 'idigi_dia'. """ self._name = name self._core = core_services self._handle = None self._tracer = get_tracer(name) settings_list = [ Setting(name='target_name', type=str, required=False, default_value='idigi_dia'), ] if settings is not None: settings.extend(settings_list) else: settings = settings_list ## Initialize settings: PresentationBase.__init__(self, name=name, settings_list=settings)
def __init__(self, name, core_services): self._scheduler = core_services.get_service("scheduler") ## Settings Table Definition: settings_list = [ Setting( name='interval', type=float, required=False, default_value=0.0, verify_function=lambda x: x > 1.0), Setting( name='trigger_value', type=bool, required=False, default_value=True) ] ## Channel Properties Definition: property_list = [] ## Initialize the DeviceBase interface: FilterChannelFactoryBase.__init__(self, name, core_services, settings_list, property_list)
def __init__(self, name, core_services): self.__name = name self.__core = core_services import core.tracing as tracing self.__tracer = tracing.get_tracer(name) # Settings: # # page: name of presented web page # port: port to use. digiweb ignores this and uses port 80. # polling: how frequently to request an update from the server # (passed to javascript in the browser) # use_default_httpserver: use digiweb on the ConnectPort, # BaseHTTPServer on other platforms. If false, always use # BaseHTTPServer. # title: set the title of the web page ## Settings Table Definition: settings_list = [ Setting(name='page', type=str, required=False, default_value='index'), Setting(name='port', type=int, required=False, default_value=8001), Setting(name='polling', type=int, required=False, default_value=0), Setting(name='use_default_httpserver', type=bool, required=False, default_value=True), Setting(name='title', type=str, required=False, default_value='DIA Web Presentation'), ] ## Initialize settings: PresentationBase.__init__(self, name=name, settings_list=settings_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.__stopevent = threading.Event() from core.tracing import get_tracer self.__tracer = get_tracer(name) self.use_proxy = None self.proxy_host = None self.proxy_port = None # Configuration Settings: settings_list = [ Setting(name="cosm_host", type=str, required=False, default_value="api.cosm.com"), Setting(name="cosm_key", type=str, required=True), Setting(name="cosm_feed_id0", type=str, required=True), Setting(name="channel0", type=str, required=True), Setting(name="cosm_datastream0", type=str, required=True), Setting(name="use_proxy", type=bool, required=False, default_value=False), Setting(name="proxy_host", type=str, required=False), Setting(name="proxy_port", type=int, required=False, default_value=3128), ] PresentationBase.__init__(self, name=name, settings_list=settings_list) self.use_proxy = SettingsBase.get_setting(self, "use_proxy") if self.use_proxy: self.proxy_host = SettingsBase.get_setting(self, "proxy_host") self.proxy_port = SettingsBase.get_setting(self, "proxy_port") if not self.proxy_host: self.__tracer.warning( "proxy_host configuration parameter not set. Will ignore use_proxy to false" ) self.use_proxy = False threading.Thread.__init__(self, name=name) threading.Thread.setDaemon(self, True) return
def __init__(self, name, core_services): self.__name = name self.__core = core_services # The __scheduler_handler is the variable that will tell us if there # is already a pulse. It is 'None' when the channel is not pulsing self.__sched = self.__core.get_service("scheduler") self.__scheduler_handler = None from core.tracing import get_tracer self.__tracer = get_tracer(name) ## Settings Table Definition: settings_list = [ Setting(name='duration', type=float, required=False, default_value=5.0, verify_function=lambda x: x > 0.0), Setting(name='initial_value', type=bool, required=False, default_value=False, verify_function=lambda x: x is True or x is False), ] ## Channel Properties Definition: property_list = [ ChannelSourceDeviceProperty(name="pulse_channel", type=bool, initial=Sample(timestamp=0, value=False), perms_mask=DPROP_PERM_GET | DPROP_PERM_SET, options=DPROP_OPT_AUTOTIMESTAMP, set_cb=self.pulse_channel_cb), ] ## Initialize the DeviceBase interface: DeviceBase.__init__(self, self.__name, self.__core, settings_list, property_list)
def __init__(self, name, core_services, settings, properties): # save these for use of sub-classed device drivers self._name = name self._core = core_services self._tracer = get_tracer(name) ## local variables # These are to be used by 'health monitoring' functions - all drivers # should correctly manage these (or leave set to None to mark as N/A) # # use self.get_time_of_last_data() and # self.set_time_of_last_data() to access! self.__last_data_timestamp = None # use self.get_data_update_rate_seconds() and # self.set_data_update_rate_seconds() to access! self.__data_update_rate = None # cache the channel DB reference self._channel_db = None # 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 = {} if properties is not None: 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__()")