Libreria Bluetooth Low Energy - Gratuito RTOS
PanoramicaArchitetturaDipendenze e requisitiFile di configurazione della libreriaOttimizzazioneLimitazioni d'usoInizializzazioneRiferimento APIEsempio di utilizzoPortabilitàAppendice A: MQTT su profilo BLE GATT

Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.

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 RTOS repository Github gratuito da Amazon

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

Dispositivi BLE che si connettono AWS IoT Core tramite MQTT/HTTP/WebSocket tramite Cognito. AWS

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.

Livelli di architettura cloud: applicazione utente, servizi, middleware, wrapper di basso livello, produttore BLE Stack.

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.

Diagramma di architettura che mostra i componenti: BLE, List/Queue, Network e Clock, con frecce direzionali che indicano le interazioni.

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.