Bibliothèque Bluetooth Low Energy - Gratuit RTOS
PrésentationArchitectureDépendances et exigencesFichier de configuration des bibliothèquesOptimisationRestrictions liées à l'utilisationInitialisationRéférence d’APIExemple d’utilisationPortageAnnexe A : Profil MQTT sur BLE GATT

Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.

Bibliothèque Bluetooth Low Energy

Important

Cette bibliothèque est hébergée sur le référentiel Amazon-FreeRTOS qui est obsolète. Nous vous recommandons de commencer ici lorsque vous créez un nouveau projet. Si vous possédez déjà un projet FreeRTOS basé sur le référentiel Amazon-FreeRTOS, désormais obsolète, consultez le. Guide de migration du référentiel RTOS Github gratuit sur Amazon

Présentation

FreeRTOS prend en charge la publication et l'abonnement à des sujets relatifs au transport télémétrique des messages en file d'attente (MQTT) via Bluetooth Low Energy via un périphérique proxy, tel qu'un téléphone portable. Grâce à la bibliothèque FreeRTOS Bluetooth Low Energy (BLE), votre microcontrôleur peut communiquer en toute sécurité avec le courtier MQTT. AWS IoT

Appareils BLE se connectant AWS IoT Core via MQTT/HTTP/WebSocket via Cognito. AWS

À l'aide des SDK mobiles pour les appareils Bluetooth FreeRTOS, vous pouvez écrire des applications mobiles natives qui communiquent avec les applications intégrées sur votre microcontrôleur via BLE. Pour plus d'informations sur les kits SDK mobiles, consultez SDK mobiles pour appareils Bluetooth FreeRTOS.

La bibliothèque FreeRTOS BLE inclut des services permettant de configurer des réseaux Wi-Fi, de transférer de grandes quantités de données et de fournir des abstractions réseau via BLE. La bibliothèque FreeRTOS BLE inclut également des intergiciels et des API de niveau inférieur pour un contrôle plus direct de votre stack BLE.

Architecture

Trois couches constituent la bibliothèque FreeRTOS BLE : les services, les intergiciels et les wrappers de bas niveau.

Couches d'architecture cloud : application utilisateur, services, intergiciels, wrappers de bas niveau, fabricant BLE Stack.

Services

La couche de services FreeRTOS BLE comprend quatre services d'attributs génériques (GATT) qui exploitent les API du middleware :

  • Informations sur les périphériques

  • Mise en service Wi-Fi

  • Abstraction réseau

  • Transfert d'objets volumineux

Informations sur les périphériques

Le service d'informations sur les appareils recueille des informations sur votre microcontrôleur, notamment :

  • Version de FreeRTOS utilisée par votre appareil.

  • AWS IoT Point de terminaison du compte pour lequel l'appareil est enregistré.

  • Unité de transmission maximale Bluetooth Low Energy (MTU).

Mise en service Wi-Fi

La mise en service Wi-Fi permet aux microcontrôleurs dotés de fonctionnalités Wi-Fi d'effectuer les opérations suivantes :

  • Répertorier les réseaux dans une plage.

  • Enregistrer les réseaux et les informations d'identification correspondantes sur la mémoire flash.

  • Définir la priorité du réseau.

  • Supprimer les réseaux et les informations d'identification correspondantes de la mémoire flash.

Abstraction réseau

Le service d'abstraction réseau extrait le type de connexion réseau pour les applications. Une API courante interagit avec le Wi-Fi, l'Ethernet et la pile matérielle Bluetooth Low Energy de votre appareil, ce qui permet à une application d'être compatible avec plusieurs types de connexion.

Transfert d'objets volumineux

Le service Large Object Transfer envoie des données à un client et en reçoit des données. D'autres services, tels que le provisionnement Wi-Fi et l'abstraction du réseau, utilisent le service Large Object Transfer pour envoyer et recevoir des données. Vous pouvez également utiliser l'API Large Object Transfer pour interagir directement avec le service.

MQTT via BLE

MQTT over BLE contient le profil GATT pour créer un service proxy MQTT sur BLE. Le service proxy MQTT permet à un client MQTT de communiquer avec le courtier AWS MQTT par le biais d'une passerelle. Par exemple, vous pouvez utiliser le service proxy pour connecter un appareil exécutant FreeRTOS à MQTT via une AWS application pour smartphone. Le dispositif BLE est le serveur GATT et expose les services et les caractéristiques du dispositif passerelle. Le serveur GATT utilise ces services et caractéristiques exposés pour effectuer des opérations MQTT avec le cloud pour cet appareil. Pour plus d'informations, consultez Annexe A : Profil MQTT sur BLE GATT .

Intergiciel

Le middleware Bluetooth Low Energy FreeRTOS est une abstraction des API de niveau inférieur. Les API d'intergiciel constituent une interface plus conviviale pour la pile Bluetooth Low Energy.

À l'aide des API d'intergiciel, vous pouvez enregistrer plusieurs rappels, dans plusieurs couches, pour un seul événement. L'initialisation de l'intergiciel Bluetooth Low Energy initialise également des services et démarre la publicité.

Abonnement de rappel flexible

Supposons que votre matériel Bluetooth Low Energy se déconnecte et que le service MQTT sur Bluetooth Low Energy ait besoin de détecter la déconnexion. Une application que vous avez créée peut également avoir à détecter le même événement de déconnexion. L'intergiciel BLE peut acheminer l'événement à différentes parties du code où vous avez enregistré des rappels, sans que les couches supérieures n'aient à se disputer les ressources de niveau inférieur.

Wrappers de bas niveau

Les wrappers Bluetooth Low Energy FreeRTOS de bas niveau sont une abstraction de la gamme Bluetooth Low Energy du fabricant. Les wrappers de bas niveau offrent un ensemble commun d'API pour un contrôle direct sur le matériel. Les API de bas niveau optimisent l'utilisation de la RAM, mais leurs fonctionnalités sont limitées.

Utilisez les API du service Bluetooth Low Energy pour interagir avec les services Bluetooth Low Energy. Les API de service exigent plus de ressources que les API de bas niveau.

Dépendances et exigences

La bibliothèque Bluetooth Low Energy comporte les dépendances directes suivantes :

  • Bibliothèque de conteneurs linéaires

  • Une couche de plateforme en interface avec le système d'exploitation pour la gestion des threads, les minuteurs, les fonctions d'horloge et l'accès réseau.

Schéma d'architecture montrant les composants : BLE, List/Queue, Network et Clock, avec des flèches directionnelles indiquant les interactions.

Seul le service Wi-Fi Provisioning possède des dépendances à la bibliothèque FreeRTOS :

Service GATT Dépendance
Mise en service Wi-Fi Bibliothèque Wi-Fi

Pour communiquer avec le courtier AWS IoT MQTT, vous devez avoir un AWS compte et enregistrer vos appareils en tant qu' AWS IoT objets. Pour en savoir plus sur la configuration, consultez le Manuel du développeur AWS IoT.

FreeRTOS Bluetooth Low Energy utilise Amazon Cognito pour l'authentification des utilisateurs sur votre appareil mobile. Pour utiliser les services proxy MQTT, vous devez créer une identité Amazon Cognito et des groupes d'utilisateurs. Chaque identité Amazon Cognito doit être associée à la politique appropriée. Pour plus d'informations, consultez le Guide du développeur Amazon Cognito.

Fichier de configuration des bibliothèques

Les applications qui utilisent le service FreeRTOS MQTT over Bluetooth Low Energy doivent fournir iot_ble_config.h un fichier d'en-tête dans lequel les paramètres de configuration sont définis. Les paramètres de configuration non définis utilisent les valeurs par défaut spécifiées dans iot_ble_config_defaults.h.

Voici quelques paramètres de configuration importants :

IOT_BLE_ADD_CUSTOM_SERVICES

Autorise les utilisateurs à créer leurs propres services.

IOT_BLE_SET_CUSTOM_ADVERTISEMENT_MSG

Permet aux utilisateurs de personnaliser la publicité et d'analyser les messages de réponse.

Pour de plus amples informations, veuillez consulter Référence d'API Bluetooth Low Energy.

Optimisation

Lors de l'optimisation des performances de votre carte, prenez en considération les éléments suivants :

  • Les API de bas niveau utilisent moins de RAM, mais offrent des fonctionnalités limitées.

  • Vous pouvez définir le paramètre bleconfigMAX_NETWORK dans le fichier d'en-tête iot_ble_config.h sur une valeur inférieure afin de réduire la quantité de pile consommée.

  • Vous pouvez augmenter la taille MTU à sa valeur maximale pour limiter la mise en mémoire tampon des messages, accélérer l'exécution du code et consommer moins de RAM.

Restrictions liées à l'utilisation

Par défaut, la bibliothèque FreeRTOS Bluetooth Low Energy définit eBTpropertySecureConnectionOnly la propriété sur TRUE, ce qui place l'appareil en mode Connexions sécurisées uniquement. Comme défini par la spécification Bluetooth Core v5.0, vol 3, partie C, 10.2.4, lorsqu'un appareil utilise un mode autorisant uniquement les connexions sécurisées, le plus haut niveau de sécurité basse énergie du mode 1, à savoir le niveau 4, est requis pour l'accès à n'importe quel attribut disposant d'autorisations supérieures au niveau de sécurité basse énergie inférieur du mode 1, à savoir le niveau 1. Dans le mode de sécurité basse énergie 1 de niveau 4, un appareil doit avoir des fonctionnalités d'entrée et de sortie pour la comparaison numérique.

Voici les modes pris en charge et les propriétés associées :

Mode 1, Niveau 1 (aucune sécurité)
/* 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 )
Mode 1, Niveau 2 (appairage non authentifié avec chiffrement)
#define IOT_BLE_ENABLE_NUMERIC_COMPARISON        ( 0 )
#define IOT_BLE_ENABLE_SECURE_CONNECTION         ( 0 )
#define IOT_BLE_INPUT_OUTPUT                     ( eBTIONone )
Mode 1, Niveau 3 (appairage authentifié avec chiffrement)

Ce mode n'est pas pris en charge.

Mode 1, Niveau 4 (appairage des connexions sécurisées LE authentifiées avec chiffrement)

Ce mode est pris en charge par défaut.

Pour de plus amples informations sur les modes de sécurité basse énergie, veuillez consulter la spécification Bluetooth Core v5.0, vol 3, partie C, 10.2.1.

Initialisation

Si votre application interagit avec la pile Bluetooth Low Energy via un intergiciel, vous devez uniquement initialiser ce dernier. L'intergiciel s'occupe de l'initialisation des couches inférieures de la pile.

Intergiciel

Pour initialiser le middleware

  1. Initialisez n'importe quel pilote matériel Bluetooth Low Energy avant d'appeler l'API d'intergiciel Bluetooth Low Energy.

  2. Activez Bluetooth Low Energy.

  3. Initialisez l'intergiciel avec IotBLE_Init().

    Note

    Cette étape d'initialisation n'est pas requise si vous exécutez les AWS démos. L'initialisation des démonstrations est gérée par le gestionnaire de réseau local, situé à freertos/demos/network_manager.

API de bas niveau

Si vous ne souhaitez pas utiliser les services FreeRTOS Bluetooth Low Energy GATT, vous pouvez contourner le middleware et interagir directement avec les API de bas niveau pour économiser des ressources.

Pour initialiser les API de bas niveau

  1. Initialisez n'importe quel pilote de matériel Bluetooth Low Energy avant d'appeler les API. L'initialisation des pilotes ne fait pas partie des API de base niveau Bluetooth Low Energy.

  2. L'API Bluetooth Low Energy de bas niveau fournit un appel d'activation et de désactivation à la pile Bluetooth Low Energy pour optimiser la puissance et les ressources. Avant d'appeler les API, vous devez activer Bluetooth Low Energy.

    const BTInterface_t * pxIface = BTGetBluetoothInterface();
xStatus = pxIface->pxEnable( 0 );

  3. Le gestionnaire Bluetooth contient des API qui sont communes à Bluetooth Low Energy et au Bluetooth classique. Les rappels du gestionnaire doivent ensuite être initialisés.

    xStatus = xBTInterface.pxBTInterface->pxBtManagerInit( &xBTManagerCb );

  4. L'adaptateur Bluetooth Low Energy peut être ajouté en plus de l'API courante. Vous devez initialiser ses rappels courants comme vous avez initialisé l'API courante.

    xBTInterface.pxBTLeAdapterInterface = ( BTBleAdapter_t * ) xBTInterface.pxBTInterface->pxGetLeAdapter();
xStatus = xBTInterface.pxBTLeAdapterInterface->pxBleAdapterInit( &xBTBleAdapterCb );

  5. Enregistrez votre nouvelle application utilisateur.

    xBTInterface.pxBTLeAdapterInterface->pxRegisterBleApp( pxAppUuid );

  6. Initialisez les rappels aux serveurs GATT.

    xBTInterface.pxGattServerInterface = ( BTGattServerInterface_t * ) xBTInterface.pxBTLeAdapterInterface->ppvGetGattServerInterface();
xBTInterface.pxGattServerInterface->pxGattServerInit( &xBTGattServerCb );

    Une fois que vous avez initialisé l'adaptateur Bluetooth Low Energy, vous pouvez ajouter un serveur GATT. Vous pouvez enregistrer un seul serveur GATT à la fois.

    xStatus = xBTInterface.pxGattServerInterface->pxRegisterServer( pxAppUuid );

  7. Définissez les propriétés de l'application comme la connexion sécurisée uniquement et la taille MTU.

    xStatus = xBTInterface.pxBTInterface->pxSetDeviceProperty( &pxProperty[ usIndex ] );

Référence d’API

Pour obtenir une référence d'API complète, veuillez consulter Référence d'API Bluetooth Low Energy.

Exemple d’utilisation

Les exemples ci-dessous montrent comment utiliser la bibliothèque Bluetooth Low Energy pour la publicité et la création de nouveaux services. Pour les applications de démonstration FreeRTOS Bluetooth Low Energy complètes, voir Applications de démonstration Bluetooth Low Energy.

Publicité

  1. Dans votre application, définissez les UUID de publicité :

    static const BTUuid_t _advUUID =
{
    .uu.uu128 = IOT_BLE_ADVERTISING_UUID,
    .ucType   = eBTuuidType128
};

  2. Ensuite, définissez la fonction de rappel 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;
}

    Ce rappel envoie l'UUID dans le message de publicité et le nom complet dans la réponse d'analyse.

  3. Ouvrez vendors/vendor/boards/board/aws_demos/config_files/iot_ble_config.h et définissez IOT_BLE_SET_CUSTOM_ADVERTISEMENT_MSG sur 1. Cela déclenche le rappel IotBle_SetCustomAdvCb.

Ajout d'un nouveau service

Pour consulter l'ensemble des exemples de services, accédez à freertos/.../ble/services.

  1. Créez des UUID pour la caractéristique et les descripteurs du service :

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

  2. Créez un tampon pour enregistrer les handles de la caractéristique et des descripteurs :

    static uint16_t usHandlesBuffer[egattDemoNbAttributes];

  3. Créez la table de l'attribut. Pour enregistrer une RAM, définissez la table en tant que const.

    Important

    Créez toujours les attributs dans l'ordre, avec le service en tant que premier attribut.

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

  4. Créez un tableau des rappels. Ce tableau de rappels doit suivre le même ordre que le tableau de table défini ci-dessus.

    Par exemple, si vReadCounter est déclenché lorsque xCharCounterUUID_TYPE est consulté, et si vWriteCommand se déclenche lorsque xCharControlUUID_TYPE est consulté, définissez le tableau comme suit :

    static const IotBleAttributeEventCallback_t pxCallBackArray[egattDemoNbAttributes] =
    {
  NULL,
  vReadCounter,
  vEnableNotification,
  vWriteCommand
};

  5. Créez le service :

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

  6. Appelez l'API IotBle_CreateService avec la structure que vous avez créée à l'étape précédente. L'intergiciel synchronise la création de tous les services, ce qui signifie que tous les nouveaux services doivent être déjà définis lorsque le rappel IotBle_AddCustomServicesCb est déclenché.

    1. Définissez IOT_BLE_ADD_CUSTOM_SERVICES sur 1 dans vendors/vendor/boards/board/aws_demos/config_files/iot_ble_config.h.

    2. Créez IotBle _ AddCustomServicesCb dans votre application :

      void IotBle_AddCustomServicesCb(void)
{
    BTStatus_t xStatus;
    /* Select the handle buffer. */
    xStatus = IotBle_CreateService( (BTService_t *)&xGattDemoService, (IotBleAttributeEventCallback_t *)pxCallBackArray );
}

Portage

Périphériques utilisateur d'entrée et de sortie

Une connexion sécurisée nécessite des entrées et des sorties pour la comparaison numérique. L'événement eBLENumericComparisonCallback peut être enregistré à l'aide du gestionnaire d'événements :

xEventCb.pxNumericComparisonCb = &prvNumericComparisonCb;
xStatus = BLE_RegisterEventCb( eBLENumericComparisonCallback, xEventCb );

Le périphérique doit afficher la clé numérique et utiliser le résultat de la comparaison comme entrée.

Portage des implémentations d'API

Pour transférer FreeRTOS vers une nouvelle cible, vous devez implémenter certaines API pour le service Wi-Fi Provisioning et la fonctionnalité Bluetooth Low Energy.

API Bluetooth Low Energy

Pour utiliser le middleware Bluetooth Low Energy FreeRTOS, vous devez implémenter certaines API.

API communes entre GAP pour Bluetooth Classic et GAP pour Bluetooth Low Energy

  • pxBtManagerInit

  • pxEnable

  • pxDisable

  • pxGetDeviceProperty

  • pxSetDeviceProperty (toutes les options sont obligatoires, sauf eBTpropertyRemoteRssi et eBTpropertyRemoteVersionInfo)

  • pxPair

  • pxRemoveBond

  • pxGetConnectionState

  • pxPinReply

  • pxSspReply

  • pxGetTxpower

  • pxGetLeAdapter

  • pxDeviceStateChangedCb

  • pxAdapterPropertiesCb

  • pxSspRequestCb

  • pxPairingStateChangedCb

  • pxTxPowerCb

API propres à pour GAP pour Bluetooth Low Energy

  • pxRegisterBleApp

  • pxUnregisterBleApp

  • pxBleAdapterInit

  • pxStartAdv

  • pxStopAdv

  • pxSetAdvData

  • pxConnParameterUpdateRequest

  • pxRegisterBleAdapterCb

  • pxAdvStartCb

  • pxSetAdvDataCb

  • pxConnParameterUpdateRequestCb

  • pxCongestionCb

GATT Server

  • 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

Pour plus d'informations sur le portage de la bibliothèque Bluetooth Low Energy FreeRTOS sur votre plateforme, voir Portage de la bibliothèque Bluetooth Low Energy dans le Guide de portage FreeRTOS.

Annexe A : Profil MQTT sur BLE GATT

Détails des services du GATT

MQTT over BLE utilise une instance du service de transfert de données GATT pour envoyer des messages MQTT Concise Binary Object Representation (CBOR) entre le périphérique FreeRTOS et le périphérique proxy. Le service de transfert de données expose certaines caractéristiques qui permettent d'envoyer et de recevoir des données brutes via le protocole BLE GATT. Il gère également la fragmentation et l'assemblage de charges utiles supérieures à la taille maximale de l'unité de transfert (MTU) BLE.

UUID du service

A9D7-166A-D72E-40A9-A002-4804-4CC3-FF00

Instances de service

Une instance du service GATT est créée pour chaque session MQTT avec le courtier. Chaque service possède un UUID unique (deux octets) qui identifie son type. Chaque instance individuelle est différenciée par son ID d'instance.

Chaque service est instancié en tant que service principal sur chaque périphérique serveur BLE. Vous pouvez créer plusieurs instances du service sur un appareil donné. Le type de service proxy MQTT possède un UUID unique.

Caractéristiques

Format de contenu caractéristique : CBOR

Taille maximale de la valeur caractéristique : 512 octets

Caractéristiques Exigence Propriétés obligatoires Propriétés facultatives Autorisations de sécurité Brève description UUID
Contrôle M Écrire Aucun L'écriture a besoin d'un chiffrement Utilisé pour démarrer et arrêter le proxy MQTT. A9D7-166A-D72E-40A9-A002-4804-4CC3-FF01
Message TX M Lire, Notification Aucun La lecture a besoin d'un chiffrement Utilisé pour envoyer une notification contenant un message à un courtier via un proxy. A9D7-166A-D72E-40A9-A002-4804-4CC3-FF02
RX Message M Lire, écrire sans répondre Aucun La lecture et l'écriture nécessitent un chiffrement Utilisé pour recevoir un message d'un courtier via un proxy. A9D7-166A-D72E-40A9-A002-4804-4CC3-FF03
Texas LargeMessage M Lire, Notification Aucun La lecture a besoin d'un chiffrement Utilisé pour envoyer un message volumineux (Message > Taille MTU BLE) à un courtier via un proxy. A9D7-166A-D72E-40A9-A002-4804-4CC3-FF04
RX LargeMessage M Lire, écrire sans répondre Aucun La lecture et l'écriture nécessitent un chiffrement Utilisé pour recevoir un message volumineux (Message > Taille MTU BLE) d'un courtier via un proxy. A9D7-166A-D72E-40A9-A002-4804-4CC3-FF05
Exigences relatives aux procédures du GATT
Lire les valeurs caractéristiques Obligatoire
Lire les valeurs caractéristiques longues Obligatoire
Écrire des valeurs caractéristiques Obligatoire
Écrire des valeurs caractéristiques longues Obligatoire
Lire les descripteurs de caractéristiques Obligatoire
Écrire des descripteurs de caractéristiques Obligatoire
Notifications Obligatoire
Indications Obligatoire
Types de messages

Les types de messages suivants sont échangés.

Type de message Message Cartographiez avec ces paires clé/valeur
0x01 CONNECT

  • Clé = « w », valeur = type 0 entier, type de message (1)

  • Clé = « d », valeur = type 3, chaîne de texte, identifiant du client pour la session

  • Clé = « a », valeur = type 3, chaîne de texte, point de terminaison du courtier pour la session

  • Clé = « c », valeur = type de valeur simple vrai/faux
0x02 CONNACK

  • Clé = « w », valeur = type 0 entier, type de message (2)

  • Clé = « s », valeur = type 0 entier, code d'état

0x03 PUBLISH

  • Clé = « w », valeur = type 0 entier, type de message (3)

  • Clé = « u », valeur = Type 3, chaîne de texte, sujet à publier

  • Clé = « n », valeur = Type 0, entier, QoS pour la publication

  • Clé = « i », valeur = type 0, entier, identifiant de message, uniquement pour les publications de QoS 1

  • Clé = « k », valeur = type 2, chaîne d'octets, charge utile pour la publication

0x04 PUBACK

  • Envoyé uniquement pour les messages QoS 1.

  • Clé = « w », valeur = type 0 entier, type de message (4)

  • Clé = « i », valeur = Type 0, entier, identifiant du message

0x08 SUBSCRIBE

  • Clé = « w », valeur = type 0 entier, type de message (8)

  • Key = « v », valeur = Type 4, tableau de chaînes de texte, sujets d'abonnement

  • Clé = « o », valeur = Type 4, tableau d'entiers, QoS pour l'abonnement

  • Clé = « i », valeur = Type 0, entier, identifiant du message

0x09 SUBACK

  • Clé = « w », valeur = type 0 entier, type de message (9)

  • Clé = « i », valeur = Type 0, entier, identifiant du message

  • Clé = « s », valeur = Type 0, entier, code d'état pour l'abonnement

0X0A SE DÉSABONNER

  • Clé = « w », valeur = type 0 entier, type de message (10)

  • Key = « v », valeur = Type 4, tableau de chaînes de texte, sujets de désinscription

  • Clé = « i », valeur = Type 0, entier, identifiant du message

0x0B DÉBALLER

  • Clé = « w », valeur = type 0 entier, type de message (11)

  • Clé = « i », valeur = Type 0, entier, identifiant du message

  • Clé = « s », valeur = Type 0, entier, code d'état pour UnSubscription

0X0C PINGREQ

  • Clé = « w », valeur = type 0 entier, type de message (12)

0x0D PINGRESP

  • Clé = « w », valeur = type 0 entier, type de message (13)

0x0E DÉCONNECTER

  • Clé = « w », valeur = type 0 entier, type de message (14)
Caractéristiques de transfert de charges utiles importantes
Texas LargeMessage

TX LargeMessage est utilisé par le périphérique pour envoyer une charge utile importante supérieure à la taille MTU négociée pour la connexion BLE.

  • Le dispositif envoie les premiers octets MTU de la charge utile sous forme de notification par le biais de la caractéristique.

  • Le proxy envoie une demande de lecture sur cette caractéristique pour les octets restants.

  • Le périphérique envoie jusqu'à la taille de la MTU ou jusqu'au nombre d'octets restants de la charge utile, la valeur la plus faible étant retenue. À chaque fois, il augmente le décalage lu en fonction de la taille de la charge utile envoyée.

  • Le proxy continuera à lire la caractéristique jusqu'à ce qu'il obtienne une charge utile de longueur nulle ou une charge utile inférieure à la taille de la MTU.

  • Si le périphérique ne reçoit pas de demande de lecture dans un délai spécifié, le transfert échoue et le proxy et la passerelle libèrent la mémoire tampon.

  • Si le proxy n'obtient pas de réponse de lecture dans le délai spécifié, le transfert échoue et le proxy libère la mémoire tampon.

RX LargeMessage

RX LargeMessage est utilisé par le périphérique pour recevoir une charge utile importante supérieure à la taille MTU négociée pour la connexion BLE.

  • Le proxy écrit les messages, jusqu'à la taille MTU, un par un, en utilisant l'écriture avec réponse sur cette caractéristique.

  • Le périphérique met le message en mémoire tampon jusqu'à ce qu'il reçoive une demande d'écriture d'une longueur nulle ou inférieure à la taille de la MTU.

  • Si le périphérique ne reçoit pas de demande d'écriture dans le délai imparti, le transfert échoue et le périphérique libère la mémoire tampon.

  • Si le proxy ne reçoit pas de réponse en écriture dans le délai spécifié, le transfert échoue et le proxy libère la mémoire tampon.