精华内容
下载资源
问答
  • 2022-03-17 18:34:28

    今天在和其他的平台对接的时候,程序原来可以运行,传输一两次之后程序就不运行了,而且配置的端口也不能使用,从新启动可以使用,传输一次数据就死机。这个是一个很严重的问题,以为是程序的内存泄露的问题,就把传输的数据量改小,可是还是出现同样的问题。接着考虑是不是平台的问题,想到连接到以前常用的网站试试,可是还是死机。又查找了一遍,居然是端口号写错了。但是程序还是存在问题,主要有:

    1.连接不到服务器,出现程序死机的问题。主要考虑如何处理连接不到服务器,程序如何判断和如何运行。

    2.服务器关闭后,如何实现重新连接的情况。

    以上的问题亟待解决,继续努力,查找方案。

    更多相关内容
  • 基于stm32f103c8单片机运行,使用w5500模块开发的MQTT协议,支持接收与发送。下载完程序后,完成是MCU通过SPI2对w5500的读写操作,完成对IP,mac,gateway等的操作, 设置成功的话,会通过串口1把网络参数打印到串口...
  • STM32+W5500 MQTT例程 附详细讲解

    热门讨论 2018-01-26 09:59:54
    通过一个实例,讲解了MQTT 在智能家居中的应用。硬件采用W5500EVB。
  • 嵌入式微操作系统学习,STM32+W5500 MQTT例程和说明+F407探索者+LWIP+UCOSIII+UCOSII
  • stm32操作系统的学习操作,大家可以参考学习,STM32F4x7+freertos+lwip+ssl+MQTT-(MDK5)稳定可靠+W5500 MQTT例程和说明+LWIP+UCOSIII+UCOSII
  • 用STM32通过W5500实现MQTT客户端的部署 ,对于MQTT的学习具有参考意义
  • 使用STM32 W5500MQTT Client,使得数据上传broker,并接收broker传来的消息,并支持断网/拔网线再插入网线能够重新连接broker这样的功能,需要具备以下条件: 1、STM32 W5500基础入网配置,使能PC电脑端可以PING...

    使用STM32 W5500做MQTT Client,使得数据上传broker,并接收broker传来的消息,并支持断网/拔网线再插入网线能够重新连接broker这样的功能,需要具备以下条件:

    1、STM32 W5500基础入网配置,使能PC电脑端可以PING通W5500。

    2、STM32 W5500的TCP Client收发数据的回环测试没有问题。

    3、了解MQTT协议。

    关于MQTT的介绍,本文不做重点。需要了解的是MQTT协议是基于TCP协议之上封装的协议。

    关于MQTT Client依赖的MQTT支持库函数,下载地址 《MQTT C语言库函数》

    这些库函数是干嘛的?

    MQTT协议在STM32 W5500中使用的前提,首先通过TCP连接到broker指定的IP和端口。

    然后需要发送MQTT连接的指令,这个指令内容是通过 "MQTTConnectClient.c"文件中的

    int MQTTSerialize_connect(unsigned char* buf, int buflen, MQTTPacket_connectData* options)

    这个方法来实现组装的,返回值大于0表示组装后的数组有效内容长度,在通过W5500的send方法,发送给broker。

    broker接收到Client端发来的MQTT连接请求后,会返回一组数据,判断是否连接成功,或者各种失败(协议版本错误,用户名密码错误等)。

    MQTT Client如果想要接收到broker发来的消息,需要先订阅主题,订阅主题的指令内容是通过"MQTTSubscribeClient.c"文件中的

    int MQTTSerialize_subscribe(unsigned char* buf, int buflen, unsigned char dup, unsigned short packetid, int count,
    		MQTTString topicFilters[], int requestedQoSs[])

    这个方法来实现组装的,同样返回值大于0表示组装后的数组有效内容长度,在通过W5500的send方法,发送给broker。

    以上两个举例都是组装指令内容。

    那么接收到broker发来消息,如何解析?

    "MQTTDeserializePublish.c"这个文件的

    int MQTTDeserialize_publish(unsigned char* dup, int* qos, unsigned char* retained, unsigned short* packetid, MQTTString* topicName,
    		unsigned char** payload, int* payloadlen, unsigned char* buf, int buflen)

    这个方法可以实现消息内容的解析。

    总之,依赖的MQTT支持库函数几乎可以使我们不用在乎协议的具体内容,就可以实现MQTT Client的功能。

    STM32 W5500 MQTT Client端,我通过枚举类型给它定义三种状态

    enum MQTT_STATE {MQTT_INIT, MQTT_CONNOK, MQTT_SUBOK};

    MQTT_INIT - 初始状态(MQTT未连接,未订阅,注意是MQTT的,而不是TCP连接了没有

    MQTT_CONNOK - MQTT连接成功(MQTT Client端发起MQTT连接,并接收到了broker返回连接成功)

    MQTT_SUBOK - MQTT订阅成功(MQTT Client端想broker订阅消息,并受到了broker返回订阅成功)

    这几种状态的关连,在程序开始执行时,MQTT Client端处于MQTT_INIT状态,或者程序执行一段时间后,MQTT PING指令发几次broker没有回复,认为MQTT Client端处于MQTT_INIT状态。

    MQTT Client端处于MQTT_CONNOK 状态时可以发布数据到broker,但是无法接收来自broker的消息。

    MQTT Client端处于MQTT_SUBOK 状态时可以发布数据到broker,也可以接收来自broker的消息。

    如果TCP Client处于CLOSE的状态,那么MQTT Client端将处于MQTT_INIT 状态。

    做好MQTT Client端的难点在于维系 TCP socket的状态与MQTT Client的状态的关系。

    贴出我实现MQTT Client的c代码:

    impl_mqtt.c

    #ifndef __IMPL_MQTT_H
    #define __IMPL_MQTT_H
    #include "impl_mqtt.h"
    #endif
    
    int mqttstate = MQTT_INIT;
    int cnt_ping_not_response = 0;
    int cnt_sock_init = 0;
    u8 buf_pub[1024];
    u32 ping_timestamp, now_timestamp;
    
    int func_tcp_sock_send(u8 sockno, u8 *buf_mqsend, u16 len_mqsend)
    {
    	if(getSn_SR(sockno) == SOCK_ESTABLISHED)
    	{
    		return send(sockno, buf_mqsend, len_mqsend);
    	}
    	return -1;		
    }
    
    int func_tcp_sock_read(u8 sockno, u8 *buf_mqrecv, u16 len_mqrecv)
    {
    	if((getSn_SR(sockno) == SOCK_ESTABLISHED))
    	{
    		len_mqrecv = getSn_RX_RSR(sockno);
    		if(len_mqrecv > 0)
    		{
    			return recv(sockno, buf_mqrecv, len_mqrecv);
    		}
    	}
    	return -1; 
    }
    
    void func_judge_timeout_ms(u32 *timespan)
    {
    	delay_ms(1);
    	*timespan = *timespan + 1;
    }
    
    u8 func_judge_mqtt_recvmsg_package_type(u8 *buf_mqrecv, u16 len_mqrecv)
    {
    	MQTTHeader header = {0};
    	if(len_mqrecv > 0)
    	{
    		header.byte = buf_mqrecv[0];
    		return header.bits.type;
    	}
    	return 0;
    }
    
    void func_mqtt_client_dealwith_recvmsg(u8 sockno, u8 *buf_mqrecv, u16 len_mqbuf, u16 len_mqrecv)
    {
    	if(len_mqrecv > 0)
    	{
    		ping_timestamp = get_systick_timestamp();
    		// package type to deal
    		switch(func_judge_mqtt_recvmsg_package_type(buf_mqrecv, len_mqrecv))
    		{
    			case CONNACK:
    			break;
    			case PUBLISH://analysis msg
    			{
    				int rc;
    				u8 buf_recv[1024];
    				u8* payload;
    				int len_payload;
    				unsigned char retained, dup;
    				int qos;
    				unsigned short packetid; 
    				MQTTString topicrecv;
    				MQTTString topicpub;
    				payload = buf_recv;
    				rc = MQTTDeserialize_publish(&dup, &qos, &retained, &packetid, &topicrecv, &payload, &len_payload, buf_mqrecv, len_mqrecv);
    				if(rc == 1)
    				{
    					//TODO ...
    					//TEST code
    					topicpub.cstring = (char*)"mytopic";
    					memset(buf_pub, 0, sizeof(buf_pub));
    					func_run_mqtt_publish(sockno, buf_pub, sizeof(buf_pub), topicpub, payload, len_payload);
    				}
    			}			
    			break;
    			case PUBACK:
    			break;
    			case PUBREC://Qos2 msg receipt
    			case PUBREL://Qos2 msg receipt
    			case PUBCOMP://Qos2 msg receipt
    			{
    				unsigned char packettype, dup;
    				unsigned short packetid; 
    				if (MQTTDeserialize_ack(&packettype, &dup, &packetid, buf_mqrecv, len_mqbuf) == 1)
    				{
    					memset(buf_mqrecv, 0, len_mqbuf);
    					len_mqrecv = MQTTSerialize_ack(buf_mqrecv, len_mqbuf, packettype, dup, packetid);
    					if(len_mqrecv > 0)
    					{
    						func_tcp_sock_send(sockno, buf_mqrecv, len_mqrecv);
    					}
    				}
    			}
    			break;
    			case SUBACK:
    			case UNSUBACK:
    			case PINGREQ:
    			case PINGRESP:
    			case DISCONNECT:
    			break;
    			default:
    			break;
    		}
    	}
    }
    
    void func_mqtt_client_connect_broker(int *state, u8 sockno, u8 *buf_mqsend, u16 len_mqsend, MQTTPacket_connectData *conn_mqtt)
    {
    	u32 timespan;
    	int len_cont;
    	int res;
    	len_cont = MQTTSerialize_connect(buf_mqsend, len_mqsend, conn_mqtt);
    	if(len_cont > 0)
    	{
    		res = func_tcp_sock_send(sockno, buf_mqsend, len_cont);
    		if(res > 0)
    		{
    			timespan = 0;
    			memset(buf_mqsend, 0, len_mqsend);//reuse buffer
    			for(;;)
    			{
    				if((len_cont = func_tcp_sock_read(sockno, buf_mqsend, len_mqsend)) > 3)
    				{
    					if(func_judge_mqtt_recvmsg_package_type(buf_mqsend, len_cont) == CONNACK) 
    					{
    						*state = MQTT_CONNOK;
    						ping_timestamp = get_systick_timestamp();
    					}
    					break;
    				}
    				func_judge_timeout_ms(&timespan);
    				if(timespan > 500)
    				{
    					break;
    				}
    			}
    		}
    	}
    }
    
    void func_mqtt_client_ping_broker(int *state, u8 sockno, u8 *buf_mqsend, u16 len_mqsend)
    {
    	u32 timespan;
    	int len_cont;
    	int res;
    	if(get_systick_timestamp() - ping_timestamp > 5*1000)
    	{		
    		len_cont = MQTTSerialize_pingreq(buf_mqsend, len_mqsend);
    		if(len_cont > 0)
    		{
    			res = func_tcp_sock_send(sockno, buf_mqsend, len_cont);
    			if(res > 0)
    			{
    				timespan = 0;
    				memset(buf_mqsend, 0, len_mqsend);//reuse buffer
    				for(;;)
    				{
    					len_cont = func_tcp_sock_read(sockno, buf_mqsend, len_mqsend);
    					// pingrsp or others' published msg 
    					if(len_cont > 0)
    					{
    						//recv pingrsp
    						ping_timestamp = get_systick_timestamp();
    						cnt_ping_not_response = 0;
    						
    						// other type msg to deal with
    						func_mqtt_client_dealwith_recvmsg(sockno, buf_mqsend, len_mqsend, len_cont);
    						break;
    					}
    					
    					func_judge_timeout_ms(&timespan);
    					if(timespan > 10)
    					{
    						cnt_ping_not_response ++;
    						if(cnt_ping_not_response > 1)
    						{
    							*state = MQTT_INIT;
    							close(sockno);
    							cnt_ping_not_response = 0;
    						}
    						break;
    					}
    				}
    			}
    			else
    			{
    				cnt_ping_not_response ++;
    				if(cnt_ping_not_response > 2)
    				{
    					*state = MQTT_INIT;
    					close(sockno);
    					cnt_ping_not_response = 0;
    				}
    			}
    		}
    	}
    }
    
    int func_run_mqtt_publish(u8 sockno, u8 *buf_mqsend, u16 len_mqsend, MQTTString topicName, u8* payload, int payloadlen)
    {
    	int len;
    	int rc;
    	
    	if(mqttstate >= MQTT_CONNOK)
    	{
    		len = MQTTSerialize_publish(buf_mqsend, len_mqsend, 0, 0, 0, 0, topicName, payload, payloadlen);
    		if(len > 0)
    		{
    			memcpy(buf_pub, buf_mqsend, len);
    			rc = func_tcp_sock_send(sockno, buf_pub, len);
    			if(rc > 0)
    			{
    				ping_timestamp = get_systick_timestamp();
    			}
    			return rc;
    		}
    	}	
    	return 0;
    }
    
    int func_mqtt_client_subtopic_from_broker(u8 sockno, u8 *buf_mqsend, u16 len_mqsend, int count,\
    		MQTTString topicFilters[], int requestedQoSs[])
    {
    	u32 timespan;
    	int len_cont;
    	int res;
    	if(mqttstate != MQTT_SUBOK)
    	{
    		len_cont = MQTTSerialize_subscribe(buf_mqsend, len_mqsend, 0, SUBSCRIBE, count, topicFilters, requestedQoSs);
    		if(len_cont > 0)
    		{
    			res = func_tcp_sock_send(sockno, buf_mqsend, len_cont);
    			if(res > 0)
    			{
    				timespan = 0;
    				memset(buf_mqsend, 0, len_mqsend);//reuse buffer
    				for(;;)
    				{
    					if((len_cont = func_tcp_sock_read(sockno, buf_mqsend, len_mqsend)) > 0 && func_judge_mqtt_recvmsg_package_type(buf_mqsend, len_cont) == SUBACK)//nowtime, ignore other type msg 
    					{
    						mqttstate = MQTT_SUBOK;
    						ping_timestamp = get_systick_timestamp();
    						return 0;
    					}
    					func_judge_timeout_ms(&timespan);
    					if(timespan > 500)
    					{
    						return -2;
    					}
    				}
    			}
    		}
    	}
    	return -1;
    }
    
    void func_mqtt_client_recvmsg_from_broker(u8 sockno, u8 *buf_mqsend, u16 len_mqsend)
    {
    	int len_cont;
    	memset(buf_mqsend, 0, len_mqsend);
    	len_cont = func_tcp_sock_read(sockno, buf_mqsend, len_mqsend);
    	if(len_cont > 0)
    	{
    		func_mqtt_client_dealwith_recvmsg(sockno, buf_mqsend, len_mqsend, len_cont);
    	}	
    }
    
    u8 func_run_mqtt_tcpsock(u8 sockno, u8 *broker_ip, u16 broker_port, u8 *buf_mqsend, u16 len_mqsend, MQTTPacket_connectData *conn_mqtt)
    {
    	static u16 any_port = 50000;
    	u8 res;
    	
    	switch(getSn_SR(sockno))
    	{
    		case SOCK_CLOSED:
    		{
    			close(sockno);
    			socket(sockno, Sn_MR_TCP, any_port++, 0x00);
    			cnt_sock_init++;
    			if(cnt_sock_init > 30)
    			{
    				cnt_sock_init = 0;
    				close(sockno);
    				mqttstate = MQTT_INIT;
    			}
    			if(any_port > 64000)
    			{
    				any_port =50000;
    			}
    		}			
    		break;
    		case SOCK_INIT:
    		{
    			res = connect(sockno, broker_ip, broker_port);
    			if(res)
    			{
    				//mqtt connect request
    				mqttstate = func_run_mqtt_progress(mqttstate, sockno, buf_mqsend, len_mqsend, conn_mqtt);
    			}
    			else
    			{
    				if(cnt_ping_not_response > 0)
    				{
    					mqttstate = MQTT_INIT;
    				}
    			}
    		}
    		break;
    		case SOCK_ESTABLISHED:
    		{
    			//run mqtt progress
    			mqttstate = func_run_mqtt_progress(mqttstate, sockno, buf_mqsend, len_mqsend, conn_mqtt);
    		}
    		break;
    		case SOCK_CLOSE_WAIT: 
    		{
    			mqttstate = MQTT_INIT;
    			close(sockno);
    		}
    		break;
    		default:
    			break;
    	}
    	return mqttstate;
    }
    
    u8 func_run_mqtt_progress(int state, u8 sockno, u8 *buf_mqsend, u16 len_mqsend, MQTTPacket_connectData *conn_mqtt)
    {
    	switch(state)
    	{
    		case MQTT_INIT:
    		{
    			func_mqtt_client_connect_broker(&state, sockno, buf_mqsend, len_mqsend, conn_mqtt);
    		}
    		break;
    		case MQTT_CONNOK:
    		{
    			func_mqtt_client_ping_broker(&state, sockno, buf_mqsend, len_mqsend);
    			if(state > MQTT_INIT)
    			{
    //				func_mqtt_client_subtopic_from_broker(&state, sockno, buf_mqsend, len_mqsend);
    			}
    		}
    		break;
    		case MQTT_SUBOK:
    		{
    			func_mqtt_client_ping_broker(&state, sockno, buf_mqsend, len_mqsend);
    			if(state != MQTT_INIT)
    			{
    				func_mqtt_client_recvmsg_from_broker(sockno, buf_mqsend, len_mqsend);
    			}
    		}
    		break;
    		default:
    		break;
    	}
    	return state;
    }

    可能不是十分完美,但是一般工程上使用应该问题不大,我也测试了好久。

    测试的主函数,是做了MQTT的回环测试,MQTT Client端连接到broker后,发起订阅主题,并一次性订阅多个主题,分别是字符串subtopic、subtopic2、subtopic3、subtopic4。当其他客户端连接到broker后,向这四个主题发布消息,STM32 W5500 MQTT Client端接收后,会向 mytopic发布一条消息。

    #ifndef __STM32F10X_H
    #define __STM32F10X_H
    #include "stm32f10x.h"
    #endif
    
    #ifndef __Z_UTIL_TIME_H
    #define __Z_UTIL_TIME_H
    #include "z_util_time.h"
    #endif
    
    #ifndef __Z_HARDWARE_LED_H
    #define __Z_HARDWARE_LED_H
    #include "z_hardware_led.h"
    #endif
    
    #ifndef __Z_HARDWARE_SPI_H
    #define __Z_HARDWARE_SPI_H
    #include "z_hardware_spi.h"
    #endif
    
    #ifndef __W5500_H
    #define __W5500_H
    #include "w5500.h"
    #endif
    
    #ifndef __SOCKET_H
    #define __SOCKET_H
    #include "socket.h"
    #endif
    
    #ifndef __W5500_CONF_H
    #define __W5500_CONF_H
    #include "w5500_conf.h"
    #endif
    
    #ifndef __DHCP_H
    #define __DHCP_H
    #include "dhcp.h"
    #endif
    
    #ifndef __Z_HARDWARE_USART2_H
    #define __Z_HARDWARE_USART2_H
    #include "z_hardware_usart2.h"
    #endif
    
    #include "MQTTPacket.h"
    
    #ifndef __IMPL_MQTT_H
    #define __IMPL_MQTT_H
    #include "impl_mqtt.h"
    #endif
    
    
    int main(void)
    {
    	u32 dhcp_timestamp;
    	u8 ip_broker[] = {192, 168, 1, 127};
    	u16 port_broker = 1883;
    	u8 buf_mqtt_send[1024];
    	u8 mac[6]={0, };
    	DHCP_Get dhcp_get;
    	int mqtt_stat;
    	
    	MQTTString sub_topic = MQTTString_initializer;
    	MQTTString sub_topic2 = MQTTString_initializer;
    	MQTTString sub_topic3 = MQTTString_initializer;
    	MQTTString sub_topic4 = MQTTString_initializer;
    	MQTTString sub_topics[4];
    	int nums_sub_topic_qoss[4] = {0, };
    	char stpc_str[64] = {'t', 'c'};
    	
    	MQTTPacket_connectData conn_mqtt = MQTTPacket_connectData_initializer;
    	conn_mqtt.willFlag = 0;
    	conn_mqtt.MQTTVersion = 3;
    	conn_mqtt.clientID.cstring = (char*)"dev_abcdef";
    	conn_mqtt.username.cstring = (char*)"abcdef";
    	conn_mqtt.password.cstring = (char*)"123456";
    	conn_mqtt.keepAliveInterval = 60;
    	conn_mqtt.cleansession = 1;	
    	
    	systick_configuration();
    	init_led();
    	
    	init_system_spi();
    	func_w5500_reset();
    	
    	init_hardware_usart2_dma(9600);
    	
    	getMacByLockCode(mac);
    	setSHAR(mac);
    	
    	sysinit(txsize, rxsize);
    	setRTR(2000);
      setRCR(3);
    	
    	//DHCP
    	for(;func_dhcp_get_ip_sub_gw(1, mac, &dhcp_get, 500) != 0;);	
    	if(func_dhcp_get_ip_sub_gw(1, mac, &dhcp_get, 500) == 0)
    	{
    		setSUBR(dhcp_get.sub);
    		setGAR(dhcp_get.gw);
    		setSIPR(dhcp_get.lip);
    		close(1);
    	}
    	dhcp_timestamp = get_systick_timestamp();
    	
    	memcpy(stpc_str, (char*)"subtopic", strlen("subtopic"));
    	sub_topic.cstring = stpc_str;
    	sub_topics[0] = sub_topic;
    	sub_topic2.cstring = "subtopic2";
    	sub_topics[1] = sub_topic2;
    	sub_topic3.cstring = "subtopic3";
    	sub_topics[2] = sub_topic3;
    	sub_topic4.cstring = "subtopic4";
    	sub_topics[3] = sub_topic4;
    	
    	for(;;)
    	{
    		if(get_systick_timestamp() - dhcp_timestamp > 59*1000)// 1 min dhcp
    		{
    			dhcp_timestamp = get_systick_timestamp();
    			if(func_dhcp_get_ip_sub_gw(1, mac, &dhcp_get, 500) == 0)
    			{
    				setSUBR(dhcp_get.sub);
    				setGAR(dhcp_get.gw);
    				setSIPR(dhcp_get.lip);
    				close(1);
    			}
    		}
    		mqtt_stat = func_run_mqtt_tcpsock(2, ip_broker, port_broker, buf_mqtt_send, sizeof(buf_mqtt_send), &conn_mqtt);
    		if(mqtt_stat >= MQTT_CONNOK)
    		{
    			if(mqtt_stat == MQTT_CONNOK)
    			{
    				memset(buf_mqtt_send, 0, sizeof(buf_mqtt_send));
    				func_mqtt_client_subtopic_from_broker(2, buf_mqtt_send, sizeof(buf_mqtt_send), 4,	sub_topics, nums_sub_topic_qoss);
    
    			}
    			func_led1_toggle();
    		}		
    		delay_ms(500);
    				
    	}
    }

    电脑端使用MQTT.fx工具进行测试,测试效果

    目前测试还比较稳定,支持热插拔网线,以及路由器断网后再次联网,MQTT Client仍可继续连接broker。

    展开全文
  • stm32+w5500 温度传感器 MQTT协议实现
  • 玩转STM32F103+W5500 MQTT

    2019-03-24 13:40:26
    玩转STM32F103+W5500 MQTT,内有详细教程说明,手把手一步步教你移植,实现物联网功能
  • stm32操作系统的学习操作,大家可以参考学习,STM32F4x7+freertos+lwip+ssl+MQTT-(MDK5)稳定可靠+W5500 MQTT例程和说明+LWIP+UCOSIII+UCOSII
  • STM32F4x7+freertos+lwip+ssl+MQTT-(MDK5)稳定可靠+W5500 MQTT例程和说明+LWIP+UCOSIII+UCOSII源码.zip
  • STM32+FreeRTOS+W5500+MQTT

    2018-11-14 14:22:00
    在STM32F103RET6测试,FreeRTOS版本V10.0.1,STM32固件版本V3.5。 连接MQTT正常订阅接收数据,修user_mqtt.h头文件即可使用。
  • 本文主要介绍 W5500 如何通过 MQTT 协议将设备连接到阿里云 IoT,并通过 MQTT 协议实现通信。MQTT 协议是基于 TCP 的协议,所以我们只需要在单片机端实现 TCP 客户端代码之后就很容易移植 MQTT
  • STM32F103+W5500_MQTT.zip

    2018-03-06 14:27:50
    MQTT 协议+W5500EVB+DHT11模拟实现了手机端可以在外网控制板载LED 灯的亮灭和实时接收 DHT11 采集到的数据,其中 W5500EVB 作为以太网网关,负责将采集 到的温湿度数据加上设定的主题按照 MQTT 协议的要求 PO 到 ...
  • W5500实现MQTT 稳定连接

    2021-11-25 14:38:00
    W5500实现MQTT 稳定连接 自动获取ip 相关函数均带返回值 带freemodbus主从站 id=652271228891&

    W5500实现MQTT
    稳定连接
    自动获取ip
    相关函数均带返回值
    带freemodbus主从站
    请添加图片描述id=652271228891&
    请添加图片描述
    请添加图片描述

    展开全文
  • STM32+W5500+MQTT使用记录

    千次阅读 2020-11-03 23:07:47
    1.实现MQTT协议,要基于TCPIP协议,则首先要能正确的使用W5500 ,并配置成客户端,可以正常的链接服务器并传输数据,关于W5500的使用,还在学习中,现在调试是基于原来的工程,所以省了很多时间调试。只是学习的如何...

    第一次尝试写博客,不为别的,为了积累一些知识和记录下使用的遇到的问题。

    关于MQTT协议的介绍可以百度搜索或者在本论坛内查找,介绍的还是很多,而且介绍的很想学习,当然我也收藏了很多,一下主要介绍我使用时如何处理的。

    1.实现MQTT协议,要基于TCPIP协议,则首先要能正确的使用W5500 ,并配置成客户端,可以正常的链接服务器并传输数据,关于W5500的使用,还在学习中,现在调试是基于原来的工程,所以省了很多时间调试。只是学习的如何写客户端。MQTT协议不论发布数据还是订阅数据,都是基于客户端的方式进行通信的,所以我感觉调试通客户端链接服务器并传输数据是比较重要的。

    2.如何在自己的工程内添加MQTT协议,我使用的是开源的库,根据别人博客介绍进行添加到自己工程内。主要是修改几个函数如下,这个是自己根据使用中遇到的问题进行修改的.

    3.MQTT库移植完成了,接下来就是该考虑如何进行数据发布了,刚开始一头雾水,就参考别人的历程,自己修改了,总是不能发布成功,之后偶然的机会,去掉了订阅号和ID标识的链接之传输订阅号,居然成功了.可是根据我检测数据发现,每次都是发布成功一次,失败一次.之后我就在每次发布完成后关闭链接,这样就没有遇到发布不成功的时候了,以为这样就算完成MQTT的程序了,后来根据串口打印出来的信息看到,每次都需要链接一次服务器,这就出现新的问题,难道MQTT每次发布数据都是这样的.之后就绪继续查找资料,可是发现介绍的很少.请教别人也很难得到明确的答案,可是和别人的服务器对接就在眼前,只能先这样硬着头皮用了.

    4.对接的时候 用户那边也发现了这个问题,之后提出来了,这是时候得到明确的答案,MQTT发布数据,不需要每次都请求来链接服务器,只需要链接一次就可以了.既然知道了这个,接着就是想办法怎么实现了,可以把原来的发布消息拆分成两段程序,一个负责处理请求链接MQTT服务器,另外的则负责发布数据,在正确链接到服务器后再发布数据,之后完美解决了这个问题.正常联网发布数据没有问题.

    5. 我在想这样发布数据突然把网线拔掉程序会怎么样,哈哈哈突然发现程序看门狗居然复位了,程序居然重新运行了,之后使用定时器进行处理这个问题.可以暂时解决掉这个问题了.

    就写到这个了.W5500怎么自动获取IP地址呢?

    继续百度吧,多积累经验!

    1. 下载MQTT的库:Paho https://github.com/eclipse/paho.mqtt.embedded-c

     

     

     

    展开全文
  • W5500+DHCP+DNS+MQTT

    千次阅读 2022-03-22 22:17:01
    W5500+DHCP+DNS+MQTT工程代码及简要过程记录
  • stm32 + w5500 + MQTT

    热门讨论 2015-08-22 10:40:23
    物联网,stm32利用w5500以太网模块连接服务器,加入了MQTT协议
  • 设计以STM32F405为主控芯片,通过W5500模块以MQTT协议方式发布到MQTT服务器,最终在手机客户端实现数据采集和控制。 主要功能: 1.STM32F405为主控芯片,它通过传感器采集环境数据,比如温度,湿度,光照度,大气压强...
  • STM32 MQTT协议功能实现

    2018-05-17 09:40:43
    C语言实现MQTT协议客户端功能,移植好的MQtt协议,亲测可用!
  • 1.2W5500 2、RT-Thread Studio 配置及相关代码 2.1 添加WIZnet软件包 2.2 配置 WIZnet 软件包 2.3 配置 spi20 3、验证效果 4、与ali-iotkit-v3.0.1 阿里云IOT软件包 MQTT主题订阅发布 4.1 添加ali-iotkit-v...
  • 基于STM32F103+W5500+阿里云MQTT平台的物联网入门(一 )——了解MQTT协议 要使用mqtt协议来开发物联网设备,先对下面几个词汇了解一下(后面移植开发的时候,比较容易看得懂源码 Topic 作为订阅和发布的通道,类似...
  • 目的: STM32 + W5500 嵌入式以太网卡 访问 阿里云微消息队列 MQTT 服务器、实现基础的发布和订阅。 开发工具: MDK(Keil v5)、MQTT 调试工具 注意: 此处要连接的服务器是阿里云的 MQTT 服务器、不是网上流传甚广的 ...
  • 某学校对新建的实验楼有门禁管理需求,因此我们项目组借助KOB门锁(某宝销量较高的电吸锁和电插锁品牌),搭建了前端(微信小程序和网页),服务器(java服务器和mqtt服务器),单片机(基于stm32,用于控制电插锁)...
  • 这是公司实际项目工程(编译器用DK5),STM32F4x7+freertos+lwip+ssl+MQTT,其中MQTT自己花了一个礼拜移植,可以同时发布消息和订阅消息(发布主题:DongLuTest,订阅主题:mymqttsubtest),经过长期测试MQTT运行...
  • STM32F103__W5500_MQTT.zip

    2019-09-13 11:42:43
    改程序是stm32F1使用w5500作为以太网物理层,使用MQTT协议进行服务器的读取发送,里面的程序可以单独拿出来使用,是个很好的例程 资料滴啊有W5500模块原理图
  • STM32上移植MQTT协议使用W5500以太网芯片连接阿里云

    千次阅读 热门讨论 2020-03-29 17:50:55
    STM32上移植MQTT协议使用W5500以太网芯片连接阿里云前言正题核心代码结论 前言 有机会做这次项目很开心,学到了很多东西,但刚开始的时候是真的从零开始,网上找的资料都大相径庭,很多代码都有问题,而且把别人做的...
  • stm32+w5500+mqtt.zip

    2019-12-22 20:39:11
    结合这个例子可以快速跟阿里云平台进行通信。可以通过设备端订阅主题,平台发送数据,设备端可以接收,同样设备端可以进发布一些从传感器采集到数据到云平台
  • 最近在学习MQTT,发现MQTT还是挺好用的,于是花了点时间做了一个简单的应用示例,希望能给需要做这方面的人一些参考。 相关背景知识:http://www.embed-net.com/thread-224-1-1.html 具体功能为: 1,STM32F405为...

空空如也

空空如也

1 2 3 4 5 ... 11
收藏数 204
精华内容 81
关键字:

w5500mqtt