• Air protocol应用实战

    前言

    https://github.com/Tuotaba/air_protocol

    air_protocol提供一套应用于嵌入式设备的通讯协议。协议涉及协议完整性的验证，长短数据的灵活调整，以及数据过滤等。适合设备的数据传输、文件传输等。

    例1 收发数据

    1. #include "air_protocol.h"
    2. #include "fifo_buffer.h"
    3. #include 
    4. #include 
    5.  
    6. #define MAX_BUFFER_LEN	256
    7. static uint8_t pUartData[MAX_BUFFER_LEN];
    8. static buffer_list_t UartBuf;
    9.  
    10. static uint8_t air_buffer[MAX_BUFFER_LEN];
    11.  
    12. void send_uart(uint8_t cmd,uint8_t *buf,uint16_t len)
    13. {
    14. 	air_result_t result;
    15. 	air_ret_t ret;
    16. 	
    17. 	ret = air_alloc_pack(cmd,buf,len,&result);
    18. 	if(ret == AIR_FAIL)
    19. 		return;
    20. 	printf("send:\n");
    21. 	air_show_log(result.pdata,result.len);		
    22. 	printf("\n");
    23. 	buffer_append(&UartBuf,result.pdata,result.len);
    24. 	free(result.pdata);
    25. }
    26.  
    27. void uart_data_parser(void)
    28. {
    29. 	air_result_t result;
    30. 	air_ret_t ret;
    31. 	air_header_t air_header;
    32. 	uint8_t *pdata;
    33. 	int i,len;
    34. 	
    35. 	air_header.tag = AIR_TAG;
    36. 	i = buffer_find(&UartBuf,(uint8_t *)&air_header.tag,sizeof(air_header.tag));
    37. 	if(i >= 0)
    38. 	{
    39. 		if(i>0)
    40. 			buffer_pop(&UartBuf,NULL,i);
    41. 		if(get_data_length(&UartBuf) > AIR_HEADER_LEN)
    42. 		{
    43. 			pdata = (uint8_t *)&air_header;
    44. 			for(i=0;i
    45. 				pdata[i] = buffer_get(&UartBuf,i);
    46. 			len = (AIR_HEADER_LEN+air_header.len+1);
    47. 			if(get_data_length(&UartBuf) >= len)
    48. 			{
    49. 				buffer_pop(&UartBuf,air_buffer,len);
    50. 				ret = air_data_parser(air_buffer,len,&result);
    51. 				if(ret == AIR_SUCCESS)
    52. 				{
    53. 					printf("recv:cmd = %02X,len =%d\n",result.cmd,result.len);
    54. 					air_show_log(result.pdata,result.len);
    55. 					printf("\n");
    56. 				}
    57. 			}
    58. 		}
    59. 	}
    60. }
    61.  
    62. int main()
    63. {		
    64. 	int i,len;
    65. 	
    66. 	uint8_t data[] = {0xAA ,0xAA ,0xAA ,0xAA ,0xAA ,0xAA ,0xAA ,0xAA ,0xAA ,0xAA ,0xAA ,0xAA ,0xAA ,0xAA ,0xAA};
    67. 		
    68. 	buffer_init(&UartBuf,pUartData,MAX_BUFFER_LEN);
    69.  
    70. 	send_uart(0x0A,data,sizeof(data));
    71. 	uart_data_parser();
    72. 	return 0;
    73. }

    一般数据的收发，数据完整性验证，结果：

    send:

    8D 7C 6B 5A 0A 00 0F 00 AA AA AA AA AA AA AA AA

    AA AA AA AA AA AA AA DD

    recv:cmd = 0A,len =15

    AA AA AA AA AA AA AA AA AA AA AA AA AA AA AA

    例2 运动数据解析

    1. #include "air_protocol.h"
    2. #include "fifo_buffer.h"
    3. #include 
    4. #include 
    5.  
    6. #define MAX_BUFFER_LEN	256
    7. static uint8_t pUartData[MAX_BUFFER_LEN];
    8. static buffer_list_t UartBuf;
    9.  
    10. static uint8_t air_buffer[MAX_BUFFER_LEN];
    11.  
    12. typedef struct
    13. {	
    14. 	uint32_t calories;
    15. 	uint32_t speed;
    16. 	uint32_t distance;
    17. 	uint32_t time;
    18. }_sport_data_t;
    19.  
    20. #define CMD_SPORT_DATA	0x10
    21.  
    22. void send_uart(uint8_t cmd,uint8_t *buf,uint16_t len)
    23. {
    24. 	air_result_t result;
    25. 	air_ret_t ret;
    26. 	
    27. 	ret = air_alloc_pack(cmd,buf,len,&result);
    28. 	if(ret == AIR_FAIL)
    29. 		return;	
    30. 	buffer_append(&UartBuf,result.pdata,result.len);	
    31. 	free(result.pdata);
    32. }
    33.  
    34. static void command_handler(uint8_t cmd,uint8_t *buf,uint16_t len)
    35. {
    36. 	_sport_data_t *p_sport_data;
    37. 	
    38. 	switch(cmd)
    39. 	{
    40. 		case CMD_SPORT_DATA:
    41. 			p_sport_data = (_sport_data_t *)buf;
    42. 			printf("calories : %d\n",p_sport_data->calories);
    43. 			printf("speed : %d\n",p_sport_data->speed);
    44. 			printf("distance : %d\n",p_sport_data->distance);
    45. 			printf("time : %d\n",p_sport_data->time);
    46. 		break;
    47. 		default:break;
    48. 	}
    49. }
    50.  
    51. void uart_data_parser(void)
    52. {
    53. 	air_result_t result;
    54. 	air_ret_t ret;
    55. 	air_header_t air_header;
    56. 	uint8_t *pdata;
    57. 	int i,len;
    58. 	
    59. 	air_header.tag = AIR_TAG;
    60. 	i = buffer_find(&UartBuf,(uint8_t *)&air_header.tag,sizeof(air_header.tag));
    61. 	if(i >= 0)
    62. 	{
    63. 		if(i>0)
    64. 			buffer_pop(&UartBuf,NULL,i);
    65. 		if(get_data_length(&UartBuf) > AIR_HEADER_LEN)
    66. 		{
    67. 			pdata = (uint8_t *)&air_header;
    68. 			for(i=0;i
    69. 				pdata[i] = buffer_get(&UartBuf,i);
    70. 			len = (AIR_HEADER_LEN+air_header.len+1);
    71. 			if(get_data_length(&UartBuf) >= len)
    72. 			{
    73. 				buffer_pop(&UartBuf,air_buffer,len);
    74. 				ret = air_data_parser(air_buffer,len,&result);
    75. 				if(ret == AIR_SUCCESS)
    76. 				{
    77. 					command_handler(result.cmd,result.pdata,result.len);
    78. 				}
    79. 			}
    80. 		}
    81. 	}
    82. }
    83.  
    84. int main()
    85. {		
    86. 	int i,len;
    87. 	
    88. 	_sport_data_t data = {322,23,1000,30};	
    89. 	
    90. 	buffer_init(&UartBuf,pUartData,MAX_BUFFER_LEN);
    91. 	
    92. 	send_uart(CMD_SPORT_DATA,(uint8_t*)&data,sizeof(_sport_data_t));
    93. 	uart_data_parser();
    94. 	return 0;
    95. }

    收到对方发来的CMD_SPORT_DATA命令，附带_sport_data_t数据包，进行解析，解析出结果：

    calories : 322

    speed : 23

    distance : 1000

    time : 30

    例3 文件传输

    1. #include "air_protocol.h"
    2. #include "fifo_buffer.h"
    3. #include 
    4. #include 
    5. #include 
    6. #include 
    7.  
    8. #define MAX_BUFFER_LEN	512
    9. static uint8_t pUartData[MAX_BUFFER_LEN];
    10. static buffer_list_t UartBuf;
    11.  
    12. static uint8_t air_buffer[MAX_BUFFER_LEN];
    13.  
    14. typedef struct
    15. {	
    16. 	uint32_t addr;
    17. 	uint32_t len;
    18. 	uint8_t data[256];
    19. }_file_data_t;
    20.  
    21. #define CMD_FILE_BEGIN	0x10
    22. #define CMD_FILE_DATA	0x11
    23. #define CMD_FILE_END	0x12
    24.  
    25. void send_uart(uint8_t cmd,uint8_t *buf,uint16_t len)
    26. {
    27. 	air_result_t result;
    28. 	air_ret_t ret;
    29. 	
    30. 	ret = air_alloc_pack(cmd,buf,len,&result);
    31. 	if(ret == AIR_FAIL)
    32. 		return;	
    33. 	buffer_append(&UartBuf,result.pdata,result.len);	
    34. 	free(result.pdata);
    35. }
    36.  
    37. static void command_handler(uint8_t cmd,uint8_t *buf,uint16_t len)
    38. {	
    39. 	_file_data_t file_data;
    40. 	static uint32_t require_addr = 0;
    41. 	
    42. 	switch(cmd)
    43. 	{
    44. 		case CMD_FILE_BEGIN:		
    45. 			require_addr = 0;
    46. 		break;
    47. 		case CMD_FILE_DATA:			
    48. 			memcpy(&file_data,buf,len);
    49. 			printf("%08X :\n",file_data.addr);
    50. 			if(file_data.addr == require_addr){
    51. 				air_show_log(file_data.data,file_data.len);
    52. 				require_addr += file_data.len;
    53. 			}
    54. 			else{
    55. 				printf("please resend addr %08X\n",require_addr);
    56. 			}
    57. 		break;
    58. 		case CMD_FILE_END:
    59. 			printf("file is done\n");
    60. 			break;
    61. 		default:break;
    62. 	}
    63. }
    64.  
    65. void uart_data_parser(void)
    66. {
    67. 	air_result_t result;
    68. 	air_ret_t ret;
    69. 	air_header_t air_header;
    70. 	uint8_t *pdata;
    71. 	int i,len;
    72. 	
    73. 	air_header.tag = AIR_TAG;
    74. 	do{
    75. 		i = buffer_find(&UartBuf,(uint8_t *)&air_header.tag,sizeof(air_header.tag));
    76. 		if(i >= 0)
    77. 		{
    78. 			if(i>0)
    79. 				buffer_pop(&UartBuf,NULL,i);
    80. 			if(get_data_length(&UartBuf) > AIR_HEADER_LEN)
    81. 			{
    82. 				pdata = (uint8_t *)&air_header;
    83. 				for(i=0;i
    84. 					pdata[i] = buffer_get(&UartBuf,i);
    85. 				len = (AIR_HEADER_LEN+air_header.len+1);
    86. 				if(get_data_length(&UartBuf) >= len)
    87. 				{
    88. 					buffer_pop(&UartBuf,air_buffer,len);
    89. 					ret = air_data_parser(air_buffer,len,&result);
    90. 					if(ret == AIR_SUCCESS)
    91. 					{
    92. 						command_handler(result.cmd,result.pdata,result.len);
    93. 					}
    94. 					continue;
    95. 				}
    96. 			}			
    97. 		}
    98. 		break;
    99. 	}while(1);
    100. }
    101.  
    102. int main()
    103. {		
    104. 	int len;
    105. 	FILE *fp = NULL;
    106. 	
    107. 	_file_data_t file_data;
    108. 	
    109. 	buffer_init(&UartBuf,pUartData,MAX_BUFFER_LEN);
    110. 	
    111. 	file_data.addr = 0;
    112. 		
    113. 	fp = fopen("./test.bin","r");
    114. 	if(fp == NULL)
    115. 	{
    116. 		printf("not found test.bin\n");
    117. 		return 0;
    118. 	}	
    119. 	send_uart(CMD_FILE_BEGIN,NULL,0);	
    120. 	while(1){		
    121. 		len = fread(file_data.data,1,256,fp);
    122. 		if(len <= 0)
    123. 			break;
    124. 		file_data.len = len;
    125. 		send_uart(CMD_FILE_DATA,(uint8_t*)&file_data,file_data.len+8);
    126. 		uart_data_parser();
    127. 		file_data.addr += len;
    128. 	}
    129. 	send_uart(CMD_FILE_END,NULL,0);
    130. 	uart_data_parser();
    131. 	fclose(fp);
    132. 	return 0;
    133. }

    将test.bin读出，并进行传输，结果：

    00000000 :

    61 61 61 61 61 61 61 61 0A

    file is done

    如果文件足够大，会打印出更多的信息。

    因为协议有对每帧数据进行完整性验证，所以不怕数据会出错，也不需要收全文件再进行检验。

  • 相关阅读:
    Linux入门-网络基础|网络协议|OSI七层模型|TCP/IP五层模型|网络传输基本流程
    Java集合框架面试指南
    elasticsearch实现聚合后两个字段相除相加相减相乘运算
    CCF走进高校
    SaaS CRM系统的优势，与本地部署相比哪个更方便？
    解决因d3dx9_30.dll丢失程序无法运行，电脑缺失d3dx9_30.dll报错解决方案
    LeetCode热题100——贪心算法
    【CSDN】如何开启CSDN文章下的显示微信公众号、微信号、官方网站、QQ号、QQ群 ？
    wpf资源Resources探究性学习(一)
    4、React组件三大核心属性
  • 原文地址：https://blog.csdn.net/skdev/article/details/126609367