精华内容
下载资源
问答
  • stm32 w5500 例程代码

    2018-10-26 15:55:26
    stm32 w5500 实现单片机tcp udp http 网络通讯,为单片机联网提供解决方案
  • 硬件是STM32+W5500 ,使用http通信协议时间iap OTA 空中升级,文档讲的比较详细,也是我见过的比较好以及比较详细的IAP讲解了。我这边顺便说说为什么要用http 通信协议,因为http通讯协议协议头里面有个body 长度...
  • STM32F103 + w5500 网页例程
  • stm32+w5500 W5500 Official Source W5500 Official Source
  • 基于stm32f103c8单片机运行,使用w5500模块开发的MQTT协议,支持接收与发送。下载完程序后,完成是MCU通过SPI2对w5500的读写操作,完成对IP,mac,gateway等的操作, 设置成功的话,会通过串口1把网络参数打印到串口...
  • stm32_IAP远程升级程序_STM32+W5500+IAP,现在项目正在使用,基于http的get和post两种模式。
  • STM32F4系列W5500;(HAL库版本、W5500官网最新驱动)
  • stm32+w5500 温度传感器 MQTT协议实现
  • W5500产品资料 内有STM32例程 及W5500官方资料
  • STM32 W5500 HTTP Server 微型web服务实现

    千次阅读 热门讨论 2020-04-22 00:09:27
    嵌入式Web服务很常见,比如电脑通过WIFI接入网络,在浏览器地址栏输入 "192.168.1.1",或者其他...STM32 W5500几乎也可以实现上述的功能,但是由于STM32的RAM和FLASH储存大小是有限的,实现一个简单的web服务是没...

    嵌入式Web服务很常见,比如电脑通过WIFI接入网络,在浏览器地址栏输入 "192.168.1.1",或者其他地址,跟自己电脑的IP在同一个网段内,一般IP最后一段是1即可,可以打开路由器的管理页面。就像这样:

    这个页面就是有嵌入式小型web服务提供的网页。

    STM32 W5500几乎也可以实现上述的功能,但是由于STM32的RAM和FLASH储存大小是有限的,实现一个简单的web服务是没有问题的。

    STM32 W5500实现一个简单的web服务需要具备的几个条件:

    1、STM32 W5500的基础入网配置,可以PING通,可以参考《STM32F103RC驱动W5500入网,并可ping通》

    2、STM32 W5500的TCP Server回环测试没有问题,可以参考 《STM32 W5500 TCP Server 回环测试》

    3、对HTTP协议有一定的认识。

    确定一下要实现的web服务的功能,STM32 W5500配置入网后,通过DHCP动态获取IP地址,在电脑浏览器地址栏输入这个IP地址,可以获取到一个简单form表单的页面,在表单中输入数据,提交到W5500web服务,返回一个结果。如图:

    功能比较简单,比较费事儿的是字符串的处理接收到的字符串的解析,以及返回信息的组装。

    直接贴出测试的代码:

    #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
    
    #define SOCK_TCPS 0
    #define BUFFER_SIZE 1536
    #define TEXT_TEMPLATE_OK "HTTP/1.1 200 OK\r\n"\
    "Content-Type: text/html\r\n"\
    "Content-Length: %d\r\n"\
    "Connection: keep_alive\r\n\r\n%s"
    
    #define TEXT_TEMPLATE_ERR "HTTP/1.1 404 Not Found\r\n"\
    "Content-Length: 0\r\n\r\n"\
    "Connection: keep_alive\r\n\r\n"
    
    #define HTML_CONTENT "<!DOCTYPE html>"\
    "<html>"\
    "<head>"\
    "<meta charset=\"utf-8\">"\
    "<title>SN Config</title>"\
    "<style>"\
    ".d-c{ position:absolute;left:40%;top:49%}"\
    ".b-c{ position:absolute;left:40%;top:90%}"\
    "</style>"\
    "</head>"\
    "<body>"\
    "<div class=\"d-c\">"\
    "<form name=\"input\" action=\"sn_config.action\" method=\"post\">"\
    "SN:<input type=\"text\" name=\"sn\">"\
    "<input type=\"submit\" value=\"submit\">"\
    "</form>"\
    "</div>	"\
    "<div class=\"b-c\">"\
    "<p>System SN Config</p>"\
    "</div>"\
    "</body>"\
    "</html>\r\n"
    
    #define HTML_RESULT_OK "<!DOCTYPE html>"\
    "<html>"\
    "<head>"\
    "<meta charset=\"utf-8\">"\
    "<title>SN Config</title>"\
    "<style>"\
    ".c-c{ position:absolute;left:40%;top:49%}"\
    "</style>"\
    "</head>"\
    "<body>"\
    "<div class=\"c-c\">"\
    "<p>System SN Config OK</p>"\
    "</div>"\
    "</body>"\
    "</html>\r\n"
    
    #define HTML_RESULT_ERR "<!DOCTYPE html>"\
    "<html>"\
    "<head>"\
    "<meta charset=\"utf-8\">"\
    "<title>SN Config</title>"\
    "<style>"\
    ".c-c{ position:absolute;left:40%;top:49%}"\
    "</style>"\
    "</head>"\
    "<body>"\
    "<div class=\"c-c\">"\
    "<p>System SN Config FAIL</p>"\
    "</div>"\
    "</body>"\
    "</html>\r\n"
    
    u8 func_analysis_http_request(u8* buffer, u16 len_recv, char* method, char* uri, char* data_body);
    u8 func_package_http_response(u8* buffer, u16 *len_ret, u16 len_buf, char* cont, u16 len_cont);
    
    int main(void)
    {
    	u32 dhcp_timestamp;
    	u8 mac[6]={0, };
    	DHCP_Get dhcp_get;
    	u16 len;
    	u8 buffer[BUFFER_SIZE];
    	char http_method[16];
    	char http_uri[64];
    	char http_body[256];
    	u8 res_code;
    	
    	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();
    
    	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);
    			}
    		}
    		
    		switch(getSn_SR(SOCK_TCPS))
    		{
    			case SOCK_CLOSED:
    				socket(SOCK_TCPS, Sn_MR_TCP, 80, Sn_MR_ND);
    				break;
    			case SOCK_INIT:
    				listen(SOCK_TCPS);
    				break;		
    			case SOCK_ESTABLISHED:		
    				if(getSn_IR(SOCK_TCPS) & Sn_IR_CON)
    				{
    					setSn_IR(SOCK_TCPS, Sn_IR_CON);
    				}
    				len = getSn_RX_RSR(SOCK_TCPS);
    				if(len>0)
    				{
    					memset(buffer, 0, BUFFER_SIZE);
    					len = recv(SOCK_TCPS, buffer, len);
    					//analysis tcp msg, and package the feedback msg
    					if(len > 0)
    					{
    						res_code = func_analysis_http_request(buffer, len, http_method, http_uri, http_body);
    						memset(buffer, 0, sizeof(buffer));
    						if(res_code == 0)
    						{
    							if(strcmp("GET", http_method) == 0 && strcmp("/", http_uri) == 0)
    							{
    								func_package_http_response(buffer, &len, sizeof(buffer), HTML_CONTENT, strlen(HTML_CONTENT));
    								send(SOCK_TCPS, buffer, len);					
    							}
    							else if(strcmp("POST", http_method) == 0 && strcmp("/sn_config.action", http_uri) == 0)
    							{
    								func_package_http_response(buffer, &len, BUFFER_SIZE, HTML_RESULT_OK, strlen(HTML_RESULT_OK));
    								send(SOCK_TCPS, buffer, len);
    							}
    							else
    							{
    								memcpy(buffer, TEXT_TEMPLATE_ERR, strlen(TEXT_TEMPLATE_ERR));
    								send(SOCK_TCPS, buffer, strlen(TEXT_TEMPLATE_ERR));
    							}
    							disconnect(SOCK_TCPS);
    						}
    						else
    						{
    							memcpy(buffer, TEXT_TEMPLATE_ERR, strlen(TEXT_TEMPLATE_ERR));
    							send(SOCK_TCPS, buffer, strlen(TEXT_TEMPLATE_ERR));
    							disconnect(SOCK_TCPS);
    						}
    					}
    					
    				}
    				break;
    			case SOCK_CLOSE_WAIT:
    				close(SOCK_TCPS);
    				break;
    		}
    		
    		func_led1_on();
    		delay_ms(500);
    		func_led1_off();
    		delay_ms(500);
    				
    	}
    }
    
    u8 func_analysis_http_request(u8* buffer, u16 len_recv, char* method, char* uri, char* data_body)
    {
    	char chs[BUFFER_SIZE] = {0, };
    	char *res, *end;
    	if(len_recv > 0)
    	{
    		memcpy(chs, buffer, 3);
    		res = strstr(chs, "GET");
    		if(strcmp("GET", res) == 0)
    		{
    			memcpy(method, "GET", strlen("GET"));
    			
    		}
    		else
    		{
    			memset(chs, 0, BUFFER_SIZE);
    			memcpy(chs, buffer, 4);
    			res = strstr(chs, "POST");
    			if(strcmp("POST", res) == 0)
    			{
    				memcpy(method, "POST", strlen("POST"));
    				
    			}
    			else
    			{
    				return 1;
    			}
    		}
    		
    		memset(chs, 0, BUFFER_SIZE);
    		memcpy(chs, buffer, len_recv + 1);
    		res = strchr(chs, '/');
    		if(res != NULL)
    		{
    			end = strchr(res, ' ');
    			if(end != NULL)
    			{
    				memcpy(uri, res, end - res);
    			}			
    		}
    		
    		memset(chs, 0, BUFFER_SIZE);
    		memcpy(chs, buffer, len_recv + 1);
    		res = strstr(chs, "\r\n\r\n");
    		if(res != NULL)
    		{
    			if(strlen(res) > 4)
    			{
    				memcpy(data_body, res + 4, strlen(res) - 4);
    			}			
    		}
    		
    	}
    	return 0;
    }
    
    u8 func_package_http_response(u8* buffer, u16 *len_ret, u16 len_buf, char* cont, u16 len_cont)
    {
    	memset(buffer, 0, BUFFER_SIZE);
    	*len_ret = sprintf((char*)buffer, TEXT_TEMPLATE_OK, len_cont, cont);
    	return 0;
    }
    

    相关的基础函数库可以参考我的其他文章。

    测试步骤,我的W5500的IP是动态获取到的,所以先登录到路由器管理页面查看他的IP地址。

    我的 STM32 W5500 IP地址是"192.168.1.100"。在浏览器地址栏输入"192.168.1.100",可以看到页面

    在SN后的input标签内输入任意内容,点击submit后,可以看到

    数据已提交到服务。

    通过Debug单步调试可以看到浏览器提交到的数据内容,或者通过串口打印出来。一般的操作都是收到这个数据后存储到EEPROM中。

    展开全文
  • 首先我们下载FreeModbus源码,然后放到自己的工程中,新建一个MODBUS_TCP和PORT_TCP文件夹,然后将相关文件复制到里面,如下图所示: 然后修改porttcp中的代码: 首先定义一个数组用于接收数据: ...
  • STM32 W5500 LOOPBACK TEST PROGRAM
  • 通过W5500的网络功能,到文件服务器下载STM32要更新的固件(可执行bin文件),存储到STM32片内FLASH的APP备份区中,以待bootloader拷贝到APP代码执行区,以实现OTA在线升级的功能。 我使用的芯片是STM32F103RCT6,48...
  • 嵌入式微操作系统学习,STM32+W5500 MQTT例程和说明+F407探索者+LWIP+UCOSIII+UCOSII
  • stm32+W5500

    2015-12-28 10:24:40
    stm32+W5500完整原理图 可以实现嵌入式网关,或者裸机运行Socket通信,为智能家居设计
  • 使用STM32 W5500做MQTT 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。

    展开全文
  • 实现基于STM32F405RGT6移植,UDP模式下通信正常,可用于应用开发
  • 现在想让STM32 W5500通过HTTP Client POST...1、STM32 W5500的基础配置,使得PC和W5500在同一个局域网内,PC可以PING通W5500。 2、STM32 W5500的TCP Client可以成功发数据,HTTP协议是基于TCP协议之上封装的协议。 ...

    现在想让STM32 W5500通过HTTP Client POST的方式提交数据到远程服务器,并接收服务返回的JSON格式数据,解析和处理。

    实现以上功能,需要具备几个条件:

    1、STM32 W5500的基础配置,使得PC和W5500在同一个局域网内,PC可以PING通W5500

    2、STM32 W5500的TCP Client可以成功发数据,HTTP协议是基于TCP协议之上封装的协议。

    3、远程服务器接口可以访问,可以通过POSTMAN工具先测试。

    4、使用WireShark工具,追踪POSTMAN访问服务接口的报文数据,以及返回的报文数据。

    STM32 W5500的基础配置和TCP Client我已具备条件,下面看下远程服务器接口是否可以访问:

    Header部分:

    Request Body和Response Body

    接口返回了JSON 结构数据,说明接口是可以访问的。

    打开WireShark工具,追踪一下POSTMAN访问的流数据,以及服务器返回的响应报文数据。

    请求数据的追踪

    接口返回的报文数据追踪

    基础准备工作已经做好,那么STM32 W5500 Http Client POST请求的实现,由于一些信息比较敏感,对代码做了处理:

    httppost.c

    #ifndef __HTTPPOST_H
    #define __HTTPPOST_H
    #include "httppost.h"
    #endif
    
    u16 func_pack_httppost_body(char *buff_body, char *productId, char *deviceSn, char *deviceMac, char *devicePassword, char *hardwareVersion)
    {
    	u16 len;
    	len = sprintf(buff_body, "a=%s&b=%s&c=%s&d=%s&e=%s",\
    		productId, deviceSn, deviceMac, devicePassword, hardwareVersion);
    	return len;
    }
    
    u16 func_pack_httppost_head_body(char *buff_post, char *url_tail, u8 *host, u16 port, char *body, u16 body_len)
    {
    	u16 len;
    	len = sprintf(buff_post, "POST %s HTTP/1.1\r\n"
    		"Connection: close\r\n"
    		"User-Agent:W5500\r\n"
    		"Content-Type:application/x-www-form-urlencoded\r\n"
    		"Host: %d.%d.%d.%d:%d\r\n"
    		"Content-Length: %d\r\n\r\n"
    		"%s\r\n", url_tail, host[0], host[1], host[2], host[3], port, body_len, body
    	);
    	return len;
    }
    
    static u16 local_port = 50000;
    
    u8 func_http_post(u8 sock_no, u8 *rip, u16 port, char *buf_post, u16 len_post,char *buf_recv, u16 *len_recv, u16 timeout_ms)
    {
    	u16 cnt, len;	
    	char *body_cont;
    	cnt = 0;
    	
    	for(;;)
    	{
    		switch(getSn_SR(sock_no))
    		{
    			case SOCK_INIT:
    				connect(sock_no, rip, port);
    			break;
    			case SOCK_ESTABLISHED:
    				send(sock_no, (u8*)buf_post, len_post); 
    				if(getSn_IR(sock_no) & Sn_IR_CON)   					
    				{
    					setSn_IR(sock_no, Sn_IR_CON);
    				}
    				len = getSn_RX_RSR(sock_no);
    				if(len > 0)
    				{
    					memset(buf_recv, 0, len_post);
    					len = recv(sock_no, (u8*)buf_recv, len);
    					body_cont = strstr((char*)buf_recv, "HTTP/1.1 200");
    					if(body_cont == NULL)
    					{
    						return 2;
    					}
    					body_cont = strstr((char*)buf_recv, "\r\n\r\n");
    					if(body_cont != NULL)
    					{
    						len = strlen(body_cont) - 4;
    						memcpy(buf_recv, body_cont + 4, len);
    						buf_recv[len] = '\0';
    						*len_recv = len;
    						close(sock_no);
    						return 0;
    					}					
    				}				
    			break;
    			case SOCK_CLOSE_WAIT:
    				close(sock_no);
    			break;
    			case SOCK_CLOSED:
    				socket(sock_no, Sn_MR_TCP, local_port++, Sn_MR_ND);
    				if(local_port > 64000)
    				{
    					local_port = 50000;
    				}
    			break;
    		}
    		
    		cnt ++;
    		if(cnt >= timeout_ms)
    		{
    			close(sock_no);
    			return 1;
    		}
    		delay_ms(1);
    	}
    }
    

    测试的主函数代码:

    #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 __Z_HARDWARE_USART2_H
    #define __Z_HARDWARE_USART2_H
    #include "z_hardware_usart2.h"
    #endif
    
    #include "w5500.h"
    #include "socket.h"
    #include "w5500_conf.h"
    #include "dhcp.h"
    #include "dns.h"
    
    #ifndef __HTTPPOST_H
    #define __HTTPPOST_H
    #include "httppost.h"
    #endif
    
    char buf_send[2048];
    char buf_cont[256];
    	
    int main(void)
    {
    	DHCP_Get dhcp_get;
    //	u8 buf_recv[1536] = {0, };
    	
    	u16 len, recv_len;
    	u8 res;
    	
    	uint8 mac[6];
    	u8 remote_ip[4] = {192, 168, 1, 109};
    	u16 port = 8084;	
    	
    	init_led();
    	
    	init_system_spi();
    	func_w5500_reset();
    	
    	init_hardware_usart2_dma(115200);
    		
    	getMacByLockCode(mac);
    	setSHAR(mac);
    	
    	sysinit(txsize, rxsize);
    	setRTR(2000);
      setRCR(3);
    	
    	//USART DMA problem 2byte missing
    	func_usart2_dma_send_bytes(mac, 2);
    	delay_ms(100);
    	
    	//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);
    	}
    	
    	len = func_pack_httppost_body(buf_cont, "", "", "", "", "");
    	
    //	pack http message		
    	len = func_pack_httppost_head_body(buf_send, "/a/b/c/d/create", remote_ip, port, buf_cont, len);
    	
    //	res = func_httpc_post(0, remote_ip, port, buf_send, len, buf_send, &recv_len, 1000, 5000);
    	res = func_http_post(0, remote_ip, port, buf_send, len, buf_send, &recv_len, 1000);
    	if(res == 0)
    	{
    		func_usart2_dma_send_bytes((u8*)buf_send, recv_len);
    	}
    
    	for(;;)
    	{
    		
    		func_led1_on();
    		delay_ms(1000);
    		func_led1_off();
    		delay_ms(1000);
    		
    	}
    }
    

    测试的结果,解析报文的body,并通过串口打印出来:

    通过16进制转字符串转换一下,看看结果

     

    展开全文
  • STM32F1的W5500程序

    2019-01-26 16:15:14
    这是一个基于STM32F103写的W5500模块程序,供大家参考,有详细注释
  • stm32操作系统的学习操作,大家可以参考学习,STM32F4x7+freertos+lwip+ssl+MQTT-(MDK5)稳定可靠+W5500 MQTT例程和说明+LWIP+UCOSIII+UCOSII
  • STM32通过W5500实现MQTT客户端的部署 ,对于MQTT的学习具有参考意义
  • STM32W5500通讯 UDP 通讯模式 详细例程注释很多 对新手很有用
  • 经过这几天的学习与调试,终于在STM32F103VCT6+W5500(SPI1)+Freemodbus 平台上,实现Modbus-TCP协议的功能。其实很简单,只要熟悉Modbus-RTU通讯,明白Modbus帧的结构等,Modbus-TCP只是在原来的帧结构上加个头,去...
  • 玩转STM32F103+W5500 MQTT

    2019-03-24 13:40:26
    玩转STM32F103+W5500 MQTT,内有详细教程说明,手把手一步步教你移植,实现物联网功能
  • W5500_STM32F103开发板资料,包括W5500相关所有的资源、以及和STM32F103相关接口代码、原理图等等。一应俱全。毫无保留贡献出来!
  • YIXIN_W5500模块-服务端模式-STM32例程,能够通过顶层设计实现对服务器的设置,设置局域网络,可以实现无线连接。
  • 做了STM32 W5500联网通讯几个月了,回头总结一下 STM32 W5500 的TCP Server要注意的一些点: 1、有好用的W5500基础支持库 2、在PC的CMD命令窗口中可以PING通W5500设备。 3、在测试的时候,条件允许登录到路由器的...

    做了STM32 W5500联网通讯几个月了,回头总结一下 STM32 W5500 的TCP Server要注意的一些点:

    1、有好用的W5500基础支持库

    2、在PC的CMD命令窗口中可以PING通W5500设备

    3、在测试的时候,条件允许登录到路由器的管理页面,查看连接设备是否有W5500的有线连接(非必须)。

    满足以上几点,基本可以测通TCP Server的回环测试了。

    贴出测试的主函数代码:

    #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
    
    #include "w5500.h"
    #include "socket.h"
    #include "w5500_conf.h"
    
    uint8 buffer[2048];
    
    int main(void)
    {
    	uint8 mac[6]={0x00, 0x0C, 0x32, 0xDA, 0x07, 0x4C};
    	uint8 lip[4]={192,168,1,112};
    	uint8 sub[4]={255,255,255,0};
    	uint8 gw[4]={192,168,1,1};
    		
    	uint8 remote_ip[4] = {192,168,1,105};
    	uint16 remote_port = 9000;
    	uint16 local_port = 5000;
    	uint16 len;
    	u8 sock_status;
    	
    	init_led();
    	init_system_spi();
    	func_w5500_reset();
    		
    	setSHAR(mac);
      setSUBR(sub);
      setGAR(gw);
      setSIPR(lip);
    	
    	sysinit(txsize, rxsize);
    	setRTR(2000);
      setRCR(3);
    	setkeepalive(0);
    	
    //	socket(0,Sn_MR_UDP,local_port-1,0);
    //	buffer[0] = 0x55;
    //	buffer[1] = 0xAA;
    //	len = 2;
    //	sendto(0, buffer, len, remote_ip, remote_port);
    	
    
    	for(;;)
    	{	
    		sock_status = getSn_SR(1);
    		switch(sock_status)
    		{
    			case SOCK_CLOSED:
    				socket(1 ,Sn_MR_TCP,local_port,Sn_MR_ND);
    				break;    
    			case SOCK_INIT:
    				listen(1);
    				break;		
    			case SOCK_ESTABLISHED:		
    				if(getSn_IR(1) & Sn_IR_CON)
    				{
    					setSn_IR(1, Sn_IR_CON);
    				}
    				len=getSn_RX_RSR(1);
    				if(len>0)
    				{
    					len = recv(1, buffer, len);
    					send(1, buffer, len);
    				}
    				break;
    			case SOCK_CLOSE_WAIT:
    				close(1);
    				break;
    		}
    						
    		func_led1_on();
    		delay_ms(500);
    		func_led1_off();
    		delay_ms(500);
    		
    	}
    	
    	
    }
    
    

    通过PC的CMD命令窗口PING设备:

    回环测试的效果如下:

    W5500的库函数,可以参考 《测试工程代码00_W5500_ping.rar》。

    将以上的主函数替换到工程的主函数即可。

    TCP Server的拓展应用场景,可以做一个小型的嵌入式Web网站。

    展开全文
  • STM32+W5500 MQTT例程 附详细讲解

    热门讨论 2018-01-26 09:59:54
    通过一个实例,讲解了MQTT 在智能家居中的应用。硬件采用W5500EVB。
  • 基于STM32F103和W5500模块,通过STM32F103接收USART,然后通过SPI传输给W5500,最终将数据传给路由器或者电脑,实现了USART转以太网通信。本例程USART的波特率可达到921600,通过DMA的方式接收。
  • stm32模拟spi控制w5500

    2018-10-06 16:09:50
    stm32模拟spi控制w5500实现客户端模式,芯片spi借口有别的用途,通过软件模拟spi与w5500通信 stm32模拟spi控制w5500实现客户端模式,芯片spi借口有别的用途,通过软件模拟spi与w5500通信 stm32模拟spi控制w5500...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,185
精华内容 474
关键字:

stm32w5500