Libreria Bluetooth Low Energy

Importante

Questa libreria è ospitata nel repository Amazon-FreeRTOS che è obsoleto. Ti consigliamo di iniziare da qui quando crei un nuovo progetto. Se disponi già di un progetto FreeRTOS esistente basato sull'ormai obsoleto repository Amazon-FreerTOS, consulta il. Guida alla migrazione del repository Github di Amazon-FreeRTOS

Panoramica

FreerTOS supporta la pubblicazione e la sottoscrizione di argomenti MQTT (Message Queuing Telemetry Transport) tramite Bluetooth Low Energy tramite un dispositivo proxy, come un telefono cellulare. Con la libreria FreerTOS Bluetooth Low Energy (BLE), il microcontrollore può comunicare in modo sicuro con il broker MQTT. AWS IoT

Utilizzando gli SDK mobili per dispositivi Bluetooth FreerTOS, puoi scrivere applicazioni mobili native che comunicano con le applicazioni integrate sul tuo microcontrollore tramite BLE. Per ulteriori informazioni sugli SDK per dispositivi mobili, consulta SDK mobili per dispositivi Bluetooth FreerTOS.

La libreria FreerTOS BLE include servizi per la configurazione di reti Wi-Fi, il trasferimento di grandi quantità di dati e la fornitura di astrazioni di rete tramite BLE. La libreria FreerTOS BLE include anche API middleware e di livello inferiore per un controllo più diretto sullo stack BLE.

Architettura

Tre livelli costituiscono la libreria FreerTOS BLE: servizi, middleware e wrapper di basso livello.

Servizi

Il livello di servizi BLE FreerTOS è costituito da quattro servizi Generic Attribute (GATT) che sfruttano le API del middleware:

• Informazioni sul dispositivo

• Provisioning Wi-Fi

• Astrazione di rete

• Trasferimento di oggetti di grandi dimensioni

Informazioni sul dispositivo

Il servizio di informazioni sul dispositivo raccoglie dettagli sul microcontrollore, tra cui:

• La versione di FreerTOS utilizzata dal tuo dispositivo.

• L' AWS IoT endpoint dell'account per il quale è registrato il dispositivo.

• Unità di trasmissione massima (MTU) Bluetooth Low Energy

Provisioning Wi-Fi

Il servizio di provisioning Wi-Fi consente ai microcontroller con funzionalità Wi-Fi di eseguire le seguenti operazioni:

• Elencare reti nell'intervallo.

• Salvare reti e credenziali di rete nella memoria flash.

• Impostare priorità di rete.

• Eliminare reti e credenziali di rete dalla memoria flash.

Astrazione di rete

Il servizio Astrazione di rete estrae il tipo di connessione di rete per le applicazioni. Un'API comune interagisce con lo stack hardware dei servizi Wi-Fi, Ethernet e Bluetooth Low Energy del dispositivo in modo da consentire la compatibilità di un'applicazione con più tipi di connessione.

Trasferimento di oggetti di grandi dimensioni

Il servizio Large Object Transfer invia e riceve dati da un client. Altri servizi, come il provisioning Wi-Fi e l'astrazione della rete, utilizzano il servizio Large Object Transfer per inviare e ricevere dati. Puoi anche utilizzare l'API Large Object Transfer per interagire direttamente con il servizio.

MQTT over BLE

MQTT over BLE contiene il profilo GATT per la creazione di un servizio proxy MQTT su BLE. Il servizio proxy MQTT consente a un client MQTT di comunicare con il broker AWS MQTT tramite un dispositivo gateway. Ad esempio, puoi utilizzare il servizio proxy per connettere un dispositivo che esegue FreerTOS a MQTT tramite un' AWS app per smartphone. Il dispositivo BLE è il server GATT ed espone i servizi e le caratteristiche del dispositivo gateway. Il server GATT utilizza questi servizi e caratteristiche esposti per eseguire operazioni MQTT con il cloud per quel dispositivo. Per ulteriori informazioni, consulta Appendice A: MQTT su profilo BLE GATT .

Middleware

Il middleware FreerTOS Bluetooth Low Energy è un'astrazione dalle API di livello inferiore. Le API del middleware costituiscono un'interfaccia più intuitiva allo stack Bluetooth Low Energy.

Utilizzando le API del middleware, puoi registrare diversi callback, su più livelli, in un singolo evento. L'inizializzazione del middleware Bluetooth Low Energy comporta l'inizializzazione dei servizi e l'avvio della pubblicità.

Sottoscrizione ai callback flessibile

Supponiamo che l'hardware Bluetooth Low Energy si disconnetta e che il servizio MQTT su Bluetooth Low Energy debba rilevare la disconnessione. Anche un'applicazione scritta dall'utente potrebbe dover rilevare lo stesso evento di disconnessione. Il middleware Bluetooth Low Energy è in grado di instradare l'evento a diverse parti del codice in cui hai registrato i callback, senza che i livelli più elevati competano tra loro per risorse di basso livello.

Wrapper di basso livello

I wrapper FreerTOS Bluetooth Low Energy di basso livello sono un'astrazione dello stack Bluetooth Low Energy del produttore. I wrapper di basso livello offrono un set comune di API per il controllo diretto dell'hardware. Le API di basso livello ottimizzano l'uso della RAM, ma presentano limiti di funzionalità.

Utilizza le API del servizio Bluetooth Low Energy per interagire con i servizi Bluetooth Low Energy. Le API del servizio richiedono un maggior numero di risorse rispetto alle API di basso livello.

Dipendenze e requisiti

La libreria Bluetooth Low Energy è caratterizzata dalle seguenti dipendenze dirette:

• libreria Linear Containers

• Una piattaforma che si interfaccia con il sistema operativo per la gestione dei thread, i timer, le funzioni di clock e l'accesso di rete.

Solo il servizio Wi-Fi Provisioning ha dipendenze dalla libreria FreerTOS:

Servizio GATT	Dipendenza
Provisioning Wi-Fi	Libreria Wi-Fi

Per comunicare con il broker AWS IoT MQTT, è necessario disporre di un AWS account e registrare i dispositivi come oggetti. AWS IoT Per ulteriori informazioni sulla configurazione, consulta la Guida per gli sviluppatori di AWS IoT.

FreerTOS Bluetooth Low Energy utilizza Amazon Cognito per l'autenticazione degli utenti sul tuo dispositivo mobile. Per utilizzare i servizi proxy MQTT, devi creare un'identità e pool di utenti Amazon Cognito. A ogni Amazon Cognito Identity deve essere associata la policy appropriata. Per ulteriori informazioni, consulta la Guida per sviluppatori di Amazon Cognito .

File di configurazione della libreria

Le applicazioni che utilizzano il servizio FreerTOS MQTT over Bluetooth Low Energy devono fornire iot_ble_config.h un file di intestazione, in cui sono definiti i parametri di configurazione. I parametri di configurazione non definiti assumono i valori predefiniti specificati in iot_ble_config_defaults.h.

Alcune parametri di configurazione importanti includono:

IOT_BLE_ADD_CUSTOM_SERVICES

Consente agli utenti di creare i propri servizi.

IOT_BLE_SET_CUSTOM_ADVERTISEMENT_MSG

Consente agli utenti di personalizzare le pubblicità e analizzare i messaggi di risposta.

Per ulteriori informazioni, consulta la Documentazione di riferimento sull'API Bluetooth Low Energy.

Ottimizzazione

Durante l'ottimizzazione delle prestazioni della scheda, considera quanto segue:

• Le API di basso livello utilizzano meno RAM, ma offrono funzionalità limitate.

• Puoi impostare il parametro bleconfigMAX_NETWORK nel file di intestazione iot_ble_config.h su un valore più basso per ridurre la quantità di stack utilizzata.

• Puoi incrementare le dimensioni MTU fino al valore massimo per limitare il buffering dei messaggi e consentire un'esecuzione del codice più veloce e meno consumo di RAM.

Limitazioni d'uso

Per impostazione predefinita, la libreria FreerTOS Bluetooth Low Energy imposta eBTpropertySecureConnectionOnly la proprietà su TRUE, che colloca il dispositivo in modalità Solo connessioni sicure. Come specificato dal Bluetooth Core Specification v5.0, Vol 3, Part C, 10.2.4, quando un dispositivo è in modalità Secure Connections Only (Solo connessioni sicure), è richiesto il livello di modalità di sicurezza 1 LE massimo, livello 4, per accedere a qualsiasi attributo che dispone di autorizzazioni superiori a quelle del livello modalità di sicurezza 1 LE minimo, livello 1. Al livello 4 della modalità di sicurezza 1 LE, un dispositivo deve disporre di funzionalità di input e output per confronti numerici.

Di seguito sono riportate le modalità supportate e le relative proprietà associate:

Modalità 1, livello 1 (nessuna sicurezza)

/* Disable numeric comparison */
#define IOT_BLE_ENABLE_NUMERIC_COMPARISON        ( 0 )
#define IOT_BLE_ENABLE_SECURE_CONNECTION         ( 0 )
#define IOT_BLE_INPUT_OUTPUT                     ( eBTIONone )
#define IOT_BLE_ENCRYPTION_REQUIRED               ( 0 )

Modalità 1, livello 2 (associazione non autenticata con crittografia)

#define IOT_BLE_ENABLE_NUMERIC_COMPARISON        ( 0 )
#define IOT_BLE_ENABLE_SECURE_CONNECTION         ( 0 )
#define IOT_BLE_INPUT_OUTPUT                     ( eBTIONone )

Modalità 1, livello 3 (associazione autenticata con crittografia)

Questa modalità non è supportata.

Modalità 1, livello 4 (associazione autenticata delle connessioni sicure LE con crittografia)

Questa modalità è supportata per impostazione predefinita.

Per informazioni sulle modalità di sicurezza LE, consulta il documento Bluetooth Core Specification v5.0, Vol 3, Part C, 10.2.1.

Inizializzazione

Se l'applicazione interagisce con lo stack Bluetooth Low Energy tramite middleware, occorre solo inizializzare il middleware. Il middleware si occupa dell'inizializzazione dei livelli inferiori dello stack.

Middleware

Per inizializzare il middleware

1. Prima di eseguire una chiamata all'API del middleware Bluetooth Low Energy, occorre inizializzare qualsiasi driver dell'hardware Bluetooth Low Energy.

2. Abilitare Bluetooth Low Energy.

3. Inizializzare il middleware mediante IotBLE_Init().

   Nota

   Questo passaggio di inizializzazione non è necessario se si eseguono le demo. AWS L'inizializzazione delle demo viene gestita dal network manager, disponibile in freertos/demos/network_manager.

API di basso livello

Se non desideri utilizzare i servizi FreerTOS Bluetooth Low Energy GATT, puoi bypassare il middleware e interagire direttamente con le API di basso livello per risparmiare risorse.

Per inizializzare le API di basso livello

1. È necessario inizializzare qualsiasi driver hardware Bluetooth Low Energy prima di chiamare le API. L'inizializzazione del driver non fa parte delle API Bluetooth Low Energy di basso livello.

2. L'API Bluetooth Low Energy di basso livello fornisce una chiamata di abilitazione/disabilitazione allo stack Bluetooth Low Energy per l'ottimizzazione di alimentazione e risorse. Prima di chiamare le API, è necessario abilitare Bluetooth Low Energy.

   const BTInterface_t * pxIface = BTGetBluetoothInterface();
   xStatus = pxIface->pxEnable( 0 );

3. Il manager Bluetooth contiene le API comuni a Bluetooth Low Energy e Bluetooth classico. I callback per il responsabile comune devono essere inizializzati per secondi.

   xStatus = xBTInterface.pxBTInterface->pxBtManagerInit( &xBTManagerCb );

4. L'adattatore Bluetooth Low Energy si inserisce sopra l'API comune. È necessario inizializzare i relativi callback come è stata inizializzata l'API comune.

   xBTInterface.pxBTLeAdapterInterface = ( BTBleAdapter_t * ) xBTInterface.pxBTInterface->pxGetLeAdapter();
   xStatus = xBTInterface.pxBTLeAdapterInterface->pxBleAdapterInit( &xBTBleAdapterCb );

5. Registrare la nuova applicazione utente.

   xBTInterface.pxBTLeAdapterInterface->pxRegisterBleApp( pxAppUuid );

6. Inizializzare i callback ai server GATT.

   xBTInterface.pxGattServerInterface = ( BTGattServerInterface_t * ) xBTInterface.pxBTLeAdapterInterface->ppvGetGattServerInterface();
   xBTInterface.pxGattServerInterface->pxGattServerInit( &xBTGattServerCb );

   Dopo aver inizializzato l'adattatore Bluetooth Low Energy, è possibile aggiungere un server GATT. Puoi registrare un solo server GATT per volta.

   xStatus = xBTInterface.pxGattServerInterface->pxRegisterServer( pxAppUuid );

7. Impostare le proprietà dell'applicazione come Secure Connection Only (Solo connessione sicura) e dimensioni MTU.

   xStatus = xBTInterface.pxBTInterface->pxSetDeviceProperty( &pxProperty[ usIndex ] );

Riferimento API

Per informazioni di riferimento complete sull'API, consulta la Documentazione di riferimento sull'API Bluetooth Low Energy.

Esempio di utilizzo

Gli esempi riportati di seguito illustrano come utilizzare la libreria Bluetooth Low Energy per la pubblicità e la creazione di nuovi servizi. Per le applicazioni demo complete di FreerTOS Bluetooth Low Energy, vedi Applicazioni demo Bluetooth Low Energy.

Pubblicità

1. Nell'applicazione impostare l'UUID della pubblicità:

   static const BTUuid_t _advUUID =
   {
       .uu.uu128 = IOT_BLE_ADVERTISING_UUID,
       .ucType   = eBTuuidType128
   };

2. Definire la funzione di callback IotBle_SetCustomAdvCb:

   void IotBle_SetCustomAdvCb( IotBleAdvertisementParams_t * pAdvParams,  IotBleAdvertisementParams_t * pScanParams)
   {
       memset(pAdvParams, 0, sizeof(IotBleAdvertisementParams_t));
       memset(pScanParams, 0, sizeof(IotBleAdvertisementParams_t));
   
       /* Set advertisement message */
       pAdvParams->pUUID1 = &_advUUID;
       pAdvParams->nameType = BTGattAdvNameNone;
   
       /* This is the scan response, set it back to true. */
       pScanParams->setScanRsp = true;
       pScanParams->nameType = BTGattAdvNameComplete;
   }

   La funzione di callback invia l'UUID nel messaggio pubblicitario e il nome completo nella risposta di analisi (scan response).

3. Aprire vendors/vendor/boards/board/aws_demos/config_files/iot_ble_config.h e impostare IOT_BLE_SET_CUSTOM_ADVERTISEMENT_MSG su 1. In questo modo viene attivata la funzione di callback IotBle_SetCustomAdvCb.

Aggiunta di un nuovo servizio

Per esempi di servizi completi, consulta freertos/.../ble/services.

1. Creare gli UUID per le caratteristiche e i descrittori del servizio:

   #define xServiceUUID_TYPE \
   {\
       .uu.uu128 = gattDemoSVC_UUID, \
       .ucType   = eBTuuidType128 \
   }
   #define xCharCounterUUID_TYPE \
   {\
       .uu.uu128 = gattDemoCHAR_COUNTER_UUID,\
       .ucType   = eBTuuidType128\
   }
   #define xCharControlUUID_TYPE \
   {\
       .uu.uu128 = gattDemoCHAR_CONTROL_UUID,\
       .ucType   = eBTuuidType128\
   }
   #define xClientCharCfgUUID_TYPE \
   {\
       .uu.uu16 = gattDemoCLIENT_CHAR_CFG_UUID,\
       .ucType  = eBTuuidType16\
   }

2. Creare un buffer per registrare gli handle delle caratteristiche e dei descrittori:

   static uint16_t usHandlesBuffer[egattDemoNbAttributes];

3. Creare l'attributo tabella. Per salvare RAM, definire la tabella come const.

   Importante

   Creare sempre gli attributi nell'ordine indicato, con il servizio come primo attributo.

   static const BTAttribute_t pxAttributeTable[] = {
        {    
            .xServiceUUID =  xServiceUUID_TYPE
        },
       {
            .xAttributeType = eBTDbCharacteristic,
            .xCharacteristic = 
            {
                 .xUuid = xCharCounterUUID_TYPE,
                 .xPermissions = ( IOT_BLE_CHAR_READ_PERM ),
                 .xProperties = ( eBTPropRead | eBTPropNotify )
             }
        },
        {
            .xAttributeType = eBTDbDescriptor,
            .xCharacteristicDescr =
            {
                .xUuid = xClientCharCfgUUID_TYPE,
                .xPermissions = ( IOT_BLE_CHAR_READ_PERM | IOT_BLE_CHAR_WRITE_PERM )
             }
        },
       {
            .xAttributeType = eBTDbCharacteristic,
            .xCharacteristic = 
            {
                 .xUuid = xCharControlUUID_TYPE,
                 .xPermissions = ( IOT_BLE_CHAR_READ_PERM | IOT_BLE_CHAR_WRITE_PERM  ),
                 .xProperties = ( eBTPropRead | eBTPropWrite )
             }
        }
   };

4. Creare un array di funzioni di callback. L'array di funzioni di callback deve avere lo stesso ordine dell'array di tabelle definito in precedenza.

   Ad esempio, se la funzione vReadCounter viene attivata quando si accede alla funzione xCharCounterUUID_TYPE e la funzione vWriteCommand viene attivata quando si accede alla funzione xCharControlUUID_TYPE, definire l'array come segue:

   static const IotBleAttributeEventCallback_t pxCallBackArray[egattDemoNbAttributes] =
       {
     NULL,
     vReadCounter,
     vEnableNotification,
     vWriteCommand
   };

5. Creare il servizio.

   static const BTService_t xGattDemoService = 
   {
     .xNumberOfAttributes = egattDemoNbAttributes,
     .ucInstId = 0,
     .xType = eBTServiceTypePrimary,
     .pusHandlesBuffer = usHandlesBuffer,
     .pxBLEAttributes = (BTAttribute_t *)pxAttributeTable
   };

6. Richiamare l'API IotBle_CreateService con la struttura creata nella fase precedente. Il middleware sincronizza la creazione di tutti i servizi. Pertanto, i nuovi servizi devono già essere definiti quando viene attivata la funzione di callback IotBle_AddCustomServicesCb.

   1. Impostare IOT_BLE_ADD_CUSTOM_SERVICES su 1 in vendors/vendor/boards/board/aws_demos/config_files/iot_ble_config.h.

   2. Crea IotBle _ AddCustomServicesCb nella tua applicazione:

      void IotBle_AddCustomServicesCb(void)
      {
          BTStatus_t xStatus;
          /* Select the handle buffer. */
          xStatus = IotBle_CreateService( (BTService_t *)&xGattDemoService, (IotBleAttributeEventCallback_t *)pxCallBackArray );
      }

Portabilità

Periferica di input e output utente

Una connessione sicura richiede input e output per confronti numerici. L'evento eBLENumericComparisonCallback può essere registrato utilizzando la gestione eventi:

xEventCb.pxNumericComparisonCb = &prvNumericComparisonCb;
xStatus = BLE_RegisterEventCb( eBLENumericComparisonCallback, xEventCb );

La periferica deve visualizzare la passkey numerica e prendere il risultato del confronto come un input.

Implementazione delle API per la portabilità

Per portare FreerTOS su un nuovo target, è necessario implementare alcune API per il servizio Wi-Fi Provisioning e la funzionalità Bluetooth Low Energy.

API Bluetooth Low Energy

Per utilizzare il middleware FreerTOS Bluetooth Low Energy, devi implementare alcune API.

API comuni tra GAP per Bluetooth classico e GAP per Bluetooth Low Energy

• pxBtManagerInit

• pxEnable

• pxDisable

• pxGetDeviceProperty

• pxSetDeviceProperty (Tutte le opzioni sono obbligatorie tranne eBTpropertyRemoteRssi ed eBTpropertyRemoteVersionInfo)

• pxPair

• pxRemoveBond

• pxGetConnectionState

• pxPinReply

• pxSspReply

• pxGetTxpower

• pxGetLeAdapter

• pxDeviceStateChangedCb

• pxAdapterPropertiesCb

• pxSspRequestCb

• pxPairingStateChangedCb

• pxTxPowerCb

API specifiche di GAP per Bluetooth Low Energy

• pxRegisterBleApp

• pxUnregisterBleApp

• pxBleAdapterInit

• pxStartAdv

• pxStopAdv

• pxSetAdvData

• pxConnParameterUpdateRequest

• pxRegisterBleAdapterCb

• pxAdvStartCb

• pxSetAdvDataCb

• pxConnParameterUpdateRequestCb

• pxCongestionCb

Server GATT

• pxRegisterServer

• pxUnregisterServer

• pxGattServerInit

• pxAddService

• pxAddIncludedService

• pxAddCharacteristic

• pxSetVal

• pxAddDescriptor

• pxStartService

• pxStopService

• pxDeleteService

• pxSendIndication

• pxSendResponse

• pxMtuChangedCb

• pxCongestionCb

• pxIndicationSentCb

• pxRequestExecWriteCb

• pxRequestWriteCb

• pxRequestReadCb

• pxServiceDeletedCb

• pxServiceStoppedCb

• pxServiceStartedCb

• pxDescriptorAddedCb

• pxSetValCallbackCb

• pxCharacteristicAddedCb

• pxIncludedServiceAddedCb

• pxServiceAddedCb

• pxConnectionCb

• pxUnregisterServerCb

• pxRegisterServerCb

Per ulteriori informazioni sul porting della libreria Bluetooth Low Energy FreerTOS sulla tua piattaforma, consulta Porting the Bluetooth Low Energy Library nella FreerTOS Porting Guide.

Appendice A: MQTT su profilo BLE GATT

Dettagli del servizio GATT

MQTT over BLE utilizza un'istanza del servizio GATT di trasferimento dati per inviare messaggi MQTT Concise Binary Object Representation (CBOR) tra il dispositivo FreerTOS e il dispositivo proxy. Il servizio di trasferimento dati presenta alcune caratteristiche che aiutano a inviare e ricevere dati grezzi tramite il protocollo BLE GATT. Gestisce inoltre la frammentazione e l'assemblaggio di carichi utili superiori alla dimensione massima dell'unità di trasferimento massima (MTU) BLE.

UUID del servizio

A9D7-166A-D72E-40A9-A002-4804-4CC3-FF00

Istanze di servizio

Viene creata un'istanza del servizio GATT per ogni sessione MQTT con il broker. Ogni servizio ha un UUID univoco (due byte) che ne identifica il tipo. Ogni singola istanza è differenziata in base all'ID dell'istanza.

Ogni servizio viene istanziato come servizio primario su ogni dispositivo server BLE. È possibile creare più istanze del servizio su un determinato dispositivo. Il tipo di servizio proxy MQTT ha un UUID univoco.

Caratteristiche

Formato del contenuto caratteristico: CBOR

Dimensione massima del valore caratteristico: 512 byte

Caratteristica	Requisito	Proprietà obbligatorie	Proprietà opzionali	Autorizzazioni di sicurezza	Breve descrizione	UUID
Controllo	M	Scrittura	Nessuno	La scrittura richiede la crittografia	Utilizzato per avviare e arrestare il proxy MQTT.	A9D7-166A-D72E-40A9-A002-4804-4CC3-FF01
Messaggio TX	M	Lettura, notifica	Nessuno	Read necessita di crittografia	Utilizzato per inviare una notifica contenente un messaggio a un broker tramite un proxy.	A9D7-166A-D72E-40A9-A002-4804-4CC3-FF02
Messaggio RX	M	Leggi, scrivi senza risposta	Nessuno	La lettura e la scrittura richiedono la crittografia	Utilizzato per ricevere un messaggio da un broker tramite un proxy.	A9D7-166A-D72E-40A9-A002-4804-4CC3-FF03
TX LargeMessage	M	Leggi, notifica	Nessuno	Read necessita di crittografia	Utilizzato per inviare un messaggio di grandi dimensioni (Message > BLE MTU Size) a un broker tramite un proxy.	A9D7-166A-D72E-40A9-A002-4804-4CC3-FF04
RX LargeMessage	M	Leggi, scrivi senza risposta	Nessuno	La lettura e la scrittura richiedono la crittografia	Utilizzato per ricevere messaggi di grandi dimensioni (Message > BLE MTU Size) da un broker tramite un proxy.	A9D7-166A-D72E-40A9-A002-4804-4CC3-FF05

Requisiti della procedura GATT

Leggi i valori caratteristici	Obbligatorio
Leggi i valori caratteristici lunghi	Obbligatorio
Scrivi valori caratteristici	Obbligatorio
Scrivi valori caratteristici lunghi	Obbligatorio
Leggi i descrittori caratteristici	Obbligatorio
Scrivi descrittori caratteristici	Obbligatorio
Notifiche	Obbligatorio
Indicazioni	Obbligatorio

Tipi di messaggi

Vengono scambiati i seguenti tipi di messaggi.

Tipo di messaggio	Messaggio	Mappa con queste coppie chiave/valore
0x01	CONNECT	Chiave = «w», valore = tipo 0, numero intero, tipo di messaggio (1) Chiave = «d», valore = Tipo 3, stringa di testo, identificatore client per la sessione Chiave = «a», valore = Tipo 3, stringa di testo, endpoint del broker per la sessione Chiave = «c», valore = tipo di valore semplice Vero/Falso
0x02	CONNACK	Chiave = «w», valore = tipo 0, numero intero, tipo di messaggio (2) Chiave = «s», valore = tipo 0, numero intero, codice di stato
0x03	PUBLISH	Chiave = «w», valore = tipo 0 Intero, tipo di messaggio (3) Chiave = «u», valore = tipo 3, stringa di testo, argomento da pubblicare Chiave = «n», valore = Type 0, Integer, QoS per la pubblicazione Chiave = «i», valore = tipo 0, numero intero, identificatore del messaggio, solo per pubblicazioni QoS 1 Chiave = «k», valore = tipo 2, stringa di byte, payload per la pubblicazione
0x04	PUBBACK	Inviato solo per messaggi QoS 1. Chiave = «w», valore = tipo 0, numero intero, tipo di messaggio (4) Chiave = «i», valore = tipo 0, numero intero, identificatore del messaggio
0x08	SUBSCRIBE	Chiave = «w», valore = tipo 0, numero intero, tipo di messaggio (8) Chiave = «v», valore = Tipo 4, matrice di stringhe di testo, argomenti per l'abbonamento Chiave = «o», valore = Tipo 4, Matrice di numeri interi, QoS per abbonamento Chiave = «i», valore = tipo 0, numero intero, identificatore del messaggio
0x09	SUBBACK	Chiave = «w», valore = Tipo 0 Intero, tipo di messaggio (9) Chiave = «i», valore = tipo 0, numero intero, identificatore del messaggio Chiave = «s», valore = tipo 0, numero intero, codice di stato dell'abbonamento
0X0A	UNSUBSCRIBE	Chiave = «w», valore = tipo 0, numero intero, tipo di messaggio (10) Chiave = «v», valore = Tipo 4, matrice di stringhe di testo, argomenti per l'annullamento dell'iscrizione Chiave = «i», valore = tipo 0, numero intero, identificatore del messaggio
0x0B	ANNULLARE	Chiave = «w», valore = Tipo 0 Intero, tipo di messaggio (11) Chiave = «i», valore = tipo 0, numero intero, identificatore del messaggio Chiave = «s», valore = tipo 0, numero intero, codice di stato per UnSubscription
0X0C	PING REQ	Chiave = «w», valore = Tipo 0 Intero, tipo di messaggio (12)
0x0D	PING RESP	Chiave = «w», valore = Tipo 0 Intero, tipo di messaggio (13)
0x0E	DISCONNETTERE	Chiave = «w», valore = tipo 0, numero intero, tipo di messaggio (14)

Caratteristiche di trasferimento di carichi utili di grandi dimensioni

TX LargeMessage

TX LargeMessage viene utilizzato dal dispositivo per inviare un payload di grandi dimensioni superiore alla dimensione MTU negoziata per la connessione BLE.

• Il dispositivo invia i primi byte MTU del payload come notifica tramite la caratteristica.

• Il proxy invia una richiesta di lettura su questa caratteristica per i byte rimanenti.

• Il dispositivo invia fino alla dimensione MTU o ai byte rimanenti del payload, a seconda di quale sia inferiore. Ogni volta, aumenta l'offset letto in base alla dimensione del payload inviato.

• Il proxy continuerà a leggere la caratteristica fino a ottenere un payload di lunghezza zero o un payload inferiore alla dimensione MTU.

• Se il dispositivo non riceve una richiesta di lettura entro un determinato timeout, il trasferimento non riesce e il proxy e il gateway rilasciano il buffer.

• Se il proxy non riceve una risposta di lettura entro un determinato timeout, il trasferimento fallisce e il proxy rilascia il buffer.

RX LargeMessage

RX LargeMessage viene utilizzato dal dispositivo per ricevere un payload di grandi dimensioni, superiore alla dimensione MTU negoziata per la connessione BLE.

• Il proxy scrive i messaggi, fino alla dimensione MTU, uno per uno, utilizzando write with response su questa caratteristica.

• Il dispositivo memorizza il messaggio nel buffer finché non riceve una richiesta di scrittura con lunghezza zero o lunghezza inferiore alla dimensione MTU.

• Se il dispositivo non riceve una richiesta di scrittura entro un timeout specificato, il trasferimento fallisce e il dispositivo rilascia il buffer.

• Se il proxy non riceve una risposta di scrittura entro un timeout specificato, il trasferimento fallisce e il proxy rilascia il buffer.