Configurer le 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 pour appareils finaux et contrôler votre hub via le cloud d'intégrations gérées 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. hub-control-x.x.x

Prérequis

Pour configurer le contrôle du hub, vous devez d'abord disposer des éléments suivants :

• Un hub intégré au SDK du terminal, version 0.4.0 ou supérieure.

• Un composant proxy MQTT exécuté sur le hub, version 0.5.0 ou supérieure.

Composants du SDK pour appareils finaux

Vous utiliserez les composants suivants du SDK pour appareils finaux :

• 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 afin de générer le code C de bas niveau.

2. Suivez les instructions de la section Intégration du SDK de l'appareil final 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

   2. 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 cluster et l' OnOff attribut On/Off pour contrôler la fonction d'un appareil. Pour plus de détails sur l'API, consultezOpérations d'API pour les fonctions C de bas niveau.

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

   3. Configuration des points de terminaison et des 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

      2. Remplissez les points de la fonction de rappel pour chaque structure de cluster que vous souhaitez prendre en charge

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

2. Pour créer le contrôle du hub, exécutez les commandes suivantes :

   cd <hub-control-root-folder>

   mkdir build

   cd build

   cmake -DBUILD_EXAMPLE_WITH_MQTT_PROXY=ON -DIOTMI_USE_MANAGED_INTEGRATIONS_DEVICE_LOG=ON ..

   cmake -build .

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

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