def connectToPorts(connectedPorts, portNum):
if portNum == 'a':
subscribers = []
for p in range(len(connectedPorts)):
connect_manager_serial(mymanagers[p], connectedPorts[p])
# subscribe to data notifications
subscriber = IpMgrSubscribe.IpMgrSubscribe(mymanagers[p])
subscriber.start()
subscriber.subscribe(
notifTypes=[
IpMgrSubscribe.IpMgrSubscribe.NOTIFHEALTHREPORT,
IpMgrSubscribe.IpMgrSubscribe.NOTIFEVENT,
],
fun=data_handlers[p],
isRlbl=True,
)
subscribers.append(subscriber)
res = mymanagers[p].dn_getNetworkConfig()
portsManagerDict[connectedPorts[p]] = {
'manager': mymanagers[p],
'network': res.networkId,
'data_handler': data_handlers[p]
}
else:
connect_manager_serial(mymanagers[portNum], connectedPorts[portNum])
# subscribe to data notifications
subscriber = IpMgrSubscribe.IpMgrSubscribe(mymanagers[portNum])
subscriber.start()
subscriber.subscribe(
notifTypes=[
IpMgrSubscribe.IpMgrSubscribe.NOTIFHEALTHREPORT,
IpMgrSubscribe.IpMgrSubscribe.NOTIFEVENT,
],
fun=data_handlers[portNum],
isRlbl=True,
)
res = mymanagers[portNum].dn_getNetworkConfig()
portsManagerDict[connectedPorts[portNum]] = {
'manager': mymanagers[portNum],
'network': res.networkId,
'data_handler': data_handlers[portNum]
}
def __init__(
self,
connector,
disconnectedCB,
displayConfigurationCB,
displayErrorCB
):
# store params
self.connector = connector
self.disconnectedCB = disconnectedCB
self.displayConfigurationCB = displayConfigurationCB
self.displayErrorCB = displayErrorCB
# local variables
self.converters = DC2126AConverters.DC2126AConverters()
# subscriber
self.subscriber = IpMgrSubscribe.IpMgrSubscribe(self.connector)
self.subscriber.start()
self.subscriber.subscribe(
notifTypes = [
IpMgrSubscribe.IpMgrSubscribe.NOTIFDATA,
],
fun = self._notifDataCallback,
isRlbl = False,
)
self.subscriber.subscribe(
notifTypes = [
IpMgrSubscribe.IpMgrSubscribe.ERROR,
IpMgrSubscribe.IpMgrSubscribe.FINISH,
],
fun = self.disconnectedCB,
isRlbl = True,
)
def __init__(self, connector, disconnectedCallback, presenterMote=None):
# store params
self.connector = connector
self.disconnectedCallback = disconnectedCallback
# variables
self.dataLock = threading.RLock()
self.networkMotes = []
self.presenterMote = presenterMote
self.questionNum = self._getInitQuestionNum()
self._resetData()
# subscriber
if (self.connector != None and self.disconnectedCallback != None):
self.subscriber = IpMgrSubscribe.IpMgrSubscribe(self.connector)
self.subscriber.start()
self.subscriber.subscribe(
notifTypes=[
IpMgrSubscribe.IpMgrSubscribe.NOTIFDATA,
],
fun=self._notifDataCallback,
isRlbl=False,
)
self.subscriber.subscribe(
notifTypes=[
IpMgrSubscribe.IpMgrSubscribe.ERROR,
IpMgrSubscribe.IpMgrSubscribe.FINISH,
],
fun=self.disconnectedCallback,
isRlbl=False,
)
def __init__(self, connector, disconnectedCallback):
# store params
self.connector = connector
self.disconnectedCallback = disconnectedCallback
# variables
self.data = []
self.data.append(
['mac', '# Device HRs', '# Neighbors HRs',
'# Discovered HRs']) # header
self.dataLock = threading.Lock()
self.hrParser = HrParser.HrParser()
# log
hrlog.info("============= START LOGGING HEALTH REPORTS ==============")
# subscriber
self.subscriber = IpMgrSubscribe.IpMgrSubscribe(self.connector)
self.subscriber.start()
self.subscriber.subscribe(
notifTypes=[
IpMgrSubscribe.IpMgrSubscribe.NOTIFHEALTHREPORT,
],
fun=self._notifCallback,
isRlbl=True,
)
self.subscriber.subscribe(
notifTypes=[
IpMgrSubscribe.IpMgrSubscribe.ERROR,
IpMgrSubscribe.IpMgrSubscribe.FINISH,
],
fun=self.disconnectedCallback,
isRlbl=True,
)
def _mgrconnectionFrameCb_connected(self, mgrconnector):
'''
\brief Called when the application has connected to the manager.
'''
# store the connector
self.mgrconnector = mgrconnector
# add subscriber for the manager
self.mgrsubscriber = IpMgrSubscribe.IpMgrSubscribe(self.mgrconnector)
self.mgrsubscriber.start()
self.mgrsubscriber.subscribe(
notifTypes=[
IpMgrSubscribe.IpMgrSubscribe.NOTIFIPDATA,
],
fun=self._mgrRxCallback,
isRlbl=False,
)
self.mgrsubscriber.subscribe(
notifTypes=[
IpMgrSubscribe.IpMgrSubscribe.ERROR,
IpMgrSubscribe.IpMgrSubscribe.FINISH,
],
fun=self._mgrconnectionFrameCb_disconnected,
isRlbl=True,
)
def __init__(
self,
connector,
disconnectedCB,
updateMotesCB,
):
# store params
self.connector = connector
self.disconnectedCB = disconnectedCB
self.updateMotesCB = updateMotesCB
# local variables
self.converters = DC2369AConverters.DC2369AConverters(SCALE_CURRENT)
# subscriber
self.subscriber = IpMgrSubscribe.IpMgrSubscribe(self.connector)
self.subscriber.start()
self.subscriber.subscribe(
notifTypes=[
IpMgrSubscribe.IpMgrSubscribe.NOTIFDATA,
],
fun=self._notifDataCallback,
isRlbl=False,
)
self.subscriber.subscribe(
notifTypes=[
IpMgrSubscribe.IpMgrSubscribe.ERROR,
IpMgrSubscribe.IpMgrSubscribe.FINISH,
],
fun=self.disconnectedCB,
isRlbl=True,
)
def __init__(self, connector):
# store params
self.connector = connector
# local variables
self.dataLock = threading.RLock(
) # lock access to the object variables
self.expectedOAPResp = [] # MAC addresses of all operational motes
self.tsStart = None # timestamp when the OAP commands was sent
self.state = self.ST_IDLE # state of the fsm we are currently in
self.numBcastAttempts = 0 # number of broadcast attempts
self.numUnicastAttempts = 0 # number of unicast attempts (reset for each node)
self.lastUnicastDest = None # destination MAC address of the last unicast
self.toutTimer = None # timer to measure timeout
self.rtts = [] # round-trip-times of all OAP responses
self.failedNodes = [] # nodes that never answered
# subscribe to notifications from the SmartMesh IP manager
self.subscriber = IpMgrSubscribe.IpMgrSubscribe(self.connector)
self.subscriber.start()
self.subscriber.subscribe(
notifTypes=[
IpMgrSubscribe.IpMgrSubscribe.NOTIFDATA,
],
fun=self._notifDataReceived,
isRlbl=True,
)
'''
def __init__(self, connector, disconnectedCallback):
# store params
self.connector = connector
self.disconnectedCallback = disconnectedCallback
# variables
self.data = None
self.dataLock = threading.Lock()
# subscriber
self.subscriber = IpMgrSubscribe.IpMgrSubscribe(self.connector)
self.subscriber.start()
self.subscriber.subscribe(
notifTypes=[
IpMgrSubscribe.IpMgrSubscribe.NOTIFDATA,
],
fun=self._notifDataCallback,
isRlbl=False,
)
self.subscriber.subscribe(
notifTypes=[
IpMgrSubscribe.IpMgrSubscribe.ERROR,
IpMgrSubscribe.IpMgrSubscribe.FINISH,
],
fun=self.disconnectedCallback,
isRlbl=True,
)
def __init__(self, connector, disconnectedCallback):
# store params
self.connector = connector
self.disconnectedCallback = disconnectedCallback
# variables
self.hrParser = HrParser.HrParser()
# activitylog
activitylog.info("[{0}] [startLogging]".format(currentUtcTime()))
# subscriber
self.subscriber = IpMgrSubscribe.IpMgrSubscribe(self.connector)
self.subscriber.start()
self.subscriber.subscribe(
notifTypes=[
IpMgrSubscribe.IpMgrSubscribe.ERROR,
IpMgrSubscribe.IpMgrSubscribe.FINISH,
],
fun=self.disconnectedCallback,
isRlbl=False,
)
self.subscriber.subscribe(
notifTypes=[
IpMgrSubscribe.IpMgrSubscribe.NOTIFEVENT,
IpMgrSubscribe.IpMgrSubscribe.NOTIFDATA,
IpMgrSubscribe.IpMgrSubscribe.NOTIFIPDATA,
IpMgrSubscribe.IpMgrSubscribe.NOTIFHEALTHREPORT,
],
fun=self._notifCallback,
isRlbl=False,
)
def __init__(self):
# OAP dispatcher
AppData().set('oap_dispatch',OAPDispatcher.OAPDispatcher())
AppData().get('oap_dispatch').register_notif_handler(self._handle_oap_notif)
# subscriber
self.subscriber = IpMgrSubscribe.IpMgrSubscribe(AppData().get('connector'))
self.subscriber.start()
self.subscriber.subscribe(
notifTypes = [
IpMgrSubscribe.IpMgrSubscribe.NOTIFDATA,
],
fun = self._cb_NOTIFDATA,
isRlbl = False,
)
# list operational motes
AppData().set('oap_clients',{})
numMotes = getOperationalMotes()
if numMotes:
printOperationalMotes()
selectOperationalMote(0)
AppData().set('printNotifs',False)
togglePrintNotifs()
self.log_file = open(LOGFILE, 'w')
AppData().set('logNotifs',True)
toggleLogNotifs()
# Added to calculate Mgr vs system time offset in the log prints
self.mapmgrtime = MgrTime(0, 20)
self.mapmgrtime.start()
def main():
global frontendName
# Parse CLI arguments
parser = argparse.ArgumentParser(prog='rfid-cli',
description='RFID command line client')
parser.add_argument('-p',
'--port',
help='SmartMesh manager serial port',
required=True)
parser.add_argument('-f',
'--frontend',
help='The web frontend to display',
required=True)
args = parser.parse_args()
# Fetch user defined COM port
port = args.port
frontendName = args.frontend
# Create serial connection to manager
print('Connecting to {0}'.format(port))
connector = IpMgrConnectorSerial.IpMgrConnectorSerial()
try:
connector.connect({'port': port})
except ConnectionError as err:
print('Could not connect to {0}: {1}'.format(port, err))
connector.disconnect()
sys.exit(1)
# Hook program exits and perform cleanup
def cleanup(signum, frame):
# Disconnect the serial connection on exit
# NOTE: Failure to disconnect the connector will mean the
# program will not exit due to still running threads
print('Disconnecting from {0}...'.format(port))
connector.disconnect()
print('Disconnection successful')
sys.exit(0)
signal.signal(signal.SIGINT, cleanup)
# Create SmartMesh subscriber
print('Connection successful.')
print('Subscribing to SmartMesh notifications...')
subscriber = IpMgrSubscribe.IpMgrSubscribe(connector)
subscriber.start()
subscriber.subscribe(
notifTypes=[IpMgrSubscribe.IpMgrSubscribe.NOTIFDATA],
fun=meshNotificationHandler,
isRlbl=False,
)
# Start web server
print('Running web server: http://127.0.0.1:5000')
socketio.run(app, host='127.0.0.1', port='5000')
def __init__(self, apiDef, connector, disconnectedCallback):
# store params
self.apiDef = apiDef
self.connector = connector
self.disconnectedCallback = disconnectedCallback
# log
log.debug("Initialize notifClient")
# variables
self.dataLock = threading.RLock()
self.isMoteActive = {}
self.tabledata = {}
self.tableupdates = {}
# subscriber
self.subscriber = IpMgrSubscribe.IpMgrSubscribe(self.connector)
self.subscriber.start()
self.subscriber.subscribe(
notifTypes = [
NOTIFDATA,
],
fun = self._notifDataCallbackTunneled,
isRlbl = False,
)
self.subscriber.subscribe(
notifTypes = [
NOTIFEVENT,
],
fun = self._notifEventCallback,
isRlbl = True,
)
self.subscriber.subscribe(
notifTypes = [
NOTIFHEALTHREPORT,
],
fun = self._notifHrCallback,
isRlbl = True,
)
self.subscriber.subscribe(
notifTypes = [
IpMgrSubscribe.IpMgrSubscribe.ERROR,
IpMgrSubscribe.IpMgrSubscribe.FINISH,
],
fun = self.disconnectedCallback,
isRlbl = True,
)
# OAP dispatcher
self.oap_dispatch = OAPDispatcher.OAPDispatcher()
self.oap_dispatch.register_notif_handler(self._handle_oap_notif)
def connectToPort(port):
pm = portsManagerDict[port]
connect_manager_serial(pm['manager'], port)
# subscribe to data notifications
subscriber = IpMgrSubscribe.IpMgrSubscribe(pm['manager'])
subscriber.start()
subscriber.subscribe(
notifTypes=[
IpMgrSubscribe.IpMgrSubscribe.NOTIFHEALTHREPORT,
IpMgrSubscribe.IpMgrSubscribe.NOTIFEVENT,
],
fun=pm['data_handler'],
isRlbl=True,
)
def __init__(self, connector):
# store params
self.connector = connector
# subscriber
self.subscriber = IpMgrSubscribe.IpMgrSubscribe(self.connector)
self.subscriber.start()
self.subscriber.subscribe(
notifTypes=[
IpMgrSubscribe.IpMgrSubscribe.NOTIFHEALTHREPORT,
],
fun=self._notifHealthReportCb,
isRlbl=True,
)
'''
def __init__(self, apiDef, connector, disconnectedCallback, latencyCalculator):
# store params
self.apiDef = apiDef
self.connector = connector
self.disconnectedCallback = disconnectedCallback
self.latencyCalculator = latencyCalculator
# variables
self.dataLock = threading.Lock()
self.isMoteActive = {}
self.data = {}
self.updates = {}
# subscriber
self.subscriber = IpMgrSubscribe.IpMgrSubscribe(self.connector)
self.subscriber.start()
self.subscriber.subscribe(
notifTypes = [
IpMgrSubscribe.IpMgrSubscribe.NOTIFDATA,
],
fun = self._dataCallback,
isRlbl = False,
)
self.subscriber.subscribe(
notifTypes = [
IpMgrSubscribe.IpMgrSubscribe.NOTIFEVENT,
],
fun = self._eventCallback,
isRlbl = True,
)
self.subscriber.subscribe(
notifTypes = [
IpMgrSubscribe.IpMgrSubscribe.ERROR,
IpMgrSubscribe.IpMgrSubscribe.FINISH,
],
fun = self.disconnectedCallback,
isRlbl = True,
)
# OAP dispatcher
self.oap_dispatch = OAPDispatcher.OAPDispatcher()
self.oap_dispatch.register_notif_handler(self._handle_oap_notif)
def run(self):
while self.goOn:
try:
print 'Connecting to {0}...'.format(self.serialPort),
self.connector = IpMgrConnectorSerial.IpMgrConnectorSerial()
self.connector.connect({'port': self.serialPort})
subscriber = IpMgrSubscribe.IpMgrSubscribe(self.connector)
subscriber.start()
subscriber.subscribe(
notifTypes=[
IpMgrSubscribe.IpMgrSubscribe.ERROR,
IpMgrSubscribe.IpMgrSubscribe.FINISH,
],
fun=self._handle_ErrorFinish,
isRlbl=True,
)
subscriber.subscribe(
notifTypes=[
IpMgrSubscribe.IpMgrSubscribe.NOTIFDATA,
],
fun=self._handle_data,
isRlbl=False,
)
self.oap_dispatch = OAPDispatcher.OAPDispatcher()
self.oap_dispatch.register_notif_handler(self._handle_oap)
AppData().setConnector(self.connector)
except Exception as err:
print 'FAIL:'
print err
time.sleep(1)
else:
print 'PASS.'
self.reconnectEvent.clear()
self.reconnectEvent.wait()
finally:
try:
self.connector.disconnect()
except:
pass
def __init__(self, connector, disconnectedCallback):
# store params
self.connector = connector
self.disconnectedCallback = disconnectedCallback
self.oap_clients = {}
# variables
# subscriber
self.subscriber = IpMgrSubscribe.IpMgrSubscribe(self.connector)
self.subscriber.start()
self.subscriber.subscribe(
notifTypes=[
IpMgrSubscribe.IpMgrSubscribe.NOTIFEVENT,
],
fun=self._eventHandler,
isRlbl=True,
)
self.subscriber.subscribe(
notifTypes=[
IpMgrSubscribe.IpMgrSubscribe.ERROR,
IpMgrSubscribe.IpMgrSubscribe.FINISH,
],
fun=self._errorHandler,
isRlbl=True,
)
self.subscriber.subscribe(
notifTypes=[
IpMgrSubscribe.IpMgrSubscribe.NOTIFDATA,
],
fun=self._notifDataHandler,
isRlbl=False,
)
# OAP dispatcher
self.oap_dispatch = OAPDispatcher.OAPDispatcher()
self.oap_dispatch.register_notif_handler(self._handle_oap_notif)
def _connectionFrameCb_connected(self, connector):
'''
\brief Called when the connectionFrame has connected.
'''
# store the connector
self.connector = connector
# schedule the GUI to update
self.LEDPingFrame.after(LEDUPDATEPERIOD, self._gui_refresh_led)
self.LEDPingFrame.after(RATEUPDATEPERIOD, self._gui_refresh_rate)
# have LEDPingFrame enable button
self.LEDPingFrame.enableButton()
# OAP dispatcher
self.oap_dispatch = OAPDispatcher.OAPDispatcher()
# create a subscriber
self.subscriber = IpMgrSubscribe.IpMgrSubscribe(self.connector)
self.subscriber.start()
self.subscriber.subscribe(
notifTypes=[
IpMgrSubscribe.IpMgrSubscribe.NOTIFDATA,
],
fun=self.oap_dispatch.dispatch_pkt,
isRlbl=False,
)
self.subscriber.subscribe(
notifTypes=[
IpMgrSubscribe.IpMgrSubscribe.ERROR,
IpMgrSubscribe.IpMgrSubscribe.FINISH,
],
fun=self._notifClientCb_disconnected,
isRlbl=True,
)
def __init__(self, apiDef, connector, disconnectedCallback):
# store params
self.apiDef = apiDef
self.connector = connector
self.disconnectedCallback = disconnectedCallback
# log
log.debug("Initialize notifClient")
# variables
self.dataLock = threading.Lock()
self.isMoteActive = {}
self.data = {}
self.updates = {}
self.rateCalc = {}
# OAP dispatcher
self.oap_dispatch = OAPDispatcher.OAPDispatcher()
self.oap_dispatch.register_notif_handler(self._handle_oap_notif)
# subscriber
if isinstance(self.apiDef, IpMgrDefinition.IpMgrDefinition):
# we are connected to an IP manager
self.subscriber = IpMgrSubscribe.IpMgrSubscribe(self.connector)
self.subscriber.start()
self.subscriber.subscribe(
notifTypes=[
IpMgrSubscribe.IpMgrSubscribe.NOTIFDATA,
],
fun=self._dataCallback,
isRlbl=False,
)
self.subscriber.subscribe(
notifTypes=[
IpMgrSubscribe.IpMgrSubscribe.NOTIFEVENT,
],
fun=self._eventCallback,
isRlbl=True,
)
self.subscriber.subscribe(
notifTypes=[
IpMgrSubscribe.IpMgrSubscribe.ERROR,
IpMgrSubscribe.IpMgrSubscribe.FINISH,
],
fun=self.disconnectedCallback,
isRlbl=True,
)
elif isinstance(self.apiDef, HartMgrDefinition.HartMgrDefinition):
# we are connected to a HART manager
self.subscriber = HartMgrSubscriber(self.connector,
self._dataCallback,
self._eventCallback,
self.disconnectedCallback)
self.subscriber.start()
else:
output = "apiDef of type {0} unexpected".format(type(self.apiDef))
log.critical(output)
print output
raise SystemError(output)
raw_input('\nScript ended. Press Enter to exit.')
sys.exit(1)
print 'done.'
#=== Initializing the Pipe to send Data to C++
#print 'Starting Process'
#proc = subprocess.Popen('C:\Users\Henry Hein\Documents\Visual Studio 2015\Projects\ConsoleApplication4\Release\ConsoleApplication4',
# stdin = subprocess.PIPE, #stdout = subprocess.PIPE, stderr = subprocess.PIPE,
# creationflags = CREATE_NEW_CONSOLE)
#=====
try:
print "- subscribe to data notifications "
subscriber = IpMgrSubscribe.IpMgrSubscribe(connector)
subscriber.start()
subscriber.subscribe(
notifTypes=[
IpMgrSubscribe.IpMgrSubscribe.NOTIFDATA,
],
fun=handle_data,
isRlbl=False,
)
#===
raw_input("Press any key to stop.")
connector.disconnect()
print 'Script ended normally.'
def run(self):
try:
while self.goOn:
try:
# connect to the manager
self.connector = IpMgrConnectorSerial.IpMgrConnectorSerial(
)
self.connector.connect({
'port': self.serialport,
})
# subscribe to notifications
self.subscriber = IpMgrSubscribe.IpMgrSubscribe(
self.connector)
self.subscriber.start()
self.subscriber.subscribe(
notifTypes=[
IpMgrSubscribe.IpMgrSubscribe.NOTIFDATA,
],
fun=self._notifAll,
isRlbl=False,
)
self.subscriber.subscribe(
notifTypes=[
IpMgrSubscribe.IpMgrSubscribe.NOTIFEVENT,
IpMgrSubscribe.IpMgrSubscribe.NOTIFHEALTHREPORT,
IpMgrSubscribe.IpMgrSubscribe.NOTIFIPDATA,
IpMgrSubscribe.IpMgrSubscribe.NOTIFLOG,
],
fun=self._notifAll,
isRlbl=True,
)
self.subscriber.subscribe(
notifTypes=[
IpMgrSubscribe.IpMgrSubscribe.ERROR,
IpMgrSubscribe.IpMgrSubscribe.FINISH,
],
fun=self._notifErrorFinish,
isRlbl=True,
)
except Exception as err:
try:
self.connector.disconnect()
except Exception:
pass
# wait to reconnect
time.sleep(1)
else:
self.reconnectEvent.clear()
self.reconnectEvent.wait()
try:
self.connector.disconnect()
except Exception:
pass
except Exception as err:
logCrash(self.name, err)
def __init__(self, connector, connectParams):
assert isinstance(connector, ApiConnector.ApiConnector)
assert isinstance(connectParams, (str, tuple))
# record parameters
self.connector = connector
self.connectParams = connectParams
# log
log.info("creating instance")
# variables
self.netname = FormatUtils.formatConnectionParams(self.connectParams)
self.statsLock = threading.Lock()
self._clearStats()
# start snapshot thread this manager
self.snapShotThread = SnapShot.SnapShot(connector, connectParams)
# subscribe to flows
try:
self.subscriber = IpMgrSubscribe.IpMgrSubscribe(self.connector)
self.subscriber.start()
self.subscriber.subscribe(
notifTypes=[
IpMgrSubscribe.IpMgrSubscribe.NOTIFDATA,
],
fun=self._subs_notifData,
isRlbl=False,
)
self.subscriber.subscribe(
notifTypes=[
IpMgrSubscribe.IpMgrSubscribe.NOTIFEVENT,
],
fun=self._subs_notifEvent,
isRlbl=True,
)
self.subscriber.subscribe(
notifTypes=[
IpMgrSubscribe.IpMgrSubscribe.NOTIFHEALTHREPORT,
],
fun=self._subs_notifHealthReport,
isRlbl=True,
)
self.subscriber.subscribe(
notifTypes=[
IpMgrSubscribe.IpMgrSubscribe.ERROR,
IpMgrSubscribe.IpMgrSubscribe.FINISH,
],
fun=self._subs_errorORfinish,
isRlbl=True,
)
except TypeError as err:
log.error(str(err))
raise ApiException.ConnectionError(str(err))
self.subscriber._thread.name = '{0}_IpMgrSubscribe'.format(
self.netname)
# initialize parent class
EventBusClient.EventBusClient.__init__(
self,
'dataToMesh_{0}'.format(self.netname),
self._ebHandler_dataToMesh,
)
# give this thread a name
self.name = '{0}_GatewayListener'.format(self.netname)
def run(self):
with self.dataLock:
self.isReconnecting = True
while (True):
try:
#==== wait for an order to (re)connect
self.reconnectSem.acquire()
with self.dataLock:
assert self.isReconnecting == True
#==== connect to serial port
if isinstance(self.connection_details, str):
# connecting to a serial port
self.connector = IpMgrConnectorSerial.IpMgrConnectorSerial(
)
self.connector.connect({
'port': self.connection_details,
})
else:
# connecting to the serialMux
self.connector = IpMgrConnectorMux.IpMgrConnectorMux()
self.connector.connect({
'host': self.connection_details[0],
'port': self.connection_details[1],
})
#==== getTime
temp = self.connector.dn_getTime()
managerTime = float(temp.utcSecs) + float(
temp.utcUsecs / 1000000.0)
self.csvLogger.managerTime(managerTime)
#==== subscribe
self.subscriber = IpMgrSubscribe.IpMgrSubscribe(self.connector)
self.subscriber.start()
self.subscriber.subscribe(
notifTypes=[
IpMgrSubscribe.IpMgrSubscribe.NOTIFDATA,
],
fun=self._subs_notifData,
isRlbl=False,
)
self.subscriber.subscribe(
notifTypes=[
IpMgrSubscribe.IpMgrSubscribe.FINISH,
IpMgrSubscribe.IpMgrSubscribe.ERROR,
],
fun=self._subs_finishOrError,
isRlbl=True,
)
#==== log
self.csvLogger.log(CsvLogger.EVENT_CONNECTED)
log.info(CsvLogger.EVENT_CONNECTED)
except ConnectionError as err:
# log
log.warning(err)
# schedule reconnection
self._reconnect()
# wait before attempting to reconnect
time.sleep(1)
else:
with self.dataLock:
# remember I'm not connecting anymore
self.isReconnecting = False