物联笔记-5

最新推荐文章于 2024-04-01 08:54:32 发布
最新推荐文章于 2024-04-01 08:54:32 发布
阅读量683 收藏 1
点赞数
分类专栏： MCU 文章标签： c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/perceiving/article/details/123859346
版权

这次分享记录一下对mqtt框架的理解，这节课有点绕，看了两遍才勉强理清思路

一、大体思路介绍

1、网络通信通俗介绍

① mqtt是基于tcp上建立的长连接，所以需要分服务器端和客户端，客户端和服务器相连的时候需要有ip地址和端口号

② 服务器端是一个存储鉴别、转发的功能，客户端发送和接收报文，服务器根据客户端订阅的主题鉴别消息并投递

2、框架介绍

 二、详细源码介绍

首先：初始化客户端

mqtt_client_t *client = NULL;

int main(void)
{
	mqtt_message_t msg;
	memset(&msg, 0, sizeof(msg));

	1、实例化客户端
	client = mqtt_lease();

	//初始化客户端
	mqtt_set_port(client, "1883");
	mqtt_set_host(client, "47.114.187.247"); 
	mqtt_set_client_id(client, "clint_id");
	mqtt_set_user_name(client, "clint_name");
	mqtt_set_password(client, "clint_password");
	mqtt_set_clean_session(client, 1);

	2、连接服务器
	mqtt_connect(client);

	//初始化消息
	msg.payload = (void *)"first message";
	msg.qos = QOS0;
	msg.payloadlen = strlen(buf);

	3、发布消息
	mqtt_publish(client, "home", &msg);
	4、订阅消息
	mqtt_subscribe(client, "home", QOS0, smarthome_msg_handler);  

	while (1)
	{
		msg.payload = (void *)"test message";
		msg.qos = QOS0;
		msg.payloadlen = strlen(buf);
		err = mqtt_publish(client, "home", &msg);  
		osDelay(10000);
	}
}

下面依次阐述上面标黄的四个关键点

1、客户端实例化

mqtt_client_t *mqtt_lease(void)
{
    int rc;
    mqtt_client_t* c;
    分配空间
    c = (mqtt_client_t *)platform_memory_alloc(sizeof(mqtt_client_t));
    if (NULL == c)
        return NULL;
    memset(c, 0, sizeof(mqtt_client_t));
    初始化成员信息
    rc = mqtt_init(c);
    if (MQTT_SUCCESS_ERROR != rc)
        return NULL; 
    return c;
}

static int mqtt_init(mqtt_client_t* c)
{
    c->mqtt_network = (network_t*) platform_memory_alloc(sizeof(network_t));
    if (NULL == c->mqtt_network) 
	{
        ...
    }
    memset(c->mqtt_network, 0, sizeof(network_t));
    c->mqtt_packet_id = 1;
    c->mqtt_clean_session = 0;          //no clear session by default
    c->mqtt_will_flag = 0;
    c->mqtt_cmd_timeout = MQTT_DEFAULT_CMD_TIMEOUT;
    c->mqtt_client_state = CLIENT_STATE_INITIALIZED;   
    c->mqtt_ping_outstanding = 0;
    c->mqtt_ack_handler_number = 0;
    c->mqtt_client_id_len = 0;
    c->mqtt_user_name_len = 0;
    c->mqtt_password_len = 0;
    c->mqtt_keep_alive_interval = MQTT_KEEP_ALIVE_INTERVAL;
    c->mqtt_version = MQTT_VERSION;
    c->mqtt_reconnect_try_duration = MQTT_RECONNECT_DEFAULT_DURATION;
    c->mqtt_will_options = NULL;
    c->mqtt_reconnect_data = NULL;
    c->mqtt_reconnect_handler = NULL;
    c->mqtt_interceptor_handler = NULL;
    mqtt_list_init(&c->mqtt_msg_handler_list);
    mqtt_list_init(&c->mqtt_ack_handler_list);
    
    platform_mutex_init(&c->mqtt_write_lock);
    platform_mutex_init(&c->mqtt_global_lock);
    platform_timer_init(&c->mqtt_reconnect_timer);
    platform_timer_init(&c->mqtt_last_sent);
    platform_timer_init(&c->mqtt_last_received);
    RETURN_ERROR(MQTT_SUCCESS_ERROR);
}

2、连接服务器

int mqtt_connect(mqtt_client_t* c)
{
    return mqtt_connect_with_results(c);
}
static int mqtt_connect_with_results(mqtt_client_t* c)
{
    int len = 0;
    int rc = MQTT_CONNECT_FAILED_ERROR;
    platform_timer_t connect_timer;
    mqtt_connack_data_t connack_data = {0};
    MQTTPacket_connectData connect_data = MQTTPacket_connectData_initializer;

	//客户端实例成员参数检查
    if (c->...OK?)
    ....
	//网络初始化	
    rc = network_init(c->mqtt_network, c->mqtt_host, c->mqtt_port, NULL);
	（1）网络连接
    rc = network_connect(c->mqtt_network);
	
	//connect_data 初始化
    connect_data.keepAliveInterval 	= c->mqtt_keep_alive_interval;
    connect_data.cleansession 		= c->mqtt_clean_session;
    connect_data.MQTTVersion 		= c->mqtt_version;
    connect_data.clientID.cstring	= c->mqtt_client_id;
    connect_data.username.cstring 	= c->mqtt_user_name;
    connect_data.password.cstring 	= c->mqtt_password;

    //计数器减减
    platform_timer_cutdown(&c->mqtt_last_received, (c->mqtt_keep_alive_interval * 1000));
    platform_mutex_lock(&c->mqtt_write_lock);

    /* serialize connect packet */
    if ((len = MQTTSerialize_connect(
                        c->mqtt_write_buf, 
                        c->mqtt_write_buf_size, 
                        &connect_data)) <= 0)
        goto exit;    
	    //...
	
    （2）发送
    if ((rc = mqtt_send_packet(c, len, &connect_timer)) != MQTT_SUCCESS_ERROR)
        goto exit;
	（3）接收
    if (mqtt_wait_packet(c, CONNACK, &connect_timer) == CONNACK) 
	{
        if (MQTTDeserialize_connack(
            &connack_data.session_present, 
            &connack_data.rc, 
            c->mqtt_read_buf, 
            c->mqtt_read_buf_size) == 1) 
		{
            rc = connack_data.rc;
        }
        else {
            rc = MQTT_CONNECT_FAILED_ERROR;
        }
    } else {
        rc = MQTT_CONNECT_FAILED_ERROR;
    }
exit:
    if (rc == MQTT_SUCCESS_ERROR) 
	{
        if(NULL == c->mqtt_thread) 
		{
            （4）如果连接成功，则创建一个网络任务
            c->mqtt_thread= platform_thread_init(
                        "mqtt_yield_thread", 
                        mqtt_yield_thread,         //线程函数
                        c, 
                        MQTT_THREAD_STACK_SIZE,
                        MQTT_THREAD_PRIO, 
                        MQTT_THREAD_TICK);
        } 
		else 
		{
            mqtt_set_client_state(c, CLIENT_STATE_CONNECTED);  
        }
        c->mqtt_ping_outstanding = 0;       
    } 
	else 
	{
        mqtt_set_client_state(c, CLIENT_STATE_INITIALIZED); 
    }
    platform_mutex_unlock(&c->mqtt_write_lock);
    RETURN_ERROR(rc);
}

（1）network_connect(c->mqtt_network);

int network_connect(network_t *n)
{
    return nettype_tcp_connect(n);
}

int nettype_tcp_connect(network_t* n)
{
    n->socket = platform_net_socket_connect(n->host, n->port, PLATFORM_NET_PROTO_TCP);
	//...
}

int platform_net_socket_connect(const char *host, const char *port, int proto)
{
	ESP32  TCP连接服务器
}

（2）mqtt_send_packet(c, len, &connect_timer)

static int mqtt_send_packet(mqtt_client_t* c, int length, platform_timer_t* timer)
{
    //...
    while ((sent < length) && (!platform_timer_is_expired(timer))) {
        len = network_write(c->mqtt_network, &c->mqtt_write_buf[sent], length, platform_timer_remain(timer));
        if (len <= 0)  // there was an error writing the data
            break;
        sent += len;
    }
	//...
    RETURN_ERROR(MQTT_SEND_PACKET_ERROR);
}

int network_write(network_t *n, unsigned char *buf, int len, int timeout)
{
    return nettype_tcp_write(n, buf, len, timeout);
}

int nettype_tcp_write(network_t *n, unsigned char *write_buf, int len, int timeout)
{
    return platform_net_socket_write_timeout(n->socket, write_buf, len, timeout);
}

int platform_net_socket_write_timeout(int fd, unsigned char *buf, int len, int timeout)
{
	//ESP32 TCP发送
}

（3）mqtt_wait_packet(c, CONNACK, &connect_timer)

static int mqtt_wait_packet(mqtt_client_t* c, int packet_type, platform_timer_t* timer)
{
	//...
    rc = mqtt_packet_handle(c, timer);
	//...
}
static int mqtt_packet_handle(mqtt_client_t* c, platform_timer_t* timer)
{
    rc = mqtt_read_packet(c, &packet_type, timer);
    switch (packet_type) {
        case CONNACK: 
            goto exit;
		//...
    }
exit:
    if (rc == MQTT_SUCCESS_ERROR)
        rc = packet_type;
    RETURN_ERROR(rc);
}
static int mqtt_read_packet(mqtt_client_t* c, int* packet_type, platform_timer_t* timer)
{
    /* 1. read the header byte.  This has the packet type in it */
    rc = network_read(c->mqtt_network, c->mqtt_read_buf, len, platform_timer_remain(timer));
    /* 2. read the remaining length.  This is variable in itself */
    mqtt_decode_packet(c, &remain_len, platform_timer_remain(timer));
    /* 3. read the rest of the buffer using a callback to supply the rest of the data */
    if ((remain_len > 0) && ((rc = network_read(c->mqtt_network, c->mqtt_read_buf + len, remain_len, platform_timer_remain(
}
int network_read(network_t *n, unsigned char *buf, int len, int timeout)
{
    return nettype_tcp_read(n, buf, len, timeout);
}
int nettype_tcp_read(network_t *n, unsigned char *read_buf, int len, int timeout)
{
    return platform_net_socket_recv_timeout(n->socket, read_buf, len, timeout);
}
int platform_net_socket_recv_timeout(int fd, unsigned char *buf, int len, int timeout)
{
	ESP32 TCP接收
}

（4）创建线程任务：任务名称 mqtt_yield_thread

static void mqtt_yield_thread(void *arg)
{
    int rc;
    client_state_t state;
    mqtt_client_t *c = (mqtt_client_t *)arg;

    state = mqtt_get_client_state(c);
    if (CLIENT_STATE_CONNECTED !=  state) 
	{
        platform_thread_stop(c->mqtt_thread);   
    }
    while (1) 
	{
        rc = mqtt_yield(c, c->mqtt_cmd_timeout);
        if (? == rc) 
		{
            ...
        }
    }
exit:
    platform_thread_destroy(c->mqtt_thread);
}
static int mqtt_yield(mqtt_client_t* c, int timeout_ms)
{
	...
    while (!platform_timer_is_expired(&timer)) 
	{
        state = mqtt_get_client_state(c);
        if (CLIENT_STATE_CLEAN_SESSION ==  state) / else if (CLIENT_STATE_CONNECTED != state) 
		{
            ...
        }   
        /* mqtt connected, handle mqtt packet */
        rc = mqtt_packet_handle(c, &timer);
        if (rc >= 0) /else if (MQTT_NOT_CONNECT_ERROR == rc) /else 
		{
            ...
        } 
    }
    RETURN_ERROR(rc);
}
static int mqtt_packet_handle(mqtt_client_t* c, platform_timer_t* timer)
{
    int rc = MQTT_SUCCESS_ERROR;
    int packet_type = 0;
    
    rc = mqtt_read_packet(c, &packet_type, timer);

    switch (packet_type) {
        case 0:    break;

        case CONNACK:   goto exit;

        case PUBACK:
        case PUBCOMP:
            rc = mqtt_puback_and_pubcomp_packet_handle(c, timer);
            break;

        case SUBACK:
            rc = mqtt_suback_packet_handle(c, timer);
            break;
            
        case UNSUBACK:
            rc = mqtt_unsuback_packet_handle(c, timer);
            break;

        case PUBLISH:
            rc = mqtt_publish_packet_handle(c, timer);
            break;

        case PUBREC:
        case PUBREL:
            rc = mqtt_pubrec_and_pubrel_packet_handle(c, timer);
            break;

        case PINGRESP:
            c->mqtt_ping_outstanding = 0;    /* keep alive ping success */
            break;

        default:
            goto exit;
    }
    rc = mqtt_keep_alive(c);
exit:
    if (rc == MQTT_SUCCESS_ERROR)
        rc = packet_type;
    RETURN_ERROR(rc);
}

3、发布消息

int mqtt_publish(mqtt_client_t* c, const char* topic_filter, mqtt_message_t* msg)
{
    int len = 0;
    int rc = MQTT_FAILED_ERROR;
    platform_timer_t timer;
    MQTTString topic = MQTTString_initializer;
    topic.cstring = (char *)topic_filter;
    ...
    if ((NULL != msg->payload) && (0 == msg->payloadlen))
        msg->payloadlen = strlen((char*)msg->payload);
    platform_mutex_lock(&c->mqtt_write_lock);

    if (QOS0 != msg->qos) 
	{
        if (mqtt_ack_handler_is_maximum(c)) {
            rc = MQTT_ACK_HANDLER_NUM_TOO_MUCH_ERROR; 
            goto exit;
        }
        msg->id = mqtt_get_next_packet_id(c);
    }
    //发布消息---数据序列化
    len = MQTTSerialize_publish(c->mqtt_write_buf, c->mqtt_write_buf_size, 0, msg->qos, msg->retained, msg->id,topic, (uint8_t*)msg->payload, msg->payloadlen);
	...   
    if ((rc = mqtt_send_packet(c, len, &timer)) != MQTT_SUCCESS_ERROR)
        goto exit;
    if (QOS0 != msg->qos) {
	...
    }   
exit:
    msg->payloadlen = 0;       
    platform_mutex_unlock(&c->mqtt_write_lock);
    if ((MQTT_ACK_HANDLER_NUM_TOO_MUCH_ERROR == rc) || (MQTT_MEM_NOT_ENOUGH_ERROR == rc)) {
        ...
        mqtt_set_client_state(c, CLIENT_STATE_DISCONNECTED);
    }
    RETURN_ERROR(rc);     
}
mqtt_send_packet --> ...--> platform_net_socket_write_timeout(){ESP32...}

4、订阅消息

int mqtt_subscribe(mqtt_client_t* c, const char* topic_filter, mqtt_qos_t qos, message_handler_t handler)
{
	...
    uint16_t packet_id;
    platform_timer_t timer;
    MQTTString topic = MQTTString_initializer;
    topic.cstring = (char *)topic_filter;
	...
    packet_id = mqtt_get_next_packet_id(c);
	订阅消息---序列化数据
    len = MQTTSerialize_subscribe(c->mqtt_write_buf, c->mqtt_write_buf_size, 0, packet_id, 1, &topic, (int*)&qos);
	...
    if ((rc = mqtt_send_packet(c, len, &timer)) != MQTT_SUCCESS_ERROR)
        goto exit; 
    if (NULL == handler)
        handler = default_msg_handler;  
    msg_handler = mqtt_msg_handler_create(topic_filter, qos, handler);
    if (NULL == msg_handler) {
		platform_mutex_unlock(&c->mqtt_write_lock);  /* 100ask */
        RETURN_ERROR(MQTT_MEM_NOT_ENOUGH_ERROR);
    }
    rc = mqtt_ack_list_record(c, SUBACK, packet_id, len, msg_handler);
exit:
    platform_mutex_unlock(&c->mqtt_write_lock);
    RETURN_ERROR(rc);
}

最后记录一下老师提供的参考资料链接：

perceiving
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
MQTT断线重连及订阅消息恢复
qq_38334180的博客
04-27 1万+
MQTT断线重连及订阅消息恢复 注意注意，MQTT重连后需要重新订阅主题才能重新接收到消息 我这里使用的是 //设置断开后重新连接 options.setAutomaticReconnect(true); @Override public void connectionLost(Throwable throwable) { log.error("连接断开，下面做重连..."); long re
MQTT 持久会话与 Clean Session
wwwlyj123321的博客
04-10 2838
解释：publish不成功，一直发布，直到断开连接。
mqtt客户端连接Emq服务器，断开重连的connect 一直超时等待
热门推荐
weixin_42544153的博客
08-25 1万+
背景：当我们的设备更新完成，大量的设备重新连接到EMQ，导致EMQ 的cpu直接到100%，此时我的服务器在断开重连几次之后，就进入了线程等待状态，并且没有被唤醒，此时需要publish消息到EMQ,且本地一部处理receiver的的消息队列堆满，还能处理消息。 此时我陷入了一个误区，认为既然本地还有处理消息的日志，那么就代表客户端与emq仍然连接，可是我publish消息到EMQ时，却又异常消息“客户端未连接”，那么客户端与EMQ明显时断开了，那么到底有没又断开...... ...
物联网实战--入门篇之(七)嵌入式-MQTT
最新发布
ypp240124016的博客
04-01 3552
以paho mqtt为基础，结合esp8266 WIFI的收发，写一个mqtt的驱动文件
一个高性能、高稳定性的跨平台MQTT客户端——mqttclient设计与实现方式
杰杰的博客
06-15 6006
文章目录mqttclient设计与实现方式设计思想API接口MQTT客户端的核心结构mqttclient实现申请一个mqtt客户端释放已申请的mqtt客户端设置MQTT客户端的信息连接服务器订阅报文取消订阅发布报文内部线程核心的处理函数发布应答与发布完成报文的处理订阅应答报文的处理取消订阅应答报文的处理来自服务器的发布报文的处理发布收到与发布释放报文的处理 mqttclient设计与实现方式 设计思想 整体采用分层式设计，代码实现采用异步设计方式，降低耦合。 消息的处理使用回调的方式处理：用户指定订
智慧边缘计算物联解决方案.zip
09-02
5. **应用和服务**：基于边缘计算能力，开发各种物联网应用，如预测性维护、实时监控和智能分析。 6. **网络基础设施**：支持高速、低延迟的连接，保证边缘设备和云端之间的通信质量。 在实施智慧边缘计算物联解决...
PS笔记 本人制作
06-09
【Photoshop（PS）基础操作及效果制作】 ...以上是PS笔记中提及的一些基本操作和效果制作方法，掌握这些技巧可以极大地提高图像编辑效率，并创造出各种视觉效果。在实际操作中，可根据需要灵活组合使用。
人人学IoT———第三章学习笔记
01-06
窄带无线，海量物联 3.1 NB-IoT=Niubility？ NB——Narrow Band 是一项基于窄带的通信技术 发展历程： 2014.5：华为与vodafone签订NB-M2M 2015.5：第一次融合成“NB-CIoT” 2015.9：第二次融合“NB-IoT” NB-IoT在3...
物联网导论（内含笔记精简+全面）.one
07-13
物联网导论的一些知识点，有两个版本，适合不想看书和自己总结知识点的同学以及做考试准备
网络优化工程师实习笔记
08-07
NG-C 是 NG-RAN 和 5GC 之间的控制面接口，NG-U 是 NG-RAN 和 5GC 之间的用户面接口。Xn 接口是 NG-RAN 接口之间的接口。AMF 是 Access management function，UPF 是 User plane function。 三、基站设备 基站设备...
mqtt 数据关联
weixin_59638880的博客
03-26 493
1，分为订阅主题和发布主题 2，mqtt中创建的是订阅主题，案例中的实际情况就必须是发布主题 3，代码实现 data(){ devicelist: [ { name: '数据监测', isDevice: true, }, { name: '视频监测' }, { name: '远程操作' }, ], num: 0, btnnum: 0, act: 0
mqtt重连
pb951028的博客
03-25 2907
重新连接是针对与mqtt服务器的连接断开时，直接用mqttConnectOptions去重新连接 如果代码报错导致连接断开，则需要通过重新初始化去连接 package com.xw.elevator.platform.mqtt; import org.eclipse.paho.client.mqttv3.*; import org.eclipse.paho.client.mqtt...
MQTT 客户端自动重连最佳实践｜构建可靠 IoT 设备连接
emqx_broker的博客
03-30 2470
本文介绍在MQTT客户端代码实现过程中，自动重连逻辑设计的重要性与示例，帮助读者设计更为合理的重连代码，构建更加稳定可靠的物联网设备连接。
MQTT断开重连
Venus 的博客
06-24 4764
问题最近开发项目需要用到MQTT，开发完成测试的时候发现经常连接断开。由于没有报错信息，在万能的百度搜索看看有没有遇到同样问题的网友，结果发现可能是客户端ID的问题，我每次启动都是一样的客户端ID，之前的客户端ID在MQTT服务器上还保存着没有清理掉，再次启动客户端就连接不上。解决方法使用随机数生存客户端ID，重新启动，问题得到解决，不会一直连接断开。项目运行了几天发现又出现一个新问题，长时间没有操作连接还是会断开，无法发送和接收消息。在网上查阅MQTT相关文章，详细了解MQTT，发现MQTT有个自动重连功
mqtt请求不断创建连接
wdm891026的博客
11-09 1604
clinetId相同时,mqtt请求不断创建连接
stm32裸机实现mqtt遇到的问题和需要注意的地方
qq_44642831的博客
10-22 7779
stm32实现mqtt的发布和订阅遇到的问题和需要注意的地方 本文中使用的是正点原子的stm32f407系列，使用的是KEIL+stm32cubemx的构建方式，其中硬件驱动和lwip可以通过stm32cubemx直接配置进来，由此可以减少在底层驱动上消耗时间，可以更加专注于应用层的开发。 1.首先要让stm32单片机连上网，同时要清楚自己的网线另一头是接在什么地方的，如果是路由器上那么他是支持DHCP的方式来动态分配分配IP地址的，但是如果是交换机那就要看交换机是否具有DHCP的功能，一般情况下交换机是没
MQTT连接到阿里云物联
杰杰的博客
10-24 5815
连接到阿里云物联 既然懂得专门连接百度天工物接入，那么连接阿里云物联其实也是一样的，因为都是基于MQTT协议进行通信的，首先打开阿里云物联：https://iot.console.aliyun.com/product，创建账号并登陆，而且阿里云物联是需要通过实名认证才能使用的。 相对于百度天工物接入，阿里云物联的安全性更好，因为即使是客户端连接服务器都需要各种验证，还使用哈希加密算法进行加密。 使用阿里云物联 下面开始使用阿里云物联，首先在“产品”信息中创建一个产品，每个产品下允许有多个设备，产品就是设备的
mqtt协议实战（一）
知无涯
04-07 3673
背景 最近项目中用到了mqtt的协议，今天特地抽时间学习了一下，搭建了一个基于nodejs的mqtt的服务。现在写一篇文章记录，分享给大家。 本案例使用的nodejs，mqtt的代理服务是使用的是mosca。客户端使用的是mqtt.js。 其实网上也有几篇写mqtt的集成，但写的都很随便，时间也比较久，对于集成中的问 题，大多是一带而过，这篇文章我不仅带大家了解mqtt的主要特点，还交大家真正实战mqtt协议。 mqtt简介 如果有人问你什么是mqtt协议，有什么特点，你就用下面这段官方的话来回答他。 MQ
我的mqtt协议和emqttd开源项目个人理解（25） - 协议里面Clean Session为0和1的区别
$firecat利白的代码足迹$
10-13 1万+
一、基本概念 Session 会话 定义 定义：某个客户端（由ClientID作为标识）和某个服务器之间的逻辑层面的通信 生命周期（存在时间）：会话 &gt;= 网络连接 CleanSession 标记 在Connect时，由客户端设置  0 —— 开启会话重用机制。网络断开重连后，恢复之前的Session信息。需要客户端和服务器有相关Session持久化机制。 1 —— 关闭会话重用机制。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值