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