Usare Azure IoT Edge in Raspberry Pi per inoltrare all'hub IoT messaggi da dispositivo a cloud

Questa procedura dettagliata relativa all'esempio Bluetooth Low Energy illustra come usare Azure IoT Edge per:

  • Inoltrare all'hub IoT i dati di telemetria da dispositivo a cloud da un dispositivo fisico.
  • Instradare i comandi dall'hub IoT a un dispositivo fisico.

In questa procedura dettagliata verranno trattati i seguenti argomenti:

  • Architettura: informazioni importanti sull'architettura relative all'esempio Bluetooth Low Energy.
  • Compilazione ed esecuzione: i passaggi richiesti per compilare ed eseguire l'esempio.

Architettura

La procedura dettagliata illustra come compilare ed eseguire un gateway IoT Edge in un modulo Raspberry Pi 3 che esegue Raspbian Linux. Il gateway viene creato usando IoT Edge. L'esempio usa un dispositivo SensorTag di Texas Instruments basato su tecnologia Bluetooth Low Energy (BLE) per raccogliere i dati sulla temperatura.

Quando viene eseguito, il gateway IoT Edge:

  • Si connette a un dispositivo SensorTag usando il protocollo BLE.
  • Si connette all'hub IoT usando il protocollo HTTP.
  • Inoltra i dati di telemetria dal dispositivo SensorTag all'hub IoT.
  • Instrada i comandi dall'hub IoT al dispositivo SensorTag.

Il gateway contiene i moduli IoT Edge seguenti:

  • Un modulo BLE che si interfaccia con un dispositivo BLE per ricevere i dati sulla temperatura dal dispositivo e inviare comandi al dispositivo.
  • Un modulo BLE da cloud a dispositivo che converte i messaggi JSON inviati dall'hub IoT in istruzioni BLE per il modulo BLE.
  • Un modulo logger che registra tutti i messaggi del gateway in un file locale.
  • Un modulo di mapping delle identità che esegue la conversione tra gli indirizzi MAC del dispositivo BLE e le identità dispositivo dell'hub IoT di Azure.
  • Un modulo dell'hub IoT che carica i dati di telemetria in un hub IoT e riceve i comandi del dispositivo da un hub IoT.
  • Un modulo di stampa BLE che interpreta i dati di telemetria dal dispositivo BLE e stampa i dati formattati sulla console per consentire la risoluzione dei problemi e il debug.

Come avviene il flusso di dati attraverso il gateway

Il diagramma a blocchi seguente illustra la pipeline del flusso di caricamento dei dati di telemetria:

Pipeline di caricamento dei dati di telemetria attraverso il gateway

Il passaggio di un elemento di telemetria da un dispositivo BLE all'hub IoT prevede le fasi seguenti:

  1. Il dispositivo BLE genera un esempio relativo alla temperatura e lo invia tramite Bluetooth al modulo BLE nel gateway.
  2. Il modulo BLE riceve l'esempio e lo pubblica sul broker insieme all'indirizzo MAC del dispositivo.
  3. Il modulo di mapping delle identità preleva il messaggio e usa una tabella interna per convertire l'indirizzo MAC del dispositivo in un'identità dispositivo dell'hub IoT. Un'identità dispositivo dell'hub IoT è costituita da un ID di dispositivo e una chiave del dispositivo.
  4. Il modulo di mapping delle identità pubblica un nuovo messaggio contenente i dati di esempio relativi alla temperatura, nonché l'indirizzo MAC, l'ID e la chiave del dispositivo.
  5. Il modulo dell'hub IoT riceve questo nuovo messaggio (generato dal modulo di mapping delle identità) e lo pubblica nell'hub IoT.
  6. Il modulo logger registra tutti i messaggi provenienti dal broker in un file locale.

Il diagramma a blocchi seguente illustra la pipeline del flusso di invio dei comandi del dispositivo:

Pipeline dell'invio dei comandi del dispositivo attraverso il gateway

  1. Il modulo dell'hub IoT esegue periodicamente il polling dell'hub IoT per rilevare la presenza di nuovi messaggi di comando.
  2. Quando il modulo dell'hub IoT riceve un nuovo messaggio di comando, lo pubblica sul broker.
  3. Il modulo di mapping delle identità preleva il messaggio di comando e usa una tabella interna per convertire l'ID dispositivo dell'hub IoT in un indirizzo MAC di dispositivo, quindi pubblica un nuovo messaggio che include l'indirizzo MAC del dispositivo di destinazione nella mappa delle proprietà.
  4. Il modulo BLE da cloud a dispositivo preleva il messaggio e lo converte nell'istruzione BLE appropriata per il modulo BLE. Dopodiché pubblica un nuovo messaggio.
  5. Il modulo BLE preleva il messaggio ed esegue l'istruzione di I/O comunicando con il dispositivo BLE.
  6. Il modulo logger registra tutti i messaggi provenienti dal broker in un file su disco.

Prerequisiti

Per completare l'esercitazione, è necessaria una sottoscrizione di Azure attiva.

Nota

Se non si dispone di un account, è possibile creare un account di valutazione gratuita in pochi minuti. Per informazioni dettagliate, vedere la pagina relativa alla versione di valutazione gratuita di Azure.

È necessario un client SSH nel computer desktop per poter accedere in remoto alla riga di comando in Raspberry Pi.

  • Windows non include un client SSH. È consigliabile usare PuTTY.
  • La maggior parte delle distribuzioni Linux e Mac OS includono l'utilità SSH della riga di comando. Per altre informazioni, vedere SSH Using Linux or Mac OS (SSH con Linux o Mac OS).

Preparare l'hardware

Questa esercitazione presuppone che si usi un dispositivo SensorTag di Texas Instruments connesso a un modulo Raspberry Pi 3 che esegue Raspbian.

Installare Raspbian

È possibile usare una delle opzioni seguenti per installare Raspbian nel dispositivo Raspberry Pi 3.

  • Per installare la versione più recente di Raspbian, usare l'interfaccia utente grafica NOOBS.
  • Scaricare manualmente l'immagine più recente del sistema operativo Raspbian e scriverla in una scheda SD.

Accedere al terminale

Esistono due opzioni per accedere all'ambiente di un terminale in Raspberry Pi:

  • Se a Raspberry Pi sono connessi una tastiera e un monitor, è possibile usare l'interfaccia utente grafica di Raspbian per accedere a una finestra del terminale.

  • Accedere alla riga di comando in Raspberry Pi usando SSH dal computer desktop.

Usare una finestra del terminale nell'interfaccia utente grafica

Le credenziali predefinite per Raspbian sono il nome utente pi e la password raspberry. Nella barra della applicazioni dell'interfaccia utente grafica è possibile avviare l'utilità Terminal (Terminale) usando l'icona del monitor.

Accedere con SSH

È possibile usare la riga di comando SSH per accedere a Raspberry Pi. L'articolo SSH (Secure Shell) (SSH - Secure Shell) descrive come configurare SSH in Raspberry Pi e come connettersi da Windows o Linux e Mac OS.

Accedere con il nome utente pi e la password raspberry.

Installare BlueZ 5.37

I moduli BLE comunicano con l'hardware Bluetooth tramite lo stack BlueZ. Per il corretto funzionamento dei moduli è necessaria la versione 5.37 di BlueZ. Queste istruzioni consentono di verificare che sia installata la versione corretta di BlueZ.

  1. Arrestare il daemon Bluetooth corrente:

    sudo systemctl stop bluetooth
    
  2. Installare le dipendenze BlueZ:

    sudo apt-get update
    sudo apt-get install bluetooth bluez-tools build-essential autoconf glib2.0 libglib2.0-dev libdbus-1-dev libudev-dev libical-dev libreadline-dev
    
  3. Scaricare il codice sorgente BlueZ da bluez.org:

    wget http://www.kernel.org/pub/linux/bluetooth/bluez-5.37.tar.xz
    
  4. Decomprimere il codice sorgente:

    tar -xvf bluez-5.37.tar.xz
    
  5. Passare alla cartella appena creata:

    cd bluez-5.37
    
  6. Configurare il codice BlueZ da compilare:

    ./configure --disable-udev --disable-systemd --enable-experimental
    
  7. Compilare BlueZ:

    make
    
  8. Al termine, installare BlueZ:

    sudo make install
    
  9. Cambiare la configurazione del servizio systemd per bluetooth in modo che punti al nuovo daemon Bluetooth nel file /lib/systemd/system/bluetooth.service. Sostituire la riga 'ExecStart' con il testo seguente:

    ExecStart=/usr/local/libexec/bluetooth/bluetoothd -E
    

Abilitare la connettività al dispositivo SensorTag dal dispositivo Raspberry Pi 3

Prima di eseguire l'esempio è necessario verificare che il dispositivo Raspberry Pi 3 possa connettersi al dispositivo SensorTag.

  1. Assicurarsi che l'utilità rfkill sia installata:

    sudo apt-get install rfkill
    
  2. Sbloccare Bluetooth sul dispositivo Raspberry Pi 3 e verificare che il numero di versione sia 5.37:

    sudo rfkill unblock bluetooth
    bluetoothctl --version
    
  3. Per accedere a una shell del Bluetooth interattiva, avviare il servizio Bluetooth ed eseguire il comando bluetoothctl:

    sudo systemctl start bluetooth
    bluetoothctl
    
  4. Immettere il comando power on per accendere il controller bluetooth. L'output restituito dal comando è simile al seguente:

    [NEW] Controller 98:4F:EE:04:1F:DF C3 raspberrypi [default]
    
  5. Nella shell Bluetooth interattiva immettere il comando scan on per cercare i dispositivi Bluetooth. L'output restituito dal comando è simile al seguente:

    Discovery started
    [CHG] Controller 98:4F:EE:04:1F:DF Discovering: yes
    
  6. Rendere individuabile il dispositivo SensorTag premendo il pulsante piccolo (il LED verde dovrebbe lampeggiare). Il modulo Raspberry Pi 3 dovrebbe individuare il dispositivo SensorTag:

    [NEW] Device A0:E6:F8:B5:F6:00 CC2650 SensorTag
    [CHG] Device A0:E6:F8:B5:F6:00 TxPower: 0
    [CHG] Device A0:E6:F8:B5:F6:00 RSSI: -43
    

    In questo esempio è possibile notare che l'indirizzo MAC del dispositivo SensorTag è A0:E6:F8:B5:F6:00.

  7. Disattivare la scansione immettendo il comando scan off:

    [CHG] Controller 98:4F:EE:04:1F:DF Discovering: no
    Discovery stopped
    
  8. Connettersi al dispositivo SensorTag tramite il relativo indirizzo MAC immettendoconnect <indirizzo MAC>. L'output di esempio seguente è abbreviato per maggiore chiarezza:

    Attempting to connect to A0:E6:F8:B5:F6:00
    [CHG] Device A0:E6:F8:B5:F6:00 Connected: yes
    Connection successful
    [CHG] Device A0:E6:F8:B5:F6:00 UUIDs: 00001800-0000-1000-8000-00805f9b34fb
    ...
    [NEW] Primary Service
            /org/bluez/hci0/dev_A0_E6_F8_B5_F6_00/service000c
            Device Information
    ...
    [CHG] Device A0:E6:F8:B5:F6:00 GattServices: /org/bluez/hci0/dev_A0_E6_F8_B5_F6_00/service000c
    ...
    [CHG] Device A0:E6:F8:B5:F6:00 Name: SensorTag 2.0
    [CHG] Device A0:E6:F8:B5:F6:00 Alias: SensorTag 2.0
    [CHG] Device A0:E6:F8:B5:F6:00 Modalias: bluetooth:v000Dp0000d0110
    

    È possibile elencare di nuovo le caratteristiche GATT del dispositivo usando il comando list-attributes.

  9. È ora possibile disconnettersi dal dispositivo usando il comando disconnect e quindi uscire dalla shell Bluetooth con il comando quit:

    Attempting to disconnect from A0:E6:F8:B5:F6:00
    Successful disconnected
    [CHG] Device A0:E6:F8:B5:F6:00 Connected: no
    

A questo punto si è pronti a eseguire l'esempio di IoT Edge BLE nel dispositivo Raspberry Pi 3.

Eseguire l'esempio di IoT Edge BLE

Per eseguire l'esempio IoT Edge BLE è necessario completare tre attività:

  • Configurare due dispositivi di esempio nell'hub IoT.
  • Compilare IoT Edge sul dispositivo Raspberry Pi 3.
  • Configurare ed eseguire l'esempio BLE sul dispositivo Raspberry Pi 3.

Al momento della redazione di questo documento, IoT Edge supporta solo moduli BLE in gateway che vengono eseguiti in Linux.

Configurare due dispositivi di esempio nell'hub IoT

  • Creare un hub IoT nella sottoscrizione di Azure. Per completare questa procedura, è necessario disporre del nome dell'hub. Se non si ha un account, è possibile crearne uno gratuito in pochi minuti.
  • Aggiungere un dispositivo chiamato SensorTag_01 all'hub IoT e prendere nota del relativo ID e della chiave del dispositivo. È possibile usare lo strumento per Esplora dispositivi o iothub-explorer per aggiungere il dispositivo all'hub IoT creato nel passaggio precedente e recuperarne la chiave. Il mapping del dispositivo al SensorTag avviene quando si configura il gateway.

Compilare Azure IoT Edge su Raspberry Pi 3

Installare le dipendenze per Azure IoT Edge:

sudo apt-get install cmake uuid-dev curl libcurl4-openssl-dev libssl-dev

Usare i comandi seguenti per clonare IoT Edge e tutti i relativi moduli secondari nella directory home:

cd ~
git clone https://github.com/Azure/iot-edge.git

Quando si ha una copia completa del repository di IoT Edge nel dispositivo Raspberry Pi 3, è possibile procedere alla compilazione usando il comando seguente dalla cartella contenente l'SDK:

cd ~/iot-edge
./tools/build.sh  --disable-native-remote-modules

Configurare ed eseguire l'esempio BLE sul dispositivo Raspberry Pi 3

Per avviare ed eseguire l'esempio, è necessario configurare ogni modulo IoT Edge coinvolto nell'attività del gateway. La configurazione viene definita in un file JSON ed è necessario configurare tutti e cinque i moduli IoT Edge coinvolti. Nell'archivio chiamato gateway_sample.json è presente un file JSON di esempio che è possibile usare come base per creare il file di configurazione. Il file si trova nella cartella samples/ble_gateway_hl/src della copia locale del repository IoT Edge.

Le sezioni seguenti descrivono come modificare il file di configurazione per l'esempio BLE, supponendo che il repository IoT Edge si trovi nella cartella /home/pi/iot-edge/ del dispositivo Raspberry Pi 3. Se l'archivio si trova in un'altra posizione, modificare i percorsi di conseguenza.

Configurazione del modulo logger

Se l'archivio del gateway si trova nella cartella /home/pi/iot-edge/, configurare il modulo logger nel modo seguente:

{
  "name": "Logger",
  "loader": {
    "name" : "native",
    "entrypoint" : {
      "module.path" : "build/modules/logger/liblogger.so"
    }
  },
  "args":
  {
    "filename": "<</path/to/log-file.log>>"
  }
}

Configurazione del modulo BLE

La configurazione di esempio per il dispositivo BLE presuppone che venga usato un dispositivo SensorTag di Texas Instruments. Dovrebbe essere possibile usare qualsiasi dispositivo BLE standard in grado di funzionare come periferica GATT, ma in tal caso sarà necessario aggiornare i dati e gli ID delle caratteristiche GATT. Aggiungere l'indirizzo MAC del dispositivo SensorTag:

{
  "name": "SensorTag",
  "loader": {
    "name" : "native",
    "entrypoint" : {
      "module.path": "build/modules/ble/libble.so"
    }
  },
  "args": {
    "controller_index": 0,
    "device_mac_address": "<<AA:BB:CC:DD:EE:FF>>",
    "instructions": [
      {
        "type": "read_once",
        "characteristic_uuid": "00002A24-0000-1000-8000-00805F9B34FB"
      },
      {
        "type": "read_once",
        "characteristic_uuid": "00002A25-0000-1000-8000-00805F9B34FB"
      },
      {
        "type": "read_once",
        "characteristic_uuid": "00002A26-0000-1000-8000-00805F9B34FB"
      },
      {
        "type": "read_once",
        "characteristic_uuid": "00002A27-0000-1000-8000-00805F9B34FB"
      },
      {
        "type": "read_once",
        "characteristic_uuid": "00002A28-0000-1000-8000-00805F9B34FB"
      },
      {
        "type": "read_once",
        "characteristic_uuid": "00002A29-0000-1000-8000-00805F9B34FB"
      },
      {
        "type": "write_at_init",
        "characteristic_uuid": "F000AA02-0451-4000-B000-000000000000",
        "data": "AQ=="
      },
      {
        "type": "read_periodic",
        "characteristic_uuid": "F000AA01-0451-4000-B000-000000000000",
        "interval_in_ms": 1000
      },
      {
        "type": "write_at_exit",
        "characteristic_uuid": "F000AA02-0451-4000-B000-000000000000",
        "data": "AA=="
      }
    ]
  }
}

Se non si usa un dispositivo SensorTag, esaminare la documentazione del dispositivo BLE per determinare se è necessario aggiornare i dati e gli ID delle caratteristiche GATT.

modulo dell'hub IoT

Aggiungere il nome dell'hub IoT. Il valore del suffisso è in genere azure-devices.net:

{
  "name": "IoTHub",
  "loader": {
    "name" : "native",
    "entrypoint" : {
      "module.path": "build/modules/iothub/libiothub.so"
    }
  },
  "args": {
    "IoTHubName": "<<Azure IoT Hub Name>>",
    "IoTHubSuffix": "<<Azure IoT Hub Suffix>>",
    "Transport" : "amqp"
  }
}

Configurazione del modulo di mapping delle identità

Aggiungere l'indirizzo MAC del dispositivo SensorTag, nonché l'ID e la chiave del dispositivo SensorTag_01 che è stato aggiunto all'hub IoT:

{
  "name": "mapping",
  "loader": {
    "name" : "native",
    "entrypoint" : {
      "module.path": "build/modules/identitymap/libidentity_map.so"
    }
  },
  "args": [
    {
      "macAddress": "<<AA:BB:CC:DD:EE:FF>>",
      "deviceId": "<<Azure IoT Hub Device ID>>",
      "deviceKey": "<<Azure IoT Hub Device Key>>"
    }
  ]
}

Configurazione del modulo di stampa BLE

{
  "name": "BLE Printer",
  "loader": {
    "name" : "native",
    "entrypoint" : {
      "module.path": "build/samples/ble_gateway/ble_printer/libble_printer.so"
    }
  },
  "args": null
}

Configurazione del modulo BLEC2D

{
  "name": "BLEC2D",
  "loader": {
    "name" : "native",
    "entrypoint" : {
      "module.path": "build/modules/ble/libble_c2d.so"
    }
  },
  "args": null
}

Configurazione di routing

La configurazione seguente garantisce che i moduli IoT Edge:

  • Il modulo Logger riceva e registri tutti i messaggi.
  • Il modulo SensorTag invii i messaggi a entrambi i moduli mapping e BLE Printer.
  • Il modulo mapping invii i messaggi al modulo IoTHub per farli recapitare all'hub IoT.
  • Il modulo IoTHub invii di nuovo i messaggi al modulo mapping.
  • Il modulo mapping invii i messaggi al modulo BLEC2D.
  • Il modulo BLEC2D invii di nuovo i messaggi al modulo SensorTag.
"links" : [
    {"source" : "*", "sink" : "Logger" },
    {"source" : "SensorTag", "sink" : "mapping" },
    {"source" : "SensorTag", "sink" : "BLE Printer" },
    {"source" : "mapping", "sink" : "IoTHub" },
    {"source" : "IoTHub", "sink" : "mapping" },
    {"source" : "mapping", "sink" : "BLEC2D" },
    {"source" : "BLEC2D", "sink" : "SensorTag"}
 ]

Per eseguire l'esempio, passare il percorso del file di configurazione JSON come parametro al codice binario ble_gateway. Il comando seguente assume che si stia usano il file di configurazione gateway_sample.json. Eseguire questo comando dalla cartella iot-edge in Raspberry Pi:

./build/samples/ble_gateway/ble_gateway ./samples/ble_gateway/src/gateway_sample.json

Prima di eseguire l'esempio, potrebbe essere necessario premere il pulsante piccolo sul dispositivo SensorTag per renderlo individuabile.

Durante l'esecuzione dell'esempio è possibile usare lo strumento Device Explorer o iothub-explorer per monitorare i messaggi che il gateway IoT Edge inoltra dal dispositivo SensorTag. Ad esempio, tramite iothub-explorer è possibile monitorare i messaggi da dispositivo a cloud usando il comando seguente:

iothub-explorer monitor-events --login "HostName={Your iot hub name}.azure-devices.net;SharedAccessKeyName=iothubowner;SharedAccessKey={Your IoT Hub key}"

Inviare messaggi da cloud a dispositivo

Il modulo BLE supporta anche l'invio di comandi dall'hub IoT al dispositivo. È possibile usare lo strumento Esplora dispositivi o iothub-explorer per inviare i messaggi JSON che il modulo BLE del gateway inoltra al dispositivo BLE.

Se si usa il dispositivo SensorTag di Texas Instruments, è possibile attivare il LED rosso, il LED verde o il segnalatore acustico inviando comandi dall'hub IoT. Prima dell'invio dei comandi dall'hub IoT, occorre tuttavia inviare i due messaggi JSON seguenti nell'ordine indicato. Sarà quindi possibile inviare i comandi per attivare i LED o il segnalatore acustico.

  1. Reimpostare tutti i LED e il segnalatore acustico (spegnerli):

    {
      "type": "write_once",
      "characteristic_uuid": "F000AA65-0451-4000-B000-000000000000",
      "data": "AA=="
    }
    
  2. Configurare l'I/O come "remote":

    {
      "type": "write_once",
      "characteristic_uuid": "F000AA66-0451-4000-B000-000000000000",
      "data": "AQ=="
    }
    

È possibile a questo punto inviare i comandi seguenti per attivare i LED o il segnalatore acustico sul dispositivo SensorTag:

  • Accendere il LED rosso:

    {
      "type": "write_once",
      "characteristic_uuid": "F000AA65-0451-4000-B000-000000000000",
      "data": "AQ=="
    }
    
  • Accendere il LED verde:

    {
      "type": "write_once",
      "characteristic_uuid": "F000AA65-0451-4000-B000-000000000000",
      "data": "Ag=="
    }
    
  • Accendere il segnalatore acustico:

    {
      "type": "write_once",
      "characteristic_uuid": "F000AA65-0451-4000-B000-000000000000",
      "data": "BA=="
    }
    

Passaggi successivi

Per ottenere informazioni più avanzate su IoT Edge e provare alcuni esempi di codice, vedere le seguenti risorse ed esercitazioni per gli sviluppatori:

Per altre informazioni sulle funzionalità dell'hub IoT, vedere: