def connect_clicb(params):
# filter params
port = params[0]
try:
AppData().get('connector')
except KeyError:
pass
else:
print 'already connected.'
return
# create a connector
AppData().set('connector',IpMgrConnectorSerial.IpMgrConnectorSerial())
# connect to the manager
try:
AppData().get('connector').connect({
'port': port,
})
except ConnectionError as err:
print 'Could not connect to {0}: {1}'.format(
port,
err,
)
AppData().delete('connector')
return
# start threads
AppData().set('manager',Manager())
def disconnectManagers(port):
pm = portsManagerDict[port]
try:
pm['manager'].disconnect()
pm['manager'] = IpMgrConnectorSerial.IpMgrConnectorSerial()
except Exception as e:
print e
def __init__(self):
self.fileLock = threading.RLock()
self.hdlc = OpenHdlc.OpenHdlc()
self.hrParser = HrParser.HrParser()
self.api = IpMgrDefinition.IpMgrDefinition()
self.connSerial = IpMgrConnectorSerial.IpMgrConnectorSerial()
self.oapLock = threading.RLock()
self.oap = OAPDispatcher.OAPDispatcher()
self.oap.register_notif_handler(self._handle_oap_notif)
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 run(self):
# connect to manager
self.mgr = IpMgrConnectorSerial.IpMgrConnectorSerial()
self.mgr.connect({'port': SERIALPORT_MGR})
# connect to tag
self.tag = IpMoteConnector.IpMoteConnector()
self.tag.connect({'port': SERIALPORT_TAG})
for networksize in range(5,46,5):
self.runExperimentForSize(networksize)
def connect_clicb(params):
global connector
global oapTxRx
# filter params
port = params[0]
# create a coonnector
connector = IpMgrConnectorSerial.IpMgrConnectorSerial()
# connect to the manager
try:
connector.connect({
'port': port,
})
except ConnectionError as err:
printExcAndQuit(err)
# create main object
oapTxRx = OapTxRx(connector)
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 connect_clicb(params):
global connector
global notifThread
global snapshotThread
# filter params
port = params[0]
# create a coonnector
connector = IpMgrConnectorSerial.IpMgrConnectorSerial()
# connect to the manager
try:
connector.connect({
'port': port,
})
except ConnectionError as err:
printExcAndQuit(err)
# start threads
notifThread = NotifThread(connector)
snapshotThread = SnapshotThread(connector)
def createManagers(ports):
global mymanagers
mymanagers = []
for p in ports:
mymanagers.append(IpMgrConnectorSerial.IpMgrConnectorSerial())
DEFAULT_MgrSERIALPORT = '/dev/ttyUSB3'
NUMBER_OF_NETWORKS = 3
#============================ Global Variables ================================
networkIds = []
reportQueue = Queue.Queue(maxsize=0)
errorQueue = Queue.Queue(maxsize=0)
queueReady = True
queueBusy = False
session = requests.Session()
database_session = dict()
mymanagers = []
moteDict = {}
mymanager = IpMgrConnectorSerial.IpMgrConnectorSerial()
portsManagerDict = {}
indexPortsDict = {}
globalmacAddress = [0, 0, 0, 0, 0, 0, 0, 0]
managerAddress = []
#============================ functions =======================================
#----------------------------------------------------
# find_connected_devices(mymanager):
# - The point of this function is to scan for
# all connected USB devices and recognize the
# Dust Managers
# - This should be platform independent
# - TODO: Scanning should be implemented by
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
def _addManagerConnection(self,connectParam):
dld = DustLinkData.DustLinkData()
with dld.dataLock:
assert(connectParam not in self.apiconnectors)
assert(connectParam not in self.listeners)
assert(connectParam not in self.netstate)
assert(connectParam not in self.analyzers)
assert(connectParam not in self.publishers)
try:
#===== self.apiconnectors
if isinstance(connectParam,str):
# connecting to a serial port
newConnector = IpMgrConnectorSerial.IpMgrConnectorSerial()
newConnector.connect({
'port': connectParam,
})
else:
# connecting to the serialMux
newConnector = IpMgrConnectorMux.IpMgrConnectorMux()
newConnector.connect({
'host': connectParam[0],
'port': connectParam[1],
})
# log
log.info('added apiconnectors {0}'.format(connectParam))
self.apiconnectors[connectParam] = newConnector
dld.updateManagerConnectionState(
connectParam,
DustLinkData.DustLinkData.MANAGERCONNECTION_STATE_ACTIVE
)
#===== delete network
try:
dld.deleteNetwork(FormatUtils.formatConnectionParams(connectParam))
except ValueError:
pass # happens if network doesn't exist
#===== add network
try:
dld.addNetwork(FormatUtils.formatConnectionParams(connectParam))
except ValueError:
pass # happens if network already exists from previous connection
#===== self.listeners
assert(connectParam not in self.listeners)
self.listeners[connectParam] = GatewayListener.GatewayListener(
self.apiconnectors[connectParam],
connectParam,
)
log.info('added listener {0}'.format(connectParam))
#===== self.netstate
assert(connectParam not in self.netstate)
self.netstate[connectParam] = NetworkState.NetworkState(connectParam)
log.info('added netstate {0}'.format(connectParam))
#===== self.analyzers
assert(connectParam not in self.analyzers)
self.analyzers[connectParam] = NetworkStateAnalyzer.NetworkStateAnalyzer(connectParam)
log.info('added analyzer {0}'.format(connectParam))
#===== self.publishers
assert(connectParam not in self.publishers)
self.publishers[connectParam] = NetworkStatePublisher.NetworkStatePublisher(connectParam)
log.info('added publisher {0}'.format(connectParam))
except Exception as err:
# log
log.warning('could not add apiconnectors {0}: {1}'.format(connectParam, err))
# update state
dld.updateManagerConnectionState(
connectParam,
DustLinkData.DustLinkData.MANAGERCONNECTION_STATE_FAIL,
reason = str(err),
)
# detelete the connection to the manager
self._deleteManagerConnection(connectParam)
def run(self):
try:
dld = DustLinkData.DustLinkData()
dld._resetScratchpad()
dld._addScratchpad(
"<p class=\"doc-header\">Resetting manager.</p>")
#===== connecting to manager
dld._addScratchpad("<p>connecting to manager at {0}.</p>".format(
self.connectionParams))
try:
if isinstance(self.connectionParams, tuple):
# over serialMux
connector = IpMgrConnectorMux.IpMgrConnectorMux()
connector.connect({
'host': self.connectionParams[0],
'port': self.connectionParams[1],
})
else:
# over serial
connector = IpMgrConnectorSerial.IpMgrConnectorSerial()
connector.connect({
'port': self.connectionParams,
})
except Exception as err:
dld._addScratchpad(
"<p class=\"doc-warning\">connection failed: {0}.</p>".
format(err))
return
else:
dld._addScratchpad(
"<p class=\"doc-success\">connection successful.</p>")
try:
#===== issuing dn_getNetworkConfig()
dld._addScratchpad("<p>issuing dn_getNetworkConfig()</p>")
try:
oldconf = connector.dn_getNetworkConfig()
except Exception as err:
dld._addScratchpad(
"<p class=\"doc-warning\">failed issuing dn_getNetworkConfig(): {0}.</p>"
.format(err))
return
else:
output = []
output += [
"<p class=\"doc-success\">issued dn_getNetworkConfig() succesfully.</p>"
]
output += ["<p>Received the following fields:</p>"]
output += ["<table>"]
output += [
"<tr><td>{0}</td><td>{1}</td></tr>".format(
k, getattr(oldconf, k)) for k in oldconf._fields
]
output += ["</table>"]
output = ''.join(output)
dld._addScratchpad(output)
#===== issuing dn_setNetworkConfig()
newconf = {
'networkId': oldconf.networkId,
'apTxPower': 8,
'frameProfile': 1,
'maxMotes': 33,
'baseBandwidth': 9000,
'downFrameMultVal': 1,
'numParents': 2,
'ccaMode': 0,
'channelList': 32767,
'autoStartNetwork': 1,
'locMode': 0,
'bbMode': 0,
'bbSize': 1,
'isRadioTest': 0,
'bwMult': 300,
'oneChannel': 255,
}
output = []
output += [
"<p>issuing dn_setNetworkConfig() with the following parameters</p>"
]
output += ["<table>"]
output += [
"<tr><td>{0}</td><td>{1}</td></tr>".format(k, v)
for (k, v) in newconf.items()
]
output += ["</table>"]
output = ''.join(output)
dld._addScratchpad(output)
try:
connector.dn_setNetworkConfig(**newconf)
except Exception as err:
dld._addScratchpad(
"<p class=\"doc-warning\">failed issuing dn_setNetworkConfig(): {0}.</p>"
.format(err))
return
else:
dld._addScratchpad(
"<p class=\"doc-success\">issued dn_setNetworkConfig() succesfully.</p>"
)
#===== issuing dn_reset()
dld._addScratchpad("<p>issuing dn_reset()</p>")
try:
connector.dn_reset(
type=0, # 0 = resetSystem
macAddress=[0] *
8, # this field is not used when resetting the system
)
except Exception as err:
pass # happens since receiving no ACK from manager which is resetting
finally:
#===== disconnect and delete connector
dld._addScratchpad(
"<p>disconnecting from manager at {0}.</p>".format(
self.connectionParams))
try:
connector.disconnect()
except Exception as err:
dld._addScratchpad(
"<p class=\"doc-warning\">disconnection failed: {0}.</p>"
.format(err))
else:
dld._addScratchpad(
"<p class=\"doc-success\">disconnection successful.</p>"
)
del connector
dld._addScratchpad("<p class=\"doc-header\">done.</p>")
except Exception as err:
output = []
output += ['===== crash in thread {0} ====='.format(self.name)]
output += ['\nerror:\n']
output += [str(err)]
output += ['\ncall stack:\n']
output += [traceback.format_exc()]
output = '\n'.join(output)
print output # critical error
log.critical(output)
raise
def _connectSerial(self):
'''
\brief Connect through the serial port.
'''
# initialize the connector
try:
if isinstance(self.apiDef,IpMgrDefinition.IpMgrDefinition):
self.connector = IpMgrConnectorSerial.IpMgrConnectorSerial()
elif isinstance(self.apiDef,IpMoteDefinition.IpMoteDefinition):
self.connector = IpMoteConnector.IpMoteConnector()
elif isinstance(self.apiDef,HartMoteDefinition.HartMoteDefinition):
self.connector = HartMoteConnector.HartMoteConnector()
else:
raise SystemError
except NotImplementedError as err:
self.guiLock.acquire()
self.tipLabel.configure(text=str(err))
self.guiLock.release()
return
# read connection params from GUI
self.guiLock.acquire()
connectParams = {
'port': self.serialPortText.get(1.0,Tkinter.END).strip(),
}
self.guiLock.release()
# connect to the serial port
try:
self.connector.connect(connectParams)
except ConnectionError as err:
self.guiLock.acquire()
self.serialPortText.configure(bg=dustStyle.COLOR_ERROR)
self.tipLabel.configure(text=str(err))
self.guiLock.release()
return
# if you get here, the connector could connect, i.e. the COM port is available
# make sure that the device attached to the serial port is really the mote we expect
if isinstance(self.apiDef,IpMgrDefinition.IpMgrDefinition):
# nothing to do, since connecting to a manager includes a handshake
pass
elif isinstance(self.apiDef,IpMoteDefinition.IpMoteDefinition):
try:
res = self.connector.dn_getParameter_moteInfo()
except (ConnectionError,CommandError) as err:
# disconnect the connector
self.connector.disconnect()
# print error text
output = []
output += ["Could open the COM port, but issuing dn_getParameter_moteInfo() failed."]
output += ["Exact error received: {0}".format(err)]
output += ["Please verify that the device connected to {0} is a SmartMesh IP mote.".format(connectParams['port'])]
output += ["Please verify that the SmartMesh IP mote is configured in slave mode."]
output = '\n'.join(output)
self.guiLock.acquire()
self.serialPortText.configure(bg=dustStyle.COLOR_WARNING_NOTWORKING)
self.tipLabel.configure(text=output)
self.guiLock.release()
return
elif isinstance(self.apiDef,HartMoteDefinition.HartMoteDefinition):
try:
res = self.connector.dn_getParameter_moteInfo()
except (ConnectionError,CommandError) as err:
# disconnect the connector
self.connector.disconnect()
# print error text
output = []
output += ["Could open the COM port, but issuing dn_getParameter_moteInfo() failed."]
output += ["Exact error received: {0}".format(err)]
output += ["Please verify that the device connected to {0} is a SmartMesh WirelessHART mote.".format(connectParams['port'])]
output += ["Please verify that the SmartMesh WirelessHART mote is configured in slave mode."]
output = '\n'.join(output)
self.guiLock.acquire()
self.serialPortText.configure(bg=dustStyle.COLOR_WARNING_NOTWORKING)
self.tipLabel.configure(text=output)
self.guiLock.release()
return
else:
raise SystemError
# if you get here, the connection has succeeded
self.guiLock.acquire()
self.serialPortText.configure(bg=dustStyle.COLOR_NOERROR)
self.tipLabel.configure(text="Connection successful.")
self.guiLock.release()
# hide other connectFrames
self.guiLock.acquire()
self.serialMuxFrame.grid_forget()
self.xmlFrame.grid_forget()
self.guiLock.release()
# update the button
self.guiLock.acquire()
self.serialButton.configure(text='disconnect', command=self._disconnect)
self.guiLock.release()
# common connect routing
self._connect()
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)
UDP_PORT_NUMBER = 60000
STRING_TO_PUBLISH = "Hello, World!"
PUBLISH_RATE_SEC = 5
#============================ main ============================================
try:
print 'SimpleIPDownstreamMgr (c) Dust Networks'
print 'SmartMesh SDK {0}\n'.format('.'.join(
[str(b) for b in sdk_version.VERSION]))
print 'Note: Use with SimpleIPDownstreamMote\n'
#=====
print "- create the variable 'mgrconnector'"
mgrconnector = IpMgrConnectorSerial.IpMgrConnectorSerial()
#=====
print "- connect to the manager's serial port"
serialport = raw_input(
"Enter the serial API port of SmartMesh IP Manager (e.g. COM7): ")
mgrconnector.connect({'port': serialport})
#=====
print "- retrieve the list of all connected motes"
operationalMacs = []
currentMac = (0, 0, 0, 0, 0, 0, 0, 0
) # start getMoteConfig() iteration with the 0 MAC address
continueAsking = True
def connect(params):
# filter params
#port = params[0]
port = params
try:
AppData().get('connector')
except KeyError:
pass
else:
print 'already connected.'
return
# create a connector
AppData().set('connector', IpMgrConnectorSerial.IpMgrConnectorSerial())
# connect to the manager
try:
AppData().get('connector').connect({
'port': port,
})
except ConnectionError as err:
print 'Could not connect to {0}: {1}'.format(
port,
err,
)
AppData().delete('connector')
return
# Set ACL's
joinKey = [
0x44, 0x55, 0x53, 0x54, 0x4E, 0x45, 0x54, 0x57, 0x4F, 0x52, 0x4B, 0x53,
0x52, 0x4F, 0x43, 0x4B
]
mac = [0x00, 0x17, 0x0d, 0x00, 0x00, 0x30, 0xb3, 0x5c]
print "Setting ACL for {0} to {1}".format(FormatUtils.formatBuffer(mac),
joinKey)
AppData().get('connector').dn_setACLEntry(macAddress=mac, joinKey=joinKey)
joinKey = [
0x44, 0x55, 0x53, 0x54, 0x4E, 0x45, 0x54, 0x57, 0x4F, 0x52, 0x4B, 0x53,
0x52, 0x4F, 0x43, 0x4B
]
mac = [0x00, 0x17, 0x0d, 0x00, 0x00, 0x30, 0xb6, 0x81]
print "Setting ACL for {0} to {1}".format(FormatUtils.formatBuffer(mac),
joinKey)
AppData().get('connector').dn_setACLEntry(macAddress=mac, joinKey=joinKey)
joinKey = [
0x44, 0x55, 0x53, 0x54, 0x4E, 0x45, 0x54, 0x57, 0x4F, 0x52, 0x4B, 0x53,
0x52, 0x4F, 0x43, 0x4B
]
print "Setting common join key to {0}".format(
FormatUtils.formatBuffer(joinKey))
AppData().get('connector').dn_setCommonJoinKey(joinKey)
networkId = 1337
apTxPower = 8 # TX power 8
frameProfile = 1 # Frame profile 1
maxMotes = 33
baseBandwidth = 9000
downFrameMultVal = 1
numParents = 2
ccaMode = 0 # off
channelList = 32767
autoStartNetwork = True
locMode = 0
bbMode = 0 # off
bbSize = 1
isRadioTest = 0
bwMult = 300
oneChannel = 255
print "Setting network ID to {0}".format(networkId)
AppData().get('connector').dn_setNetworkConfig(
networkId=networkId,
apTxPower=apTxPower,
frameProfile=frameProfile,
maxMotes=maxMotes,
baseBandwidth=baseBandwidth,
downFrameMultVal=downFrameMultVal,
numParents=numParents,
ccaMode=ccaMode,
channelList=channelList,
autoStartNetwork=autoStartNetwork,
locMode=locMode,
bbMode=bbMode,
bbSize=bbSize,
isRadioTest=isRadioTest,
bwMult=bwMult,
oneChannel=oneChannel)
print "Resetting manager"
mac = [0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]
AppData().get('connector').dn_reset(0, mac) # System Reset
# start threads
AppData().set('manager', Manager())
