This application is the simplest one to utilize our mesh networking stack. It just joins your device to the unsecure 6LoWPAN-ND network. The canonical source for this example lives at https://github.com/ARMmbed/mbed-os-example-mesh-minimal

Example mesh application for Mbed OS

With this application, you can use our mesh networking stack. This application joins your device to the unsecure 6LoWPAN-ND network.

Setup

Building with Mbed CLI

If you'd like to use Mbed CLI to build this offline, then you should refer to the Mbed CLI documentation. The instructions here relate to using the Mbed Online Compiler

  1. Click `Import this application` button.
  2. Change the channel settings: See the file `mbed_app.json` for an example of defining an IEEE 802.15.4 channel to use.
  3. Compile the application

A binary is generated at the end of the build process.

Connect the RF shield to the board

By default, we are using the Atmel AT86RF233, which you can purchase. Place the shield on top of your board, and power it on.

Program the target

Drag and drop the binary to the target to program the application.

Update the firmware of the border router.

You can read the instructions on updating the firmware of your board working as 6LoWPAN border router here.

Please remember to connect the Ethernet cable between the border router and your router. Then, power up the board.

Testing

As soon as both the border router and the target are up and running, you can verify the correct behavior. Open a serial console, and see the IP address obtained by the device.

Note: This application uses a baud rate of 115200.

Quote:

connected. IP = 2001:db8:a0b:12f0::1

You can use this IP address to ping from your PC and verify that the connection is working correctly.

Changing the radio driver (optional)

To run a 6LoWPAN-ND network, you need a working RF driver for Nanostack. This example uses the Atmel AT86RF233 by default.

To change the RF driver:

  1. Uninstall the Atmel RF driver.
  2. Install the new driver. (For example, for the FRDM-CR20A radio shield based on the MCR20A device.)
  3. Recompile your application.
Committer:
mbed_official
Date:
Fri Sep 22 07:00:13 2017 +0100
Revision:
53:82a191e2c133
Parent:
52:27692043e962
Child:
58:e0f2bf24e6db
New ram configuration (#129)

* Changes in Thread RAM configurations (kw24)

* empty spaces added

* Update README.md

remove some lines from previous commit

* Update README.md

minor fix

* Update Hardware.md

one more note about k24w

* minor change

* memory to 15kb

* let's use 15kb only for thread

* minor fix

* Update README.md

15kb for thread end device

* Update README.md

minor change

.
Commit copied from https://github.com/ARMmbed/mbed-os-example-mesh-minimal

Who changed what in which revision?

UserRevisionLine numberNew contents of line
mbed_official 26:b28ab71ff595 1 properties ([[$class: 'ParametersDefinitionProperty', parameterDefinitions: [
mbed_official 52:27692043e962 2 [$class: 'StringParameterDefinition', name: 'mbed_os_revision', defaultValue: '', description: 'Revision of mbed-os to build. Use format "pull/PR-NUMBER/head" to access mbed-os PR'],
mbed_official 26:b28ab71ff595 3 [$class: 'BooleanParameterDefinition', name: 'smoke_test', defaultValue: false, description: 'Enable to run HW smoke test after building']
mbed_official 26:b28ab71ff595 4 ]]])
mbed_official 26:b28ab71ff595 5
mbed_official 52:27692043e962 6 if (params.mbed_os_revision == '') {
mbed_official 52:27692043e962 7 echo 'Use mbed OS revision from mbed-os.lib'
mbed_official 52:27692043e962 8 } else {
mbed_official 52:27692043e962 9 echo "Use mbed OS revisiong ${params.mbed_os_revision}"
mbed_official 52:27692043e962 10 if (params.mbed_os_revision.matches('pull/\\d+/head')) {
mbed_official 52:27692043e962 11 echo "Revision is a Pull Request"
mbed_official 52:27692043e962 12 }
mbed_official 52:27692043e962 13 }
mbed_official 32:8b28e79d2ed0 14 echo "Run smoke tests: ${params.smoke_test}"
mbed_official 26:b28ab71ff595 15
mbed_official 26:b28ab71ff595 16
mbed_official 26:b28ab71ff595 17 // Map RaaS instances to corresponding test suites
mbed_official 52:27692043e962 18 // Run only selected set of tests.
mbed_official 52:27692043e962 19 // Board: K64F
mbed_official 52:27692043e962 20 // Radios: Atmel & MCR20A
mbed_official 52:27692043e962 21 // configurations: 6LP + Thread
mbed_official 26:b28ab71ff595 22 def raas = [
mbed_official 26:b28ab71ff595 23 "lowpan_mesh_minimal_smoke_k64f_atmel.json": "8001",
mbed_official 52:27692043e962 24 // "lowpan_mesh_minimal_smoke_k64f_mcr20.json": "8034",
mbed_official 52:27692043e962 25 // "lowpan_mesh_minimal_smoke_429zi_atmel.json": "8030",
mbed_official 52:27692043e962 26 // "lowpan_mesh_minimal_smoke_429zi_mcr20.json": "8033",
mbed_official 52:27692043e962 27 // "lowpan_mesh_minimal_smoke_ublox_atmel.json": "8031",
mbed_official 52:27692043e962 28 // "thread_mesh_minimal_smoke_k64f_atmel.json": "8007"
mbed_official 26:b28ab71ff595 29 "thread_mesh_minimal_smoke_k64f_mcr20.json": "8034",
mbed_official 52:27692043e962 30 // "thread_mesh_minimal_smoke_429zi_atmel.json": "8030",
mbed_official 52:27692043e962 31 // "thread_mesh_minimal_smoke_429zi_mcr20.json": "8033",
mbed_official 52:27692043e962 32 // "thread_mesh_minimal_smoke_ublox_atmel.json": "8031"
mbed_official 26:b28ab71ff595 33 ]
mbed_official 26:b28ab71ff595 34
mbed_official 21:6c1e9147037c 35 // List of targets with supported RF shields to compile
mbed_official 21:6c1e9147037c 36 def targets = [
mbed_official 21:6c1e9147037c 37 "K64F": ["ATMEL", "MCR20"],
mbed_official 27:2b3fc6ca5872 38 "NUCLEO_F401RE": ["ATMEL", "MCR20"],
mbed_official 21:6c1e9147037c 39 "NUCLEO_F429ZI": ["ATMEL", "MCR20"],
mbed_official 21:6c1e9147037c 40 //"NCS36510": ["NCS36510"],
mbed_official 52:27692043e962 41 "UBLOX_EVK_ODIN_W2": ["ATMEL"],
mbed_official 52:27692043e962 42 "KW24D": ["MCR20"]
mbed_official 21:6c1e9147037c 43 ]
mbed_official 34:bc1827b97c5e 44
mbed_official 21:6c1e9147037c 45 // Map toolchains to compilers
mbed_official 21:6c1e9147037c 46 def toolchains = [
mbed_official 21:6c1e9147037c 47 ARM: "armcc",
mbed_official 21:6c1e9147037c 48 GCC_ARM: "arm-none-eabi-gcc",
mbed_official 21:6c1e9147037c 49 IAR: "iar_arm"
mbed_official 21:6c1e9147037c 50 ]
mbed_official 21:6c1e9147037c 51
mbed_official 21:6c1e9147037c 52 // Supported RF shields
mbed_official 21:6c1e9147037c 53 def radioshields = [
mbed_official 21:6c1e9147037c 54 "ATMEL",
mbed_official 21:6c1e9147037c 55 "MCR20",
mbed_official 21:6c1e9147037c 56 "NCS36510"
mbed_official 21:6c1e9147037c 57 ]
mbed_official 21:6c1e9147037c 58
mbed_official 21:6c1e9147037c 59 // Mesh interfaces: 6LoWPAN and Thread
mbed_official 21:6c1e9147037c 60 def meshinterfaces = [
mbed_official 21:6c1e9147037c 61 "6lp",
mbed_official 21:6c1e9147037c 62 "thd"
mbed_official 21:6c1e9147037c 63 ]
mbed_official 34:bc1827b97c5e 64
mbed_official 21:6c1e9147037c 65 def stepsForParallel = [:]
mbed_official 21:6c1e9147037c 66
mbed_official 21:6c1e9147037c 67 // Jenkins pipeline does not support map.each, we need to use oldschool for loop
mbed_official 21:6c1e9147037c 68 for (int i = 0; i < targets.size(); i++) {
mbed_official 21:6c1e9147037c 69 for(int j = 0; j < toolchains.size(); j++) {
mbed_official 21:6c1e9147037c 70 for(int k = 0; k < radioshields.size(); k++) {
mbed_official 21:6c1e9147037c 71 for(int l = 0; l < meshinterfaces.size(); l++) {
mbed_official 21:6c1e9147037c 72 def target = targets.keySet().asList().get(i)
mbed_official 21:6c1e9147037c 73 def allowed_shields = targets.get(target)
mbed_official 21:6c1e9147037c 74 def toolchain = toolchains.keySet().asList().get(j)
mbed_official 21:6c1e9147037c 75 def compilerLabel = toolchains.get(toolchain)
mbed_official 21:6c1e9147037c 76 def radioshield = radioshields.get(k)
mbed_official 21:6c1e9147037c 77 def meshInterface = meshinterfaces.get(l)
mbed_official 27:2b3fc6ca5872 78
mbed_official 27:2b3fc6ca5872 79 // Skip unwanted combination
mbed_official 27:2b3fc6ca5872 80 if (target == "NUCLEO_F401RE" && toolchain == "IAR") {
mbed_official 27:2b3fc6ca5872 81 continue
mbed_official 27:2b3fc6ca5872 82 }
mbed_official 27:2b3fc6ca5872 83
mbed_official 21:6c1e9147037c 84 def stepName = "${target} ${toolchain} ${radioshield} ${meshInterface}"
mbed_official 21:6c1e9147037c 85 if(allowed_shields.contains(radioshield)) {
mbed_official 21:6c1e9147037c 86 stepsForParallel[stepName] = buildStep(target, compilerLabel, toolchain, radioshield, meshInterface)
mbed_official 21:6c1e9147037c 87 }
mbed_official 21:6c1e9147037c 88 }
mbed_official 21:6c1e9147037c 89 }
mbed_official 21:6c1e9147037c 90 }
mbed_official 21:6c1e9147037c 91 }
mbed_official 21:6c1e9147037c 92
mbed_official 26:b28ab71ff595 93 def parallelRunSmoke = [:]
mbed_official 26:b28ab71ff595 94
mbed_official 26:b28ab71ff595 95 // Need to compare boolean against string value
mbed_official 34:bc1827b97c5e 96 if ( params.smoke_test == true ) {
mbed_official 26:b28ab71ff595 97 // Generate smoke tests based on suite amount
mbed_official 26:b28ab71ff595 98 for(int i = 0; i < raas.size(); i++) {
mbed_official 26:b28ab71ff595 99 def suite_to_run = raas.keySet().asList().get(i)
mbed_official 26:b28ab71ff595 100 def raasPort = raas.get(suite_to_run)
mbed_official 26:b28ab71ff595 101 // Parallel execution needs unique step names. Remove .json file ending.
mbed_official 26:b28ab71ff595 102 def smokeStep = "${raasPort} ${suite_to_run.substring(0, suite_to_run.indexOf('.'))}"
mbed_official 26:b28ab71ff595 103 parallelRunSmoke[smokeStep] = run_smoke(targets, toolchains, radioshields, meshinterfaces, raasPort, suite_to_run)
mbed_official 26:b28ab71ff595 104 }
mbed_official 26:b28ab71ff595 105 }
mbed_official 26:b28ab71ff595 106
mbed_official 21:6c1e9147037c 107 timestamps {
mbed_official 21:6c1e9147037c 108 parallel stepsForParallel
mbed_official 26:b28ab71ff595 109 parallel parallelRunSmoke
mbed_official 21:6c1e9147037c 110 }
mbed_official 21:6c1e9147037c 111
mbed_official 21:6c1e9147037c 112 def buildStep(target, compilerLabel, toolchain, radioShield, meshInterface) {
mbed_official 21:6c1e9147037c 113 return {
mbed_official 21:6c1e9147037c 114 stage ("${target}_${compilerLabel}_${radioShield}_${meshInterface}") {
mbed_official 21:6c1e9147037c 115 node ("${compilerLabel}") {
mbed_official 21:6c1e9147037c 116 deleteDir()
mbed_official 21:6c1e9147037c 117 dir("mbed-os-example-mesh-minimal") {
mbed_official 21:6c1e9147037c 118 checkout scm
mbed_official 50:5d4045379c2f 119 def config_file = "mbed_app.json"
mbed_official 21:6c1e9147037c 120
mbed_official 21:6c1e9147037c 121 if ("${meshInterface}" == "thd") {
mbed_official 50:5d4045379c2f 122 config_file = "./configs/mesh_thread.json"
mbed_official 51:de6c96c52689 123 // Use systest Thread Border Router for testing (CH=18, PANID=BAAB)
mbed_official 51:de6c96c52689 124 execute("sed -i '/mbed-mesh-api.thread-device-type\":/a \"mbed-mesh-api.thread-config-channel\": 18,' ${config_file}")
mbed_official 51:de6c96c52689 125 execute("sed -i '/mbed-mesh-api.thread-device-type\":/a \"mbed-mesh-api.thread-config-panid\": \"0xBAAB\",' ${config_file}")
mbed_official 52:27692043e962 126 execute("sed -i 's/\"NANOSTACK\", \"THREAD_ROUTER\", \"COMMON_PAL\"/\"NANOSTACK\", \"THREAD_END_DEVICE\", \"COMMON_PAL\"/' ${config_file}")
mbed_official 52:27692043e962 127 execute("sed -i 's/\"mbed-mesh-api.thread-device-type\": \"MESH_DEVICE_TYPE_THREAD_ROUTER\"/\"mbed-mesh-api.thread-device-type\": \"MESH_DEVICE_TYPE_THREAD_MINIMAL_END_DEVICE\"/' ${config_file}")
mbed_official 53:82a191e2c133 128 }
mbed_official 21:6c1e9147037c 129
mbed_official 21:6c1e9147037c 130 if ("${meshInterface}" == "6lp") {
mbed_official 50:5d4045379c2f 131 config_file = "./configs/mesh_6lowpan.json"
mbed_official 51:de6c96c52689 132 // Use systest 6LoWPAN Border Router for testing (CH=17, PANID=ABBA)
mbed_official 51:de6c96c52689 133 execute("sed -i 's/\"mbed-mesh-api.6lowpan-nd-channel\": 12/\"mbed-mesh-api.6lowpan-nd-channel\": 17/' ${config_file}")
mbed_official 51:de6c96c52689 134 execute("sed -i 's/\"mbed-mesh-api.6lowpan-nd-panid-filter\": \"0xffff\"/\"mbed-mesh-api.6lowpan-nd-panid-filter\": \"0xABBA\"/' ${config_file}")
mbed_official 21:6c1e9147037c 135 }
mbed_official 26:b28ab71ff595 136
mbed_official 52:27692043e962 137 if ("${radioShield}" == "MCR20") {
mbed_official 52:27692043e962 138 // Replace default rf shield
mbed_official 52:27692043e962 139 execute("sed -i 's/\"value\": \"ATMEL\"/\"value\": \"MCR20\"/' ${config_file}")
mbed_official 52:27692043e962 140 }
mbed_official 52:27692043e962 141
mbed_official 52:27692043e962 142 if ("${radioShield}" == "NCS36510") {
mbed_official 52:27692043e962 143 // Replace default rf shield
mbed_official 52:27692043e962 144 execute("sed -i 's/\"value\": \"ATMEL\"/\"value\": \"NCS36510\"/' ${config_file}")
mbed_official 52:27692043e962 145 }
mbed_official 52:27692043e962 146
mbed_official 52:27692043e962 147 // For KW24D, we need to optimize for low memory
mbed_official 52:27692043e962 148 if ("${target}" == "KW24D") {
mbed_official 52:27692043e962 149 // Use optimal mbed TLS config file, need double escaping of '\' characters, first ones to escape Grooy, second ones to escape shell
mbed_official 52:27692043e962 150 // Need to use SH shells
mbed_official 52:27692043e962 151 sh("sed -i '/\"target_overrides\"/ i \"macros\": [\"MBEDTLS_USER_CONFIG_FILE=\\\\\"mbedtls_config.h\\\\\"\"],' ${config_file}")
mbed_official 52:27692043e962 152 // Limit mesh heap size to 11kB
mbed_official 52:27692043e962 153 execute("sed -i 's/mbed-mesh-api.heap-size\": .*,/mbed-mesh-api.heap-size\": 11000,/' ${config_file}")
mbed_official 52:27692043e962 154 // Limit event loop heap size
mbed_official 52:27692043e962 155 execute("sed -i '/target.features_add/ i \"nanostack-hal.event_loop_thread_stack_size\": 2048,' ${config_file}")
mbed_official 53:82a191e2c133 156 if ("${toolchain}" == "GCC_ARM" && "${meshInterface}" == "thd") {
mbed_official 53:82a191e2c133 157 execute("sed -i 's/mbed-mesh-api.heap-size\": .*,/mbed-mesh-api.heap-size\": 15000,/' ${config_file}")
mbed_official 53:82a191e2c133 158 execute("sed -i '/mbed-mesh-api.thread-device-type\":/a \"mbed-mesh-api.use-malloc-for-heap\": true,' ${config_file}")
mbed_official 53:82a191e2c133 159 }
mbed_official 52:27692043e962 160 }
mbed_official 52:27692043e962 161
mbed_official 51:de6c96c52689 162 // Activate traces
mbed_official 51:de6c96c52689 163 execute("sed -i 's/\"mbed-trace.enable\": false/\"mbed-trace.enable\": true/' ${config_file}")
mbed_official 51:de6c96c52689 164
mbed_official 26:b28ab71ff595 165 // Set mbed-os to revision received as parameter
mbed_official 21:6c1e9147037c 166 execute ("mbed deploy --protocol ssh")
mbed_official 52:27692043e962 167 if (params.mbed_os_revision != '') {
mbed_official 52:27692043e962 168 dir ("mbed-os") {
mbed_official 52:27692043e962 169 if (params.mbed_os_revision.matches('pull/\\d+/head')) {
mbed_official 52:27692043e962 170 execute("git fetch origin ${params.mbed_os_revision}:PR")
mbed_official 52:27692043e962 171 execute("git checkout PR")
mbed_official 52:27692043e962 172 } else {
mbed_official 52:27692043e962 173 execute ("git checkout ${params.mbed_os_revision}")
mbed_official 52:27692043e962 174 }
mbed_official 52:27692043e962 175 }
mbed_official 21:6c1e9147037c 176 }
mbed_official 26:b28ab71ff595 177
mbed_official 50:5d4045379c2f 178 execute ("mbed compile --build out/${target}_${toolchain}_${radioShield}_${meshInterface}/ -m ${target} -t ${toolchain} -c --app-config ${config_file}")
mbed_official 21:6c1e9147037c 179 }
mbed_official 26:b28ab71ff595 180 stash name: "${target}_${toolchain}_${radioShield}_${meshInterface}", includes: '**/mbed-os-example-mesh-minimal.bin'
mbed_official 21:6c1e9147037c 181 archive '**/mbed-os-example-mesh-minimal.bin'
mbed_official 26:b28ab71ff595 182 step([$class: 'WsCleanup'])
mbed_official 21:6c1e9147037c 183 }
mbed_official 21:6c1e9147037c 184 }
mbed_official 21:6c1e9147037c 185 }
mbed_official 21:6c1e9147037c 186 }
mbed_official 26:b28ab71ff595 187
mbed_official 26:b28ab71ff595 188 def run_smoke(targets, toolchains, radioshields, meshinterfaces, raasPort, suite_to_run) {
mbed_official 26:b28ab71ff595 189 return {
mbed_official 26:b28ab71ff595 190 // Remove .json from suite name
mbed_official 26:b28ab71ff595 191 def suiteName = suite_to_run.substring(0, suite_to_run.indexOf('.'))
mbed_official 26:b28ab71ff595 192 stage ("smoke_${raasPort}_${suiteName}") {
mbed_official 30:81d713ba997d 193 node ("mesh-test") {
mbed_official 26:b28ab71ff595 194 deleteDir()
mbed_official 26:b28ab71ff595 195 dir("mbed-clitest") {
mbed_official 26:b28ab71ff595 196 git "git@github.com:ARMmbed/mbed-clitest.git"
mbed_official 26:b28ab71ff595 197 execute("git checkout ${env.LATEST_CLITEST_REL}")
mbed_official 52:27692043e962 198 }
mbed_official 52:27692043e962 199 dir("testcases") {
mbed_official 52:27692043e962 200 git "git@github.com:ARMmbed/mbed-clitest-suites.git"
mbed_official 52:27692043e962 201 execute("git checkout master")
mbed_official 52:27692043e962 202 execute("git submodule update --init --recursive")
mbed_official 52:27692043e962 203 dir("6lowpan") {
mbed_official 26:b28ab71ff595 204 execute("git checkout master")
mbed_official 26:b28ab71ff595 205 }
mbed_official 52:27692043e962 206 dir("thread-tests") {
mbed_official 52:27692043e962 207 execute("git checkout master")
mbed_official 52:27692043e962 208 }
mbed_official 52:27692043e962 209 }
mbed_official 26:b28ab71ff595 210
mbed_official 52:27692043e962 211 for (int i = 0; i < targets.size(); i++) {
mbed_official 52:27692043e962 212 for(int j = 0; j < toolchains.size(); j++) {
mbed_official 52:27692043e962 213 for(int k = 0; k < radioshields.size(); k++) {
mbed_official 52:27692043e962 214 for(int l = 0; l < meshinterfaces.size(); l++) {
mbed_official 52:27692043e962 215 def target = targets.keySet().asList().get(i)
mbed_official 52:27692043e962 216 def allowed_shields = targets.get(target)
mbed_official 52:27692043e962 217 def toolchain = toolchains.keySet().asList().get(j)
mbed_official 52:27692043e962 218 def radioshield = radioshields.get(k)
mbed_official 52:27692043e962 219 def meshInterface = meshinterfaces.get(l)
mbed_official 52:27692043e962 220 // Skip unwanted combination
mbed_official 52:27692043e962 221 if (target == "NUCLEO_F401RE" && toolchain == "IAR") {
mbed_official 52:27692043e962 222 continue
mbed_official 52:27692043e962 223 }
mbed_official 52:27692043e962 224 if(allowed_shields.contains(radioshield)) {
mbed_official 52:27692043e962 225 unstash "${target}_${toolchain}_${radioshield}_${meshInterface}"
mbed_official 26:b28ab71ff595 226 }
mbed_official 26:b28ab71ff595 227 }
mbed_official 26:b28ab71ff595 228 }
mbed_official 26:b28ab71ff595 229 }
mbed_official 26:b28ab71ff595 230 }
mbed_official 52:27692043e962 231 env.RAAS_USERNAME = "user"
mbed_official 52:27692043e962 232 env.RAAS_PASSWORD = "user"
mbed_official 52:27692043e962 233 execute("./mbed-clitest/clitest.py --tcdir testcases --suitedir testcases/suites/ --suite ${suite_to_run} --type hardware --reset --raas 62.44.193.186:${raasPort} --raas_share_allocs --failure_return_value -vvv -w --log log_${raasPort}_${suiteName}")
mbed_official 52:27692043e962 234 archive "log_${raasPort}_${suiteName}/**/*"
mbed_official 26:b28ab71ff595 235 }
mbed_official 26:b28ab71ff595 236 }
mbed_official 26:b28ab71ff595 237 }
mbed_official 26:b28ab71ff595 238 }