Linux应用-阿里云MQTT物联网实践

MQTT 是一种基于客户端服务端架构的发布/订阅模式的消息传输协议。它的设计思想是轻巧、开放、

简单、规范，易于实现。这些特点使得它对很多场景来说都是很好的选择，特别是对于受限的环境如机器与机器的通信（M2M）以及物联网环境（IoT）。 ----MQTT 协议中文版

MQTT 协议是为工作在低带宽、不可靠网络的远程传感器和控制设备之间的通讯而设计的协议，它具

有以下主要的几项特性：

①、 使用发布/订阅消息模式，提供一对多的消息发布，解除应用程序耦合。

②、基于 TCP/IP 提供网络连接。

主流的 MQTT 是基于 TCP 连接进行数据推送的，但是同样也有基于 UDP 的版本，叫做 MQTT-SN。这

两种版本由于基于不同的连接方式，优缺点自然也就各有不同了。

③、支持 QoS 服务质量等级。

根据消息的重要性不同设置不同的服务质量等级。

④、 小型传输， 开销很小，协议交换最小化，以降低网络流量。

这就是为什么在介绍里说它非常适合"在物联网领域，传感器与服务器的通信，信息的收集"，要知道嵌

入式设备的运算能力和带宽都相对薄弱，使用这种协议来传递消息再适合不过了， 在手机移动应用方面，

MQTT 是一种不错的 Android 消息推送方案。

⑤、使用 will 遗嘱机制来通知客户端异常断线。

⑥、基于主题发布/订阅消息，对负载内容屏蔽的消息传输。

⑦、支持心跳机制。

以上便是 MQTT 的主要特性了。

MQTT 是一种基于客户端-服务端架构的消息传输协议，所以在 MQTT 协议通信中，有两个最为重要的

角色，它们便是服务端和客户端。

服务端

MQTT 服务端通常是一台服务器（broker）， 它是 MQTT 信息传输的枢纽，负责将 MQTT 客户端发送

来的信息传递给 MQTT 客户端； MQTT 服务端还负责管理 MQTT 客户端，以确保客户端之间的通讯顺畅，

保证 MQTT 信息得以正确接收和准确投递。

客户端

MQTT 客户端可以向服务端发布信息，也可以从服务端收取信息； 我们把客户端发送信息的行为称为

“发布”信息。而客户端要想从服务端收取信息，则首先要向服务端“订阅”信息。“订阅”信息这一操作

很像我们在使用微信时“关注”了某个公众号， 当公众号的作者发布新的文章时， 微信官方会向关注了该公

众号的所有用户发送信息，告诉他们有新文章更新了，以便用户查看。

MQTT 主题

上面我们讲到了，客户端想要从服务器获取信息，首先需要订阅信息，那客户端如何订阅信息呢？这里

我们要引入“主题（Topic）”的概念，“主题”在 MQTT 通信中是一个非常重要的概念，客户端发布信息

以及订阅信息都是围绕“主题”来进行的，并且 MQTT 服务端在管理 MQTT 信息时，也是使用“主题”来

控制的。

客户端发布消息时需要为消息指定一个“主题”， 表示将消息发布到该主题；而对于订阅消息的客户端

来说，可通过订阅“主题” 来订阅消息，这样当其它客户端或自己（当前客户端）向该主题发布消息时，

MQTT 服务端就会将该主题的信息发送给该主题的订阅者（客户端）。

更细节的知识就不赘述了，我们快进到开发部分。

首先，我们可以在电脑上安装一个MQTT客户端软件MQTT_fx，这可以模拟一个客户端设备，去连接，服务端，订阅或发布消息。这对于我们的测试，开发很有用。http://mqttfx.jensd.de/，软件在官方下载。

然后就是MQTT的服务器了，阿里云为我们提供了免费的公共测试实例（当然也有收费的），我们可以用免费的物联网平台来作为MQTT服务端。

物联网平台 (aliyun.com)

来到这里，根据阿里云的文档，创建产品，创建设备等等

阿里云物联网平台 (aliyun.com)，阿里云的文档做的很详细，我就不赘述了。

我在这里创建了一个名叫MQTT_TEST的产品

以及创建了一个叫MQTT_TEST和MQTT_TEST_FX的设备，前者用于Linux平台，后者用于MQTT_FX的测试。

进入设备界面，我们可以查看关于这个设备的一些信息，这些信息对于我们的开发是必要的。

打开MQTT_FX，创建连接

在这个界面，我们需要填入的东西有很多，怎么来呢，不急，阿里云对这些比如账号，密码这些进行了加密处理（虽然不知道有啥用），我们可以用MQTT签名工具生成，这个网上很多。

MQTT-TCP连接通信 (aliyun.com)在这个文档中，介绍了一些参数的用处。

进入签名工具，按照指示填入信息，就可以生成密码。

服务器的地址，根据服务器的地区来填写，在官方文档中可以找到

再将MQTT_FX的框框填满，点击连接，就发现我们的设备上线了

然后我们测试一下订阅与发布。

在产品中查看TOPIC类列表，这里阿里云提供了很多功能的topic，也可以自己定义topic。

我们自定义一个叫test的topic(这里可以的topic名必须满足阿里云的规定，在${devicename}这一级下，阿里云对M2M通过主题直接通信做了限制，必须按照阿里云的规定，或者基于服务端SDK开发服务端处理程序来实现M2M的通信，比如路由)

然后在MQTT_FX中订阅及发布

发布消息

订阅到这条消息

同时，在云平台的日志服务中，也可以看到这一条消息

至此，我们已经体验了一波MQTT的快乐了，接下来就是更加快乐的Linux平台程序的设计。

我们首先，在MQTT官网Software (mqtt.org)，下载MQTT源代码，这里选择paho embedded c版的源码，下载后，进入该文件夹。

我们可以在demo程序的基础上进行开发，进入MQTTCLIENT-C/SANMPLES/LINUX子文件夹，这里存放着linux平台的实例程序。

先前提到，阿里云对其密码做了加密处理，我们难道每次都要用签名工具生成吗，当然不是，阿里云提供了转换的程序aiot_mqtt_sign.c

/*
 * Copyright (C) 2015-2019 Alibaba Group Holding Limited
 */

#include 
#include 
#include 
#include 

#define PRODUCTKEY_MAXLEN           (20)
#define DEVICENAME_MAXLEN           (32)
#define DEVICESECRET_MAXLEN         (64)

#define SIGN_SOURCE_MAXLEN          (200)
#define CLIENTID_MAXLEN             (150)
#define USERNAME_MAXLEN             (64)
#define PASSWORD_MAXLEN             (65)

#define TIMESTAMP_VALUE             "2524608000000"
#define MQTT_CLINETID_KV            "|timestamp=2524608000000,_v=paho-c-1.0.0,securemode=3,signmethod=hmacsha256,lan=C|"

static void utils_hmac_sha256(const uint8_t *msg, uint32_t msg_len, const uint8_t *key, uint32_t key_len, uint8_t output[32]);

static void _hex2str(uint8_t *input, uint16_t input_len, char *output)
{
    char *zEncode = "0123456789ABCDEF";
    int i = 0, j = 0;

    for (i = 0; i < input_len; i++) {
        output[j++] = zEncode[(input[i] >> 4) & 0xf];
        output[j++] = zEncode[(input[i]) & 0xf];
    }
}

int aiotMqttSign(const char *productKey, const char *deviceName, const char *deviceSecret, 
                     char clientId[150], char username[64], char password[65])
{
    char deviceId[PRODUCTKEY_MAXLEN + DEVICENAME_MAXLEN + 2] = {0};
    char macSrc[SIGN_SOURCE_MAXLEN] = {0};
    uint8_t macRes[32] = {0};
    int res;

    /* check parameters */
    if (productKey == NULL || deviceName == NULL || deviceSecret == NULL ||
        clientId == NULL || username == NULL || password == NULL) {
        return -1;
    }
    if ((strlen(productKey) > PRODUCTKEY_MAXLEN) || (strlen(deviceName) > DEVICENAME_MAXLEN) ||
        (strlen(deviceSecret) > DEVICESECRET_MAXLEN)) {
        return -1;
    }

    /* setup deviceId */
    memcpy(deviceId, deviceName, strlen(deviceName));
    memcpy(deviceId + strlen(deviceId), "&", strlen("&"));
    memcpy(deviceId + strlen(deviceId), productKey, strlen(productKey));

    /* setup clientid */
    memcpy(clientId, deviceId, strlen(deviceId));
    memcpy(clientId + strlen(deviceId), MQTT_CLINETID_KV, strlen(MQTT_CLINETID_KV));
    memset(clientId + strlen(deviceId) + strlen(MQTT_CLINETID_KV), 0, 1);

    /* setup username */
    memcpy(username, deviceId, strlen(deviceId));
    memset(username + strlen(deviceId), 0, 1);

    /* setup password */
    memcpy(macSrc, "clientId", strlen("clientId"));
    memcpy(macSrc + strlen(macSrc), deviceId, strlen(deviceId));
    memcpy(macSrc + strlen(macSrc), "deviceName", strlen("deviceName"));
    memcpy(macSrc + strlen(macSrc), deviceName, strlen(deviceName));
    memcpy(macSrc + strlen(macSrc), "productKey", strlen("productKey"));
    memcpy(macSrc + strlen(macSrc), productKey, strlen(productKey));
    memcpy(macSrc + strlen(macSrc), "timestamp", strlen("timestamp"));
    memcpy(macSrc + strlen(macSrc), TIMESTAMP_VALUE, strlen(TIMESTAMP_VALUE));

    utils_hmac_sha256((uint8_t *)macSrc, strlen(macSrc), (uint8_t *)deviceSecret,
                      strlen(deviceSecret), macRes);

    memset(password, 0, PASSWORD_MAXLEN);
    _hex2str(macRes, sizeof(macRes), password);
    return 0;
}

/******************************
 * hmac-sha256 implement below
 ******************************/
#define SHA256_KEY_IOPAD_SIZE   (64)
#define SHA256_DIGEST_SIZE      (32)

/**
 * \brief          SHA-256 context structure
 */
typedef struct {
    uint32_t total[2];          /*!< number of bytes processed  */
    uint32_t state[8];          /*!< intermediate digest state  */
    unsigned char buffer[64];   /*!< data block being processed */
    int is224;                  /*!< 0 => SHA-256, else SHA-224 */
} iot_sha256_context;

typedef union {
    char sptr[8];
    uint64_t lint;
} u_retLen;

/*
 * 32-bit integer manipulation macros (big endian)
 */
#ifndef GET_UINT32_BE
#define GET_UINT32_BE(n,b,i)                                \
    do {                                                    \
        (n) = ( (uint32_t) (b)[(i)    ] << 24 )             \
              | ( (uint32_t) (b)[(i) + 1] << 16 )           \
              | ( (uint32_t) (b)[(i) + 2] <<  8 )           \
              | ( (uint32_t) (b)[(i) + 3]       );          \
    } while( 0 )
#endif

#ifndef PUT_UINT32_BE
#define PUT_UINT32_BE(n,b,i)                                \
    do {                                                    \
        (b)[(i)    ] = (unsigned char) ( (n) >> 24 );       \
        (b)[(i) + 1] = (unsigned char) ( (n) >> 16 );       \
        (b)[(i) + 2] = (unsigned char) ( (n) >>  8 );       \
        (b)[(i) + 3] = (unsigned char) ( (n)       );       \
    } while( 0 )
#endif


static void utils_sha256_zeroize(void *v, uint32_t n)
{
    volatile unsigned char *p = v;
    while (n--) {
        *p++ = 0;
    }
}

void utils_sha256_init(iot_sha256_context *ctx)
{
    memset(ctx, 0, sizeof(iot_sha256_context));
}

void utils_sha256_free(iot_sha256_context *ctx)
{
    if (NULL == ctx) {
        return;
    }

    utils_sha256_zeroize(ctx, sizeof(iot_sha256_context));
}

void utils_sha256_starts(iot_sha256_context *ctx)
{
    int is224 = 0;
    ctx->total[0] = 0;
    ctx->total[1] = 0;

    if (is224 == 0) {
        /* SHA-256 */
        ctx->state[0] = 0x6A09E667;
        ctx->state[1] = 0xBB67AE85;
        ctx->state[2] = 0x3C6EF372;
        ctx->state[3] = 0xA54FF53A;
        ctx->state[4] = 0x510E527F;
        ctx->state[5] = 0x9B05688C;
        ctx->state[6] = 0x1F83D9AB;
        ctx->state[7] = 0x5BE0CD19;
    }

    ctx->is224 = is224;
}

static const uint32_t K[] = {
    0x428A2F98, 0x71374491, 0xB5C0FBCF, 0xE9B5DBA5,
    0x3956C25B, 0x59F111F1, 0x923F82A4, 0xAB1C5ED5,
    0xD807AA98, 0x12835B01, 0x243185BE, 0x550C7DC3,
    0x72BE5D74, 0x80DEB1FE, 0x9BDC06A7, 0xC19BF174,
    0xE49B69C1, 0xEFBE4786, 0x0FC19DC6, 0x240CA1CC,
    0x2DE92C6F, 0x4A7484AA, 0x5CB0A9DC, 0x76F988DA,
    0x983E5152, 0xA831C66D, 0xB00327C8, 0xBF597FC7,
    0xC6E00BF3, 0xD5A79147, 0x06CA6351, 0x14292967,
    0x27B70A85, 0x2E1B2138, 0x4D2C6DFC, 0x53380D13,
    0x650A7354, 0x766A0ABB, 0x81C2C92E, 0x92722C85,
    0xA2BFE8A1, 0xA81A664B, 0xC24B8B70, 0xC76C51A3,
    0xD192E819, 0xD6990624, 0xF40E3585, 0x106AA070,
    0x19A4C116, 0x1E376C08, 0x2748774C, 0x34B0BCB5,
    0x391C0CB3, 0x4ED8AA4A, 0x5B9CCA4F, 0x682E6FF3,
    0x748F82EE, 0x78A5636F, 0x84C87814, 0x8CC70208,
    0x90BEFFFA, 0xA4506CEB, 0xBEF9A3F7, 0xC67178F2,
};

#define  SHR(x,n) ((x & 0xFFFFFFFF) >> n)
#define ROTR(x,n) (SHR(x,n) | (x << (32 - n)))

#define S0(x) (ROTR(x, 7) ^ ROTR(x,18) ^  SHR(x, 3))
#define S1(x) (ROTR(x,17) ^ ROTR(x,19) ^  SHR(x,10))

#define S2(x) (ROTR(x, 2) ^ ROTR(x,13) ^ ROTR(x,22))
#define S3(x) (ROTR(x, 6) ^ ROTR(x,11) ^ ROTR(x,25))

#define F0(x,y,z) ((x & y) | (z & (x | y)))
#define F1(x,y,z) (z ^ (x & (y ^ z)))

#define R(t)                                        \
    (                                               \
            W[t] = S1(W[t -  2]) + W[t -  7] +      \
                   S0(W[t - 15]) + W[t - 16]        \
    )

#define P(a,b,c,d,e,f,g,h,x,K)                      \
    {                                               \
        temp1 = h + S3(e) + F1(e,f,g) + K + x;      \
        temp2 = S2(a) + F0(a,b,c);                  \
        d += temp1; h = temp1 + temp2;              \
    }

void utils_sha256_process(iot_sha256_context *ctx, const unsigned char data[64])
{
    uint32_t temp1, temp2, W[64];
    uint32_t A[8];
    unsigned int i;

    for (i = 0; i < 8; i++) {
        A[i] = ctx->state[i];
    }

    for (i = 0; i < 64; i++) {
        if (i < 16) {
            GET_UINT32_BE(W[i], data, 4 * i);
        } else {
            R(i);
        }

        P(A[0], A[1], A[2], A[3], A[4], A[5], A[6], A[7], W[i], K[i]);

        temp1 = A[7];
        A[7] = A[6];
        A[6] = A[5];
        A[5] = A[4];
        A[4] = A[3];
        A[3] = A[2];
        A[2] = A[1];
        A[1] = A[0];
        A[0] = temp1;
    }

    for (i = 0; i < 8; i++) {
        ctx->state[i] += A[i];
    }
}
void utils_sha256_update(iot_sha256_context *ctx, const unsigned char *input, uint32_t ilen)
{
    size_t fill;
    uint32_t left;

    if (ilen == 0) {
        return;
    }

    left = ctx->total[0] & 0x3F;
    fill = 64 - left;

    ctx->total[0] += (uint32_t) ilen;
    ctx->total[0] &= 0xFFFFFFFF;

    if (ctx->total[0] < (uint32_t) ilen) {
        ctx->total[1]++;
    }

    if (left && ilen >= fill) {
        memcpy((void *)(ctx->buffer + left), input, fill);
        utils_sha256_process(ctx, ctx->buffer);
        input += fill;
        ilen  -= fill;
        left = 0;
    }

    while (ilen >= 64) {
        utils_sha256_process(ctx, input);
        input += 64;
        ilen  -= 64;
    }

    if (ilen > 0) {
        memcpy((void *)(ctx->buffer + left), input, ilen);
    }
}

static const unsigned char sha256_padding[64] = {
    0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
};

void utils_sha256_finish(iot_sha256_context *ctx, uint8_t output[32])
{
    uint32_t last, padn;
    uint32_t high, low;
    unsigned char msglen[8];

    high = (ctx->total[0] >> 29)
           | (ctx->total[1] <<  3);
    low  = (ctx->total[0] <<  3);

    PUT_UINT32_BE(high, msglen, 0);
    PUT_UINT32_BE(low,  msglen, 4);

    last = ctx->total[0] & 0x3F;
    padn = (last < 56) ? (56 - last) : (120 - last);

    utils_sha256_update(ctx, sha256_padding, padn);
    utils_sha256_update(ctx, msglen, 8);

    PUT_UINT32_BE(ctx->state[0], output,  0);
    PUT_UINT32_BE(ctx->state[1], output,  4);
    PUT_UINT32_BE(ctx->state[2], output,  8);
    PUT_UINT32_BE(ctx->state[3], output, 12);
    PUT_UINT32_BE(ctx->state[4], output, 16);
    PUT_UINT32_BE(ctx->state[5], output, 20);
    PUT_UINT32_BE(ctx->state[6], output, 24);

    if (ctx->is224 == 0) {
        PUT_UINT32_BE(ctx->state[7], output, 28);
    }
}

void utils_sha256(const uint8_t *input, uint32_t ilen, uint8_t output[32])
{
    iot_sha256_context ctx;

    utils_sha256_init(&ctx);
    utils_sha256_starts(&ctx);
    utils_sha256_update(&ctx, input, ilen);
    utils_sha256_finish(&ctx, output);
    utils_sha256_free(&ctx);
}

static void utils_hmac_sha256(const uint8_t *msg, uint32_t msg_len, const uint8_t *key, uint32_t key_len, uint8_t output[32])
{
    iot_sha256_context context;
    uint8_t k_ipad[SHA256_KEY_IOPAD_SIZE];    /* inner padding - key XORd with ipad  */
    uint8_t k_opad[SHA256_KEY_IOPAD_SIZE];    /* outer padding - key XORd with opad */
    int32_t i;

    if ((NULL == msg) || (NULL == key) || (NULL == output)) {
        return;
    }

    if (key_len > SHA256_KEY_IOPAD_SIZE) {
        return;
    }

    /* start out by storing key in pads */
    memset(k_ipad, 0, sizeof(k_ipad));
    memset(k_opad, 0, sizeof(k_opad));
    memcpy(k_ipad, key, key_len);
    memcpy(k_opad, key, key_len);

    /* XOR key with ipad and opad values */
    for (i = 0; i < SHA256_KEY_IOPAD_SIZE; i++) {
        k_ipad[i] ^= 0x36;
        k_opad[i] ^= 0x5c;
    }

    /* perform inner SHA */
    utils_sha256_init(&context);                                      /* init context for 1st pass */
    utils_sha256_starts(&context);                                    /* setup context for 1st pass */
    utils_sha256_update(&context, k_ipad, SHA256_KEY_IOPAD_SIZE);     /* start with inner pad */
    utils_sha256_update(&context, msg, msg_len);                      /* then text of datagram */
    utils_sha256_finish(&context, output);                            /* finish up 1st pass */

    /* perform outer SHA */
    utils_sha256_init(&context);                              /* init context for 2nd pass */
    utils_sha256_starts(&context);                            /* setup context for 2nd pass */
    utils_sha256_update(&context, k_opad, SHA256_KEY_IOPAD_SIZE);    /* start with outer pad */
    utils_sha256_update(&context, output, SHA256_DIGEST_SIZE);     /* then results of 1st hash */
    utils_sha256_finish(&context, output);                       /* finish up 2nd pass */
}

将这个文件存入linux文件夹中

再在demo程序的基础上进行修改

aiot_c_demo.c

#include 
#include 
#include "/home/jiaojiao/桌面/嵌入式开发/例程源码/11、Linux C应用编程例程源码/paho.mqtt.embedded-c/MQTTClient-C/src/MQTTClient.h"

#include 
#include 
#include 

#define EXAMPLE_PRODUCT_KEY            "guuyg6zYeMa"
#define EXAMPLE_DEVICE_NAME            "MQTT_TEST"
#define EXAMPLE_DEVICE_SECRET       "b4dfaa4b05dda4506e2d1c0004a043c4"

/* declare the external function aiotMqttSign() */
extern int aiotMqttSign(const char *productKey, const char *deviceName, const char *deviceSecret, 
                         char clientId[150], char username[65], char password[65]);

volatile int toStop = 0;

void cfinish(int sig)
{
    signal(SIGINT, NULL);
    toStop = 1;
}

void messageArrived(MessageData* md)
{
    MQTTMessage* message = md->message;

    printf("%.*s\t", md->topicName->lenstring.len, md->topicName->lenstring.data);
    printf("%.*s\n", (int)message->payloadlen, (char*)message->payload);
}

/* main function */
int main(int argc, char** argv)
{
    int rc = 0;

    /* setup the buffer, it must big enough for aliyun IoT platform */
    unsigned char buf[1000];
    unsigned char readbuf[1000];

    Network n;
    MQTTClient c;
    char *host = EXAMPLE_PRODUCT_KEY".iot-as-mqtt.cn-shanghai.aliyuncs.com";
    short port = 443;
    const char *subTopic = "/"EXAMPLE_PRODUCT_KEY"/"EXAMPLE_DEVICE_NAME"/user/get";
    const char *pubTopic = "/"EXAMPLE_PRODUCT_KEY"/"EXAMPLE_DEVICE_NAME"/user/update";
    const char *testTopic = "/"EXAMPLE_PRODUCT_KEY"/""MQTT_TEST/user/test";

    /* invoke aiotMqttSign to generate mqtt connect parameters */
    char clientId[150] = {0};
    char username[65] = {0};
    char password[65] = {0};

    if ((rc = aiotMqttSign(EXAMPLE_PRODUCT_KEY, EXAMPLE_DEVICE_NAME, EXAMPLE_DEVICE_SECRET, clientId, username, password) < 0)) {
        printf("aiotMqttSign -%0x4x\n", -rc);
        return -1;
    }
    printf("clientid: %s\n", clientId);
    printf("username: %s\n", username);
    printf("password: %s\n", password);

    signal(SIGINT, cfinish);
    signal(SIGTERM, cfinish);

    /* network init and establish network to aliyun IoT platform */
    NetworkInit(&n);
    rc = NetworkConnect(&n, host, port);
    printf("NetworkConnect %d\n", rc);

    /* init mqtt client */
    MQTTClientInit(&c, &n, 1000, buf, sizeof(buf), readbuf, sizeof(readbuf));
 
    /* set the default message handler */
    c.defaultMessageHandler = messageArrived;

    /* set mqtt connect parameter */
    MQTTPacket_connectData data = MQTTPacket_connectData_initializer;       
    data.willFlag = 0;
    data.MQTTVersion = 3;
    data.clientID.cstring = clientId;
    data.username.cstring = username;
    data.password.cstring = password;
    data.keepAliveInterval = 60;
    data.cleansession = 1;
    printf("Connecting to %s %d\n", host, port);

    rc = MQTTConnect(&c, &data);
    printf("MQTTConnect %d, Connect aliyun IoT Cloud Success!\n", rc);
    
    printf("Subscribing to %s\n", subTopic);
    rc = MQTTSubscribe(&c, subTopic, 1, messageArrived);
    printf("MQTTSubscribe %d\n", rc);

    int cnt = 0;
    unsigned int msgid = 0;
    while (!toStop)
    {
        MQTTYield(&c, 1000);    

        if (++cnt % 5 == 0) {
            MQTTMessage msg = {
                QOS1, 
                0,
                0,
                0,
                "Hello world",
                strlen("Hello world"),
            };
            msg.id = ++msgid;
            rc = MQTTPublish(&c, testTopic, &msg);
            printf("MQTTPublish %d, msgid %d\n", rc, msgid);
        }
    }

    printf("Stopping\n");

    MQTTDisconnect(&c);
    NetworkDisconnect(&n);

    return 0;
}

Paho-MQTT C（嵌入式版）接入示例 (aliyun.com)这个文档是阿里云官方的嵌入式设备接入的C教程

之后进行编译

add_executable(

  aiot_c_demo

  aiot_c_demo.c

  aiot_mqtt_sign.c

)



target_link_libraries(aiot_c_demo paho-embed-mqtt3cc paho-embed-mqtt3c)

target_include_directories(aiot_c_demo PRIVATE "../../src" "../../src/linux")

target_compile_definitions(aiot_c_demo PRIVATE MQTTCLIENT_PLATFORM_HEADER=MQTTLinux.h)

将这些添加进linux文件夹级的cmakelists后，回到源文件的第一级文件夹进行编译得到可执行文件，之后运行本地日志如下

也可以看到我们的MQTT_TEST设备上线，发布的消息也可以在日志中看到。

到这里，我们还剩下把这个程序，在arm设备上跑起来，真正扮演一个MQTT设备的角色，我们需要对MQTT进行交叉编译。

以这个编译器配置文件作为实例，将其拷贝入linux文件夹

编译器配置文件

##################################
# 配置 ARM 交叉编译
#################################
set(CMAKE_SYSTEM_NAME Linux) #设置目标系统名字
set(CMAKE_SYSTEM_PROCESSOR arm) #设置目标处理器架构
# 指定编译器的 sysroot 路径
set(TOOLCHAIN_DIR /opt/fsl-imx-x11/4.1.15-2.1.0/sysroots)
set(CMAKE_SYSROOT ${TOOLCHAIN_DIR}/cortexa7hf-neon-poky-linux-gnueabi)
# 指定交叉编译器 arm-linux-gcc 和 arm-linux-g++
set(CMAKE_C_COMPILER ${TOOLCHAIN_DIR}/x86_64-pokysdk-linux/usr/bin/arm-poky-linux-gnueabi/arm-poky-linux-gnueabi-gcc)
set(CMAKE_CXX_COMPILER ${TOOLCHAIN_DIR}/x86_64-pokysdk-linux/usr/bin/arm-poky-linux-gnueabi/arm-poky-linux-gnueabi-g++)
# 为编译器添加编译选项
set(CMAKE_C_FLAGS "-march=armv7ve -mfpu=neon -mfloat-abi=hard -mcpu=cortex-a7")
set(CMAKE_CXX_FLAGS "-march=armv7ve -mfpu=neon -mfloat-abi=hard -mcpu=cortex-a7")
set(CMAKE_FIND_ROOT_PATH_MODE_PROGRAM NEVER)
set(CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY)
set(CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY)
#################################
# end
##################################

cmake的shell

cmake -DCMAKE_BUILD_TYPE=Release -
DCMAKE_INSTALL_PREFIX=./install -
DCMAKE_TOOLCHAIN_FILE=../cmake/arm-linux-setup.cmake -DPAHO_WITH_SSL=TRUE -
DPAHO_BUILD_SAMPLES=TRUE ..

然后创建build,install文件夹，在build文件夹中cmake,然后make make install，最后得到arm版的库文件。

然后修改cmakelists文件

cmake_minimum_required(VERSION 3.16)

project(mqtt)

include(./arm-linux-setup.cmake)



add_executable(

  aiot_c_demo

  aiot_c_demo.c

  aiot_mqtt_sign.c

)



target_link_libraries(aiot_c_demo paho-embed-mqtt3cc paho-embed-mqtt3c)

target_include_directories(aiot_c_demo PRIVATE "../../src" "../../src/linux" "/usr/lib" "../../../build")

target_compile_definitions(aiot_c_demo PRIVATE MQTTCLIENT_PLATFORM_HEADER=MQTTLinux.h)

之后编译过程就跟上文在x86平台一致了，最终得到arm版可执行文件，在板子上运行成功。

（吐槽一下，阿里云免费版MQTT的限制也太多了吧，把MQTT魔改一通，真是互联网大厂啊，嵌入式地位低微，能让纯软件搞的绝对不让嵌入式插手，服务端都没有C语言SDK，难受）

这里推荐一个免费的MQTT测试平台，还原了MQTT原生的样子，可以体验最舒服的MQTT开发，有时间也会写这个的博客，这个平台叫然也物联，通过申请后就可以得到用户名，用户id和密码，开发起来比阿里云的条条框框舒服多了。