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__()")