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](freertos-getting-started-modular.md). 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](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 Mobile SDKs for FreerTOS Bluetooth Devices, puoi scrivere applicazioni mobili native che comunicano con le applicazioni integrate sul tuo microcontrollore tramite BLE. Per ulteriori informazioni sul cellulare SDKs, consulta. [Mobile SDKs per dispositivi Bluetooth FreerTOS](freertos-ble-mobile.md) 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 middleware e di APIs 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 di basso livello, produttore BLE Stack.](http://docs.aws.amazon.com/it_it/freertos/latest/userguide/images/ble-architecture.png) ### Servizi Il livello di servizi FreerTOS BLE è costituito da quattro servizi Generic Attribute (GATT) che sfruttano il middleware: APIs + 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](#freertos-ble-gatt-profile). ### Middleware Il middleware FreerTOS Bluetooth Low Energy è un'astrazione dal livello inferiore. APIs Il middleware costituisce un'interfaccia più intuitiva APIs per lo stack Bluetooth Low Energy. Utilizzando il middleware APIs, è possibile registrare più callback, su più livelli, su 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 per il controllo diretto dell'hardware. APIs I modelli di basso livello APIs ottimizzano l'utilizzo della RAM, ma hanno funzionalità limitate. Utilizza il servizio Bluetooth Low Energy APIs per interagire con i servizi Bluetooth Low Energy. Il servizio APIs richiede più risorse rispetto a quello di basso livello APIs. ## 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 | | --- | --- | | Provisioning Wi-Fi | [Libreria Wi-Fi](freertos-wifi.md) | 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](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: + Il basso livello APIs utilizza meno RAM, ma offre 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`. ### Di basso livello APIs Se non desideri utilizzare i servizi FreerTOS Bluetooth Low Energy GATT, puoi bypassare il middleware e interagire direttamente con il livello basso per risparmiare risorse. APIs **Per inizializzare il livello basso APIs** 1. **** Inizializza tutti i driver hardware Bluetooth Low Energy prima di chiamare il. APIs L'inizializzazione del driver non fa parte del livello Bluetooth Low Energy di basso livello. APIs 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 il APIs, è necessario abilitare Bluetooth Low Energy. ``` const BTInterface_t * pxIface = BTGetBluetoothInterface(); xStatus = pxIface->pxEnable( 0 ); ``` 1. **** Il gestore Bluetooth contiene elementi comuni APIs sia a Bluetooth Low Energy che a Bluetooth classic. 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. Crea UUIDs 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 implementarne APIs alcuni per il servizio Wi-Fi Provisioning e la funzionalità Bluetooth Low Energy. #### Bluetooth Low Energy APIs Per utilizzare il middleware FreerTOS Bluetooth Low Energy, è necessario implementarne alcuni. APIs ##### APIs comune tra GAP per Bluetooth Classic 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` ##### APIs specifico per 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 ** **TXLargeMessaggio ** TXLargeIl messaggio 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. **RXLargeMessaggio ** RXLargeIl messaggio 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.