Lines Matching refs:self
117 def wrapped_api_func(self, *args, **kwargs): argument
124 ret = func(self, *args, **kwargs)
125 self.log("%s returns %r", callstr, ret)
128 self.log("FUNC %s failed: %s", func_name, str(ex))
171 def comm_func(self, *args, **kwargs): argument
172 self._onCommissionStart()
174 return func(self, *args, **kwargs)
176 self._onCommissionStop()
183 def __init__(self, code, msg): argument
185 self.code = code
186 self.msg = msg
188 super(CommandError, self).__init__("Error %d: %s" % (code, msg))
222 def __init__(self, **kwargs): argument
228 self.intialize(kwargs)
231 def _connect(self): argument
237 def _disconnect(self): argument
243 def _cliReadLine(self): argument
251 def _cliWriteLine(self, line): argument
259 def _onCommissionStart(self): argument
262 def _onCommissionStop(self): argument
265 def _deviceBeforeReset(self): argument
268 def _deviceAfterReset(self): argument
271 def _restartAgentService(self): argument
274 def _beforeRegisterMulticast(self, sAddr, timeout): argument
282 def __sendCommand(self, cmd, expectEcho=True): argument
283 cmd = self._cmdPrefix + cmd
285 self._cliWriteLine(cmd)
287 self.__expect(cmd, endswith=True)
293 def __executeCommand(self, cmd, timeout=DEFAULT_COMMAND_TIMEOUT): argument
304 if self.logThreadStatus == self.logStatus['running']:
305 self.logThreadStatus = self.logStatus['pauseReq']
306 while (self.logThreadStatus != self.logStatus['paused'] and
307 self.logThreadStatus != self.logStatus['stop']):
311 self.__sendCommand(cmd)
316 line = self.__readCliLine()
334 raise Exception('%s: failed to find end of response: %s' % (self, response))
337 self.log('__executeCommand() Error: ' + str(e))
338 self._disconnect()
339 self._connect()
344 def __expect(self, expected, timeout=5, endswith=False): argument
355 line = self.__readCliLine()
364 self.sleep(0.01)
374 def __readCliLine(self, ignoreLogs=True): argument
376 line = self._cliReadLine()
379 line = self._cliReadLine()
384 def getVersionNumber(self): argument
386 return self.__executeCommand('version')[0]
388 def log(self, fmt, *args): argument
392 print('%s %s' % (self.port, msg))
396 def sleep(self, duration): argument
398 self.log("sleeping for %ss ...", duration)
402 def intialize(self, params): argument
404 self.mac = params.get('EUI')
405 self.backboneNetif = params.get('Param8') or 'eth0'
406 self.extraParams = self.__parseExtraParams(params.get('Param9'))
409 self._parseConnectionParams(params)
411 self.UIStatusMsg = ''
412 self.AutoDUTEnable = False
413 self.isPowerDown = False
414 self._is_net = False # whether device is through ser2net
415 self.logStatus = {
421 self.joinStatus = {
427 self.logThreadStatus = self.logStatus['stop']
429 self.deviceConnected = False
432 self._connect()
433 if not self.IsBorderRouter:
434 self.__detectZephyr()
435 self.__discoverDeviceCapability()
436 self.UIStatusMsg = self.getVersionNumber()
438 if self.firmwarePrefix in self.UIStatusMsg:
439 self.deviceConnected = True
441 … self.UIStatusMsg = ('Firmware Not Matching Expecting ' + self.firmwarePrefix + ', Now is ' +
442 self.UIStatusMsg)
446 self.__detectReference20200818()
448 def __repr__(self): argument
449 if self.connectType == 'ip':
450 return '[%s:%d]' % (self.telnetIp, self.telnetPort)
452 return '[%s]' % self.port
454 def _parseConnectionParams(self, params): argument
460 self.port = params.get('SerialPort', '')
462 self.log('All parameters: %r', params)
465 ipaddress.ip_address(self.port)
467 self.connectType = 'ip'
468 self.telnetIp = self.port
469 self.telnetPort = 22
470 self.telnetUsername = 'pi' if params.get('Param6') is None else params.get('Param6')
471 … self.telnetPassword = 'raspberry' if params.get('Param7') is None else params.get('Param7')
473 self.connectType = (params.get('Param5') or 'usb').lower()
474 self.telnetIp = params.get('TelnetIP')
475 self.telnetPort = int(params.get('TelnetPort')) if params.get('TelnetPort') else 22
477 self.telnetUsername = 'pi' if params.get('Param6') is None else params.get('Param6')
479 … self.telnetPassword = 'raspberry' if params.get('Param7') is None else params.get('Param7')
482 def __parseExtraParams(self, Param9): argument
513 def closeConnection(self): argument
515 self._disconnect()
517 def __disableRouterEligible(self): argument
521 self.__executeCommand(cmd)
523 def __setDeviceMode(self, mode): argument
538 return self.__executeCommand(cmd)[-1] == 'Done'
540 def __setRouterUpgradeThreshold(self, iThreshold): argument
552 return self.__executeCommand(cmd)[-1] == 'Done'
554 def __setRouterDowngradeThreshold(self, iThreshold): argument
567 return self.__executeCommand(cmd)[-1] == 'Done'
569 def __setRouterSelectionJitter(self, iRouterJitter): argument
580 return self.__executeCommand(cmd)[-1] == 'Done'
582 def __setAddressfilterMode(self, mode): argument
590 return self.__executeCommand(cmd)[-1] == 'Done'
592 def __startOpenThread(self): argument
599 if self.hasActiveDatasetToCommit:
600 if self.__executeCommand('dataset commit active')[0] != 'Done':
603 self.hasActiveDatasetToCommit = False
607 if self.isPowerDown:
608 if self._addressfilterMode == 'allowlist':
609 if self.__setAddressfilterMode(self.__replaceCommands['allowlist']):
610 for addr in self._addressfilterSet:
611 self.addAllowMAC(addr)
612 elif self._addressfilterMode == 'denylist':
613 if self.__setAddressfilterMode(self.__replaceCommands['denylist']):
614 for addr in self._addressfilterSet:
615 self.addBlockedMAC(addr)
618 if self.deviceRole in [
623 self.__setRouterSelectionJitter(1)
624 elif self.deviceRole in [Thread_Device_Role.BR_1, Thread_Device_Role.BR_2]:
627 self.IsBeingTestedAsCommercialBBR = True
628 self.__setRouterSelectionJitter(1)
630 if self.IsBeingTestedAsCommercialBBR:
632 self.__configBbrDataset(SeqNum=self.bbrSeqNum,
633 MlrTimeout=self.bbrMlrTimeout,
634 ReRegDelay=self.bbrReRegDelay)
636 if self.__useDefaultDomainPrefix:
637 self.__addDefaultDomainPrefix()
639 self.__executeCommand('ifconfig up')
640 self.__executeCommand('thread start')
641 self.isPowerDown = False
645 def __isOpenThreadRunning(self): argument
652 return self.__executeCommand('state')[0] != 'disabled'
655 def __isDeviceAttached(self): argument
663 return self.__executeCommand('state')[0] not in detached_states
666 def __convertRlocToRouterId(self, xRloc16): argument
675 routerList = self.__executeCommand('router list')[0].split()
681 router = self.__executeCommand(cmd)
707 def __convertLongToHex(self, iValue, fillZeros=None): argument
725 def __readCommissioningLogs(self, durationInSeconds): argument
734 self.logThreadStatus = self.logStatus['running']
741 if self.logThreadStatus == self.logStatus['pauseReq']:
742 self.logThreadStatus = self.logStatus['paused']
744 if self.logThreadStatus != self.logStatus['running']:
745 self.sleep(0.01)
749 line = self.__readCliLine(ignoreLogs=False)
752 self.log("commissioning log: %s", line)
763 self.sleep(0.01)
768 …self.joinCommissionedStatus = self.joinStatus['succeed'] if joinSucceed else self.joinStatus['fail…
769 self.logThreadStatus = self.logStatus['stop']
773 def __convertChannelMask(self, channelsArray): argument
790 def __setChannelMask(self, channelMask): argument
792 self.hasActiveDatasetToCommit = True
793 return self.__executeCommand(cmd)[-1] == 'Done'
795 def __setSecurityPolicy(self, securityPolicySecs, securityPolicyFlags): argument
800 self.hasActiveDatasetToCommit = True
801 return self.__executeCommand(cmd)[-1] == 'Done'
803 def __setKeySwitchGuardTime(self, iKeySwitchGuardTime): argument
814 if self.__executeCommand(cmd)[-1] == 'Done':
815 self.sleep(1)
820 def __getCommissionerSessionId(self): argument
822 return self.__executeCommand('commissioner sessionid')[0]
825 def _deviceEscapeEscapable(self, string): argument
842 if self._cmdPrefix == ZEPHYR_PREFIX and escapable_chars_present:
847 def setNetworkName(self, networkName='GRL'): argument
857 networkName = self._deviceEscapeEscapable(networkName)
860 self.hasActiveDatasetToCommit = True
861 …return self.__executeCommand(cmd)[-1] == 'Done' and self.__executeCommand(datasetCmd)[-1] == 'Done'
864 def setChannel(self, channel=11): argument
879 self.hasSetChannel = True
880 self.hasActiveDatasetToCommit = True
881 …return self.__executeCommand(cmd)[-1] == 'Done' and self.__executeCommand(datasetCmd)[-1] == 'Done'
884 def getChannel(self): argument
886 return self.__executeCommand('channel')[0]
889 def setMAC(self, xEUI): argument
900 address64 = self.__convertLongToHex(xEUI, 16)
905 if self.__executeCommand(cmd)[-1] == 'Done':
906 self.mac = address64
912 def getMAC(self, bType=MacType.RandomMac): argument
923 if self.isPowerDown:
924 macAddr64 = self.mac
927 macAddr64 = self.__executeCommand('eui64')[0]
929 macAddr64 = self.__executeCommand('joiner id')[0]
930 elif bType == MacType.EthMac and self.IsBorderRouter:
931 return self._deviceGetEtherMac()
933 macAddr64 = self.__executeCommand('extaddr')[0]
938 def getLL64(self): argument
940 return self.__executeCommand('ipaddr linklocal')[0]
943 def getRloc16(self): argument
945 rloc16 = self.__executeCommand('rloc16')[0]
949 def getRloc(self): argument
951 return self.__executeCommand('ipaddr rloc')[0]
953 def __getGlobal(self): argument
958 rlocAddr = self.getRloc()
960 addrs = self.__executeCommand('ipaddr')
979 def setNetworkKey(self, key): argument
989 cmdName = self.__replaceCommands['networkkey']
992 networkKey = self.__convertLongToHex(key, 32)
1000 self.networkKey = networkKey
1001 self.hasActiveDatasetToCommit = True
1002 …return self.__executeCommand(cmd)[-1] == 'Done' and self.__executeCommand(datasetCmd)[-1] == 'Done'
1005 def addBlockedMAC(self, xEUI): argument
1018 macAddr = self.__convertLongToHex(xEUI)
1021 if macAddr == self.mac:
1025 if self._addressfilterMode != 'denylist':
1026 if self.__setAddressfilterMode(self.__replaceCommands['denylist']):
1027 self._addressfilterMode = 'denylist'
1030 ret = self.__executeCommand(cmd)[-1] == 'Done'
1032 self._addressfilterSet.add(macAddr)
1034 for addr in self._addressfilterSet:
1040 def addAllowMAC(self, xEUI): argument
1053 macAddr = self.__convertLongToHex(xEUI)
1055 if self._addressfilterMode != 'allowlist':
1056 if self.__setAddressfilterMode(self.__replaceCommands['allowlist']):
1057 self._addressfilterMode = 'allowlist'
1060 ret = self.__executeCommand(cmd)[-1] == 'Done'
1062 self._addressfilterSet.add(macAddr)
1064 for addr in self._addressfilterSet:
1069 def clearBlockList(self): argument
1078 for addr in self._addressfilterSet:
1082 if self.__setAddressfilterMode('disable'):
1083 self._addressfilterMode = 'disable'
1086 if self.__executeCommand(cmd)[-1] == 'Done':
1087 self._addressfilterSet.clear()
1092 def clearAllowList(self): argument
1101 for addr in self._addressfilterSet:
1105 if self.__setAddressfilterMode('disable'):
1106 self._addressfilterMode = 'disable'
1109 if self.__executeCommand(cmd)[-1] == 'Done':
1110 self._addressfilterSet.clear()
1115 def getDeviceRole(self): argument
1117 return self.__executeCommand('state')[0]
1120 def joinNetwork(self, eRoleId): argument
1129 self.deviceRole = eRoleId
1131 if ModuleHelper.LeaderDutChannelFound and not self.hasSetChannel:
1132 self.channel = ModuleHelper.Default_Channel
1139 if self.AutoDUTEnable is False:
1141 self.__setRouterDowngradeThreshold(33)
1145 if self.AutoDUTEnable is False:
1147 self.__setRouterDowngradeThreshold(33)
1151 if self.AutoDUTEnable is False:
1153 self.__setRouterDowngradeThreshold(33)
1157 self.__setPollPeriod(self.__sedPollPeriod)
1161 self.setCSLperiod(self.cslPeriod)
1162 self.setCSLtout(self.ssedTimeout)
1163 self.setCSLsuspension(False)
1170 if self.AutoDUTEnable is False:
1172 self.__setRouterUpgradeThreshold(0)
1177 self.__disableRouterEligible()
1184 if self.IsReference20200818:
1188 self.__setDeviceMode(mode)
1191 self.__startOpenThread()
1192 self.wait_for_attach_to_the_network(expected_role=eRoleId,
1193 timeout=self.NETWORK_ATTACHMENT_TIMEOUT,
1197 def wait_for_attach_to_the_network(self, expected_role, timeout, raise_assert=False): argument
1202 if self.__isDeviceAttached():
1207 self, timeout))
1211 if self._update_router_status:
1212 self.__updateRouterStatus()
1217 if self.getDeviceRole() == "router":
1222 self, timeout * 2))
1226 if self.IsBorderRouter:
1227 self._waitBorderRoutingStabilize()
1232 def getNetworkFragmentID(self): argument
1238 if not self.__isOpenThreadRunning():
1241 leaderData = self.__executeCommand('leaderdata')
1245 def getParentAddress(self): argument
1252 parentInfo = self.__executeCommand('parent')
1265 def powerDown(self): argument
1267 self._reset()
1270 def powerUp(self): argument
1272 self.isPowerDown = False
1274 if not self.__isOpenThreadRunning():
1275 if self.deviceRole == Thread_Device_Role.SED:
1276 self.__setPollPeriod(self.__sedPollPeriod)
1277 self.__startOpenThread()
1280 def _reset(self, timeout=3): argument
1283 self.__sendCommand('reset', expectEcho=False)
1284 self.isPowerDown = True
1288 if not self.IsBorderRouter:
1289 self._disconnect()
1290 self._connect()
1292 self.__executeCommand('state', timeout=0.1)
1297 raise AssertionError("Could not connect with OT device {} after reset.".format(self))
1299 def reset_and_wait_for_connection(self, timeout=3): argument
1300 self._reset(timeout=timeout)
1301 if self.deviceRole == Thread_Device_Role.SED:
1302 self.__setPollPeriod(self.__sedPollPeriod)
1305 def reboot(self): argument
1312 self.reset_and_wait_for_connection()
1313 self.__startOpenThread()
1314 …return self.wait_for_attach_to_the_network(expected_role="", timeout=self.NETWORK_ATTACHMENT_TIMEO…
1317 def resetAndRejoin(self, timeout): argument
1327 self.powerDown()
1329 self.powerUp()
1330 …return self.wait_for_attach_to_the_network(expected_role="", timeout=self.NETWORK_ATTACHMENT_TIMEO…
1333 def ping(self, strDestination, ilength=0, hop_limit=64, timeout=5): argument
1343 if not self.IsReference20200818:
1346 self.__executeCommand(cmd)
1347 if self.IsReference20200818:
1349 self.sleep(6) # increase delay temporarily (+5s) to remedy TH's delay updates
1352 def multicast_Ping(self, destination, length=20): argument
1361 self.__sendCommand(cmd)
1363 self.sleep(1)
1366 def setPANID(self, xPAN): argument
1382 self.hasActiveDatasetToCommit = True
1383 …return self.__executeCommand(cmd)[-1] == 'Done' and self.__executeCommand(datasetCmd)[-1] == 'Done'
1386 def reset(self): argument
1388 self._deviceBeforeReset()
1390 self.__sendCommand('factoryreset', expectEcho=False)
1396 if not self.IsBorderRouter:
1397 self._disconnect()
1398 self._connect()
1400 self.__executeCommand('state', timeout=0.1)
1403 self._restartAgentService()
1405 self.__sendCommand('factoryreset', expectEcho=False)
1409 raise AssertionError("Could not connect with OT device {} after reset.".format(self))
1411 self.log('factoryreset finished within 10s timeout.')
1412 self._deviceAfterReset()
1414 if self.IsBorderRouter:
1415 self.__executeCommand('log level 5')
1418 def removeRouter(self, xRouterId): argument
1428 routerId = self.__convertRlocToRouterId(xRouterId)
1434 return self.__executeCommand(cmd)[-1] == 'Done'
1437 def setDefaultValues(self): argument
1440 self.networkName = ModuleHelper.Default_NwkName
1441 self.networkKey = ModuleHelper.Default_NwkKey
1442 self.channel = ModuleHelper.Default_Channel
1443 self.channelMask = '0x7fff800' # (0xffff << 11)
1444 self.panId = ModuleHelper.Default_PanId
1445 self.xpanId = ModuleHelper.Default_XpanId
1446 self.meshLocalPrefix = ModuleHelper.Default_MLPrefix
1449 self.pskc = hex(stretchedPSKc).rstrip('L').lstrip('0x')
1450 self.securityPolicySecs = ModuleHelper.Default_SecurityPolicy
1451 self.securityPolicyFlags = 'onrc'
1452 self.activetimestamp = ModuleHelper.Default_ActiveTimestamp
1454 self.__sedPollPeriod = 3 * 1000 # in milliseconds
1455 self.ssedTimeout = 30 # in seconds
1456 self.cslPeriod = 500 # in milliseconds
1457 self.deviceRole = None
1458 self.provisioningUrl = ''
1459 self.hasActiveDatasetToCommit = False
1460 self.logThread = Queue()
1461 self.logThreadStatus = self.logStatus['stop']
1462 self.joinCommissionedStatus = self.joinStatus['notstart']
1464 self.networkDataRequirement = ''
1466 self.isPowerDown = False
1468 self._addressfilterMode = 'disable'
1469 self._addressfilterSet = set() # cache filter entries
1471 self.isActiveCommissioner = False
1474 self.hasSetChannel = False
1475 self.IsBeingTestedAsCommercialBBR = False
1477 self.__useDefaultDomainPrefix = True
1478 self.__isUdpOpened = False
1479 self.IsHost = False
1482 if self.IsBorderRouter:
1483 self.stopListeningToAddrAll()
1486 self.bbrSeqNum = random.randint(0, 126) # 5.21.4.2
1487 self.bbrMlrTimeout = 3600
1488 self.bbrReRegDelay = 5
1491 self.setMAC(self.mac)
1492 self.__setChannelMask(self.channelMask)
1493 self.__setSecurityPolicy(self.securityPolicySecs, self.securityPolicyFlags)
1494 self.setChannel(self.channel)
1495 self.setPANID(self.panId)
1496 self.setXpanId(self.xpanId)
1497 self.setNetworkName(self.networkName)
1498 self.setNetworkKey(self.networkKey)
1499 self.setMLPrefix(self.meshLocalPrefix)
1500 self.setPSKc(self.pskc)
1501 self.setActiveTimestamp(self.activetimestamp)
1504 def getDeviceConncetionStatus(self): argument
1506 return self.deviceConnected
1509 def setPollingRate(self, iPollingRate): argument
1521 if self.__sedPollPeriod != iPollingRate:
1526 self.__sedPollPeriod = iPollingRate
1529 if self.__isOpenThreadRunning():
1530 return self.__setPollPeriod(self.__sedPollPeriod)
1534 def __setPollPeriod(self, iPollPeriod): argument
1545 return self.__executeCommand(cmd)[-1] == 'Done'
1548 def setLinkQuality(self, EUIadr, LinkQuality): argument
1570 address64 = self.__lstrip0x(euiStr)
1577 return self.__executeCommand(cmd)[-1] == 'Done'
1580 def setOutBoundLinkQuality(self, LinkQuality): argument
1596 return self.__executeCommand(cmd)[-1] == 'Done'
1599 def removeRouterPrefix(self, prefixEntry): argument
1611 if self.__executeCommand(cmd)[-1] == 'Done':
1613 cmd = self.__replaceCommands['netdata register']
1614 return self.__executeCommand(cmd)[-1] == 'Done'
1620 self, argument
1650 if P_dp == 0 and not self.__isOpenThreadRunning():
1651 self.__useDefaultDomainPrefix = False
1689 if self.__executeCommand(cmd)[-1] == 'Done':
1692 if not self.__isOpenThreadRunning():
1696 cmd = self.__replaceCommands['netdata register']
1697 return self.__executeCommand(cmd)[-1] == 'Done'
1702 def getNetworkData(self): argument
1703 lines = self.__executeCommand('netdata show')
1732 def setNetworkIDTimeout(self, iNwkIDTimeOut): argument
1744 return self.__executeCommand(cmd)[-1] == 'Done'
1747 def setKeepAliveTimeOut(self, iTimeOut): argument
1758 return self.__executeCommand(cmd)[-1] == 'Done'
1761 def setKeySequenceCounter(self, iKeySequenceValue): argument
1772 self.__setKeySwitchGuardTime(0)
1775 if self.__executeCommand(cmd)[-1] == 'Done':
1776 self.sleep(1)
1782 def getKeySequenceCounter(self): argument
1784 keySequence = self.__executeCommand('keysequence counter')[0]
1788 def incrementKeySequenceCounter(self, iIncrementValue=1): argument
1799 self.__setKeySwitchGuardTime(0)
1800 currentKeySeq = self.getKeySequenceCounter()
1802 return self.setKeySequenceCounter(keySequence)
1805 def setNetworkDataRequirement(self, eDataRequirement): argument
1816 self.networkDataRequirement = 'n'
1820 def configExternalRouter(self, P_Prefix, P_stable, R_Preference=0): argument
1853 if self.__executeCommand(cmd)[-1] == 'Done':
1855 cmd = self.__replaceCommands['netdata register']
1856 return self.__executeCommand(cmd)[-1] == 'Done'
1859 def getNeighbouringRouters(self): argument
1866 routerList = self.__executeCommand('router list')[0].split()
1874 router = self.__executeCommand(cmd)
1894 def getChildrenInfo(self): argument
1904 childrenList = self.__executeCommand('child list')[0].split()
1912 child = self.__executeCommand(cmd)
1938 def setXpanId(self, xPanId): argument
1950 xpanid = self.__convertLongToHex(xPanId, 16)
1958 self.xpanId = xpanid
1959 self.hasActiveDatasetToCommit = True
1960 …return self.__executeCommand(cmd)[-1] == 'Done' and self.__executeCommand(datasetCmd)[-1] == 'Done'
1963 def getNeighbouringDevices(self): argument
1974 parentAddr = self.getParentAddress()
1979 childNeighbours = self.getChildrenInfo()
1985 routerNeighbours = self.getNeighbouringRouters()
1993 def setPartationId(self, partationId): argument
2003 cmd = self.__replaceCommands['partitionid preferred'] + ' '
2005 return self.__executeCommand(cmd)[-1] == 'Done'
2008 def getGUA(self, filterByPrefix=None, eth=False): argument
2022 globalAddrs = self.__getGlobal()
2033 def getShortAddress(self): argument
2035 return self.getRloc16()
2038 def getULA64(self): argument
2040 return self.__executeCommand('ipaddr mleid')[0]
2043 def setMLPrefix(self, sMeshLocalPrefix): argument
2046 self.hasActiveDatasetToCommit = True
2047 return self.__executeCommand(cmd)[-1] == 'Done'
2050 def getML16(self): argument
2052 return self.getRloc()
2055 def downgradeToDevice(self): argument
2059 def upgradeToRouter(self): argument
2063 def forceSetSlaac(self, slaacAddress): argument
2074 return self.__executeCommand(cmd)[-1] == 'Done'
2077 def setSleepyNodePollTime(self): argument
2081 def enableAutoDUTObjectFlag(self): argument
2083 self.AutoDUTEnable = True
2086 def getChildTimeoutValue(self): argument
2088 childTimeout = self.__executeCommand('childtimeout')[0]
2092 def diagnosticGet(self, strDestinationAddr, listTLV_ids=()): argument
2104 return self.__sendCommand(cmd, expectEcho=False)
2107 def diagnosticReset(self, strDestinationAddr, listTLV_ids=()): argument
2119 return self.__executeCommand(cmd)
2122 def diagnosticQuery(self, strDestinationAddr, listTLV_ids=()): argument
2123 self.diagnosticGet(strDestinationAddr, listTLV_ids)
2126 def startNativeCommissioner(self, strPSKc='GRLPASSPHRASE'): argument
2130 self.__executeCommand('ifconfig up')
2132 return self.__executeCommand(cmd)[-1] == 'Done'
2135 def startExternalCommissioner(self, baAddr, baPort): argument
2143 if self.externalCommissioner is None:
2147 config.pskc = bytearray.fromhex(self.pskc)
2149 self.externalCommissioner = OTCommissioner(config, self)
2151 if not self.externalCommissioner.isActive():
2152 self.externalCommissioner.start(baAddr, baPort)
2154 if not self.externalCommissioner.isActive():
2160 def stopExternalCommissioner(self): argument
2165 if self.externalCommissioner is not None:
2166 self.externalCommissioner.stop()
2167 return not self.externalCommissioner.isActive()
2170 def startCollapsedCommissioner(self, role=Thread_Device_Role.Leader): argument
2177 if self.__startOpenThread():
2178 self.wait_for_attach_to_the_network(expected_role=self.deviceRole,
2179 timeout=self.NETWORK_ATTACHMENT_TIMEOUT,
2182 if self.__executeCommand(cmd)[-1] == 'Done':
2183 self.isActiveCommissioner = True
2184 self.sleep(20) # time for petition process
2189 def setJoinKey(self, strPSKc): argument
2193 def scanJoiner(self, xEUI='*', strPSKd='THREADJPAKETEST'): argument
2204 self.log("scanJoiner on channel %s", self.getChannel())
2210 eui64 = self.__convertLongToHex(xEUI, 16)
2214 strPSKd = self.__normalizePSKd(strPSKd)
2217 self._deviceEscapeEscapable(eui64),
2222 if self.__executeCommand(cmd)[-1] == 'Done':
2223 if self.logThreadStatus == self.logStatus['stop']:
2224 self.logThread = ThreadRunner.run(target=self.__readCommissioningLogs, args=(120,))
2234 def setProvisioningUrl(self, strURL='grl.com'): argument
2244 self.provisioningUrl = strURL
2245 if self.deviceRole == Thread_Device_Role.Commissioner:
2247 return self.__executeCommand(cmd)[-1] == 'Done'
2251 def allowCommission(self): argument
2259 if self.__executeCommand(cmd)[-1] == 'Done':
2260 self.isActiveCommissioner = True
2262 self.sleep(3)
2268 def joinCommissioned(self, strPSKd='THREADJPAKETEST', waitTime=20): argument
2278 self.log("joinCommissioned on channel %s", self.getChannel())
2280 if self.deviceRole in [
2285 self.__setRouterSelectionJitter(1)
2286 self.__executeCommand('ifconfig up')
2287 strPSKd = self.__normalizePSKd(strPSKd)
2288 cmd = 'joiner start %s %s' % (strPSKd, self.provisioningUrl)
2289 if self.__executeCommand(cmd)[-1] == 'Done':
2291 self.joinCommissionedStatus = self.joinStatus['ongoing']
2293 if self.logThreadStatus == self.logStatus['stop']:
2294 … self.logThread = ThreadRunner.run(target=self.__readCommissioningLogs, args=(maxDuration,))
2298 if self.joinCommissionedStatus == self.joinStatus['succeed']:
2300 elif self.joinCommissionedStatus == self.joinStatus['failed']:
2303 self.sleep(1)
2305 self.setMAC(self.mac)
2306 self.__executeCommand('thread start')
2307 self.wait_for_attach_to_the_network(expected_role=self.deviceRole,
2308 timeout=self.NETWORK_ATTACHMENT_TIMEOUT,
2315 def getCommissioningLogs(self): argument
2321 rawLogs = self.logThread.get()
2370 self, argument
2392 channelMask = '0x' + self.__convertLongToHex(self.__convertChannelMask(listChannelMask))
2400 return self.__executeCommand(cmd)[-1] == 'Done'
2403 def MGMT_PANID_QUERY(self, sAddr, xCommissionerSessionId, listChannelMask, xPanId): argument
2414 channelMask = '0x' + self.__convertLongToHex(self.__convertChannelMask(listChannelMask))
2420 return self.__executeCommand(cmd)[-1] == 'Done'
2423 def MGMT_ANNOUNCE_BEGIN(self, sAddr, xCommissionerSessionId, listChannelMask, xCount, xPeriod): argument
2430 channelMask = '0x' + self.__convertLongToHex(self.__convertChannelMask(listChannelMask))
2437 return self.__executeCommand(cmd)[-1] == 'Done'
2440 def MGMT_ACTIVE_GET(self, Addr='', TLVs=()): argument
2455 cmd += ' ' + self.__replaceCommands['-x'] + ' '
2458 return self.__executeCommand(cmd)[-1] == 'Done'
2462 self, argument
2495 xpanid = self.__convertLongToHex(xExtendedPanId, 16)
2501 cmd += self._deviceEscapeEscapable(str(sNetworkName))
2512 cmd += ' ' + self.__replaceCommands['networkkey'] + ' '
2513 key = self.__convertLongToHex(xMasterKey, 32)
2523 cmd += '0x' + self.__convertLongToHex(self.__convertChannelMask(listChannelMask))
2528 cmd += ' ' + self.__replaceCommands['-x'] + ' '
2545 if self.DeviceCapability == DevCapb.V1_1:
2590 if self.DeviceCapability != DevCapb.V1_1:
2613 steeringData = self.__convertLongToHex(xSteeringData)
2620 return self.__executeCommand(cmd)[-1] == 'Done'
2623 def MGMT_PENDING_GET(self, Addr='', TLVs=()): argument
2638 cmd += ' ' + self.__replaceCommands['-x'] + ' '
2641 return self.__executeCommand(cmd)[-1] == 'Done'
2645 self, argument
2687 cmd += ' ' + self.__replaceCommands['networkkey'] + ' '
2688 key = self.__convertLongToHex(xMasterKey, 32)
2698 cmd += self._deviceEscapeEscapable(str(sNetworkName))
2701 cmd += ' ' + self.__replaceCommands['-x'] + ' '
2710 return self.__executeCommand(cmd)[-1] == 'Done'
2713 def MGMT_COMM_GET(self, Addr='ff02::1', TLVs=()): argument
2724 cmd += ' ' + self.__replaceCommands['-x'] + ' '
2727 return self.__executeCommand(cmd)[-1] == 'Done'
2731 self, argument
2753 if self.isActiveCommissioner is True:
2755 cmd += self.__getCommissionerSessionId()
2768 cmd += ' ' + self.__replaceCommands['-x'] + ' '
2771 return self.__executeCommand(cmd)[-1] == 'Done'
2774 def setPSKc(self, strPSKc): argument
2776 self.hasActiveDatasetToCommit = True
2777 return self.__executeCommand(cmd)[-1] == 'Done'
2780 def setActiveTimestamp(self, xActiveTimestamp): argument
2781 self.activetimestamp = xActiveTimestamp
2782 self.hasActiveDatasetToCommit = True
2784 return self.__executeCommand(cmd)[-1] == 'Done'
2787 def setUdpJoinerPort(self, portNumber): argument
2798 return self.__executeCommand(cmd)[-1] == 'Done'
2801 def commissionerUnregister(self): argument
2809 return self.__executeCommand(cmd)[-1] == 'Done'
2812 def sendBeacons(self, sAddr, xCommissionerSessionId, listChannelMask, xPanId): argument
2813 self.__sendCommand('scan', expectEcho=False)
2816 def updateRouterStatus(self): argument
2818 self._update_router_status = True
2821 def __updateRouterStatus(self): argument
2824 state = self.__executeCommand(cmd)[0]
2833 return self.__executeCommand(cmd)[-1] == 'Done'
2836 def setRouterThresholdValues(self, upgradeThreshold, downgradeThreshold): argument
2837 self.__setRouterUpgradeThreshold(upgradeThreshold)
2838 self.__setRouterDowngradeThreshold(downgradeThreshold)
2841 def setMinDelayTimer(self, iSeconds): argument
2843 return self.__executeCommand(cmd)[-1] == 'Done'
2846 def ValidateDeviceFirmware(self): argument
2847 assert not self.IsBorderRouter, "Method not expected to be used with border router devices"
2849 if self.DeviceCapability == OT11_CAPBS:
2850 return OT11_VERSION in self.UIStatusMsg
2851 elif self.DeviceCapability == OT12_CAPBS:
2852 return OT12_VERSION in self.UIStatusMsg
2853 elif self.DeviceCapability == OT13_CAPBS:
2854 return OT13_VERSION in self.UIStatusMsg
2859 def setBbrDataset(self, SeqNumInc=False, SeqNum=None, MlrTimeout=None, ReRegDelay=None): argument
2876 …if (MlrTimeout and MlrTimeout != self.bbrMlrTimeout) or (ReRegDelay and ReRegDelay != self.bbrReRe…
2881 if self.bbrSeqNum in (126, 127):
2882 self.bbrSeqNum = 0
2883 elif self.bbrSeqNum in (254, 255):
2884 self.bbrSeqNum = 128
2886 self.bbrSeqNum = (self.bbrSeqNum + 1) % 256
2888 self.bbrSeqNum = SeqNum
2890 …return self.__configBbrDataset(SeqNum=self.bbrSeqNum, MlrTimeout=MlrTimeout, ReRegDelay=ReRegDelay)
2892 def __configBbrDataset(self, SeqNum=None, MlrTimeout=None, ReRegDelay=None): argument
2894 ReRegDelay = self.bbrReRegDelay
2903 ret = self.__executeCommand(cmd)[-1] == 'Done'
2906 self.bbrSeqNum = SeqNum
2909 self.bbrMlrTimeout = MlrTimeout
2912 self.bbrReRegDelay = ReRegDelay
2914 cmd = self.__replaceCommands['netdata register']
2915 self.__executeCommand(cmd)
2921 def setCSLtout(self, tout=30): argument
2922 self.ssedTimeout = tout
2923 cmd = 'csl timeout %u' % self.ssedTimeout
2924 return self.__executeCommand(cmd)[-1] == 'Done'
2927 def setCSLchannel(self, ch=11): argument
2929 return self.__executeCommand(cmd)[-1] == 'Done'
2932 def setCSLperiod(self, period=500): argument
2939 return self.__executeCommand(cmd)[-1] == 'Done'
2994 def LinkMetricsSingleReq(self, dst_addr, metrics): argument
2995 cmd = 'linkmetrics query %s single %s' % (dst_addr, self.getMetricsFlagsFromHexStr(metrics))
2996 return self.__executeCommand(cmd)[-1] == 'Done'
2999 def LinkMetricsMgmtReq(self, dst_addr, type_, flags, metrics, series_id): argument
3002 cmd += 'forward %d %s' % (series_id, self.getForwardSeriesFlagsFromHexOrStr(flags))
3004 cmd += ' %s' % (self.getMetricsFlagsFromHexStr(metrics))
3008 cmd += ' register %s' % (self.getMetricsFlagsFromHexStr(metrics))
3011 return self.__executeCommand(cmd)[-1] == 'Done'
3014 def LinkMetricsGetReport(self, dst_addr, series_id): argument
3016 return self.__executeCommand(cmd)[-1] == 'Done'
3020 def LinkMetricsSendProbe(self, dst_addr, ack=True, size=0): argument
3022 return self.__executeCommand(cmd)[-1] == 'Done'
3025 def setTxPower(self, level): argument
3035 return self.__executeCommand(cmd)[-1] == 'Done'
3038 def sendUdp(self, destination, port, payload='hello'): argument
3041 return self.__executeCommand(cmd)[-1] == 'Done'
3044 def send_udp(self, interface, destination, port, payload='12ABcd'): argument
3049 self.__udpOpen()
3052 return self.__executeCommand(cmd)[-1] == 'Done'
3054 def __udpOpen(self): argument
3055 if not self.__isUdpOpened:
3057 self.__executeCommand(cmd)
3060 rlocAddr = self.getRloc()
3063 self.__executeCommand(cmd)
3065 self.__isUdpOpened = True
3068 def sendMACcmd(self, enh=False): argument
3070 return self.__executeCommand(cmd)[-1] == 'Done'
3073 def sendMACdata(self, enh=False): argument
3075 return self.__executeCommand(cmd)[-1] == 'Done'
3078 def setCSLsuspension(self, suspend): argument
3080 self.__setPollPeriod(240 * 1000)
3082 self.__setPollPeriod(int(0.9 * self.ssedTimeout * 1000))
3085 def set_max_addrs_per_child(self, num): argument
3087 self.__executeCommand(cmd)
3090 def config_next_dua_status_rsp(self, mliid, status_code): argument
3102 self.__executeCommand(cmd)
3105 def getDUA(self): argument
3106 dua = self.getGUA('fd00:7d03')
3109 def __addDefaultDomainPrefix(self): argument
3110 self.configBorderRouter(P_dp=1, P_stable=1, P_on_mesh=1, P_default=1)
3112 def __setDUA(self, sDua): argument
3118 return self.__executeCommand(cmd)[-1] == 'Done'
3120 def __getMlIid(self): argument
3123 mleid = ModuleHelper.GetFullIpv6Address(self.getULA64()).lower()
3127 def __setMlIid(self, sMlIid): argument
3131 self.__executeCommand(cmd)
3134 def registerDUA(self, sAddr=''): argument
3135 self.__setDUA(sAddr)
3138 def config_next_mlr_status_rsp(self, status_code): argument
3140 return self.__executeCommand(cmd)[-1] == 'Done'
3143 def setMLRtimeout(self, iMsecs): argument
3145 self.setBbrDataset(MlrTimeout=iMsecs)
3148 def stopListeningToAddr(self, sAddr): argument
3151 self.__executeCommand(cmd)
3161 def registerMulticast(self, listAddr=('ff04::1234:777a:1',), timeout=MLR_TIMEOUT_MIN): argument
3168 self._beforeRegisterMulticast(each_sAddr, timeout)
3174 self.__executeCommand(cmd)
3182 def getMlrLogs(self): argument
3183 return self.externalCommissioner.getMlrLogs()
3186 def migrateNetwork(self, channel=None, net_name=None): argument
3199 mliid = self.__getMlIid()
3200 dua = self.getDUA()
3201 self.reset()
3202 deviceRole = self.deviceRole
3203 self.setDefaultValues()
3204 self.setChannel(channel)
3206 self.setNetworkName(net_name)
3207 self.__setMlIid(mliid)
3208 self.__setDUA(dua)
3209 return self.joinNetwork(deviceRole)
3212 def setParentPrio(self, prio): argument
3214 return self.__executeCommand(cmd)[-1] == 'Done'
3217 def role_transition(self, role): argument
3219 return self.__executeCommand(cmd)[-1] == 'Done'
3222 def setLeaderWeight(self, iWeight=72): argument
3223 self.__executeCommand('leaderweight %d' % iWeight)
3226 def isBorderRoutingEnabled(self): argument
3228 self.__executeCommand('br omrprefix local')
3233 def __detectZephyr(self): argument
3237 self._lineSepX = re.compile(r'\r\n|\r|\n')
3238 if self.__executeCommand(ZEPHYR_PREFIX + 'thread version')[0].isdigit():
3239 self._cmdPrefix = ZEPHYR_PREFIX
3241 self._lineSepX = LINESEPX
3243 def __detectReference20200818(self): argument
3248 self.IsReference20200818 = not self.__executeCommand('version api')[0].isdigit()
3250 if self.IsReference20200818:
3251 self.__replaceCommands = {
3263 def __getitem__(self, key): argument
3266 self.__replaceCommands = IdentityDict()
3268 def __discoverDeviceCapability(self): argument
3270 thver = self.__executeCommand('thread version')[0]
3271 if thver in ['1.3', '4'] and not self.IsBorderRouter:
3272 self.log("Setting capability of {}: (DevCapb.C_FTD13 | DevCapb.C_MTD13)".format(self))
3273 self.DeviceCapability = OT13_CAPBS
3274 elif thver in ['1.3', '4'] and self.IsBorderRouter:
3275 self.log("Setting capability of {}: (DevCapb.C_BR13 | DevCapb.C_Host13)".format(self))
3276 self.DeviceCapability = OT13BR_CAPBS
3277 elif thver in ['1.2', '3'] and not self.IsBorderRouter:
3278 … self.log("Setting capability of {}: DevCapb.L_AIO | DevCapb.C_FFD | DevCapb.C_RFD".format(self))
3279 self.DeviceCapability = OT12_CAPBS
3280 elif thver in ['1.2', '3'] and self.IsBorderRouter:
3281 …self.log("Setting capability of BR {}: DevCapb.C_BBR | DevCapb.C_Host | DevCapb.C_Comm".format(sel…
3282 self.DeviceCapability = OT12BR_CAPBS
3284 self.log("Setting capability of {}: DevCapb.V1_1".format(self))
3285 self.DeviceCapability = OT11_CAPBS
3287 self.log("Capability not specified for {}".format(self))
3288 self.DeviceCapability = DevCapb.NotSpecified
3307 def setCcmState(self, state=0): argument
3309 self.__executeCommand("ccm {}".format("enable" if state == 1 else "disable"))
3312 def setVrCheckSkip(self): argument
3313 self.__executeCommand("tvcheck disable")
3316 def addBlockedNodeId(self, node_id): argument
3318 self.__executeCommand(cmd)
3321 def clearBlockedNodeIds(self): argument
3323 self.__executeCommand(cmd)
3328 def _connect(self): argument
3329 print('My port is %s' % self)
3330 self.__lines = []
3334 if self.port.startswith('COM'):
3338 self.__handle = serial.Serial(self.port, 115200, timeout=0, write_timeout=1)
3339 self.sleep(1)
3340 self.__handle.write('\r\n')
3341 self.sleep(0.1)
3342 self._is_net = False
3345 self.log("{} port not ready, retrying to connect...".format(self.port))
3347 raise SerialException("Could not open {} port: {}".format(self.port, port_error))
3348 elif ':' in self.port:
3349 host, port = self.port.split(':')
3350 self.__handle = socket.create_connection((host, port))
3351 self.__handle.setblocking(False)
3352 self._is_net = True
3356 def _disconnect(self): argument
3357 if self.__handle:
3358 self.__handle.close()
3359 self.__handle = None
3361 def __socRead(self, size=512): argument
3362 if self._is_net:
3363 return self.__handle.recv(size)
3365 return self.__handle.read(size)
3367 def __socWrite(self, data): argument
3368 if self._is_net:
3369 self.__handle.sendall(data)
3371 self.__handle.write(data)
3373 def _cliReadLine(self): argument
3374 if len(self.__lines) > 1:
3375 return self.__lines.pop(0)
3378 if len(self.__lines) != 0:
3379 tail = self.__lines.pop()
3382 tail += self.__socRead()
3384 logging.exception('%s: No new data', self)
3385 self.sleep(0.1)
3387 self.__lines += self._lineSepX.split(tail)
3388 if len(self.__lines) > 1:
3389 return self.__lines.pop(0)
3391 def _cliWriteLine(self, line): argument
3392 if self._cmdPrefix == ZEPHYR_PREFIX:
3393 if not line.startswith(self._cmdPrefix):
3394 line = self._cmdPrefix + line
3395 self.__socWrite(line + '\r')
3397 self.__socWrite(line + '\r\n')