Visão geral Arquitetura Dependências e requisitos Arquivo de configuração da biblioteca Otimização Restrições de uso Inicialização Referência de API Exemplo de uso Portabilidade Apêndice A: perfil MQTT por GATT BLE

Biblioteca de Bluetooth Low Energy

Importante

Essa biblioteca está hospedada no repositório Amazon-FreeRTOS, que está preterido. Recomendamos começar aqui 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.

Visão geral

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 Energy (BLE), seu microcontrolador pode se comunicar com segurança com o broker MQTT. AWS IoT

Dispositivos BLE conectados AWS IoT Core via MQTT/HTTP/WebSocket por meio do Cognito. AWS

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.

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 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.

Serviços

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
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 .

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.

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 wrappers de baixo nível 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
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 interações.

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

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.

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.

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.

Otimização

Ao otimizar o desempenho da placa, considere o seguinte:

APIs de baixo nível usam menos RAM, mas oferecem funcionalidade ilimitada.
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 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 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

Inicialize qualquer driver de hardware Bluetooth Low Energy antes de chamar a API de middleware da Bluetooth Low Energy.
Habilitar Bluetooth Low Energy.
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.

APIs de baixo nível

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

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.
A API de baixo nível da Bluetooth Low Energy fornece uma chamada de habilitação/desabilitação para a pilha Bluetooth Low Energy a fim de otimizar a potência e os recursos. Antes de chamar as APIs, habilite Bluetooth Low Energy.
```
const BTInterface_t * pxIface = BTGetBluetoothInterface();
xStatus = pxIface->pxEnable( 0 );
```
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 );
```

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 );

Registre a nova aplicação do usuário.


xBTInterface.pxBTLeAdapterInterface->pxRegisterBleApp( pxAppUuid );

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 );

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.

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.


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.

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.

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\
}

Crie um buffer para registrar as alças da característica e dos descritores:
```
static uint16_t usHandlesBuffer[egattDemoNbAttributes];
```

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 )
          }
     }
};

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
};
```

Crie o serviço:


static const BTService_t xGattDemoService = 
{
  .xNumberOfAttributes = egattDemoNbAttributes,
  .ucInstId = 0,
  .xType = eBTServiceTypePrimary,
  .pusHandlesBuffer = usHandlesBuffer,
  .pxBLEAttributes = (BTAttribute_t *)pxAttributeTable
};

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.
2. 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 fazer a portabilidade do FreeRTOS para um novo destino, é necessário implementar algumas APIs para o serviço de Provisionamento de Wi-Fi e funcionalidade de 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 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

Característica	Requisito	Propriedades obrigatórias	Propriedades opcionais	Permissões de segurança	Breve descrição	UUID
Controle	M	Escrever	Nenhum	Gravação precisa de criptografia	Usado para iniciar e interromper o proxy MQTT.	`A9D7-166A-D72E-40A9-A002-4804-4CC3-FF01`
TXMessage	M	Leitura, notificação	Nenhum	Leitura precisa de criptografia	Usado para enviar uma notificação contendo uma mensagem para um agente por meio de um proxy.	`A9D7-166A-D72E-40A9-A002-4804-4CC3-FF02`
RXMessage	M	Leitura, gravação sem resposta	Nenhum	Leitura, gravação precisa de criptografia	Usado para receber uma mensagem de um corretor por meio de um proxy.	`A9D7-166A-D72E-40A9-A002-4804-4CC3-FF03`
TX LargeMessage	M	Leitura, notificação	Nenhum	Leitura precisa de criptografia	Usado para enviar uma grande mensagem (Mensagem > Tamanho do MTU da BLE) para um agente por meio de um proxy.	`A9D7-166A-D72E-40A9-A002-4804-4CC3-FF04`
RX LargeMessage	M	Leitura, gravação sem resposta	Nenhum	Leitura, gravação precisa de criptografia	Usado para receber uma grande mensagem (Mensagem > Tamanho do MTU da BLE) de um agente por meio de um proxy.	`A9D7-166A-D72E-40A9-A002-4804-4CC3-FF05`

Requisitos de procedimento do GATT

Valores característicos de leitura	Obrigatório
Valores característicos longos de leitura	Obrigatório
Valores característicos de gravação	Obrigatório
Valores característicos longos de gravação	Obrigatório
Descritores característicos de leitura	Obrigatório
Descritores característicos de gravação	Obrigatório
Notificações	Obrigatório
Indicações	Obrigatório

Tipos de mensagem

Os tipos de mensagem a seguir são trocados.

Tipo de mensagem	Message	Mapa com esses pares de chave/valor
0x01	CONECTAR	Chave = "w", valor = tipo 0 inteiro, tipo de mensagem (1) Chave = "d", valor = tipo 3, string de texto, identificador do cliente para a sessão Chave = "a", valor = tipo 3, string de texto, endpoint do agente para a sessão Chave = "c", valor = tipo de valor simples verdadeiro/falso
0x02	CONNACK	Chave = "w", valor = tipo 0 inteiro, tipo de mensagem (2) Chave = "s", valor = tipo 0 inteiro, código de status
0x03	PUBLISH	Chave = "w", valor = tipo 0 inteiro, tipo de mensagem (3) Chave = "u", valor = tipo 3, string de texto, tópico para publicação Chave = "n", valor = tipo 0, inteiro, QoS para publicação Chave = "i", valor = tipo 0, número inteiro, identificador de mensagem, somente para publicações de QoS 1 Chave = "k", valor = tipo 2, string de bytes, carga útil para publicação
0x04	PUBACK	Enviado somente para mensagens de QoS 1. Chave = "w", valor = tipo 0 inteiro, tipo de mensagem (4) Chave = "i", valor = tipo 0, inteiro, identificador de mensagem
0x08	SUBSCRIBE	Chave = "w", valor = tipo 0 inteiro, tipo de mensagem (8) Chave = "v", valor = tipo 4, matriz de strings de texto, tópicos para assinatura Chave = "o", valor = tipo 4, matriz de números inteiros, QoS para assinatura Chave = "i", valor = tipo 0, inteiro, identificador de mensagem
0x09	SUBACK	Chave = "w", valor = tipo 0 inteiro, tipo de mensagem (9) Chave = "i", valor = tipo 0, inteiro, identificador de mensagem Chave = "s", valor = tipo 0 inteiro, código de status para assinatura
0X0A	CANCELAR INSCRIÇÃO	Chave = "w", valor = tipo 0 inteiro, tipo de mensagem (10) Chave = "v", valor = tipo 4, matriz de strings de texto, tópicos para cancelamento de assinatura Chave = "i", valor = tipo 0, inteiro, identificador de mensagem
0x0B	UNSUBACK	Chave = "w", valor = tipo 0 inteiro, tipo de mensagem (11) Chave = "i", valor = tipo 0, inteiro, identificador de mensagem Chave = “s”, valor = Tipo 0, número inteiro, código de status para UnSubscription
0X0C	PINGREQ	Chave = "w", valor = tipo 0 inteiro, tipo de mensagem (12)
0x0D	PINGRESP	Chave = "w", valor = tipo 0 inteiro, tipo de mensagem (13)
0x0E	DISCONNNECT	Chave = "w", valor = tipo 0 inteiro, tipo de mensagem (14)

Características de transferência de carga útil grande

TX LargeMessage

O TX LargeMessage é 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.

RX LargeMessage

O RX LargeMessage é 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.

Atenção O Javascript está desativado ou não está disponível no seu navegador.

Para usar a documentação da AWS, o Javascript deve estar ativado. Consulte as páginas de Ajuda do navegador para obter instruções.

Convenções do documento

backoffAlgorithm

SDKs móveis para dispositivos Bluetooth do FreeRTOS

Biblioteca de Bluetooth Low Energy

Importante

Visão geral

Arquitetura

Serviços

Informações do dispositivo

Provisionamento de Wi-Fi

Abstração de rede

Transferência de objetos grandes

MQTT por BLE

Middleware

Assinatura de retorno de chamada flexível

Wrappers de baixo nível

Dependências e requisitos

Arquivo de configuração da biblioteca

Otimização

Restrições de uso

Inicialização

Middleware

nota

APIs de baixo nível

Referência de API

Exemplo de uso

Publicidade

Adição de um novo serviço

Importante

Portabilidade

Periférico de entrada e saída do usuário

Transferência de implementações da API

APIs de Bluetooth Low Energy

APIs comuns entre GAP para Bluetooth Classic e GAP para Bluetooth Low Energy

APIs específicas para GAP para Bluetooth Low Energy

Servidor GATT

Apêndice A: perfil MQTT por GATT BLE

Detalhes do serviço GATT