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 Amazon-FreeRTOS référentiel qui est obsolète. Nous vous recommandons de [commencer ici](freertos-getting-started-modular.md) lorsque vous créez un nouveau projet. Si vous possédez déjà un projet FreeRTOS basé sur le référentiel désormais Amazon-FreeRTOS obsolète, consultez le. [Amazon-FreeRTOS Guide de migration du référentiel Github](github-repo-migration.md) ## Présentation de 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](https://docs.aws.amazon.com/freertos/latest/lib-ref/html2/ble/index.html) 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 AWS Cognito.](http://docs.aws.amazon.com/fr_fr/freertos/latest/userguide/images/blediagram.jpg) À 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](freertos-ble-mobile.md). La bibliothèque FreeRTOS BLE inclut des services permettant de Wi-Fi configurer des réseaux, 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, Low-level wrappers, fabricant BLE Stack.](http://docs.aws.amazon.com/fr_fr/freertos/latest/userguide/images/ble-architecture.png) ### 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 + Wi-Fi approvisionnement + Abstraction réseau + Transfert d'objets de grande taille #### 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). #### Wi-Fi approvisionnement Le service de Wi-Fi provisionnement permet aux microcontrôleurs dotés Wi-Fi des capacités 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 commune interagit avec le matériel Ethernet et Bluetooth Low Energy de votre appareil, permettant à une application d'être compatible avec plusieurs types de connexion. Wi-Fi #### 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 Wi-Fi provisionnement 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 via 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](#freertos-ble-gatt-profile). ### 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. ### Low-level emballages Les wrappers Bluetooth Low Energy FreeRTOS de bas niveau sont une abstraction de la gamme Bluetooth Low Energy du fabricant. Low-level les wrappers proposent un ensemble commun d'API pour un contrôle direct du 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 [Linear Containers](https://docs.aws.amazon.com/freertos/latest/lib-ref/c-sdk/linear_containers/index.html) + 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.](http://docs.aws.amazon.com/fr_fr/freertos/latest/userguide/images/ble-dependencies.png) Seul le service Wi-Fi Provisioning possède des dépendances de bibliothèque FreeRTOS : **** | Service GATT | Dépendance | | --- | --- | | Wi-Fi Approvisionnement | [Wi-Fi bibliothèque](freertos-wifi.md) | 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](https://docs.aws.amazon.com/iot/latest/developerguide/). 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](https://docs.aws.amazon.com/cognito/latest/developerguide/). ## 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](https://docs.aws.amazon.com/freertos/latest/lib-ref/html2/ble/index.html). ## Optimisation Lors de l'optimisation des performances de votre carte, prenez en considération les éléments suivants : + Low-level Les API 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](https://www.bluetooth.com/specifications/bluetooth-core-specification) 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](https://www.bluetooth.com/specifications/bluetooth-core-specification) 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. 1. Activez Bluetooth Low Energy. 1. 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`. ### Low-level APIs 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. 1. **** L'API Bluetooth Low Energy Low-Level fournit un enable/disable appel à 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 ); ``` 1. **** 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 ); ``` 1. **** 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 ); ``` 1. **** Enregistrez votre nouvelle application utilisateur. ``` xBTInterface.pxBTLeAdapterInterface->pxRegisterBleApp( pxAppUuid ); ``` 1. **** 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 ); ``` 1. **** 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 des API Pour obtenir une référence d'API complète, veuillez consulter [Référence d'API Bluetooth Low Energy](https://docs.aws.amazon.com/freertos/latest/lib-ref/html2/ble/index.html). ## 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](https://docs.aws.amazon.com/freertos/latest/userguide/ble-demo.html) 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 }; ``` 1. 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. 1. 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\ } ``` 1. Créez un tampon pour enregistrer les handles de la caractéristique et des descripteurs : ``` static uint16_t usHandlesBuffer[egattDemoNbAttributes]; ``` 1. 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 ) } } }; ``` 1. 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 }; ``` 1. Créez le service : ``` static const BTService_t xGattDemoService = { .xNumberOfAttributes = egattDemoNbAttributes, .ucInstId = 0, .xType = eBTServiceTypePrimary, .pusHandlesBuffer = usHandlesBuffer, .pxBLEAttributes = (BTAttribute_t *)pxAttributeTable }; ``` 1. 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`. 1. 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 porter FreeRTOS vers une nouvelle cible, vous devez implémenter certaines API pour Wi-Fi le service 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](https://docs.aws.amazon.com/freertos/latest/portingguide/afr-porting-ble.html) 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 **** [See the AWS documentation website for more details](http://docs.aws.amazon.com/fr_fr/freertos/latest/userguide/freertos-ble-library.html) **Exigences relatives aux procédures du GATT ** **** [See the AWS documentation website for more details](http://docs.aws.amazon.com/fr_fr/freertos/latest/userguide/freertos-ble-library.html) **Types de messages ** Les types de messages suivants sont échangés. **** [See the AWS documentation website for more details](http://docs.aws.amazon.com/fr_fr/freertos/latest/userguide/freertos-ble-library.html) **Caractéristiques de transfert de charges utiles importantes ** **TXLargeMessage ** TXLargeMessage 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. **RXLargeMessage ** RXLargeMessage 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'option d'é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.