Piattaforme-IoT (1)

Sviluppo Firmware per dispositivi IoT con FreeRTOS

Piattaforme-IoT (1)

Sviluppo Firmware per dispositivi IoT con FreeRTOS

FreeRTOS è un sistema operativo in tempo reale (RTOS) open source e gratuito, progettato per applicazioni embedded e IoT. FreeRTOS offre una serie di vantaggi per lo sviluppo di firmware, tra cui:

 

  • Gestione semplice e flessibile dei task, delle priorità e della sincronizzazione
  • Supporto per diversi protocolli di comunicazione, come MQTT, HTTP e BLE
  • Integrazione con AWS IoT Core e altri servizi cloud
  • Portabilità su diverse architetture e piattaforme hardware
  • Supporto a tecnologie per la riduzione del consumo di energia

     

In questo articolo, vedremo come sviluppare un firmware per un dispositivo IoT basato su ESP32, una scheda di sviluppo con un SoC (System on a Chip) che integra un microcontrollore, una connessione Wi-Fi e Bluetooth, e vari sensori e periferiche. Il nostro obiettivo sarà quello di creare un dispositivo che misuri la temperatura e l’umidità dell’ambiente e le invii ad Azure IoT Central, una piattaforma cloud che consente di gestire e monitorare i dispositivi IoT.

Fase 1: Progettazione Firmware

La prima fase dello sviluppo del firmware è la progettazione, in cui si definiscono le specifiche e le funzionalità del dispositivo, si sceglie l’hardware e il software necessari, e si progetta l’architettura e il flusso del programma.

Per il nostro progetto, abbiamo bisogno di:

 

  • Una scheda ESP32 DevKit, che ci fornirà il SoC, la connessione Wi-Fi e Bluetooth, e una porta USB per la programmazione e il debug
  • Un sensore DHT11, che ci permetterà di misurare la temperatura e l’umidità dell’aria
  • Un cavo micro USB, per collegare la scheda al computer
  • Un account Azure, per creare e accedere ad Azure IoT Central
  • Un ambiente di sviluppo integrato (IDE), per scrivere e compilare il codice
  • Un framework di sviluppo, per facilitare la programmazione e l’integrazione con i servizi cloud

     

Per l’IDE, possiamo usare Visual Studio Code, un editor di codice gratuito e multipiattaforma, che supporta vari linguaggi e strumenti. Per il framework di sviluppo, possiamo usare ESP-IDF, il framework ufficiale di Espressif per ESP32, che include FreeRTOS e diversi componenti e librerie per lo sviluppo di applicazioni IoT.

L’architettura del nostro firmware sarà basata sul modello a task di FreeRTOS, in cui il programma è suddiviso in unità di esecuzione indipendenti e concorrenti, chiamate task, che vengono schedulate dal kernel di FreeRTOS in base alle loro priorità e alle risorse disponibili. Il nostro firmware avrà tre task principali:

 

  • Un task per la lettura dei dati dal sensore DHT11, che verrà eseguito periodicamente ogni 5 secondi
  • Un task per la connessione al Wi-Fi e ad Azure IoT Central, che verrà eseguito una sola volta all’avvio del dispositivo
  • Un task per l’invio dei dati ad Azure IoT Central, che verrà eseguito ogni volta che riceve un messaggio dal task del sensore

     

Il flusso del nostro firmware sarà il seguente:

 

  • All’accensione del dispositivo, il task di connessione si occupa di stabilire la connessione Wi-Fi e di registrare il dispositivo ad Azure IoT Central, usando le credenziali fornite
  • Il task di connessione crea una coda di messaggi, che userà per comunicare con il task di invio
  • Il task di connessione avvia il task di lettura e il task di invio, e termina la sua esecuzione
  • Il task di lettura legge i valori di temperatura e umidità dal sensore DHT11, li converte in un formato JSON, e li invia alla coda di messaggi
  • Il task di invio riceve i messaggi dalla coda, e li invia ad Azure IoT Central, usando il protocollo MQTT
  • Il task di invio riceve anche i comandi e le proprietà da Azure IoT Central, e li gestisce in modo appropriato

Fase 2: Implementazione Firmware

La seconda fase dello sviluppo del firmware è l’implementazione, in cui si scrive il codice sorgente, si compila il programma, e si carica il firmware sulla scheda ESP32.

Per scrivere il codice, possiamo seguire i seguenti passi:

 

  • Installare Visual Studio Code e le estensioni necessarie, come ESP-IDF e C/C++
  • Creare un nuovo progetto ESP-IDF, usando il comando ESP-IDF: Create Project
  • Aprire il file main.c nella cartella main, dove scriveremo il codice del nostro firmware
  • Includere le librerie necessarie, come freertos/FreeRTOS.h, freertos/task.h, freertos/queue.h, esp_wifi.h, esp_log.h, dht.h, e azure_iot.h
  • Definire le costanti e le variabili globali, come il nome e la password della rete Wi-Fi, le credenziali di Azure IoT Central, i pin del sensore DHT11, gli handle dei task e della coda, e il tag per il logging
  • Scrivere le funzioni per la creazione e la gestione dei task, seguendo la logica descritta nella fase di progettazione
  • Scrivere la funzione app_main, che verrà chiamata all’avvio del dispositivo, e che si occuperà di inizializzare il sistema, creare il task di connessione, e avviare il kernel di FreeRTOS

     

Per compilare il programma, possiamo usare il comando ESP-IDF: Build, che eseguirà il tool idf.py e genererà il file binario del firmware. Per caricare il firmware sulla scheda ESP32, possiamo usare il comando ESP-IDF: Flash, che eseguirà il tool esptool.py e trasferirà il file binario sulla memoria flash del SoC. Per monitorare il comportamento del dispositivo, possiamo usare il comando ESP-IDF: Monitor, che aprirà una finestra di terminale e mostrerà i messaggi di log inviati dal firmware.

 

Questo è il task che si occupa della lettura periodica del sensore di umidità, usando la libreria DHT11 per ESP-IDF. La lettura avviene ogni 5 secondi e i valori letti vengono salvati in 2 variabili apposite.

Nel secondo blocco vi è il task che, una volta collegato ad Azure tramite l'Azure iothub C sdk di Microsoft, pubblica ogni 10s il messaggio contenete i valori delle 2 variabili lette dal sensore

In questo blocco è presente il punto di entrata del codice, ovvero l'app_main(), che si occupa dell'inizializzazione della periferica WiFi, del task di lettura periodica del DHT11 e del task che si collega ad Azure.

Fase 3: Test e Debug Firmware

La terza fase dello sviluppo del firmware è il tests and the debug, in cui si verifica il funzionamento del dispositivo, si individuano e si correggono gli eventuali errori, e si ottimizza il codice e le prestazioni.

Per testare il dispositivo, possiamo usare Azure IoT Central, che ci permetterà di visualizzare i dati inviati dal dispositivo, di inviare comandi e proprietà al dispositivo, e di configurare le regole e le azioni per il monitoraggio e l’analisi dei dati. Per accedere ad Azure IoT Central, possiamo seguire i seguenti passi:

 

  • Creare un account Azure, se non lo abbiamo già
  • Accedere al portale di Azure, e creare una nuova applicazione IoT Central, scegliendo il modello Custom app
  • Nella dashboard dell’applicazione, cliccare su Device templates, e creare un nuovo modello di dispositivo, scegliendo il tipo IoT device
  • Nella pagina del modello, cliccare su Import capability model, e importare il file JSON che contiene la definizione delle capacità del nostro dispositivo, come la temperatura, l’umidità, il comando di reset, e la proprietà di intervallo di lettura
  • Nella pagina del modello, cliccare su Views, e personalizzare le viste del dispositivo, come la dashboard, le impostazioni, i comandi, e i grafici
  • Nella pagina del modello, cliccare su Publish, e pubblicare il modello, in modo che possa essere usato dai dispositivi
  • Nella dashboard dell’applicazione, cliccare su Devices, e aggiungere un nuovo dispositivo, scegliendo il modello appena creato, e assegnandogli un nome e un ID
  • Nella pagina del dispositivo, cliccare su Connect, e copiare le credenziali di connessione, come l’ID dello scope, l’ID del dispositivo, e la chiave primaria
  • Inserire le credenziali di connessione nel codice del firmware, e ricompilare e ricaricare il firmware sulla scheda ESP32

     

     

A questo punto, il dispositivo dovrebbe essere connesso ad Azure IoT Central.

Fase 4: Deploy e Monitoraggio

L’ultima fase dello sviluppo del firmware è il deploy e il monitoraggio, in cui si distribuisce il firmware sui dispositivi finali, si gestisce il ciclo di vita del firmware, e si monitorano le prestazioni e la sicurezza dei dispositivi.

Per distribuire il firmware sui dispositivi finali, possiamo usare diverse tecniche, come il flashing OTA (Over-The-Air), il provisioning automatico, o il deployment tramite container. Per gestire il ciclo di vita del firmware, possiamo usare Azure IoT Hub, che ci permetterà di creare e gestire i dispositivi, di distribuire il firmware, di monitorare le prestazioni e la sicurezza, e di ricevere gli allarmi e le notifiche in caso di problemi.

Per monitorare le prestazioni e la sicurezza dei dispositivi, possiamo usare Azure Monitor, che ci permetterà di raccogliere e analizzare i dati di telemetria, di visualizzare le metriche e i log, di creare le dashboard e gli alert, e di integrare con altri servizi di monitoraggio e di analisi.

 

In questo articolo, abbiamo visto come sviluppare un firmware per dispositivi IoT con FreeRTOS, partendo dalla progettazione e arrivando al deploy e al monitoraggio. FreeRTOS offre una soluzione completa e flessibile per lo sviluppo di firmware, che può essere integrata con diversi servizi cloud, come AWS IoT Core e Azure IoT Hub, per creare soluzioni IoT scalabili e sicure.

 

Read more

Facebook
LinkedIn