def __init__(self):
CompositeNode.__init__(self)
AutoDiscoveredNode.__init__(self)
self.running = 0
self.discover_mode = 'never'
self._been_discovered = 0
self.source = 'broadway' #or 'bacnet'
def __init__(self):
CompositeNode.__init__(self)
self.coprocessor = None
self.port_map = None
self.eth_map = None
self.modem_map = None
return
def configure(self, config):
CompositeNode.configure(self, config)
set_attribute(self, 'url', '', config, str)
set_attribute(self, 'user', '', config, str)
set_attribute(self, 'password', '', config, str)
set_attribute(self, 'spreadsheet', self.name, config, str) #spreadsheet name
set_attribute(self, 'worksheet', '', config, str)
def start(self):
CompositeNode.start(self)
next_position = 0
timestamp = PeriodicColumn()
timestamp.configure({'parent':self.get_child('recorders'),
'name':'timestamp',
'position':next_position,
'sort_order':'ascending',
'args':(),
'function':self.scheduled_time})
timestamp.sequence = 0
sequences = []
for child in self.get_child('recorders').children_nodes():
if child.__class__ == Recorder:
if child.sequence in sequences:
raise EConfiguration(
'Conflicting RecorderSet sequence %s on %r' %
(child.sequence, child.name))
sequences.append(child.sequence)
# Force Timestamp as column '0'.
self.collector.add_column(timestamp)
children = self.get_child('recorders').children_nodes()
children.sort(_sort)
for child in children:
if child.__class__ == Recorder:
for channel in child.channels():
next_position += 1
channel.position = next_position
self.collector.add_column(channel)
cc = ColumnConfiguration()
cc.configure(timestamp.configuration())
self.log.configure([cc]+self.collector.columns[1:],
self.minimum_size,self.maximum_size)
self.collector.start()
def start(self):
self.port = self.parent
if not self.port.is_open():
self.port.open()
self.line_handler = cat_lib.CCMLineHandler(self.port)
self.line_handler.start(self.password)
CompositeNode.start(self)
def test_configure_sequence_get(self):
p = PeriodicLog()
p.configure({'name':'log','parent':None, 'period':1})
h = CompositeNode()
h.configure({'name':'columns','parent':p})
c = PeriodicDeltaColumn()
c.configure({'position':0, 'name':'2', 'parent':h,
'function':self._next})
p.start()
try:
l = []
if c.get() != None:
raise 'Get didn\'t return None on first get'
if c.get() != None:
raise 'Get didn\'t return None on second get'
self.seq.value = 0
c.function()
self._next()
self._next()
self._next()
if c.get() != self.seq.value - 1:
raise 'Got incorrect value after incrementing'
finally:
p.stop()
return
def start(self):
CompositeNode.start(self)
self.local_context = {}
try:
self.compiled_statement = compile(self.statement, '', 'eval')
#examine each variable and decide what to do with it
for variable in self.variables:
name = variable['vn']
definition = variable['node_reference']
if self.local_context.has_key(name):
raise EInvalidValue('variable',name,
'Variable name duplicated')
exceptions = []
conversions = self._conversions[:]
while conversions:
conversion = conversions.pop(0)
try:
reference = conversion(definition)
break
except Exception,e:
exceptions.append(e)
else:
self.local_context = {}
raise EInvalidValue('variable',name,
('Conversions %s Gave Errors %s.' %
(self._conversions,exceptions)))
self.local_context[name] = reference
self.started = 1
def __init__(self):
CompositeNode.__init__(self)
ProxyAbstractClass.__init__(self)
self.debug = 0
self.value = None
self.buffer = None
self.last_set_exception = None
def __init__(self):
CompositeNode.__init__(self)
self._threads = set()
self.started = 0
self._failed = {}
self._exception = None
return
def configure(self, config_dict):
CompositeNode.configure(self, config_dict)
set_attribute(self, "debug", 0, config_dict, int)
# Default the period (between tickling our children) to 15
# seconds. Note: This may be overriden for specific
# applications.
set_attribute(self, "period", 15, config_dict, int)
def configure(self,config):
CompositeNode.configure(self,config)
set_attribute(self, 'port', 502, config, int)
set_attribute(self, 'debug', 0, config, int)
self.udp_port = self.port
self.port = self #intercept any calls to the port
return
def configure(self, config):
CompositeNode.configure(self, config)
set_attribute(self, "debug", 0, config, as_boolean)
set_attribute(self, "discover", "never", config, str)
set_attribute(self, "discover_start", 0, config, int)
set_attribute(self, "discover_stop", 255, config, int)
debug = self.debug
def configure(self, config):
CompositeNode.configure(self,config)
set_attribute(self, 'id', 0, config, str)
set_attribute(self,'cache_life',30,config,float)
set_attribute(self,'timeout',10,config,float)
set_attribute(self,'patience',1,config,float)
self.port = self.parent
def stop(self):
try:
self._interface_node.stop()
except:
msglog.log('tsws',msglog.types.ERR,'tsws failed to stop interface node')
self._interface_node = None
CompositeNode.stop(self)
def configure(self, config):
CompositeNode.configure(self, config)
set_attribute(self,'debug', debug, config, as_boolean)
set_attribute(self,'post',REQUIRED,config, str)
set_attribute(self,'server',REQUIRED, config, str)
set_attribute(self,'action',REQUIRED, config, str)
set_attribute(self,'ttl',1.0, config, float)
def __init__(self):
CompositeNode.__init__(self)
self._pdo_lock = Lock()
self._pdo = None
self.__running = False
self.debug = 0
return
def start( self ):
CompositeNode.start( self )
if not self.isStarted:
self.isStarted = 1
self._schedule(.15)
else:
raise EAlreadyRunning
def configure(self,config):
if self.debug:
msglog.log('EnergywiseManager:', msglog.types.INFO,
'Inside configure' )
CompositeNode.configure(self, config)
set_attribute(self, 'debug', 0, config, int)
return
def configure(self, config):
CompositeNode.configure(self, config)
set_attribute(self, "timeout", 1.0, config, float)
set_attribute(self, "debug", 0, config, int)
self.port = self.parent
if not self.port.is_open():
self.port.open()
def children_nodes(self):
children = CompositeNode.children_nodes(self)
stats = get_c_stat_names()
# remove all nodes that do not have a stat
nodeNameList = []
for c in children:
if c.name not in stats:
c.prune()
else:
nodeNameList.append( c.name)
# add all stats to node tree (unless already there)
for stat in stats:
if stat not in nodeNameList:
n = CStatNode(stat)
cd = { 'name' : stat,
'parent' : self,
'log_on_change': -1,
'time_last_changed': ''}
n.configure( cd)
return CompositeNode.children_nodes(self)
def configure(self, config):
CompositeNode.configure(self, config)
set_attribute(self, 'debug', debug, config, as_boolean)
set_attribute(self,'device_name',REQUIRED,config, str)
set_attribute(self,'unit_number',REQUIRED, config, int)
set_attribute(self,'controller_type',None, config, str)
set_attribute(self,'controller_version',None, config, str)
def configure(self, cd):
CompositeNode.configure(self, cd)
set_attribute(self, 'source',self.source, cd, str)
set_attribute(self, 'device_link', None, cd, str) #url of Devices node
set_attribute(self, 'discover_mode', self.discover_mode, cd, str)
set_attribute(self, '__node_id__',self._node_id, cd, str)
set_attribute(self, 'bacnet_datatype', 'real', cd, str)
def configure(self, config):
CompositeNode.configure(self, config)
# get handle to ARM in arm.py.
# self.coprocessor is the surrogate parent this child.
#
set_attributes(self, (('id',REQUIRED),('coprocessor',REQUIRED)), config)
self._coprocessor = self.coprocessor._coprocessor # the moab megatron ARM object
def test_configure_sequence(self):
p = PeriodicLog()
p.configure({'name':'log','parent':None, 'period':1})
h = CompositeNode()
h.configure({'name':'columns','parent':p})
c = PeriodicAverageColumn()
c.configure({'position':0, 'name':'2', 'parent':h,
'function':self._next})
p.start()
try:
l = []
v = []
for i in range(0,100):
l.append(c._evaluate())
v.append(i-0.5)
if l.pop(0) != None:
raise 'First delta not None.'
v.pop(0)
for i in l:
j = v.pop(0)
if i != j:
raise 'Incorrect average of %s should be %s.' % (i, j)
finally:
p.stop()
return
def start(self):
if self.parent.room == 1:
msglog.log('USAP', INFO, 'Object:start() - %s --> %s --> %s' % (self.parent.parent.name, self.parent.name, self.name))
self.path = string.join([self.parent.name, self.name], '.')
self.lh = self.parent.parent.lh
self.request_obj = self.parent.parent.request_obj
self.response_obj = self.parent.parent.response_obj
self.unison_v1_9_0_or_prior = self.parent.parent.unison_v1_9_0_or_prior
else:
msglog.log('USAP', INFO, 'Object:start() - %s --> %s --> %s --> %s' % (self.parent.parent.parent.name, self.parent.parent.name, self.parent.name, self.name))
self.path = string.join([self.parent.parent.name, \
self.parent.name, self.name], '.')
self.lh = self.parent.parent.parent.lh
self.request_obj = self.parent.parent.parent.request_obj
self.response_obj = self.parent.parent.parent.response_obj
self.unison_v1_9_0_or_prior = self.parent.parent.parent.unison_v1_9_0_or_prior
# Find the relevant protocol child objects ahead of time to
# be more efficient.
self.req_startCode_obj = self.request_obj.findChildByName("startCode")
self.req_vData_obj = self.request_obj.findChildByName("vData")
self.req_crc_obj = self.request_obj.findChildByName("crc")
#
self.resp_startCode_obj = self.response_obj.findChildByName("startCode")
self.resp_vData_obj = self.response_obj.findChildByName("vData")
self.resp_crc_obj = self.response_obj.findChildByName("crc")
#
CompositeNode.start(self)
def __init__(self):
CompositeNode.__init__(self)
self.running = 0
self.line_handler = None
self._pnts_map = {}
self.debug_lvl = 0 # should be valid immediately after ctor, NOT just after configure()
self.__status = None
def start(self):
if self.__running:
return
if self.debug:
msglog.log('EnergywiseManager :', msglog.types.INFO, 'Inside start' )
CompositeNode.start(self)
# start_node = as_node('/services/EnergywiseManager/')
# self.configure_trend_in_switches(start_node, 60)
self.__running = True
self._pdo_lock.acquire()
self._pdo = PersistentDataObject(self, dmtype=GC_NEVER)
self._pdo.trends = {}
self._pdo.load()
self._pdo_lock.release()
if self.has_child('trends'):
self.trends = self.get_child('trends')
else:
self.trends = CompositeNode()
self.trends.configure({'parent':self, 'name':'trends'})
self.trends.start()
# start trending for saved domains
for domain,freq in self._pdo.trends.items():
try:
start_node = as_node(domain)
# self.configure_trend_in_switches( start_node,freq )
start_node.new_trend(freq)
except:
self.delete_trend_configuration(domain)
return
def start(self):
CompositeNode.start(self)
self._set_zip_file()
tread = Thread(name="AutoDiscovery",target=self.kick_start_discovery)
scheduler.after(2, tread.start)
self.ad = AutoDiscovery()
self.ad.configure({"parent":self,"name":"AutoDiscover"})
def start(self):
self.device_map = {}
if self.debug: print 'Start modbus serial slave node'
CompositeNode.start(self)
self.subnet.start()
if self.debug: print 'modbus serial slave node started'
return
def __init__(self):
self._running = 0
self.driver = None
self.mac_address = None
self.discovery_mode = 'None'
CompositeNode.__init__(self)
AutoDiscoveredNode.__init__(self)
EventProducerMixin.__init__(self)
self.device_map = {} #keyed by mac address of clients; value=Child node
self._out_q = [] #request queue
self._out_q_cv = threading.Condition()
self._mutex = threading.Lock() #prevent multiple access to outbound commands
self._registered_clients = {}
self.transceiver_state = TransceiverState[0]
self.cov = ChangeOfValueEvent(self, None, self.transceiver_state)
self.debug = debug
self.timeout = 10 #seconds
self.who_is_interval = 10 #seconds
self.default_discovered_protocol_module = None
# @todo
# initailize this through configuration
self.default_discovered_protocol_module = feu
self.transceiver_state = 0
self.relay_node = '/interfaces/relay1' #this is temporary, should be None
self.active_devices = {}
self.status = None
def __init__(self):
CompositeNode.__init__(self)
EventConsumerMixin.__init__(self, self._cov_event_handler)
self._smid = None
self._last_value = None
self.link = None #url of bacnet schedule object
self.source = 'broadway' #or 'bacnet'
self._bacnet_datatype = 'auto'
pass
def configure(self, config):
CompositeNode.configure(self, config)
set_attribute(self, 'enabled', 1, config, int)
set_attribute(self, 'bbmd_table', [], config)
set_attribute(self, 'allow_external_table_editor', 1, config, int)
self.debug = 0
if self.debug:
print 'configure bbmd'
print str(config)
def __init__(self, log_id):
CompositeNode.__init__(self)
ConnectionMixin.__init__(self)
EventProducerMixin.__init__(self)
self.critical_data = self._CriticalData()
self._log_id = log_id
self._service_name = None
self._device = None
self._port = None
def configure(self, config):
self._pdo = PersistentDataObject(self)
self._pdo.stats_dict = {
} #used to detect changes to xml files based on timestamp. Tuple (modify time, pickle string)
self._pdo.load()
# write_priority can be set for the entire control service, though
# it may be specialized at the individual application node level.
set_attribute(self, 'write_priority', 9, config, int)
CompositeNode.configure(self, config)
def start(self):
if self._running == 0:
self._running = 1
for event_class in self._event_handlers.keys():
self.parent.event_subscribe(self, event_class)
else:
msglog.log('broadway', msglog.types.WARN, \
'Instance of %s is already running.' % str(self.__class__))
CompositeNode.start(self)
def __init__(self, cache, name, rgvm, args):
CompositeNode.__init__(self)
self.parent = cache.ion()
self.name = name
self._cache = cache
file = 'mpx.ion.capstone.micro_turbine.personality.RO_CommandCache.CommandION.__init__'
self._compiled_reference = compile(rgvm, file, 'eval')
self._rgvm_args = args
self.parent._add_child(self)
def __init__(self):
CompositeNode.__init__(self)
self.running = 0
self.discover = 0
self.line_handler = None
self._pnts_map = {}
self.debug_lvl = 0 #16383 # should be valid immediately after ctor, NOT just after configure()
self.__status = None
self.connection_type = 'rs-485'
def configure(self, config):
CompositeNode.configure(self, config)
set_attribute(self, 'dev', REQUIRED, config)
set_attribute(self, 'parity', parity_to_int('none'), config,
parity_to_int)
set_attribute(self, 'baud', 9600, config, str)
if self.baud == 'Custom':
self.baud = -1 # flag for later processing of custom_baud
else:
self.baud = int(self.baud) # normal path
set_attributes(self, (('bits', 8), ('stop_bits', 1), ('debug', 0),
('dump_cpl', 16)), config, int)
set_attribute(self, 'custom_baud', 76800, config, int)
set_attribute(self, 'flow_control', flowctl_to_int('none'), config,
flowctl_to_int)
set_attribute(self, 'lock_directory', properties.get('VAR_LOCK'),
config, str)
set_attribute(self, 'VINTR', '\x03', config, str)
set_attribute(self, 'VQUIT', '\x1c', config, str)
set_attribute(self, 'VERASE', '\x7f', config, str)
set_attribute(self, 'VKILL', '\x15', config, str)
set_attribute(self, 'VEOF', '\x04', config, str)
set_attribute(self, 'VTIME', 0, config, int)
set_attribute(self, 'VMIN', 1, config, int)
set_attribute(self, 'VSWTC', '\x00', config, str)
set_attribute(self, 'VSTART', '\x11', config, str)
set_attribute(self, 'VSTOP', '\x13', config, str)
set_attribute(self, 'VSUSP', '\x1a', config, str)
set_attribute(self, 'VEOL', '\x00', config, str)
set_attribute(self, 'VREPRINT', '\x12', config, str)
set_attribute(self, 'VDISCARD', '\x0f', config, str)
set_attribute(self, 'VWERASE', '\x17', config, str)
set_attribute(self, 'VLNEXT', '\x16', config, str)
set_attribute(self, 'VEOL2', '\x00', config, str)
set_attribute(self, 'cc17', '\x00', config, str)
set_attribute(self, 'cc18', '/', config, str)
set_attribute(self, 'cc19', '\x00', config, str)
set_attribute(self, 'cc20', '\x00', config, str)
set_attribute(self, 'cc21', '\x00', config, str)
set_attribute(self, 'cc22', '\x00', config, str)
set_attribute(self, 'cc23', '\x00', config, str)
set_attribute(self, 'cc24', '\x00', config, str)
set_attribute(self, 'cc25', '\x00', config, str)
set_attribute(self, 'cc26', '\x00', config, str)
set_attribute(self, 'cc27', '\x00', config, str)
set_attribute(self, 'cc28', '\x00', config, str)
set_attribute(self, 'cc29', '\x00', config, str)
set_attribute(self, 'cc30', '\x00', config, str)
set_attribute(self, 'cc31', '\x00', config, str)
self._devlock = DeviceLock(self.dev, self.lock_directory)
if self.is_open():
self._set_serial()
return
def configure( self, config_dict ):
CompositeNode.configure( self, config_dict )
set_attribute( self, 'enabled', 0, config_dict, int )
set_attribute( self, 'debug', self.debug, config_dict, int )
set_attribute( self, 'period', self.period, config_dict, int )
set_attribute( self, 'fast_adjust_threshold', self.fast_adjust_threshold, config_dict, int )
set_attribute( self, 'adjust_threshold', self.adjust_threshold, config_dict, int )
set_attribute( self, 'nudge_amount', self.nudge_amount, config_dict, int )
set_attribute( self, 'bcu_date', REQUIRED, config_dict )
set_attribute( self, 'bcu_time', REQUIRED, config_dict )
def start(self):
# all known relevant calculators are presently imported to this name space from xconvert.
# NameError raised if there's issue.
self.group_id = _get_group_id(self)
self.addr = _get_addr(self)
self.timeout = _get_timeout(self)
self.cache = _get_cache(self)
self.ion = self.parent
self.translator = ConversionFactory(self.cls_name, self)
CompositeNode.start(self)
def configure(self, config):
#
# log_error_value and log_error_type are used by logs that invoke
# functions to there value and may throw an exception. This provides
# a default for all columns.
#
set_attribute(self, 'log_error_value', 'None', config)
set_attribute(self, 'log_error_type', 'eval', config)
CompositeNode.configure(self, config)
return
def configure(self, cd):
CompositeNode.configure(self, cd)
self.line_handler = self.parent
set_attribute(self, 'turbine', REQUIRED, cd, int)
set_attribute(self, 'password', None, cd)
if not self._configured_caches:
self._create_alldat_cache()
self._create_single_children()
self._create_lmdata_cache()
self._configured_caches = 1
def start(self):
if self.is_remote():
e_prop = EntityProp(name='Entity',
type='Entity',
label='',
description='',
url=self.display,
entity=as_entity_url(self))
self._properties = [e_prop.as_dict()]
CompositeNode.start(self)
def __init__(self, dev_node, ckt_svc_nodes=None):
CompositeNode.__init__(self)
if ckt_svc_nodes is None:
ckt_svc_nodes = []
self._ckt_svc_nodes = ckt_svc_nodes
self._status_nodes = []
self.running = 0
self._dev_node = dev_node
self._reqs = []
return
def __init__(self):
CompositeNode.__init__(self)
self._cpc_uhp_node = None
self._cases = []
self._racks = []
self.running = 0
self._start_thread_inst = None
self._ready = 0
self.debug_lvl = 1
return
def __init__(self, ckt_dev_node):
CompositeNode.__init__(self)
self._alm_status_nodes = []
self._defr_status_nodes = []
self.running = 0
self._ckt_dev_node = ckt_dev_node
self._alarms = []
self._alm_reqs = []
self._defr_reqs = []
return
def start(self):
self.device_map = {}
if self.debug: print 'Start modbus tcpip server node'
if self.parent.__class__ == IP: #then must be an 'internet_protocol' node (1.3)
self.ip = self.parent.address
else: #must be directly under the eth# port (1.4)
self.ip = ip_address(self.parent.name)
self.server = TcpServerConnection(self.ip, self.udp_port, self)
CompositeNode.start(self)
if self.debug: print 'modbus tcpip server node started'
def __init__( self ):
CompositeNode.__init__( self )
EventProducerMixin.__init__( self )
#
self.mount_point = None
self.debug = None
#
# Set old value to something which will never be valid so that
# we always generate an event on startup.
self.old_value = -99
def __init__(self):
self._last_rcvd = 0
self._subscribers = 0
self._scheduled = None
self._skip_cache = False
self._cached_result = None
self._exec_delay = _Buffer(5)
self._subscription_lock = Lock()
CompositeNode.__init__(self)
EventProducerMixin.__init__(self)
def configure(self, config):
CompositeNode.configure(self, config)
set_attribute(self, 'debug', debug, config, int)
#
#
if debug: self.debug = debug
#
#
self.port = self #intercept any calls to the port
return
def start(self):
if not self._threadpool:
port_name = self.parent.name
self._threadpool = thread_pool.ThreadPool(
1, name='Sensorsoft ThreadPool-' + port_name)
if not self._port or not self._port.is_open():
self._port = self.parent
self._port.open()
self._port.drain()
CompositeNode.start(self)
def __init__(self, lib_device=None, discovered=None):
CompositeNode.__init__(self)
self.__node_id__ = '1254'
self.running = 0
self.device_name = None
self.discovered = discovered
self.tcstype = None
if lib_device:
if debug: print 'TCS device type= ', str(lib_device.type)
self.tcstype = str(lib_device.type)
def configure(self, cd):
CompositeNode.configure(self, cd)
try:
log_on_change = get_c_stat_log_on_change(self.c_stat_name)
except:
# If this happens, it is probably because the stat disappeared
self.log_stat_disappeared()
return None
set_attribute(self, 'log_on_change', log_on_change, cd, int)
set_attribute(self, 'time_last_changed', ctime(0), cd, str)
def configure(self, config):
if self.debug: print 'Configure modbus point'
CompositeNode.configure(self, config)
set_attribute(self, 'register', REQUIRED, config, int)
self.offset = self.register - self.base_register()
set_attribute(self, 'read_only', 1, config, int)
set_attribute(self, 'debug', 1, config, int)
set_attribute(self, 'length', 1, config, int)
ProxyAbstractClass.configure(self, config)
if self.debug: print 'Configured modbus point', self
def stop(self):
self._running = 0
##
# @todo Remove auto-created nodes (eg logger, aeroserver, etc.),
# to prevent "Already Exists" errors at next call on start(). OR
# simply check for node pre-existence during start. Reconfig if
# nodes already exist.
#
CompositeNode.stop(self)
return
def __init__(self):
self._threadpool = None
self._init_complete = False
self._port = None
self._request = {} # k:(rqst_type, addr,) v: request object
self.__update_freqs = {}
self.__callbacks = {}
self.__callback_lock = threading.Lock()
self.__port_lock = threading.Lock()
CompositeNode.__init__(self)
def configure(self, config):
CompositeNode.configure(self, config)
set_attribute(self, 'ncounters', REQUIRED, config, int)
set_attribute(self, 'nDIs', REQUIRED, config, int)
set_attribute(self, 'nrelays', REQUIRED, config, int)
set_attribute(self, 'ndallas_busses', REQUIRED, config, int)
set_attribute(self, 'nGPIOs', REQUIRED, config, int)
# Open the avr devices.
self.avr = None
self.avroob = None
try:
self.avr = open("/dev/avr", "r+")
self.avroob = open("/dev/avroob", "r")
self.p = select.poll()
self.p.register(self.avroob, select.POLLIN)
avr_maj_ver = ord(self.invoke_message('\x17\x00\x00')[0])
if (avr_maj_ver < 2) and (self.nGPIOs > 0):
self.nGPIOs = 0
msglog.log('mpx',msglog.types.ERR,'No GPIOs created; AVR version is %s; should be 2.x or greater.' \
% self.version())
# Attach the counters, relays and dallas busses to the AVR.
config_list = (('mpx.ion.host.avr.counter', 'counter',
self.ncounters), ('mpx.ion.host.avr.di', 'DI',
self.nDIs),
('mpx.ion.host.avr.relay', 'relay', self.nrelays),
('mpx.ion.host.avr.dallasbus', 'dallas',
self.ndallas_busses), ('mpx.ion.host.avr.gpio',
'gpio', self.nGPIOs))
for module, prefix, count in config_list:
for i in range(1, count + 1):
name = prefix + str(i)
config = {
'name': name,
'id': i,
'avr': self,
'parent': self
}
ion = mpx.lib.factory(module)
ion.configure(config)
except:
msglog.log('broadway', msglog.types.ERR,
"Failed to open avr device.")
msglog.exception()
self.p = select.poll()
if self.avr:
self.avr.close()
self.avr = None
if self.avroob:
self.avroob.close()
self.avroob = None
pass
return
def start(self):
CompositeNode.start(self)
for i in range(0,4):
label = getattr(self,'label%s' % (i+1,))
point = getattr(self,'point%s' % (i+1,))
if point:
node = as_node(point)
else:
node = None
self._channels.append(_Channel(i,self.id,label,node))
return
def configure(self,config):
self.timeout = 1.0
CompositeNode.configure(self,config)
set_attribute(self, 'ip', REQUIRED, config)
set_attribute(self, 'port', 502, config, int)
self.udp_port = int(self.port)
set_attribute(self, 'debug', 0, config, int)
set_attribute(self, 'retries', 3, config, int)
set_attribute(self, 'report_timeouts', 1, config, int)
self.port = self #intercept any calls to the port
return
def start(self):
if self.interval_calculation == self.CHARACTER_TIME:
self.__silent_interval = (self.silent_interval_characters *
self.port.seconds_per_character())
elif self.interval_calculation == self.ABSOLUTE:
self.__silent_interval = self.silent_interval_absolute
else:
raise EInvalidValue('interval_calculation',
self.interval_calculation)
CompositeNode.start(self)
return
