:Integrar el SDK en módulos compatibles con MQTT

Configurar el SDK

A continuación se explica cómo configurar las funciones de software obligatorias.

Ejecutar el comando de configuración

• Linux

Vaya al directorio raíz del SDK y ejecute el siguiente comando:

make menuconfig
            

• Sistema operativo Windows

Ejecute config.bat en el directorio raíz del SDK.

config.bat
            

Ambos métodos inician la herramienta de configuración del SDK. La interfaz se muestra de la siguiente manera:

Nota:

• Un asterisco ()* junto a una opción de función indica que la función está habilitada. Si no hay asterisco, significa que la función está deshabilitada.

• La tabla muestra las opciones configurables. Las funciones principales del SDK permanecen activas incluso si usted deshabilita todas las opciones configurables.

• Presione la barra espaciadora para seleccionar o anular la selección de una función. Use las teclas de flecha hacia arriba y hacia abajo del teclado para cambiar entre funciones.

• Para conocer más sobre una opción, use las teclas de flecha para mover la barra de resaltado hasta esa opción y presione la tecla 'h' del teclado. Aparecerá un texto de ayuda que explica la opción y los efectos de habilitarla o deshabilitarla.

Para este escenario:

• Si el entorno de desarrollo admite stdint.h, habilite PLATFORM_HAS_STDINT.

• Si el entorno de desarrollo admite malloc/free, habilite PLATFORM_HAS_DYNMEM.

• Si el entorno de ejecución tiene un sistema operativo, habilite PLATFORM_HAS_OS.

Deshabilite todas las demás opciones. Una vez que termine la configuración, seleccione el botón 'Exit' y guarde la configuración cuando el sistema lo solicite.

Extraer el código del SDK

A continuación se explica cómo extraer el código del SDK.

Ejecutar el comando de extracción

• Linux

Vaya al directorio raíz del SDK y ejecute el siguiente comando:

sh ./extract.sh
            

• Sistema operativo Windows

Puede ejecutar config.bat en el directorio raíz del SDK.

extract.bat
            

int32_t IOT_Sign_MQTT(iotx_mqtt_region_types_t region, iotx_dev_meta_info_t *meta, iotx_sign_mqtt_t *signout)
            

#include "dev_sign_internal.h"
            

typedef enum {
    IOTX_CLOUD_REGION_SHANGHAI,   /* Shanghai */
    IOTX_CLOUD_REGION_SINGAPORE,  /* Singapore */
    IOTX_CLOUD_REGION_JAPAN,      /* Japan */
    IOTX_CLOUD_REGION_USA_WEST,   /* America */
    IOTX_CLOUD_REGION_GERMANY,    /* Germany */
    IOTX_CLOUD_REGION_CUSTOM,     /* Custom setting */
    IOTX_CLOUD_DOMAIN_MAX         /* Maximum number of domain */
} iotx_mqtt_region_types_t;
            

typedef struct {
    char product_key[IOTX_PRODUCT_KEY_LEN + 1];
    char product_secret[IOTX_PRODUCT_SECRET_LEN + 1];
    char device_name[IOTX_DEVICE_NAME_LEN + 1];
    char device_secret[IOTX_DEVICE_SECRET_LEN + 1];
} iotx_dev_meta_info_t;
            

typedef struct {
    char hostname[DEV_SIGN_HOSTNAME_MAXLEN];
    uint16_t port;
    char clientid[DEV_SIGN_CLIENT_ID_MAXLEN];
    char username[DEV_SIGN_USERNAME_MAXLEN];
    char password[DEV_SIGN_PASSWORD_MAXLEN];
} iotx_sign_mqtt_t;
            

#define EXAMPLE_PRODUCT_KEY     "a1X2bEnP82z"
#define EXAMPLE_PRODUCT_SECRET  "7jluWm1zql7bt8qK"
#define EXAMPLE_DEVICE_NAME     "example1"
#define EXAMPLE_DEVICE_SECRET   "ga7XA6KdlEeiPXQPpRbAjOZXwG8ydgSe"

/* Implement this HAL or use "printf" of your own system if you want to print something in the example. */
void HAL_Printf(const char *fmt, ...);

int main(int argc, char *argv[])
{
    iotx_mqtt_region_types_t region = IOTX_CLOUD_REGION_SHANGHAI;
    iotx_dev_meta_info_t meta;
    iotx_sign_mqtt_t sign_mqtt;

    memset(&meta,0,sizeof(iotx_dev_meta_info_t));
    memcpy(meta.product_key,EXAMPLE_PRODUCT_KEY,strlen(EXAMPLE_PRODUCT_KEY));
    memcpy(meta.product_secret,EXAMPLE_PRODUCT_SECRET,strlen(EXAMPLE_PRODUCT_SECRET));
    memcpy(meta.device_name,EXAMPLE_DEVICE_NAME,strlen(EXAMPLE_DEVICE_NAME));
    memcpy(meta.device_secret,EXAMPLE_DEVICE_SECRET,strlen(EXAMPLE_DEVICE_SECRET));

    if (IOT_Sign_MQTT(region,&meta,&sign_mqtt) < 0) {
        return -1;
    }
    ...
}

            

#define PID_STRING_LEN_MAX          32  /* Maximum length of the PID string */
#define MID_STRING_LEN_MAX          32  /* Maximum length of the MID string */

int example_report_pid_mid(void *pclient, const char *product_key, const char *device_name, const char *pid, const char *mid)
{
    int res = 0;
    iotx_mqtt_topic_info_t topic_msg;

    const char topic_frag1[] = "/sys/";
    const char topic_frag2[] = "/thing/deviceinfo/update";
    char topic[sizeof(topic_frag1) + sizeof(topic_frag2) + IOTX_PRODUCT_KEY_LEN + IOTX_DEVICE_NAME_LEN] = {0};

    const char payload_frag1[] = "{\"id\":\"0\",\"version\":\"1.0\",\"params\":[{\"attrKey\":\"SYS_MODULE_ID\",\"attrValue\":\"";
    const char payload_frag2[] = "\",\"domain\":\"SYSTEM\"},{\"attrKey\":\"SYS_PARTNER_ID\",\"attrValue\":\"";
    const char payload_frag3[] = "\",\"domain\":\"SYSTEM\"}],\"method\": \"thing.deviceinfo.update\"}";
    char payload[sizeof(payload_frag1) + sizeof(payload_frag2) + sizeof(payload_frag3) + PID_STRING_LEN_MAX + MID_STRING_LEN_MAX] = {0};

    if (strlen(pid) > PID_STRING_LEN_MAX || strlen(mid) > MID_STRING_LEN_MAX) {
        return -1;
    }

    /* Assemble the MQTT topic string. */
    memcpy(topic, topic_frag1, strlen(topic_frag1));
    memcpy(topic + strlen(topic), product_key, strlen(product_key));
    memcpy(topic + strlen(topic), "/", 1);
    memcpy(topic + strlen(topic), device_name, strlen(device_name));
    memcpy(topic + strlen(topic), topic_frag2, strlen(topic_frag2));

    /* Assemble the MQTT payload string. The payload contains the PID and MID strings. */
    memcpy(payload, payload_frag1, strlen(payload_frag1));
    memcpy(payload + strlen(payload), mid, strlen(mid));
    memcpy(payload + strlen(payload), payload_frag2, strlen(payload_frag2));
    memcpy(payload + strlen(payload), pid, strlen(pid));
    memcpy(payload + strlen(payload), payload_frag3, strlen(payload_frag3));

    topic_msg.qos = IOTX_MQTT_QOS0;
    topic_msg.retain = 0;
    topic_msg.dup = 0;
    topic_msg.payload = (void *)payload;
    topic_msg.payload_len = strlen(payload);

    /* Use the MQTT publish API to send the message that contains the PID and MID. 
       Because you are using the module's built-in MQTT feature, replace the following publish function with your actual publish function during integration. */
    res = IOT_MQTT_Publish(pclient, topic, &topic_msg);
    if (res < 0) {
        return -1;
    }

    return 0;
}

            

Conectar el módulo a Alibaba Cloud IoT Platform

Debe escribir una función para conectar el módulo a Alibaba Cloud IoT Platform. El componente de MQTT del módulo debería proporcionar una función para conectarse al broker de MQTT. En esta función, debe ingresar el nombre de dominio, el puerto, el ClientID, el nombre de usuario y la contraseña que se obtienen al invocar la API IOT_Sign_MQTT() de Link SDK.

El siguiente pseudocódigo es un ejemplo de integración del SDK con mosquitto, una biblioteca de MQTT de código abierto:

        // Call the signature function to get MQTT username, password, clientID, and other information.
        IOT_Sign_MQTT(region,&meta,&sign_mqtt);

        mosquitto_lib_init();

        // The following code sets the MQTT clientID and cleansession parameters.
        mosq = mosquitto_new(sign_mqtt.clientid,0/*dont clean session*/,NULL);
        if(mosq==NULL){
                printf("Error:Failed creating mosquitto client\n\r");
                return(-1);
        }
        // The following code sets the username and password for the MQTT connection.
        if(0 != mosquitto_username_pw_set(mosq, sign_mqtt.username, sign_mqtt.password)){
                printf("Error:Failed setting username or password\n\r");
                return(-1);
        }

        ...
        // The following code establishes a connection to the MQTT broker. It uses the domain name and port.
        if(mosquitto_connect(mosq, sign_mqtt.hostname, sign_mqtt.port, kaInterval)){
                printf("Error: Failed connecting cloud.\n\r");
                sleep(1);
                return -1;
        }
            

Nota: cuando establezca una conexión de MQTT, también debe especificar el intervalo de keepalive. El valor recomendado es de 60 segundos. También puede proporcionar un comando AT para permitir que la MCU modifique dinámicamente este parámetro. Alibaba Cloud IoT Platform acepta un intervalo de keepalive de entre 30 y 1200 segundos.

Una vez que el módulo se conecta a IoT Platform, permanece en línea si no cierra la conexión de MQTT. Busque el dispositivo de prueba en la consola de Alibaba Cloud IoT Platform para consultar su estado. La siguiente imagen muestra el estado de un dispositivo en línea:

Cómo comprobar si el programa puede enviar datos a IoT Platform

Después de que el módulo establezca la conexión con Alibaba Cloud IoT Platform, envíe un mensaje al tema /${productKey}/${deviceName}/get para comprobar si los datos se envían correctamente a la plataforma.

Nota: de forma predeterminada, el tema /${productKey}/${deviceName}/get solo tiene el permiso 'Subscribe'. En la consola de IoT Platform, cambie su permiso a 'Publish and Subscribe'. Este cambio evita que la nube descarte el mensaje después de enviarlo. Modificar el permiso del tema a 'Publish and Subscribe' sirve principalmente para garantizar que el programa de ejemplo se ejecute sin errores.

A continuación se muestra un ejemplo de implementación de referencia:

    int res = 0;
    iotx_mqtt_topic_info_t topic_msg;
    const char *fmt = "/%s/%s/get";
    char *topic = NULL;
    int topic_len = 0;
    char *payload = "hello,world";

    topic_len = strlen(fmt) + strlen(product_key) + strlen(device_name) + 1;
    topic = HAL_Malloc(topic_len);
    if (topic == NULL) {
        HAL_Printf("memory not enough\n");
        return -1;
    }
    memset(topic, 0, topic_len);
    // Generate the topic here.
    HAL_Snprintf(topic, topic_len, fmt, product_key, device_name);

        // The following code generates a message.
    memset(&topic_msg, 0x0, sizeof(iotx_mqtt_topic_info_t));
    topic_msg.qos = IOTX_MQTT_QOS0;
    topic_msg.retain = 0;
    topic_msg.dup = 0;
    topic_msg.payload = (void *)payload;
    topic_msg.payload_len = strlen(payload);

        // The following code sends a message to the specified topic. 
        // Replace the sending function below with the MQTT Publish function on your module.
    res = IOT_MQTT_Publish(handle, topic, &topic_msg);
            

En la consola de IoT Platform, revise el registro de Simple Log Service del dispositivo específico para ver si la plataforma recibió los datos:

Nota:

• El registro muestra la hora en que se recibió el mensaje del dispositivo y el tema del mensaje. No muestra el contenido del mensaje.

• Actualmente, Alibaba Cloud IoT Platform no admite Quality of Service (QoS) 2.

Cómo comprobar si el programa se suscribió correctamente a un tema

Suscríbase al tema /{productKey}/${deviceName}/get. De esta manera, cuando el dispositivo reporte datos a IoT Platform, la plataforma los devolverá al dispositivo. Esto le permite verificar que la suscripción funciona correctamente. A continuación se muestra un ejemplo de pseudocódigo:

    int res = 0;
    const char *fmt = "/%s/%s/get";
    char *topic = NULL;
    int topic_len = 0;

    topic_len = strlen(fmt) + strlen(product_key) + strlen(device_name) + 1;
    topic = HAL_Malloc(topic_len);
    if (topic == NULL) {
        HAL_Printf("memory not enough\n");
        return -1;
    }
    // The following code assembles the topic.
    memset(topic, 0, topic_len);
    snprintf(topic, topic_len, fmt, product_key, device_name);

    /* The following code subscribes to the topic and specifies the message handler function.
      Replace the code below with the actual MQTT subscribe function on your module. */
    res = IOT_MQTT_Subscribe(handle, topic, IOTX_MQTT_QOS0, example_message_arrive, NULL);
            

En la consola de IoT Platform, compruebe si la plataforma envió los datos al dispositivo:

Nota:

• El registro muestra la hora en que se envió el mensaje al dispositivo. No muestra el contenido del mensaje.

• Debe revisar en el módulo que los datos recibidos sean iguales a los datos que cargó. Esto garantiza que la recepción de datos funciona correctamente.

Implementación de comandos AT

También debe proporcionar comandos AT que la MCU pueda invocar. Como el módulo ya admite MQTT, debería ofrecer interfaces para la configuración de la conexión de MQTT, el inicio de la conexión, la desconexión, la suscripción y la publicación. Después de integrar Link SDK, agregue nuevos comandos AT para Alibaba Cloud o modifique los existentes.

A continuación se muestran los comandos AT recomendados para agregar:

Para las instrucciones restantes de MQTT, continúe usando las del proveedor del módulo.