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.__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):
"""
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.__thread = None
self.websocketCom = False
self.retrying = False
self.pingy = 0
self.reconnecting = 0
self.started = False
self.ping_loop = False
from core.tracing import get_tracer
self.__tracer = get_tracer(name)
settings_list = [
Setting(
name='target_name', type=str,
required=False, default_value='idigi_dia'),
]
## 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.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, transport_managers, settings):
"""\
The typical init function.
"""
self.__name = name
self.__core = core
self.__transport_managers = transport_managers
# Store a few of the settings that we use outside of init.
self.__transport = settings['transport']
from core.tracing import get_tracer
self.__tracer = get_tracer(name)
# Get our device ID
try:
self.__deviceid = get_device_id()
except:
raise
# Allocate the transport method we should use for this client.
try:
if settings['transport'] == "sms":
self.__transport_obj = iDigiSMSTransportClient(self,
self.__transport_managers['SMS'])
else:
raise Exception, "Unknown Transport Type"
except:
raise
def __init__(self):
## Thread initialization:
self.__stopevent = threading.Event()
self.__queue = Queue.Queue(1)
name = "XBeeDeviceManagerConfiguratorWorker"
self.__tracer = get_tracer(name)
threading.Thread.__init__(self, name=name)
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 parse_dd(dd):
"""\
Parse a Digi Device type value.
Parses a given Digi Device type value gotten from a DDO DD command,
into a tuple of (module_id, product_id).
The top 2 bytes specify the wireless module type.
The lower 2 bytes specify the end product type.
"""
if isinstance(dd, str):
try:
# pad to four
ln = len(dd)
if ln > 4:
raise ValueError("Value too long!")
dd = '\x00' * (4 - ln) + dd
dd = struct.unpack(">I", dd)[0]
except:
from core.tracing import get_tracer
_tracer = get_tracer('prodid')
_tracer.warning("Unable to determine device type, dd = \'" + \
dd + "\'. Check Xbee firmware.")
dd = 0x00 # unspecified device/product
if not isinstance(dd, (int, long)):
raise TypeError("dd must be given as a string or int (given %s)" %
(str(type(dd))))
module_id = dd >> 16
product_id = dd & 0xffff
return (module_id, product_id)
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='extended_address', type=str, required=False,
default_value=''),
Setting(
name='sample_rate_ms', type=int, required=False),
Setting(
name='channel_settings', type=str, required=False,
default_value="name,unit"),
Setting(
name='encryption', type=bool, required=False,
default_value=False)
]
## 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()
threading.Thread.__init__(self, name=name)
threading.Thread.setDaemon(self, True)
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, name, core_services, extra_settings=[],
create_remote=True, create_local=True):
self.__name = name
self.__core = core_services
self.__create_remote = create_remote
self.__create_local = create_local
## Local State Variables:
self.__xbee_manager = None
from core.tracing import get_tracer
self.__tracer = get_tracer(name)
## Settings Table Definition:
settings_list = [
Setting( name='xbee_device_manager', type=str, required=True),
Setting( name='extended_address', type=str, required=True),
Setting( name='endpoint', type=int, required=True),
Setting( name='profile', type=int, required=True),
Setting( name='cluster', type=int, required=True),
Setting( name='local', type=str, required=False),
Setting( name='remote', type=str, required=False),
]
for s in extra_settings:
settings_list.append(Setting(name=s['name'], type=s['type'],
required=s['required']))
## 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, 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):
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):
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, source_channel, filter_channel):
self._name = name
self._core = core
self.source_channel = source_channel
self.filter_channel = filter_channel
self._target_channel_name = filter_channel.name
self._tracer = get_tracer(name)
dm = self._core.get_service("device_driver_manager")
target_device_name = source_channel.name().split('.')[0]
target_device = dm.instance_get(target_device_name)
self._target_device = target_device
cm = self._core.get_service("channel_manager")
cp = cm.channel_publisher_get()
cp.subscribe(source_channel.name(), self._receive)
# Attempt to force a copy of the source's current value into our value.
try:
self._receive(source_channel)
except:
pass
# Override the default refresh callback with our more specific one.
filter_channel.device_refresh_cb = self.property_refresh
def __init__(self, name, core, transport_managers, settings):
self.__name = name
self.__core = core
self.__transport_managers = transport_managers
# Store a few of the settings that we use outside of init.
self.__update_message = settings['update_message']
self.__alarm_message = settings['alarm_message']
self.__command_access = settings['command_access']
self.__transport = settings['transport']
# Get our device ID
self.__deviceid = get_device_id()
from core.tracing import get_tracer
self.__tracer = get_tracer(name)
# Allocate the transport method we should use for this client.
try:
if settings['transport'] == "sms":
self.__transport_obj = SMSTransportClient(self,
self.__transport_managers['SMS'],
settings['number'])
else:
raise Exception, "Unknown Transport Type"
except:
raise
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, binding=(), setting_defs=[]):
# Add the binding:
if binding in self._settings_global_bindings:
if not self in self._settings_global_bindings:
self._settings_global_bindings[binding].append(self)
else:
self._settings_global_bindings[binding] = [self]
# Local (non-shared state) variables:
self._settings_binding = binding
self._settings_definitions = {}
self._settings_running_registry = \
self._settings_global_running_registry
self._settings_pending_registry = \
self.__get_local_registry_ref(
self._settings_global_pending_registry, binding)
self._settings_running_registry = \
self.__get_local_registry_ref(
self._settings_global_running_registry, binding)
from core.tracing import get_tracer
self.__tracer = get_tracer("SettingsBase")
# Load settings into self._settings_definitions:
for setting in setting_defs:
self._settings_definitions[setting.name] = setting
# Attempt to apply current pending settings:
accepted, rejected, not_found = self.apply_settings()
if rejected:
raise ValueError, "ERROR: Invalid settings: %s" % rejected
if not_found:
raise SettingNotFound, "ERROR: Missing settings: %s" % not_found
def __init__(self, binding=(), setting_defs = []):
# Add the binding:
if binding in self._settings_global_bindings:
if not self in self._settings_global_bindings:
self._settings_global_bindings[binding].append(self)
else:
self._settings_global_bindings[binding] = [self]
# Local (non-shared state) variables:
self._settings_binding = binding
self._settings_definitions = { }
self._settings_running_registry = \
self._settings_global_running_registry
self._settings_pending_registry = \
self.__get_local_registry_ref(
self._settings_global_pending_registry, binding)
self._settings_running_registry = \
self.__get_local_registry_ref(
self._settings_global_running_registry, binding)
from core.tracing import get_tracer
self.__tracer = get_tracer("SettingsBase")
# Load settings into self._settings_definitions:
for setting in setting_defs:
self._settings_definitions[setting.name] = setting
# Attempt to apply current pending settings:
accepted, rejected, not_found = self.apply_settings()
if rejected:
raise ValueError, "ERROR: Invalid settings: %s" % rejected
if not_found:
raise SettingNotFound, "ERROR: Missing settings: %s" % not_found
def __init__(self):
## Thread initialization:
self.__stopevent = threading.Event()
self.__queue = Queue.Queue(1)
name = "XBeeDeviceManagerConfiguratorWorker"
self.__tracer = get_tracer(name)
threading.Thread.__init__(self, name=name)
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 parse_dd(dd):
"""\
Parse a Digi Device type value.
Parses a given Digi Device type value gotten from a DDO DD command,
into a tuple of (module_id, product_id).
The top 2 bytes specify the wireless module type.
The lower 2 bytes specify the end product type.
"""
if isinstance(dd, str):
try:
# pad to four
ln = len(dd)
if ln > 4:
raise ValueError("Value too long!")
dd = '\x00' * (4 - ln) + dd
dd = struct.unpack(">I", dd)[0]
except:
from core.tracing import get_tracer
_tracer = get_tracer('prodid')
_tracer.warning("Unable to determine device type, dd = \'" + \
dd + "\'. Check Xbee firmware.")
dd = 0x00 # unspecified device/product
if not isinstance(dd, (int, long)):
raise TypeError("dd must be given as a string or int (given %s)" %
(str(type(dd))))
module_id = dd >> 16
product_id = dd & 0xffff
return (module_id, product_id)
def __init__(self, name, core_services, settings, properties):
self._name = name
self._core = core_services
self._tracer = get_tracer(name)
# 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 = { }
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__()")
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, name, core_services, settings_in=None, property_in=None):
self._my_tracer = get_tracer('MBusH8036(%s)' % name)
## Local State Variables:
self._H8036 = VerisH8036()
# init the My-Gang logic - chain multiple
self.init_gang()
## Settings Table Definition:
settings_list = [
# Setting( name='sample_rate_sec' is in Robust_Device
Setting(
name='channels', type=list, required=False,
default_value=self.ENB_CHN_DEFAULTS),
Setting(
name='unit_id', type=int, required=False,
default_value=self.DEF_UNIT_ID),
]
settings_out = self._safely_merge_lists(settings_in, settings_list)
## Channel Properties Definition: assume ecm1240
# property_list = [ ]
# Add our property_list entries to the properties passed to us.
# properties = self._safely_merge_lists(properties, property_list)
property_out = property_in
## Initialize the DeviceBase interface:
RobustBase.__init__(self, name, core_services, settings_out, property_out)
return
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.__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.__tracer = get_tracer(name)
self.__xbee_manager = None
## Initialize the XBeeBase interface:
XBeeBase.__init__(self, self.__name, self.__core, [], [])
def __init__(self, name, core_services):
self.__name = name
self.__core = core_services
self.targets = {}
from core.tracing import get_tracer
self.__tracer = get_tracer(name)
## Settings Table Definition:
settings_list = [
Setting(name=PROP_PRINTF, type=str, required=False, default_value=PROP_MINUTE),
Setting( # how often to check for work
name=PROP_TICK_RATE, type=int, required=False,
default_value=DEFAULT_TICK_RATE,
verify_function=lambda x: x > 0.0),
]
## Channel Properties Definition:
property_list = [
# gettable properties
ChannelSourceDeviceProperty(name=PROP_15SEC, type=tuple,
initial=Sample(timestamp=0, value=(0,None)),
perms_mask=DPROP_PERM_GET),
ChannelSourceDeviceProperty(name=PROP_MINUTE, type=tuple,
initial=Sample(timestamp=0, value=(0,None)),
perms_mask=DPROP_PERM_GET),
ChannelSourceDeviceProperty(name=PROP_15MIN, type=tuple,
initial=Sample(timestamp=0, value=(0,None)),
perms_mask=DPROP_PERM_GET),
ChannelSourceDeviceProperty(name=PROP_HOUR, type=tuple,
initial=Sample(timestamp=0, value=(0,None)),
perms_mask=DPROP_PERM_GET),
ChannelSourceDeviceProperty(name=PROP_SIXHR, type=tuple,
initial=Sample(timestamp=0, value=(0,None)),
perms_mask=DPROP_PERM_GET),
ChannelSourceDeviceProperty(name=PROP_DAY, type=tuple,
initial=Sample(timestamp=0, value=(0,None)),
perms_mask=DPROP_PERM_GET),
]
## 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)
self.main_addr = "mainMistaway_" + gw_extended_address()
## 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 >= 1 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, ext_addr):
# format for below: { 'XX': (value, method, failure_callback), ... }
self.__parameters = {}
self.__pending_parameters = {}
from core.tracing import get_tracer
self.__tracer = get_tracer('XBeeConfigBlockDDO')
AbstractXBeeConfigBlockDDO.__init__(self, ext_addr)
def __init__(self, core_services):
self.__core = core_services
self.__core.set_service("logging_manager", self)
from core.tracing import get_tracer
self.__tracer = get_tracer('LoggingManager')
# Initialize our base class:
AbstractServiceManager.__init__(self, core_services, ('loggers',))
def __init__(self, core_services):
self.__core = core_services
self.__new_channel_listeners = set()
self.__channel_listeners = {}
self.__rlock = threading.RLock()
self.__logging_manager = None
from core.tracing import get_tracer
self.__tracer = get_tracer("ChannelPublisher")
def __init__(self, name, core, source_channel, filter_channel,
upper_threshold, lower_threshold,
disable_upper, disable_lower):
self._tracer = get_tracer(name)
self._lower_threshold = lower_threshold
self._upper_threshold = upper_threshold
self._disable_lower = disable_lower
self._disable_upper = disable_upper
FilterChannelBase.__init__(self, name, core, source_channel, filter_channel)
def __init__(self, core_services):
self.__core = core_services
self.__core.set_service("logging_manager", self)
from core.tracing import get_tracer
self.__tracer = get_tracer('LoggingManager')
# Initialize our base class:
AbstractServiceManager.__init__(self, core_services, ('loggers', ))
def __init__(self, name, core, source_channel, filter_channel,
interval, trigger_value, scheduler):
self._tracer = get_tracer(name)
self._interval = interval
self._trigger_condition = trigger_value
self._scheduled_event_handle = None
self._scheduler = scheduler
self._scheduler_lock = Lock()
FilterChannelBase.__init__(self, name, core, source_channel, filter_channel)
def __init__(self, core_services):
self.__core = core_services
self.__new_channel_listeners = set()
self.__channel_listeners = {}
self.__rlock = threading.RLock()
self.__logging_manager = None
from core.tracing import get_tracer
self.__tracer = get_tracer("ChannelPublisher")
def __init__(self, ext_addr):
# format for below: { 'XX': (value, method, failure_callback), ... }
self.__parameters = { }
self.__pending_parameters = { }
from core.tracing import get_tracer
self.__tracer = get_tracer('XBeeConfigBlockDDO')
AbstractXBeeConfigBlockDDO.__init__(self, ext_addr)
def __init__(self, name, core, source_channel, filter_channel,
interval, trigger_value, scheduler):
self._tracer = get_tracer(name)
self._interval = interval
self._trigger_condition = trigger_value
self._scheduled_event_handle = None
self._scheduler = scheduler
self._scheduler_lock = Lock()
FilterChannelBase.__init__(self, name, core, source_channel, filter_channel)
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
## 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, source_channel, filter_channel,
threshold, readings, continuous):
self._tracer = get_tracer(name)
self._filter_channel = filter_channel
self._threshold = threshold
self._readings = readings
self._continuous = continuous
self.__above_count = 0
self.__below_count = 0
FilterChannelBase.__init__(self, name, core, source_channel, filter_channel)
def __init__(self, name, core_services):
self.__name = name
self.__core_services = core_services
from core.tracing import get_tracer
self.__tracer = get_tracer(name)
settings_list = []
LoggerBase.__init__(self, name=name, settings_list=settings_list)
def __init__(self, name, core_services):
self.__name = name
self.__core_services = core_services
from core.tracing import get_tracer
self.__tracer = get_tracer(name)
settings_list = [ ]
LoggerBase.__init__(self, name=name, settings_list=settings_list)
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)
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)
settings_list = [ ]
## Initialize settings:
ServiceBase.__init__(self, name=name, settings_list=settings_list)
def __init__(self):
self.__state = self.STATE_INITIALIZING
self.__event_specs = []
self.__config_blocks = []
self.__config_sched_handle = None
self.__ext_addr = None # Set by xbee_device_event_spec_add()
self.__config_attempts = 0
self.__last_heard_from = None
from core.tracing import get_tracer
self.__tracer = get_tracer('XbeeDeviceState')
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 = []
## Initialize settings:
ServiceBase.__init__(self, name=name, settings_list=settings_list)
def __init__(self, name, core_services):
"""\
Initialize an XBee Wall Router instance.
Parameters:
* name - The name of the XBee Wall Router instance.
* core_services - The Core services instance.
"""
self.__name = name
self.__core = core_services
## Local State Variables:
self.__xbee_manager = None
from core.tracing import get_tracer
self.__tracer = get_tracer(name)
# Settings:
#
# xbee_device_manager: must be set to the name of an XBeeDeviceManager
# instance.
# extended_address: is the extended address of the XBee device you
# would like to monitor.
# sample_rate_ms: is the sample rate of the XBee Wall Router.
settings_list = [
Setting(
name = 'xbee_device_manager', type = str, required = False,
default_value = ''),
Setting(
name = 'extended_address', type = str, required = False,
default_value = ''),
Setting(
name = 'sample_rate_ms', type = int, required = False,
default_value = 1000,
verify_function = lambda x: x > 0 and x < 0xffff),
]
## Channel Properties Definition:
property_list = [
# gettable properties
ChannelSourceDeviceProperty(name = "light", type = float,
initial = Sample(timestamp = 0, unit = "brightness", value = 0.0),
perms_mask = DPROP_PERM_GET, options = DPROP_OPT_AUTOTIMESTAMP),
ChannelSourceDeviceProperty(name = "temperature", type = float,
initial = Sample(timestamp = 0, unit = "C", value = 0.0),
perms_mask = DPROP_PERM_GET, options = DPROP_OPT_AUTOTIMESTAMP),
]
## 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):
self.__state = self.STATE_INITIALIZING
self.__event_specs = []
self.__config_blocks = []
self.__config_sched_handle = None
self.__ext_addr = None # Set by xbee_device_event_spec_add()
self.__config_attempts = 0
self.__last_heard_from = None
from core.tracing import get_tracer
self.__tracer = get_tracer('XbeeDeviceState')
def __init__(self, name, core, source_channel, filter_channel, threshold,
readings, continuous):
self._tracer = get_tracer(name)
self._filter_channel = filter_channel
self._threshold = threshold
self._readings = readings
self._continuous = continuous
self.__above_count = 0
self.__below_count = 0
FilterChannelBase.__init__(self, name, core, source_channel,
filter_channel)
def __init__(self, name, core_services):
self.__name = name
self.__core = core_services
## Settings Table Definition:
settings_list = [
Setting(
name='prefix_init', type=str, required=False,
default_value="Hello ",
verify_function=lambda x: len(x) >= 1),
Setting(
name='suffix_init', type=str, required=False,
default_value="World!",
verify_function=lambda x: len(x) >= 1),
Setting(
name='update_rate', type=float, required=False,
default_value=1.0,
verify_function=lambda x: x > 0.0),
]
from core.tracing import get_tracer
self.__tracer = get_tracer(name)
## Channel Properties Definition:
property_list = [
# gettable properties
ChannelSourceDeviceProperty(name="prefix_string", type=str,
initial=Sample(timestamp=0, value="Hello "),
perms_mask=DPROP_PERM_GET, options=DPROP_OPT_AUTOTIMESTAMP),
ChannelSourceDeviceProperty(name="xtended_string", type=str,
initial=Sample(timestamp=0, value="Hello World!"),
perms_mask=DPROP_PERM_GET, options=DPROP_OPT_AUTOTIMESTAMP),
# gettable & settable properties
ChannelSourceDeviceProperty(name="suffix_string", type=str,
initial=Sample(timestamp=0, value="World!"),
perms_mask=(DPROP_PERM_GET|DPROP_PERM_SET),
options=DPROP_OPT_AUTOTIMESTAMP,
set_cb=self.prop_set_suffix),
]
## 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, ext_addr):
self.__parameters = {}
self.__pending_parameters = {}
self.__sleep_mode = SM_DISABLED
self.__sleep_period_ms = 0
from core.tracing import get_tracer
self.__tracer = get_tracer('XBeeConfigBlockSleep')
AbstractXBeeConfigBlockDDO.__init__(self, ext_addr)
AbstractXBeeConfigBlockDDO.apply_only_to_modules(
self, SLEEPABLE_MODULES)
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__()")
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="scheduler", core=None):
self.__name = name
self.__core = core
self.__tracer = get_tracer(name)
self.__semaphore = threading.Semaphore(0)
self.__stop_flag = False
self.__sched = sched.scheduler()
threading.Thread.__init__(self)
threading.Thread.setDaemon(self, True)
def __init__(self, name, parent, channel, mode, source):
self.__name = name
self.__parent = parent
self.__channel = channel
self.__mode = mode
self.__source = source
from core.tracing import get_tracer
self.__tracer = get_tracer(name)
## Local State Variables:
self.__dia_device_obj = self.__parent.get_parent()
self.__xbee_manager = self.__parent.get_xbee_manager()