Versnel IoT-productontwikkeling met Mbed-ecosysteem

Ontwikkelingsteams van embedded en IoT-producten (Internet of Things) staan onder continue druk om hun ontwerp zo snel mogelijk af te hebben en te verzenden. Om snel te kunnen werken, hebben ze beproefde componenten en softwareframeworks nodig met een sterk ecosysteem. Ook moeten ze er rekening mee houden hoe hun systemen in de toekomst worden onderhouden en geschaald, wat betekent dat oplossingen ook draagbaar moeten zijn en zo nodig op meerdere hardwareplatforms moeten kunnen draaien.

Leveranciers van microcontrollers binden ontwikkelaars echter vaak aan hun eigen ecosysteem, wat het moeilijker maakt om over te schakelen tussen microcontrollers. Bovendien zijn de softwaretools voor microcontroller-ecosystemen vaak ontoereikend omdat ze meestal op C zijn gebaseerd, wat ontwikkelingsteams ook kan hinderen.

Met het oog op deze vereisten wordt in dit artikel het Mbed-platform en -besturingssysteem van Arm geïntroduceerd. We laten zien hoe ontwikkelaars het Mbed-ecosysteem kunnen gebruiken om hun embedded producten sneller te ontwikkelen en ze buiten het ecosysteem van de microcontrollerleverancier te schalen.

Wat is Arm Mbed?

Mbed is een online collaboratie onder leiding van Arm voor ontwikkelaars die geïnteresseerd zijn in het bouwen van IoT-apparaten¹. Mbed biedt ontwikkelaars een brede keuze aan resources die speciaal zijn ontworpen om ontwikkeling te versnellen, variërend van Mbed OS en Mbed TLS tot ontwikkelingsboards en individuele hardwarecomponenten die door Mbed-bibliotheken worden ondersteund.

De premisse achter Mbed is een groot ecosysteem dat wordt ondersteund door 200.000 ontwikkelaars in online community's samen met bekende microcontrollerleveranciers, zoals Cypress Semiconductor, NXP Semiconductors en STMicroelectronics, zodat ontwikkelaars met behulp van bestaande componenten, ontwikkeltools en bibliotheken hun werk kunnen versnellen. Gebruik van het Mbed-ecosysteem heeft veel voordelen:

• De bibliotheken en voorbeelden zijn geschreven in C++, een moderne objectgeoriënteerde taal die code schaalbaar en herbruikbaar maakt.
• De mogelijkheid om via een bestaand hardwareplatform snel een prototype te maken van een embedded product om aan te tonen dat het haalbaar is.
• Toegang tot online en offline Mbed-compilers samen met de Mbed CLI (command line interface), wat het ontwikkelen van softwaretests vereenvoudigd (en die zelfs zijn opgenomen in vele voorbeelden en bibliotheken).
• Ingebouwde tools voor het ontwikkelen van IoT-apparaten, zoals de cloudservice Connector waarmee een apparaat niet alleen gemakkelijk aan de cloud kan worden gekoppeld, maar ook via andere cloudgebaseerde diensten kan worden beheerd.

Dankzij het algemene architecturale model is Mbed uiterst flexibel en schaalbaar voor embedded ontwikkelaars. Zo wordt het architecturale model bijvoorbeeld onderverdeeld in drie afzonderlijke lagen (Afbeelding 1):

• Een low-level hardware abstraction layer (HAL).
• Mbed OS API, wat als middleware fungeert en mogelijkheden biedt zoals opslag, RTOS, veilige connectiviteit en communicatiestacks.
• Een high-level IoT-laag die de applicatiecode, Mbed OS-bibliotheken en connectiviteitsclient(en) bevat.

Afbeelding 1: De Mbed-architectuur bestaat uit drie primaire lagen die zo nodig geschaald en uitgebreid kunnen worden: een low-level hardware-interface die geabstraheerd wordt via een HAL, een Mbed OS API-laag die middleware abstraheert en een high-level laag voor de applicatiecode, bibliotheken en clients zoals Pelion. (Bron afbeelding: Arm Mbed)

De architectuur is zo ontworpen dat ontwikkelaars de onderdelen die ze voor hun toepassing nodig hebben, kunnen gebruiken en de rest weg kunnen laten. Hierdoor wordt de architectuur schaalbaar en flexibel en kunnen ontwikkelaars eenvoudig prototypen ontwikkelen en hun product sneller van prototype in productie nemen.

Mbed begint met de hardware

Hoewel Mbed een geweldige softwarebasis heeft, biedt het meer dan alleen software en de tools die nodig zijn om die software te ontwikkelen. De snelste manier waarop een team een product kan ontwikkelen, is het benutten van het Mbed hardware-ecosysteem, bestaande uit drie gebieden:

• modules
• boards
• componenten

Modules zijn in wezen IoT-gerichte connectiviteitscomponenten die in een gecertificeerd en gebruiksklaar pakket worden geleverd. Een ontwikkelaar die bijvoorbeeld aan een product werkt dat LoRaWAN ondersteunt, kan wellicht de MTMDK-XDOT-NA1-A00 xDot module, een ontwikkelingsset van Multi-Tech Systems, kiezen (Afbeelding 2). De xDot-module levert bidirectionele communicatie tot een afstand van meer dan 15 km in direct zicht en tussen 1,5 en 5 km in gebouwen bij datasnelheden variërend van 293 bit per seconde (bit/s) tot 20 kilobit per seconde (kbit/s). De module gebruikt een low-power STM32L151CCU6 processor van STMicroelectronics die op 32 megahertz (MHz) draait en kan worden bestuurd door middel van een AT messaging scheme via SPI, UART of I²C-interfaces.

Afbeelding 2: De xDot module biedt ontwikkelaars een gecertificeerde LoRaWAN module die wordt ondersteund door de Mbed-softwarestacks en waarmee een ontwikkelaar in aanzienlijk minder tijd aan de slag kan. (Bron afbeelding: Multi-Tech Systems Inc.)

Mbed-boards zijn in wezen ontwikkelingsboards voor verschillende microcontrollerfamilies die allemaal worden ondersteund door Mbed. Elk ontwikkelingsboard bevat unieke functies en mogelijkheden die door de leverancier van de microcontroller worden vertrekt. Een ontwikkelaar die bijvoorbeeld geïnteresseerd is in een board dat Bluetooth Low Energy (BLE) ondersteunt, is wellicht geïnteresseerd in de CY8CKIT-062-BLE van Cypress Semiconductor (Afbeelding 3).

Afbeelding 3: Het CY8CKIT-062-BLE ontwikkelingsboard bevat tal van functies voor het ontwikkelen van een IoT-apparaat, waaronder een E-Ink display, capacitieve aanraakknoppen en schuifregelaar, een BLE-module en een KitProg2-debugger. (Bron afbeelding: Cypress Semiconductor)

Uniek aan de CY8CKIT is een multi-core PSoC 62 veilige microcontroller. Eén core is een Arm® Cortex®-M4 processor en de andere een low-power Arm Cortex-M0+. Hierdoor kunnen ontwikkelaars hun toepassingscode partitioneren, zoals één processor de BLE-communicatie laten verwerken, of de toepassing vergrendelen door de Cortex-M0+-core als beveiligingsprocessor gebruiken. Dankzij alle I/O-uitbreidingen die op de boards aanwezig zijn, kunnen ontwikkelaars veel eenvoudiger een prototype van hun systeem maken door Mbed-componenten aan te sluiten.

Een Mbed-component is a hardwarecomponent dat door Mbed ondersteunde bibliotheken bevat evenals bijbehorende middleware die fungeert als building blocks voor een product. Zo kan een ontwikkelaar die aan een IoT-project werkt bijvoorbeeld besluiten een temperatuursensor op te nemen. De ontwikkelaar gaat vervolgens op zoek naar Mbed-componenten voor ondersteunde temperatuursensoren en komt bijvoorbeeld de MAX31723PMB1 van Maxim Integrated tegen die wordt geleverd in een perifere module en kan worden gebruikt voor snel prototypeontwikkeling (Afbeelding 4).

Het voordeel van dergelijke Mbed-componenten is dat ze bijna altijd als een ontwikkelingsboard worden geleverd, inclusief schema's. Zo zien ontwikkelaars niet alleen de benodigde hardwareconfiguratie, maar hebben ze ook de beschikking over de softwarebibliotheek voor de sensor.

Afbeelding 4: De perifere module MAX31723PMB1 digitale thermometer en thermostaat (schema afgebeeld) kan moeiteloos op een Mbed-ontwikkelingsboard worden aangesloten waarna de bijbehorende Mbed-componentbibliotheek kan worden gebruikt voor communicatie met de temperatuursensor. (Bron afbeelding: Maxim Integrated)

Eenvoudige sensoren zoals temperatuur- en vochtigheidssensoren zijn niet de enige die via Mbed beschikbaar zijn. Ontwikkelaars van medische apparaten zijn wellicht geïnteresseerd in de MAXREFDES220# module van Maxim Integrated omdat deze een referentieontwerp bevat voor een hartslag- en saturatiemeter (Afbeelding 5).

Afbeelding 5: De MAXREFDES220# module biedt een ontwikkelingsboard met een hartslag- en saturatiemeter. (Bron afbeelding: Maxim Integrated)

Er zijn ook componenten, zoals het 114991252 VL53L0X Flow breakoutboard van Seeed Technology, die kunnen worden gebruikt voor toepassingen zoals lichtsensoren en het meten van 3D time-of-flight (ToF) afstand (Afbeelding 6). Een ontwikkelaar kan bijvoorbeeld geïnteresseerd zijn in deze sensor om randtechnologieën met gebarenbesturing te ontwikkelen.

Afbeelding 6: Het 114991252 Flow breakout sensorboard van Seeed Technologies kan eenvoudig worden geïntegreerd in een Mbed-ontwikkelingsboard voor toepassingen met licht- of 3D time-of-flight-sensoren zoals voor gebarendetectie. (Afbeelding bron: Seeed Technology)

Nadat ontwikkelaars hun ontwikkelingsboard en componenten hebben geselecteerd, kunnen ze eerst een ‘Hello World’ LEDBlinky ontwikkelen, een toepassing waarbij je een ledje moet laten knipperen, om te testen of ze hun board op de juiste manier kunnen programmeren.

Een ‘Hello World’ LEDBlinky toepassing schrijven met Mbed

Er zijn verschillende manieren om een Mbed-toepassing te ontwikkelen: met de online compiler, de offline compiler of door gebruik te maken van opdrachtregels in de CLI-tool (command line interface). Persoonlijk raad ik aan de CLI te gebruiken omdat deze meer controle biedt over het ontwikkelproces en eenvoudiger kan worden geïntegreerd in ontwikkelprocessen, zoals testharnassen en continue integratieservers.

De CLI werkt via opdrachtregels, dus een ontwikkelaar die met Windows werkt, kan de opdrachtprompt gebruiken om de code te compileren. De eerste stap bij het maken van de LEDBlinky-toepassing is het vooraf gemaakte voorbeeld dat met Mbed wordt meegeleverd. Hiervoor moet de volgende opdracht in de opdrachtprompt worden ingevoerd:

mbed import mbed-os-example-blinky

Het downloaden van het voorbeeld kan enkele minuten duren, omdat het tevens Mbed OS en andere componenten omvat die in de toepassing kunnen worden gebruikt. Zodra het downloaden klaar is, gaat de ontwikkelaar naar het bestand main.cpp in de map mbed-os-example-blinky. Deze module kan worden geopend in een willekeurige editor en ziet er als volgt uit:

Copy #include "mbed.h" #include "platform/mbed_thread.h" #include "stats_report.h"   DigitalOut led1(LED1);   #define SLEEP_TIME                  500 // (msec) #define PRINT_AFTER_N_LOOPS         20   // main() runs in its own thread in the OS int main() {     SystemReport sys_state( SLEEP_TIME * PRINT_AFTER_N_LOOPS /* Loop delay time in ms */);       int count = 0;     while (true) {         // Blink LED and wait 0.5 seconds         led1 = !led1;         thread_sleep_for(SLEEP_TIME);           if ((0 == count) || (PRINT_AFTER_N_LOOPS == count)) {             // Following the main thread wait, report on the current system status             sys_state.report_state();             count = 0;         }         ++count;     } } 

De ontwikkelaar kan nu wijzigingen aanbrengen, maar voor de toepassing van dit artikel zijn de standaardwaarden prima. Het is veel belangrijker dat de code wordt gecompileerd en geïmplementeerd. De exacte opdracht voor het compileren en implementeren van de code is afhankelijk van de hardware. Hieronder laten we als voorbeeld zien hoe het CY8CKIT-062-BLE-ontwikkelingsboard van Cypress met één opdracht kan worden gecompileerd en geprogrammeerd:

mbed compile -m CY8CKIT_062_BLE -t GCC_ARM -f

De eerste keer dat het project wordt gecompileerd, kan enkele minuten duren, aangezien de toolketen alle bijbehorende bestanden moet bouwen die automatisch in een Mbed-toepassing komen. Zodra de compilatiecyclus is voltooid, zal het resultaat er ongeveer uitzien als in afbeelding 7 hieronder.

Afbeelding 7: Afbeelding van het resultaat van de Mbed-compiler als het LEDBlinky-project correct is gecompileerd. (Bron afbeelding: Jacob Beningo)

De optie -f in de opdrachtregel kopieert het gecompileerde HEX-bestand automatisch naar het ontwikkelingsboard, dat verschijnt als een DAPLink-apparaat voor massaopslag. Als het goed is, gaat er nu een led knipperen en kan de ontwikkelaar beginnen met het ontwikkelen van de primaire toepassing.

Tips voor het werken met Mbed

Werken met Mbed is simpel, maar kan enkele uitdagingen met zich meebrengen. Hieronder staan een paar tips voor het ontwikkelen van een product met behulp van Mbed:

• Gebruik niet de online compiler. Deze werkt prima voor hobbyisten, maar kan voor professionals problemen veroorzaken omdat de broncode op de server van iemand anders staat. Ook kan het werken in de cloud het debuggen vertragen. Een lokale compiler zoals de Mbed IDE of de Mbed CLI is een betere optie.
• Mbed ondersteunt multi-threading, maar de hoofdfunctie draait standaard in zijn eigen thread.
• Begin met Mbed-voorbeeldprojecten om te leren hoe je efficiënter met Mbed-toepassingen kunt werken.
• Maak gebruik van het Mbed-testharness om er zeker van te zijn dat de toepassingsontwikkeling niet per ongeluk iets in het Mbed-framework heeft gebroken.
• Gebruik de Mbed-hardwaresite om ontwikkelingsboards, componenten en modules te vinden die samen kunnen worden geïntegreerd om een product te ontwikkelen.

Met deze tips kunnen ontwikkelaars de tijd die ze besteden aan het ontwikkelen van embedded producten minimaliseren.

Conclusie

Embedded en IoT-ontwikkelaars hebben een goed ondersteund ecosysteem nodig met moderne tools, processen en software die hun werk te versnellen en ontwikkelingskosten minimaliseren. Zoals we hebben gezien, is het Mbed-platform en -besturingssysteem één van de mogelijkheden waar ontwikkelaars gebruik van kunnen maken.

Mbed biedt een schaalbare en flexibele softwarearchitectuur met veel componenten die al samen zijn geïntegreerd en getest. Dankzij de uitgebreide ondersteuning en verschillende hardwaremodules, boards en componenten kunnen ontwikkelaars snel en eenvoudig een productprototype maken dat vervolgens kan worden geschaald tot een productieoplossing.

Referenties

1. https://www.mbed.com/en/about-mbed/what-mbed/