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 Amazon-FreeRTOS repository che è obsoleto. Ti consigliamo di [iniziare da qui](freertos-getting-started-modular.md) quando crei un nuovo progetto. Se hai già un progetto FreerTOS esistente basato sul repository ora obsoleto, Amazon-FreeRTOS consulta il. [Amazon-FreeRTOS Guida alla migrazione del repository Github](github-repo-migration.md) ## Panoramica di 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](https://docs.aws.amazon.com/freertos/latest/lib-ref/html2/ble/index.html) Energy (BLE), il microcontrollore può comunicare in modo sicuro con il broker MQTT. AWS IoT ![Dispositivi BLE che si connettono AWS IoT Core MQTT/HTTP/Websocket tramite AWS Cognito.](http://docs.aws.amazon.com/it_it/freertos/latest/userguide/images/blediagram.jpg) 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](freertos-ble-mobile.md). La libreria FreerTOS BLE include servizi per la Wi-Fi configurazione di reti, 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. ## Architecture Tre livelli costituiscono la libreria FreerTOS BLE: servizi, middleware e wrapper di basso livello. ![Livelli di architettura cloud: applicazione utente, servizi, middleware, wrapper, produttore BLE Stack. Low-level](http://docs.aws.amazon.com/it_it/freertos/latest/userguide/images/ble-architecture.png) ### Servizi Il livello di servizi BLE FreerTOS è costituito da quattro servizi Generic Attribute (GATT) che sfruttano le API del middleware: + Informazioni sul dispositivo + Wi-Fi approvvigionamento + 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 #### Wi-Fi approvvigionamento Il servizio di Wi-Fi provisioning consente ai microcontrollori in grado di eseguire Wi-Fi 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 del dispositivo Wi-Fi, Ethernet e Bluetooth Low Energy, consentendo a un'applicazione di essere compatibile 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 Wi-Fi provisioning 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](#freertos-ble-gatt-profile). ### 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. ### Low-level involucri I wrapper FreerTOS Bluetooth Low Energy di basso livello sono un'astrazione dello stack Bluetooth Low Energy del produttore. Low-level i wrapper 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](https://docs.aws.amazon.com/freertos/latest/lib-ref/c-sdk/linear_containers/index.html) + 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.](http://docs.aws.amazon.com/it_it/freertos/latest/userguide/images/ble-dependencies.png) Solo il servizio Wi-Fi Provisioning ha dipendenze dalla libreria FreerTOS: **** | Servizio GATT | Dipendenza | | --- | --- | | Wi-Fi Provisioning | [Wi-Fi biblioteca](freertos-wifi.md) | Per comunicare con il broker AWS IoT MQTT, è necessario disporre di un AWS account e registrare i AWS IoT dispositivi. Per ulteriori informazioni sulla configurazione, consulta la [Guida per gli sviluppatori di AWS IoT](https://docs.aws.amazon.com/iot/latest/developerguide/). 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](https://docs.aws.amazon.com/cognito/latest/developerguide/) . ## 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](https://docs.aws.amazon.com/freertos/latest/lib-ref/html2/ble/index.html). ## Ottimizzazione Durante l'ottimizzazione delle prestazioni della scheda, considera quanto segue: + Low-level Le API 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](https://www.bluetooth.com/specifications/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](https://www.bluetooth.com/specifications/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. 1. Abilitare Bluetooth Low Energy. 1. 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`. ### Low-level API 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. 1. **** L'API di basso livello Bluetooth Low Energy fornisce una enable/disable chiamata allo stack Bluetooth Low Energy per ottimizzare alimentazione e risorse. Prima di chiamare le API, è necessario abilitare Bluetooth Low Energy. ``` const BTInterface_t * pxIface = BTGetBluetoothInterface(); xStatus = pxIface->pxEnable( 0 ); ``` 1. **** 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 ); ``` 1. **** 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 ); ``` 1. **** Registrare la nuova applicazione utente. ``` xBTInterface.pxBTLeAdapterInterface->pxRegisterBleApp( pxAppUuid ); ``` 1. **** 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 ); ``` 1. **** Impostare le proprietà dell'applicazione come Secure Connection Only (Solo connessione sicura) e dimensioni MTU. ``` xStatus = xBTInterface.pxBTInterface->pxSetDeviceProperty( &pxProperty[ usIndex ] ); ``` ## Guida di riferimento alle API Per informazioni di riferimento complete sull'API, consulta la [Documentazione di riferimento sull'API Bluetooth Low Energy](https://docs.aws.amazon.com/freertos/latest/lib-ref/html2/ble/index.html). ## 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](https://docs.aws.amazon.com/freertos/latest/userguide/ble-demo.html) Energy. ### Pubblicità 1. Nell'applicazione impostare l'UUID della pubblicità: ``` static const BTUuid_t _advUUID = { .uu.uu128 = IOT_BLE_ADVERTISING_UUID, .ucType = eBTuuidType128 }; ``` 1. 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). 1. 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\ } ``` 1. Creare un buffer per registrare gli handle delle caratteristiche e dei descrittori: ``` static uint16_t usHandlesBuffer[egattDemoNbAttributes]; ``` 1. 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 ) } } }; ``` 1. 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 }; ``` 1. Creare il servizio. ``` static const BTService_t xGattDemoService = { .xNumberOfAttributes = egattDemoNbAttributes, .ucInstId = 0, .xType = eBTServiceTypePrimary, .pusHandlesBuffer = usHandlesBuffer, .pxBLEAttributes = (BTAttribute_t *)pxAttributeTable }; ``` 1. 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`. 1. 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 Provisioning e Wi-Fi 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](https://docs.aws.amazon.com/freertos/latest/portingguide/afr-porting-ble.html). ## 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 **** [See the AWS documentation website for more details](http://docs.aws.amazon.com/it_it/freertos/latest/userguide/freertos-ble-library.html) **Requisiti della procedura GATT ** **** [See the AWS documentation website for more details](http://docs.aws.amazon.com/it_it/freertos/latest/userguide/freertos-ble-library.html) **Tipi di messaggi ** Vengono scambiati i seguenti tipi di messaggi. **** [See the AWS documentation website for more details](http://docs.aws.amazon.com/it_it/freertos/latest/userguide/freertos-ble-library.html) **Caratteristiche di trasferimento di carichi utili di grandi dimensioni ** **TXLargeMessage ** TXLargeMessage 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. **RXLargeMessage ** RXLargeMessage 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.