STM32 W5500 MQTT Client 發佈訂閱及斷線重連

原創 Mr_Johhny 2020-04-24 14:29

使用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。

發表評論
所有評論
還沒有人評論，想成為第一個評論的人麼? 請在上方評論欄輸入並且點擊發布.
相關文章

初出茅廬的小李第28篇博客之MQTT學習筆記

物聯網學習入門篇之MQTT協議 MQTT: Massage Queuing Telemetry Transport,消息隊列遙測傳輸 MQTT是基於互聯網的基礎協議TCP/IP協議而構建的，由IBM在1999年發佈，基於發佈和訂閱

Aqst-666 2020-07-07 11:55:28

STM32中enumeration特殊使用方法

                                                  STM32中enumeration特殊使用方法 定義如下： /*! * STM32 Pin Names */ #define MCU

yanlaifan 2020-07-08 07:48:26

warnings by IAR Embedded workbench IDE:transfer of control bypasses initialization of...

                            warnings by IAR Embedded workbench IDE:transfer of control bypasses initialization of...  

yanlaifan 2020-07-08 07:48:26

printf函數簡潔實現

#include <stdarg.h> #include <stdlib.h> #include <stdio.h> int My_putchar(int ch) { HalSerial_UARTWrite((uint8 *)&c

zhuohui307317684 2020-07-08 03:38:33

STM32智能遙控小車，超詳細-附下載直接可以用，雙電源跑賊快！

簡介 小車的動力部分由4個帶減速箱的電機，和兩個L298N電機驅動模塊組成。 通過STM32核心板控制電機驅動模塊，JDY-31藍牙模塊與手機通訊。 總共三塊電池，一塊專門給單片機供電，另外兩塊串聯在一起同時給電機驅動模塊供電

你就叫我李大帅 2020-07-07 21:45:58

多定時器複用一個硬件定時器

當定時器不夠用或者不想浪費資源時。我們可以利用定時器複用功能。使用一個硬件定時器就可以實現多個時間的定時。類似於軟件定時器。 優點：可以多個定時器複用要給硬件，節約資源 缺點：它是在某個任務或者mian中一直循環查詢。優先級沒有定

断雁孤鸿 2020-07-07 19:05:39

STM32F4/F1+ESP8266連接移動雲（OneNET）

參考視頻：B站超緯電子 目錄參考視頻：[B站超緯電子](https://www.bilibili.com/video/BV16E41147uZ?t=5&p=14)源碼實踐過程（1）硬件連接（2）調試時注意（3）實驗現象主要問題（1

BROSY 2020-07-07 14:53:26

STM32定時器應用——輸出PWM給電機調速

目錄（資料下載看最後）一、PWM簡介二、硬件部分三、軟件部分1. PWM初始化 pwm.c2. PWM初始化pwm.h3. 電機控制motor.c4. 電機控制motor.h5. 備註三、參考資料四、資料下載 源碼下載 分享鏈接

BROSY 2020-07-07 14:53:26

ANSIC幾種特殊的標準定義（__FILE__、__LINE__、__STDC__···）

相關標題：__FILE__、__LINE__、__DATE__、__TIME__、__STDC__爲方便大家閱讀，本文內容已經整理成PDF文件：http://pan.baidu.com/s/1gfHygynⅠ、寫在前面對於我們大

Bingo Fang 2020-07-07 14:34:54

【STM32】RTC時鐘學習筆記，庫函數和寄存器步驟（可修改時間）

參考資料：STM32中文參考手冊；正點原子STM32開發指南 RTC時鐘簡介 實時時鐘是一個獨立的定時器。RTC模塊擁有一組連續計數的計數器。修改計數器的值可以重新設置系統當前的時間和日期。 RTC模塊和時鐘配置系統(RCC_

那可真是太开心了呢 2020-07-07 13:51:43

NTC熱敏電阻溫度採集與adc轉換

前言： ntc熱敏電阻的R值是10k，B值是3950 使用的是STM32F103RCT6的ADC 文章目錄1.電路理論2. NTC熱敏電阻阻值與溫度之間的轉換3.NTC熱敏電阻溫度採集與adc轉換 其中最主要的是 溫度變化，引

那可真是太开心了呢 2020-07-07 13:51:37

【方法】Ilitek ILI9325、ILI9328、ILI9341 LCD TFT彩屏利用Memory Read指令讀取屏幕上顯示的內容

網上很多彩屏例程都通過0號命令（有時也稱爲0號寄存器）讀取彩屏的ID號，以此來判斷彩屏的芯片型號，然而ILI9341芯片的0號命令是一個空操作（No Operation），無法得到器件ID。 4號命令和0xda~0xdc命令雖然是讀取I

巨大八爪鱼 2020-07-07 13:45:03

STM32F030R8Tx HAL SPI（驅動12864屏）

工程準備，例程在此鏈接的基礎上添加的 https://blog.csdn.net/mygod2008ok/article/details/107142245 加入stm32f0xx_hal_spi.c和stm32f0xx_hal_s

仙剑情缘 2020-07-07 11:41:11

STM32F030R8Tx自定義協議實現串口升級詳解

基於STM32F030R8Tx爲例來剖析串口升級，本例程分爲三個部分 STM32應用程序部分 STM32 bootloader部分 上位機串口通信分發升級包部分 上位機與STM32之間的串口數據通信協議約定  包頭 包長度 命令

仙剑情缘 2020-07-07 11:41:11

使用STM32Cube可以直接生成使用FreeRTOS的工程

使用STM32Cube可以直接生成使用FreeRTOS的工程 在這裏面說到的 https://zhuanlan.zhihu.com/p/39718844

诗筱涵 2020-07-07 10:46:43