As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá. # Biblioteca de Bluetooth Low Energy **Importante** Essa biblioteca está hospedada no repositório Amazon-FreeRTOS, que está preterido. Recomendamos [começar aqui](freertos-getting-started-modular.md) ao criar um novo projeto. Se você já tem um projeto FreeRTOS existente baseado no repositório Amazon-FreeRTOS que está preterido, consulte o [Guia de migração do repositório Github do Amazon FreeRTOS](github-repo-migration.md). ## Visão geral do O FreeRTOS é compatível com a publicação e inscrição em tópicos do Message Queuing Telemetry Transport (MQTT) por Bluetooth Low Energy por meio de um dispositivo de proxy, como um celular. Com a biblioteca [FreeRTOS Bluetooth Low](https://docs.aws.amazon.com/freertos/latest/lib-ref/html2/ble/index.html) Energy (BLE), seu microcontrolador pode se comunicar com segurança com o broker MQTT. AWS IoT ![\[Dispositivos BLE conectados AWS IoT Core MQTT/HTTP/Websocket via AWS Cognito.\]](http://docs.aws.amazon.com/pt_br/freertos/latest/userguide/images/blediagram.jpg) Usando o Mobile SDKs for FreeRTOS Bluetooth, você pode escrever aplicativos móveis nativos que se comunicam com os aplicativos incorporados em seu microcontrolador via BLE. Para obter mais informações sobre o celular SDKs, consulte[Celular SDKs para dispositivos Bluetooth FreeRTOS](freertos-ble-mobile.md). A biblioteca BLE do FreeRTOS inclui serviços para configurar redes Wi-Fi, transferir grandes quantidades de dados e fornecer abstrações de rede pela BLE. A biblioteca FreeRTOS BLE também inclui middleware e de APIs nível inferior para um controle mais direto sobre sua pilha BLE. ## Arquitetura Três camadas compõem a biblioteca BLE do FreeRTOS serviços, middleware e wrappers de nível inferior. ![\[Camadas da arquitetura em nuvem: aplicativo do usuário, serviços, middleware, wrappers de baixo nível, pilha BLE do fabricante.\]](http://docs.aws.amazon.com/pt_br/freertos/latest/userguide/images/ble-architecture.png) ### Services A camada de serviços BLE do FreeRTOS consiste em quatro serviços de atributos genéricos (GATT) que utilizam o middleware: APIs + Informações do dispositivo + Provisionamento de Wi-Fi + Abstração de rede + Transferência de objetos grandes #### Informações do dispositivo O serviço de informações do dispositivo reúne informações sobre o microcontrolador, incluindo: + A versão do FreeRTOS que seu dispositivo está usando. + O AWS IoT endpoint da conta na qual o dispositivo está registrado. + Unidade de transmissão máxima de Bluetooth Low Energy (MTU). #### Provisionamento de Wi-Fi O serviço de provisionamento de Wi-Fi permite que os microcontroladores com recursos de Wi-Fi façam o seguinte: + Listar redes no intervalo. + Salvar redes e credenciais de rede na memória flash. + Definir a prioridade da rede. + Excluir redes e credenciais de rede da memória flash. #### Abstração de rede O serviço de abstração de rede abstrai o tipo de conexão de rede para aplicações. Uma API comum interage com a pilha de hardware Wi-Fi, Ethernet e Bluetooth Low Energy do seu dispositivo, permitindo que uma aplicação seja compatível com vários tipos de conexão. #### Transferência de objetos grandes O serviço de transferência de objetos grandes envia para e recebe dados de um cliente. Outros serviços, como provisionamento de Wi-Fi e abstração de rede, usam o serviço de transferência de objetos grandes para enviar e receber dados. Você também pode usar a API de transferência de objetos grandes para interagir com o serviço diretamente. #### MQTT por BLE MQTT por BLE contém o perfil GATT para criar um serviço proxy MQTT por BLE. O serviço proxy MQTT permite que um cliente MQTT se comunique com o agente AWS MQTT por meio de um dispositivo de gateway. Por exemplo, você pode usar o serviço de proxy para conectar um dispositivo executando FreeRTOS ao MQTT por meio de um AWS aplicativo de smartphone. O dispositivo BLE é o servidor GATT e expõe serviços e características do dispositivo gateway. O servidor GATT usa esses serviços e características expostos para realizar operações MQTT com a nuvem desse dispositivo. Para obter mais detalhes, consulte [Apêndice A: perfil MQTT por GATT BLE](#freertos-ble-gatt-profile). ### Middleware O middleware FreeRTOS Bluetooth Low Energy é uma abstração do nível inferior. APIs O middleware APIs compõe uma interface mais amigável para a pilha Bluetooth Low Energy. Usando o middleware APIs, você pode registrar vários retornos de chamada, em várias camadas, em um único evento. Iniciar o middleware da biblioteca Bluetooth Low Energy também inicializa serviços e começa a publicidade. #### Assinatura de retorno de chamada flexível Suponha que o hardware Bluetooth Low Energy se desconecta, e o serviço MQTT por Bluetooth Low Energy precisa detectar a desconexão. Uma aplicação gravada também poderá ter que detectar o mesmo evento de desconexão. O middleware Bluetooth Low Energy pode rotear o evento para diferentes partes do código onde os retornos de chamada foram registrados, sem fazer com que as camadas mais altas compitam por recursos de nível inferior. ### Wrappers de baixo nível Os wrappers de nível baixo da Bluetooth Low Energy do FreeRTOS são uma abstração da pilha do fabricante Bluetooth Low Energy. Os invólucros de baixo nível oferecem um conjunto comum APIs de controle direto sobre o hardware. Os de baixo nível APIs otimizam o uso da RAM, mas têm funcionalidade limitada. Use o serviço Bluetooth Low Energy APIs para interagir com os serviços Bluetooth Low Energy. O serviço APIs exige mais recursos do que o de baixo nível APIs. ## Dependências e requisitos A biblioteca Bluetooth Low Energy tem as seguintes dependências diretas: + Biblioteca [Linear Containers](https://docs.aws.amazon.com/freertos/latest/lib-ref/c-sdk/linear_containers/index.html) + Uma camada de plataforma que faz interface com o sistema operacional para o gerenciamento de threads, temporizadores, funções de relógio e acesso à rede. ![\[Diagrama de arquitetura mostrando os componentes: BLE, lista/fila, rede e relógio, com setas direcionais indicando as interações.\]](http://docs.aws.amazon.com/pt_br/freertos/latest/userguide/images/ble-dependencies.png) Somente o serviço de provisionamento de Wi-Fi tem dependências de biblioteca do FreeRTOS: **** | Serviço de GATT | Dependência | | --- | --- | | Provisionamento de Wi-Fi | [Biblioteca de Wi-Fi](freertos-wifi.md) | Para se comunicar com o corretor AWS IoT MQTT, você deve ter uma AWS conta e registrar seus dispositivos como AWS IoT coisas. Para obter mais informações sobre a configuração, consulte o [Guia do desenvolvedor do AWS IoT](https://docs.aws.amazon.com/iot/latest/developerguide/). O Bluetooth Low Energy do FreeRTOS usa o Amazon Cognito para a autenticação do usuário em seu dispositivo móvel. Para usar os serviços de proxy MQTT, é necessário criar uma identidade do Amazon Cognito e grupos de usuários. Cada identidade do Amazon Cognito deve ter a política adequada anexada. Para obter mais informações, consulte o [Guia do desenvolvedor do Amazon Cognito](https://docs.aws.amazon.com/cognito/latest/developerguide/). ## Arquivo de configuração da biblioteca As aplicações que usam o serviço MQTT do FreeRTOS pela Bluetooth Low Energy devem fornecer um arquivo de cabeçalho `iot_ble_config.h`, no qual são definidos parâmetros de configuração. Os parâmetros de configuração não definidos assumem os valores padrão especificados em `iot_ble_config_defaults.h`. Alguns parâmetros de configuração importantes incluem: **`IOT_BLE_ADD_CUSTOM_SERVICES`** Permite que os usuários criem seus próprios serviços. **`IOT_BLE_SET_CUSTOM_ADVERTISEMENT_MSG`** Permite que os usuários personalizem o anúncio e verifiquem as mensagens de resposta. Para obter mais informações, consulte [Referência de API do Bluetooth Low Energy](https://docs.aws.amazon.com/freertos/latest/lib-ref/html2/ble/index.html). ## Otimização Ao otimizar o desempenho da placa, considere o seguinte: + O nível baixo APIs usa menos RAM, mas oferece funcionalidade limitada. + Você pode definir o parâmetro `bleconfigMAX_NETWORK` no arquivo de cabeçalho `iot_ble_config.h` como um valor menor para reduzir a quantidade consumida da pilha. + Você pode aumentar o tamanho da MTU até seu valor máximo para limitar o armazenamento em buffer de mensagens e fazer com que o código execute mais rápido e consuma menos RAM. ## Restrições de uso Por padrão, a biblioteca Bluetooth Low Energy do FreeRTOS define a propriedade `eBTpropertySecureConnectionOnly` como VERDADEIRA, que coloca o dispositivo em um modo Somente conexões seguras. Conforme especificado pela [Bluetooth Core Specification](https://www.bluetooth.com/specifications/bluetooth-core-specification) v5.0, Vol. 3, Parte C, 10.2.4, quando um dispositivo está no modo Somente conexões seguras, é necessário o nível de segurança LE mais alto do modo 1, o nível 4, para acessar qualquer atributo que tem permissões mais altas que o nível de segurança LE mais baixo do modo 1, o nível 1. No nível 4 de segurança LE do modo 1, um dispositivo deve ter recursos de entrada e saída para comparação numérica. Aqui estão os modos compatíveis e suas propriedades associadas: **Modo 1, Nível 1 (sem segurança)** ``` /* 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 ) ``` **Modo 1, Nível 2 (emparelhamento com criptografia não autenticada)** ``` #define IOT_BLE_ENABLE_NUMERIC_COMPARISON ( 0 ) #define IOT_BLE_ENABLE_SECURE_CONNECTION ( 0 ) #define IOT_BLE_INPUT_OUTPUT ( eBTIONone ) ``` **Modo 1, Nível 3 (emparelhamento com criptografia autenticada)** Esse modo não é compatível. **Modo 1, Nível 4 (emparelhamento com criptografia de conexões seguras LE autenticadas)** Esse modo é suportado por padrão. Para obter informações sobre os modos de segurança LE, consulte a [Bluetooth Core Specification](https://www.bluetooth.com/specifications/bluetooth-core-specification) v5.0, Vol. 3, Parte C, 10.2.1. ## Inicialização Se a aplicação interage com a pilha Bluetooth Low Energy por meio de middleware, só é necessário inicializar o middleware. O middleware cuida da inicialização das camadas inferiores da pilha. ### Middleware **Para inicializar o middleware** 1. Inicialize qualquer driver de hardware Bluetooth Low Energy antes de chamar a API de middleware da Bluetooth Low Energy. 1. Habilitar Bluetooth Low Energy. 1. Inicialize o middleware com `IotBLE_Init()`. **nota** Essa etapa de inicialização não é necessária se você estiver executando as AWS demonstrações. A inicialização de demonstração é processada pelo gerenciador de rede, localizado em `freertos/demos/network_manager`. ### Nível baixo APIs Se você não quiser usar os serviços FreeRTOS Bluetooth Low Energy GATT, você pode ignorar o middleware e interagir diretamente com os de baixo nível para economizar recursos. APIs **Para inicializar o nível baixo APIs** 1. **** Inicialize todos os drivers de hardware Bluetooth Low Energy antes de ligar para o. APIs A inicialização do driver não faz parte do nível baixo APIs do Bluetooth Low Energy. 1. **** A API de baixo nível Bluetooth Low Energy fornece uma enable/disable chamada para a pilha Bluetooth Low Energy para otimizar a energia e os recursos. Antes de ligar para o APIs, você deve ativar o Bluetooth Low Energy. ``` const BTInterface_t * pxIface = BTGetBluetoothInterface(); xStatus = pxIface->pxEnable( 0 ); ``` 1. **** O gerenciador de Bluetooth contém o APIs que é comum ao Bluetooth Low Energy e ao Bluetooth classic. Os retornos de chamada para o gerenciador comum devem ser inicializados depois. ``` xStatus = xBTInterface.pxBTInterface->pxBtManagerInit( &xBTManagerCb ); ``` 1. **** O adaptador Bluetooth Low Energy se encaixa em cima da API comum. É necessário inicializar os retornos de chamada da mesma forma que a API comum foi inicializada. ``` xBTInterface.pxBTLeAdapterInterface = ( BTBleAdapter_t * ) xBTInterface.pxBTInterface->pxGetLeAdapter(); xStatus = xBTInterface.pxBTLeAdapterInterface->pxBleAdapterInit( &xBTBleAdapterCb ); ``` 1. **** Registre a nova aplicação do usuário. ``` xBTInterface.pxBTLeAdapterInterface->pxRegisterBleApp( pxAppUuid ); ``` 1. **** Inicialize os retornos de chamada para os servidores GATT. ``` xBTInterface.pxGattServerInterface = ( BTGattServerInterface_t * ) xBTInterface.pxBTLeAdapterInterface->ppvGetGattServerInterface(); xBTInterface.pxGattServerInterface->pxGattServerInit( &xBTGattServerCb ); ``` Depois de inicializar o adaptador Bluetooth Low Energy, você pode adicionar um servidor GATT. Só é possível registrar um servidor GATT por vez. ``` xStatus = xBTInterface.pxGattServerInterface->pxRegisterServer( pxAppUuid ); ``` 1. **** Defina as propriedades da aplicação, como somente conexão segura e tamanho da MTU. ``` xStatus = xBTInterface.pxBTInterface->pxSetDeviceProperty( &pxProperty[ usIndex ] ); ``` ## Referência de API Para obter uma referência completa de API, consulte [Referência de API do Bluetooth Low Energy](https://docs.aws.amazon.com/freertos/latest/lib-ref/html2/ble/index.html). ## Exemplo de uso Os exemplos a seguir demonstram como usar a biblioteca Bluetooth Low Energy para publicidade e criação de novos serviços. Para obter aplicações de demonstração da Bluetooth Low Energy do FreeRTOS completos, consulte [Aplicações de demonstração de Bluetooth Low Energy](https://docs.aws.amazon.com/freertos/latest/userguide/ble-demo.html). ### Publicidade 1. Na aplicação, defina o UUID de publicidade: ``` static const BTUuid_t _advUUID = { .uu.uu128 = IOT_BLE_ADVERTISING_UUID, .ucType = eBTuuidType128 }; ``` 1. Em seguida, defina a função de retorno de chamada `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; } ``` Esse retorno de chamada envia o UUID na mensagem de anúncio e o nome completo na resposta de verificação. 1. Abra `vendors/vendor/boards/board/aws_demos/config_files/iot_ble_config.h` e defina `IOT_BLE_SET_CUSTOM_ADVERTISEMENT_MSG` como `1`. Isso dispara o retorno de chamada `IotBle_SetCustomAdvCb`. ### Adição de um novo serviço Para ver exemplos completos de serviços, consulte `freertos/.../ble/services`. 1. Crie UUIDs para as características e os descritores do serviço: ``` #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. Crie um buffer para registrar as alças da característica e dos descritores: ``` static uint16_t usHandlesBuffer[egattDemoNbAttributes]; ``` 1. Crie a tabela de atributo. Para economizar RAM, defina a tabela como `const`. **Importante** Sempre crie os atributos em ordem, com o serviço como o primeiro atributo. ``` 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. Crie uma matriz de retornos de chamada. Essa matriz de retornos de chamada deve seguir a mesma ordem que a matriz de tabela definida acima. Por exemplo, se `vReadCounter` é acionado quando `xCharCounterUUID_TYPE` é acessado, e `vWriteCommand` é acionado quando `xCharControlUUID_TYPE` é acessado, defina a matriz da seguinte forma: ``` static const IotBleAttributeEventCallback_t pxCallBackArray[egattDemoNbAttributes] = { NULL, vReadCounter, vEnableNotification, vWriteCommand }; ``` 1. Crie o serviço: ``` static const BTService_t xGattDemoService = { .xNumberOfAttributes = egattDemoNbAttributes, .ucInstId = 0, .xType = eBTServiceTypePrimary, .pusHandlesBuffer = usHandlesBuffer, .pxBLEAttributes = (BTAttribute_t *)pxAttributeTable }; ``` 1. Chame a API `IotBle_CreateService` com a estrutura que você criou na etapa anterior. O middleware sincroniza a criação de todos os serviços e, portanto, é necessário que todos os novos serviços já tenham sido definidos quando o `IotBle_AddCustomServicesCb` retorno de chamada for acionado. 1. Defina `IOT_BLE_ADD_CUSTOM_SERVICES` como `1` em `vendors/vendor/boards/board/aws_demos/config_files/iot_ble_config.h`. 1. Crie IotBle \$1 AddCustomServicesCb em seu aplicativo: ``` void IotBle_AddCustomServicesCb(void) { BTStatus_t xStatus; /* Select the handle buffer. */ xStatus = IotBle_CreateService( (BTService_t *)&xGattDemoService, (IotBleAttributeEventCallback_t *)pxCallBackArray ); } ``` ## Portabilidade ### Periférico de entrada e saída do usuário Uma conexão segura requer entrada e saída para comparação numérica. O evento `eBLENumericComparisonCallback` pode ser registrado usando o gerenciador de eventos: ``` xEventCb.pxNumericComparisonCb = &prvNumericComparisonCb; xStatus = BLE_RegisterEventCb( eBLENumericComparisonCallback, xEventCb ); ``` O periférico deve exibir a chave de acesso numérica e assumir o resultado da comparação como uma entrada. ### Transferência de implementações da API Para portar os FreeRTOS para um novo destino, você deve implementar APIs alguns para o serviço de provisionamento de Wi-Fi e a funcionalidade Bluetooth Low Energy. #### Bluetooth de baixa energia APIs Para usar o middleware FreeRTOS Bluetooth Low Energy, você deve implementar alguns. APIs ##### APIs comum entre GAP para Bluetooth Classic e GAP para Bluetooth Low Energy + `pxBtManagerInit` + `pxEnable` + `pxDisable` + `pxGetDeviceProperty` + `pxSetDeviceProperty` (Todas as opções são obrigatórias, exceto `eBTpropertyRemoteRssi` e `eBTpropertyRemoteVersionInfo`) + `pxPair` + `pxRemoveBond` + `pxGetConnectionState` + `pxPinReply` + `pxSspReply` + `pxGetTxpower` + `pxGetLeAdapter` + `pxDeviceStateChangedCb` + `pxAdapterPropertiesCb` + `pxSspRequestCb` + `pxPairingStateChangedCb` + `pxTxPowerCb` ##### APIs específico para GAP para Bluetooth Low Energy + `pxRegisterBleApp` + `pxUnregisterBleApp` + `pxBleAdapterInit` + `pxStartAdv` + `pxStopAdv` + `pxSetAdvData` + `pxConnParameterUpdateRequest` + `pxRegisterBleAdapterCb` + `pxAdvStartCb` + `pxSetAdvDataCb` + `pxConnParameterUpdateRequestCb` + `pxCongestionCb` ##### Servidor 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` Para obter mais informações sobre a portabilidade da biblioteca Bluetooth Low Energy do FreeRTOS para sua plataforma, consulte [Portabilidade da biblioteca Bluetooth Low Energy](https://docs.aws.amazon.com/freertos/latest/portingguide/afr-porting-ble.html) no Guia de portabilidade do FreeRTOS. ## Apêndice A: perfil MQTT por GATT BLE ### Detalhes do serviço GATT O MQTT por BLE usa uma instância do serviço GATT de transferência de dados para enviar mensagens de representação concisa de objetos binários (CBOR) do MQTT entre o dispositivo FreeRTOS e o dispositivo proxy. O serviço de transferência de dados expõe certas características que ajudam a enviar e receber dados brutos pelo protocolo GATT da BLE. Ele também lida com a fragmentação e montagem de cargas úteis maiores que o tamanho da unidade de transferência máxima (MTU) BLE. **UUID de serviço** `A9D7-166A-D72E-40A9-A002-4804-4CC3-FF00` **Instâncias de serviço** Uma instância do serviço GATT é criada para cada sessão do MQTT com o agente. Cada serviço tem um UUID exclusivo (dois bytes) que identifica o tipo. Cada instância individual é diferenciada pelo ID da instância. Cada serviço é instanciado como um serviço primário em cada dispositivo de servidor BLE. Você pode criar várias instâncias do serviço em um determinado dispositivo. O tipo de serviço proxy MQTT tem um UUID exclusivo. **Características** Formato característico de conteúdo: **CBOR** Tamanho máximo do valor característico: 512 bytes **** [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/freertos/latest/userguide/freertos-ble-library.html) **Requisitos de procedimento do GATT ** **** [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/freertos/latest/userguide/freertos-ble-library.html) **Tipos de mensagem ** Os tipos de mensagem a seguir são trocados. **** [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/freertos/latest/userguide/freertos-ble-library.html) **Características de transferência de carga útil grande ** **TXLargeMensagem ** TXLargeA mensagem é usada pelo dispositivo para enviar uma grande carga útil maior que o tamanho da MTU negociado para a conexão BLE. + O dispositivo envia os primeiros bytes de MTU da carga como uma notificação por meio da característica. + O proxy envia uma solicitação de leitura sobre essa característica para os bytes restantes. + O dispositivo envia até o tamanho da MTU ou os bytes restantes da carga, o que for menor. Cada vez, ele aumenta o deslocamento lido pelo tamanho da carga útil enviada. + O proxy continuará lendo a característica até obter uma carga útil de comprimento zero ou uma carga útil menor que o tamanho da MTU. + Se o dispositivo não receber uma solicitação de leitura dentro de um tempo limite especificado, a transferência falhará e o proxy e o gateway liberarão o buffer. + Se o proxy não receber uma solicitação de leitura dentro de um tempo limite especificado, a transferência falhará e o proxy liberará o buffer. **RXLargeMensagem ** RXLargeA mensagem é usada pelo dispositivo para receber uma grande carga útil maior que o tamanho da MTU negociado para a conexão BLE. + O proxy grava mensagens, até o tamanho da MTU, uma por uma, usando gravação com resposta nessa característica. + O dispositivo armazena a mensagem em buffer até receber uma solicitação de gravação com tamanho zero ou menor que o tamanho da MTU. + Se o dispositivo não receber uma solicitação de gravação dentro de um tempo limite especificado, a transferência falhará e o dispositivo liberará o buffer. + Se o proxy não receber uma solicitação de gravação dentro de um tempo limite especificado, a transferência falhará e o proxy liberará o buffer.