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 Amazon-FreeRTOS repositório que está obsoleto. 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 agora Amazon-FreeRTOS obsoleto, consulte o. [Amazon-FreeRTOS Guia de migração do repositório Github](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 os SDKs móveis de dispositivos Bluetooth do FreeRTOS, grave aplicações móveis nativas que se comunicam com as aplicações incorporadas no seu microcontrolador por BLE. Para obter mais informações sobre os SDKs móveis, consulte [SDKs móveis para dispositivos Bluetooth do FreeRTOS](freertos-ble-mobile.md). A biblioteca FreeRTOS BLE inclui serviços para Wi-Fi configuração de redes, transferência de grandes quantidades de dados e fornecimento de abstrações de rede via BLE. A biblioteca BLE do FreeRTOS também inclui middleware e APIs de nível inferior para controle mais direto sobre a pilha BLE. ## Arquitetura Três camadas compõem a biblioteca BLE do FreeRTOS serviços, middleware e wrappers de nível inferior. ![Camadas de arquitetura de nuvem: aplicativo de usuário, serviços, middleware, Low-level wrappers, fabricante BLE Stack.](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 recursos genéricos (GATT) que utilizam as APIs de middleware: + Informações do dispositivo + Wi-Fi provisionamento + 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). #### Wi-Fi provisionamento O serviço de Wi-Fi provisionamento permite que microcontroladores com Wi-Fi recursos 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 de baixo consumo de energia do seu dispositivo Wi-Fi, Ethernet e Bluetooth, permitindo que um aplicativo 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 Wi-Fi provisionamento e abstração de rede, usam o serviço Large Object Transfer 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 da biblioteca Bluetooth Low Energy do FreeRTOS é uma abstração de APIs de nível inferior. As APIs de middleware compõem uma interface mais amigável para a pilha Bluetooth Low Energy. Usando APIs de middleware, você pode registrar vários retornos de chamada, em várias camadas, para 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. ### Low-level invólucros Os invólucros FreeRTOS Bluetooth Low Energy de baixo nível são uma abstração da pilha Bluetooth Low Energy do fabricante. Low-level os wrappers oferecem um conjunto comum de APIs para controle direto sobre o hardware. As APIs de baixo nível otimizam o uso de RAM, mas são limitadas em funcionalidade. Use as APIs de serviço da Bluetooth Low Energy para interagir com os serviços da Bluetooth Low Energy. As APIs de serviço exigem mais recursos do que as APIs de baixo nível. ## 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 List/Queue, Rede e Relógio, com setas direcionais indicando interações.](http://docs.aws.amazon.com/pt_br/freertos/latest/userguide/images/ble-dependencies.png) Somente o serviço de Wi-Fi Provisionamento tem dependências da biblioteca FreeRTOS: **** | Serviço de GATT | Dependência | | --- | --- | | Wi-Fi Provisionamento | [Wi-Fi biblioteca](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: + Low-level As APIs usam menos RAM, mas oferecem 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`. ### Low-level APIs Se não quiser usar os serviços de GATT Bluetooth Low Energy do FreeRTOS, é possível ignorar o middleware e interagir diretamente com as APIs de baixo nível para economizar recursos. **Para inicializar as APIs de baixo nível** 1. **** Inicialize qualquer driver de hardware Bluetooth Low Energy antes de chamar as APIs. A inicialização de driver não faz parte das APIs de baixo nível da 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 chamar as APIs, habilite Bluetooth Low Energy. ``` const BTInterface_t * pxIface = BTGetBluetoothInterface(); xStatus = pxIface->pxEnable( 0 ); ``` 1. **** O gerenciador de Bluetooth contém APIs que são comuns à Bluetooth Low Energy e ao Bluetooth clássico. 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 a característica do serviço e descritores: ``` #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 \_ 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 algumas APIs para o serviço de provisionamento e Wi-Fi a funcionalidade Bluetooth Low Energy. #### APIs de Bluetooth Low Energy Para usar o middleware Bluetooth Low Energy do FreeRTOS, é necessário implementar algumas APIs. ##### APIs comuns 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íficas 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 ** **TXLargeMessage ** TXLargeMessage é usado 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. **RXLargeMessage ** RXLargeMessage é usado 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.