Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés. # Control del hub El control de hub es una extensión del SDK para dispositivos finales de integraciones gestionadas que le permite interactuar con el `MQTTProxy` componente del SDK de Hub. Con el control del hub, puedes implementar el código mediante el SDK para dispositivos finales y controlar tu hub a través de la nube de integraciones gestionadas como un dispositivo independiente. El SDK de control de hub se proporcionará como un paquete independiente dentro del SDK de Hub, denominado como. `iot-managed-integrations-hub-control-x.x.x` **Topics** + [Requisitos previos](#getting-started-tutorial-prequisites) + [Componentes del SDK del dispositivo final](#device-sdk-components) + [Intégrelo con el SDK del dispositivo final](#device-sdk-integration) + [Ejemplo: Construir un hub control](#build-hub-control) + [Ejemplos compatibles](#hub-control-examples) + [Plataformas admitidas](#hub-control-platforms) ## Requisitos previos Para configurar el control del hub, necesitas lo siguiente: + Un hub integrado en el [SDK de Hub](managedintegrations-sdk-v2.md), versión 0.4.0 o superior. + Descarga la última versión del [SDK para dispositivos finales desde](managedintegrations-sdk-devices.md). Consola de administración de AWS + Un componente de [proxy MQTT](managedintegrations-sdk-v2.md) que se ejecuta en el hub, versión 0.5.0 o superior. ## Componentes del SDK del dispositivo final Utilice los siguientes componentes del [SDK para dispositivos finales](managedintegrations-sdk-devices.md): + Generador de código para el modelo de datos + Gestor de modelos de datos Como el SDK de Hub ya cuenta con un proceso de incorporación y una conexión a la nube, no necesitas los siguientes componentes: + Aprovisionado + Interfaz PKCS + Gestor de trabajos + Agente MQTT ## Intégrelo con el SDK del dispositivo final 1. Siga las instrucciones del [generador de códigos para Data Model](managedintegrations-sdk-device-codegen.md) para generar el código C de bajo nivel. 1. Siga las instrucciones de [Integrar el SDK para dispositivos finales](managedintegrations-sdk-device-onboarding.md) para: 1. **Configure el entorno de compilación** Cree el código en Amazon Linux 2023/x86\_64 como host de desarrollo. Instale las dependencias de compilación necesarias: ``` dnf install make gcc gcc-c++ cmake ``` 1. **Desarrolle funciones de devolución de llamadas de hardware** Antes de implementar las funciones de devolución de llamada del hardware, comprenda cómo funciona la API. En este ejemplo, se utilizan el On/Off clúster y el OnOff atributo para controlar la función de un dispositivo. Para obtener más información sobre la API, consulte[C-Function APIs de bajo nivel](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. **Configure los puntos finales y conecte las funciones de devolución de llamada del hardware** Tras implementar las funciones, cree puntos finales y registre las devoluciones de llamada. Complete estas tareas: 1. Cree un agente de dispositivo 1. Rellene los puntos de la función de devolución de llamada para cada estructura de clúster que desee admitir 1. Configure los puntos finales y registre los clústeres compatibles ``` 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); } ``` ## Ejemplo: Construir un hub control El control de Hub se proporciona como parte del paquete SDK de Hub. El subpaquete de control del hub está etiquetado con bibliotecas diferentes a las del SDK del dispositivo sin modificar `iot-managed-integrations-hub-control-x.x.x` y contiene bibliotecas diferentes. 1. Mueva los archivos generados por el código a la `example` carpeta: ``` cp codegen/out/* example/dm ``` 1. Para crear hub control, ejecute los siguientes comandos: ``` cd ``` ``` mkdir build ``` ``` cd build ``` ``` cmake -DBUILD_EXAMPLE_WITH_MQTT_PROXY=ON -DIOTMI_USE_MANAGED_INTEGRATIONS_DEVICE_LOG=ON .. ``` ``` cmake -build . ``` 1. Ejecute los ejemplos con el `MQTTProxy` componente del hub y con los `MQTTProxy` componentes `HubOnboarding` y ejecutándose. ``` ./examples/iotmi_device_sample_camera/iotmi_device_sample_camera ``` Consulte [Modelo de datos de integraciones gestionadas](managedintegrations-data-model.md) el modelo de datos. Siga el paso 5 [Comience a usar el SDK para dispositivos finales](managedintegrations-sdk-device-onboarding.md) para configurar los puntos finales y gestionar las comunicaciones entre el usuario final y las integraciones gestionadas por el IoT. ## Ejemplos compatibles Se han creado y probado los siguientes ejemplos: + iotmi\_device\_dm\_air\_purifier\_demo + iotmi\_device\_basic\_diagnosis + iotmi\_device\_dm\_camera\_demo ## Plataformas admitidas En la siguiente tabla se muestran las plataformas compatibles para el control del hub. | Arquitectura | Sistema operativo | Versión GCC | Versión de Binutils | | --- | --- | --- | --- | | X86\_64 | Linux | 10.5.0 | 2.37 | | aarch64 | Linux | 10.5.0 | 2.37 |