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.
# Contrôle du hub
Le contrôle du hub est une extension du SDK pour appareils finaux des intégrations gérées qui lui permet de s'interfacer avec le `MQTTProxy` composant du SDK du hub. Avec le contrôle du hub, vous pouvez implémenter du code à l'aide du SDK du terminal et contrôler votre hub via le cloud Managed Integrations en tant qu'appareil distinct. Le SDK de contrôle du hub sera fourni sous forme de package distinct dans le SDK du hub, étiqueté comme. `iot-managed-integrations-hub-control-x.x.x`
**Topics**
+ [Conditions préalables](#getting-started-tutorial-prequisites)
+ [Composants du SDK pour appareils finaux](#device-sdk-components)
+ [Intégration au SDK pour appareils finaux](#device-sdk-integration)
+ [Exemple : créer un contrôle du hub](#build-hub-control)
+ [Exemples pris en charge](#hub-control-examples)
+ [Plateformes prises en charge](#hub-control-platforms)
## Conditions préalables
Pour configurer le contrôle du hub, vous avez besoin des éléments suivants :
+ Un hub intégré au [SDK du Hub](managedintegrations-sdk-v2.md), version 0.4.0 ou ultérieure.
+ Téléchargez la dernière version du [SDK pour appareils finaux](managedintegrations-sdk-devices.md) à partir du Console de gestion AWS.
+ Un composant [proxy MQTT](managedintegrations-sdk-v2.md) exécuté sur le hub, version 0.5.0 ou supérieure.
## Composants du SDK pour appareils finaux
Utilisez les composants suivants du [SDK pour appareils finaux](managedintegrations-sdk-devices.md) :
+ Générateur de code pour le modèle de données
+ Gestionnaire de modèles de données
Le SDK Hub étant déjà doté d'un processus d'intégration et d'une connexion au cloud, vous n'avez pas besoin des composants suivants :
+ Bénéficiaire
+ Interface PKCS
+ Gestionnaire de tâches
+ Agent MQTT
## Intégration au SDK pour appareils finaux
1. Suivez les instructions du [générateur de code pour le modèle de données](managedintegrations-sdk-device-codegen.md) afin de générer le code C de bas niveau.
1. Suivez les instructions de la section [Intégration du SDK de l'appareil final](managedintegrations-sdk-device-onboarding.md) pour :
1.
**Configuration de l'environnement de construction**
Créez le code sur Amazon Linux 2023/x86\_64 en tant qu'hôte de développement. Installez les dépendances de build nécessaires :
```
dnf install make gcc gcc-c++ cmake
```
1.
**Développer des fonctions de rappel matérielles**
Avant d'implémenter les fonctions de rappel matériel, comprenez le fonctionnement de l'API. Cet exemple utilise le On/Off cluster et OnOff l'attribut pour contrôler la fonction d'un appareil. Pour plus de détails sur l'API, consultez[C-Function API de bas niveau](managedintegrations-sdk-device-api.md).
```
struct DeviceState
{
struct iotmiDev_Agent *agent;
struct iotmiDev_Endpoint *endpointLight;
/* This simulates the HW state of OnOff */
bool hwState;
};
/* This implementation for OnOff getter just reads
the state from the DeviceState */
iotmiDev_DMStatus exampleGetOnOff(bool *value, void *user)
{
struct DeviceState *state = (struct DeviceState *)(user);
*value = state->hwState;
return iotmiDev_DMStatusOk;
}
```
1.
**Configurer les points de terminaison et connecter les fonctions de rappel du matériel**
Après avoir implémenté les fonctions, créez des points de terminaison et enregistrez vos rappels. Effectuez les tâches suivantes :
1. Création d'un agent de terminal
1. Remplissez les points de la fonction de rappel pour chaque structure de cluster que vous souhaitez prendre en charge
1. Configuration des points de terminaison et enregistrement des clusters pris en charge
```
struct DeviceState
{
struct iotmiDev_Agent * agent;
struct iotmiDev_Endpoint *endpoint1;
/* OnOff cluster states*/
bool hwState;
};
/* This implementation for OnOff getter just reads
the state from the DeviceState */
iotmiDev_DMStatus exampleGetOnOff( bool * value, void * user )
{
struct DeviceState * state = ( struct DeviceState * ) ( user );
*value = state->hwState;
printf( "%s(): state->hwState: %d\n", __func__, state->hwState );
return iotmiDev_DMStatusOk;
}
iotmiDev_DMStatus exampleGetOnTime( uint16_t * value, void * user )
{
*value = 0;
printf( "%s(): OnTime is %u\n", __func__, *value );
return iotmiDev_DMStatusOk;
}
iotmiDev_DMStatus exampleGetStartUpOnOff( iotmiDev_OnOff_StartUpOnOffEnum * value, void * user )
{
*value = iotmiDev_OnOff_StartUpOnOffEnum_Off;
printf( "%s(): StartUpOnOff is %d\n", __func__, *value );
return iotmiDev_DMStatusOk;
}
void setupOnOff( struct DeviceState *state )
{
struct iotmiDev_clusterOnOff clusterOnOff = {
.getOnOff = exampleGetOnOff,
.getOnTime = exampleGetOnTime,
.getStartUpOnOff = exampleGetStartUpOnOff,
};
iotmiDev_OnOffRegisterCluster( state->endpoint1,
&clusterOnOff,
( void * ) state);
}
/* Here is the sample setting up an endpoint 1 with OnOff
cluster. Note all error handling code is omitted. */
void setupAgent(struct DeviceState *state)
{
struct iotmiDev_Agent_Config config = {
.thingId = IOTMI_DEVICE_MANAGED_THING_ID,
.clientId = IOTMI_DEVICE_CLIENT_ID,
};
iotmiDev_Agent_InitDefaultConfig(&config);
/* Create a device agent before calling other SDK APIs */
state->agent = iotmiDev_Agent_new(&config);
/* Create endpoint#1 */
state->endpoint1 = iotmiDev_Agent_addEndpoint( state->agent,
1,
"Data Model Handler Test Device",
(const char*[]){ "Camera" },
1 );
setupOnOff(state);
}
```
## Exemple : créer un contrôle du hub
Le contrôle du hub est fourni dans le package du SDK du hub. Le sous-package de contrôle du hub est étiqueté `iot-managed-integrations-hub-control-x.x.x` et contient des bibliothèques différentes de celles du SDK de périphérique non modifié.
1. Déplacez les fichiers générés par le code vers le `example` dossier :
```
cp codegen/out/* example/dm
```
1. Pour créer le contrôle du hub, exécutez les commandes suivantes :
```
cd
```
```
mkdir build
```
```
cd build
```
```
cmake -DBUILD_EXAMPLE_WITH_MQTT_PROXY=ON -DIOTMI_USE_MANAGED_INTEGRATIONS_DEVICE_LOG=ON ..
```
```
cmake -build .
```
1. Exécutez les exemples avec le `MQTTProxy` composant sur le hub, avec les `MQTTProxy` composants `HubOnboarding` et en cours d'exécution.
```
./examples/iotmi_device_sample_camera/iotmi_device_sample_camera
```
Voir [Modèle de données d'intégrations gérées](managedintegrations-data-model.md) pour le modèle de données. Suivez l'étape 5 [Commencez avec le SDK pour appareils finaux](managedintegrations-sdk-device-onboarding.md) pour configurer les points de terminaison et gérer les communications entre l'utilisateur final et les intégrations gérées par l'IoT.
## Exemples pris en charge
Les exemples suivants ont été créés et testés :
+ démo du purificateur d'air iotmi\_device\_dm\_air
+ iotmi\_device\_basic\_diagnostics
+ iotmi\_device\_dm\_camera\_demo
## Plateformes prises en charge
Le tableau suivant indique les plateformes prises en charge pour le contrôle du hub.
| Architecture | Système d’exploitation | Version GCC | Version binutils |
| --- | --- | --- | --- |
| X86\_64 | Linux | 10.5.0 | 2,37 |
| aarch64 | Linux | 10.5.0 | 2,37 |