1.补充提交新增文件

func/func_record.c

@@ -19,15 +19,17 @@
 /* USER CODE END Header */
 #include "main.h"
 
-#if USE_FATFS_RECORD
+#if USE_FATFS_RECORD==1
 /* Includes ------------------------------------------------------------------*/
 #include <stdint.h>
 #include <string.h>
 #include <stdlib.h>
 #include <stdbool.h>
-
+#include "func_fatfs.h"
 #include "dev_spi_sdcard.h"
-#include "func_record.h"
+#include "func_spi_w25qxx.h"
+#include "func_fatfs_record.h"
+#include "func_queue_record.h"
 #include "Data_deal.h"
 /* Private includes ----------------------------------------------------------*/
 /* USER CODE BEGIN Includes */
@@ -36,7 +38,9 @@
 
 /* Private typedef -----------------------------------------------------------*/
 #define MAX_FILE_COUNT  20
-#define NUM_FILE_SET	 	16
+#define NUM_FILE_SET	 	10
+
+
 /* Private define ------------------------------------------------------------*/
 /* USER CODE BEGIN PD */
 
@@ -52,6 +56,11 @@
 /* USER CODE BEGIN PV */
 
 /* USER CODE END PV */
+const char FILE_START[] = "20";
+const char FILE_END[] = ".TXT";
+const char FILE_FOLD[] = "JLRECORD";
+
+
 
 /* Private function prototypes -----------------------------------------------*/
 
@@ -59,9 +68,9 @@
 
 typedef struct fs_record_struct
 {
-	int8_t    fatfs_ok;
-	int8_t 		path[32];   			//操作路径
-	
+	int8_t    fs_stat;
+	const char *fold;   			//操作路径
+	int8_t *	path[32];   			//操作路径
 	int8_t 		name_new[32];			//最新的文件名
 	int8_t 		name_send[32];			//最老的文件名
 	
@@ -69,6 +78,7 @@ typedef struct fs_record_struct
 	FATFS 		fs;	
 	DIR 			dir;							//操作的文件名
 	uint32_t  opt_len;
+	uint32_t  items_num;
 	
 	int8_t 		read_buf[512];	
 	uint32_t 	read_len;
@@ -77,14 +87,21 @@ typedef struct fs_record_struct
 	uint32_t  write_len;
 	
 	uint32_t 	 file_num;
-	int8_t 		 file_list[MAX_FILE_COUNT][30];//保存文件名
+	int8_t 		 file_list[MAX_FILE_COUNT][32];//保存文件名
+	
+	int8_t     link_ok;
+
+	uint32_t 	 free_size;
+
 }fs_record_OBJ;
 
 
 fs_record_OBJ fs_record_obj = {
-	.fatfs_ok = true,
-	.path 		= "JLRecord",
+	.fs_stat = true,
+	.fold 		= FILE_FOLD,
+	.items_num= 0,
 	.file_num = 0,
+	.link_ok  = false,
 };
 
 //add boly 20221020
@@ -100,23 +117,39 @@ extern SDateTime m_datetime;
 uint8_t func_record_fatfs_isOK(void)
 {
 		
-		return fs_record_obj.fatfs_ok;
+		return fs_record_obj.fs_stat;
 }
 
 uint8_t func_record_fatfs_set_OK(uint8_t stat)
 {
-		fs_record_obj.fatfs_ok = stat;
-		return fs_record_obj.fatfs_ok;
+		fs_record_obj.fs_stat = stat;
+		return fs_record_obj.fs_stat;
 }
 
 void func_record_mk_fileName(char *buf)
 {
-		fs_record_obj.path[12] = 0;
-		sprintf(buf,"%s/%04d%02d%02d.txt",fs_record_obj.path,
+		//fs_record_obj.path[12] = 0;		
+#if 0	
+		sprintf(buf,"%s/%04d%02d%02d.TXT",fs_record_obj.fold,
 																			m_datetime.year%100 + 2000,
 																			m_datetime.month%100,
 																			m_datetime.day%100
 																			);
+#elif 0
+		sprintf(buf,"%s/%04d%02d%02d.TXT",fs_record_obj.fold,
+																			m_datetime.day%100 + 2000,
+																			m_datetime.hour%100,
+																			m_datetime.min%100	
+																			);
+#else	
+			sprintf(buf,"%s/%04d%02d%02d.TXT",fs_record_obj.fold,
+																			m_datetime.hour%100 + 2000,
+																			m_datetime.min%100,
+																			m_datetime.sec%100	
+																			);
+	
+#endif	
+
 		return;
 }
 /**
@@ -136,36 +169,36 @@ uint32_t func_record_write(uint8_t *buf ,uint32_t len)
 	res = f_open(&fs_record_obj.opt_file,(char *)fs_record_obj.name_new , FA_WRITE| FA_OPEN_EXISTING);
 	if(FR_OK != res)
 	{
+		//检查文件个数是否超限
+		func_record_files_update((char *)fs_record_obj.fold);
+		
 		if(FR_NO_FILE == res)
-		{
-			//检查文件个数是否超限
-			func_record_files_update((char *)fs_record_obj.path);
-			
+		{			
 			//创建文件并写入
 			res = f_open(&fs_record_obj.opt_file, (char*)fs_record_obj.name_new, FA_WRITE| FA_CREATE_NEW);
 			if(FR_OK != res)
 			{
-				fs_record_obj.fatfs_ok = false;
+				fs_record_obj.fs_stat = false;
 				return 0;
-			}
-			
+			}			
 		}		
 		else
 		{
 			return 0;
 		}
 	}
+	//将当前发送文件更新为当前写入文件
+	strcpy((char *)fs_record_obj.name_send,(char *)fs_record_obj.name_new);
 	
 	fs_record_obj.opt_len = f_size(&fs_record_obj.opt_file);
 	
 	//操作指针移动到文件末尾
 	res = f_lseek(&fs_record_obj.opt_file, fs_record_obj.opt_len);
-
-	res = f_write(&fs_record_obj.opt_file, buf, len, &write_len);
 	
-	res = f_sync (&fs_record_obj.opt_file ); 	//刷新文件
-	
-	res = f_close(&fs_record_obj.opt_file);		//关闭文件
+	taskENTER_CRITICAL();    /* 临界保护开启 */
+	res = f_write(&fs_record_obj.opt_file, buf, len, &write_len);	
+	res = f_close(&fs_record_obj.opt_file);		//关闭文件	
+	taskEXIT_CRITICAL();    /* 临界保护关闭 */
 	
  	return write_len;
 }
@@ -175,18 +208,12 @@ void func_record_get_NameSend(void)
 	//发送文件是否存在
 	if(strlen((char*)fs_record_obj.name_send) > 0)
 	{
-		if(strlen((char*)fs_record_obj.name_new) > 0)
-		{
-			strcpy((char*)fs_record_obj.name_send, (char*)fs_record_obj.name_new);
-		}
+		return;
 	}
-	else
-	{
-		//检查文件个数是否超限
-		func_record_files_update((char *)fs_record_obj.path);
-	}	
+
 	
-	return;
+	//检查文件个数是否超限
+	func_record_files_update((char *)fs_record_obj.fold);
 }
 
 /**
@@ -202,10 +229,7 @@ uint32_t func_record_read(uint8_t *buf, uint32_t len)
 	
 	func_record_get_NameSend();
 	
-	if(strlen((char *)fs_record_obj.name_send) > 0)
-	{
-	}
-	else
+	if(strlen((char *)fs_record_obj.name_send) <= 0)
 	{
 		return 0;
 	}
@@ -223,7 +247,10 @@ uint32_t func_record_read(uint8_t *buf, uint32_t len)
 	{
 			res = f_close(&fs_record_obj.opt_file);
 		
+			taskENTER_CRITICAL();    /* 临界保护开启 */
 			res = f_unlink((char*)fs_record_obj.name_send);
+			taskEXIT_CRITICAL();    /* 临界保护关闭 */
+		
 			if(res == FR_OK)
 			{
 				memset((char*)fs_record_obj.name_send, 0x00,sizeof(fs_record_obj.name_send));
@@ -233,22 +260,67 @@ uint32_t func_record_read(uint8_t *buf, uint32_t len)
 	res = f_lseek(&fs_record_obj.opt_file, fs_record_obj.opt_len - len);
 	
 	res = f_read(&fs_record_obj.opt_file, buf, len, &read_len);
-
+	
 	res = f_close(&fs_record_obj.opt_file);
+	
 		
 	return read_len;
 }
 
+uint32_t func_record_remove(uint8_t *buf, uint32_t len)
+{
+	FRESULT res;
+
+	uint32_t 		read_len = 0;
+	
+	func_record_get_NameSend();
+	
+	if(strlen((char *)fs_record_obj.name_send) <= 0)
+	{
+		return 0;
+	}
+	
+	res = f_open(&fs_record_obj.opt_file, (char*)fs_record_obj.name_send, FA_WRITE| FA_READ| FA_OPEN_EXISTING);
+	if(FR_OK != res)
+	{	
+		memset((char*)fs_record_obj.name_send, 0x00,sizeof(fs_record_obj.name_send));
+		return 0;
+	}		
+	
+	fs_record_obj.opt_len = f_size(&fs_record_obj.opt_file);
+	
+	//如果文件小于数据长度，则删除文件
+	if(fs_record_obj.opt_len < len)
+	{
+			res = f_close(&fs_record_obj.opt_file);
+			taskENTER_CRITICAL();    /* 临界保护开启 */
+			res = f_unlink((char*)fs_record_obj.name_send);
+			taskEXIT_CRITICAL();    /* 临界保护关闭 */
+			if(res == FR_OK)
+			{
+				memset((char*)fs_record_obj.name_send, 0x00,sizeof(fs_record_obj.name_send));
+			}
+			return 0;
+	};
+	res = f_lseek(&fs_record_obj.opt_file, fs_record_obj.opt_len - len);	
+	res = f_read(&fs_record_obj.opt_file, buf, len, &read_len);
+	
+	res = f_lseek(&fs_record_obj.opt_file, fs_record_obj.opt_len - len);	
+	
+	taskENTER_CRITICAL();    /* 临界保护开启 */
+	res = f_truncate(&fs_record_obj.opt_file ); 		//截断后面的文件
+	res = f_close(&fs_record_obj.opt_file);	
+	taskEXIT_CRITICAL();    /* 临界保护关闭 */	
+		
+	return read_len;
+}
 
 uint32_t func_record_delete(uint8_t *buf,uint32_t len)
 {
 	FRESULT res;
 	//uint32_t file_len = 0;
 	
-	if(strlen((char *)fs_record_obj.name_send) > 0)
-	{
-	}
-	else
+	if(strlen((char *)fs_record_obj.name_send) <= 0)
 	{
 		return 0;
 	}
@@ -270,8 +342,9 @@ uint32_t func_record_delete(uint8_t *buf,uint32_t len)
 	if(fs_record_obj.opt_len <= len)
 	{
 		res = f_close(&fs_record_obj.opt_file);
-		
+		taskENTER_CRITICAL();    /* 临界保护开启 */
 		res = f_unlink((char*)fs_record_obj.name_send);
+		taskEXIT_CRITICAL();    /* 临界保护关闭 */
 		if(res == FR_OK)
 		{
 			memset((char*)fs_record_obj.name_send, 0x00,sizeof(fs_record_obj.name_send));
@@ -280,11 +353,9 @@ uint32_t func_record_delete(uint8_t *buf,uint32_t len)
 	};
 	
 	res = f_lseek(&fs_record_obj.opt_file, fs_record_obj.opt_len - len);
-	
+	taskENTER_CRITICAL();    /* 临界保护开启 */
 	res = f_truncate(&fs_record_obj.opt_file ); 		//截断后面的文件
-	
-	res = f_sync(&fs_record_obj.opt_file); 					//刷新关闭文件
-	
+	taskEXIT_CRITICAL();    /* 临界保护关闭 */	
 	res = f_close(&fs_record_obj.opt_file);	
 	
 	return res;
@@ -391,11 +462,14 @@ void func_record_files_update(char * path)
 		char file_name[32] = {0};
 	  FRESULT res; 		//部分在递归过程被修改的变量，不用全局变量		
 	  FILINFO fno = {0}; 
-		
+		fs_record_obj.items_num = 0;
 		fs_record_obj.file_num = 0;				
 		memset((void *)fs_record_obj.file_list, 0x00,sizeof(fs_record_obj.file_list));		
 		memset((void *)fs_record_obj.name_send, 0x00,sizeof(fs_record_obj.name_send));
 		
+		//获取fatfs文件系统
+		fs_record_obj.free_size = func_fatfs_get_free();
+		
 #if _USE_LFN//如果使能支持长文件名 先对下面两项初始化
     fileinfo.lfsize=_MAX_LFN * 2 + 1;//
     fileinfo.lfname=(TCHAR*)FileName;//
@@ -405,7 +479,7 @@ void func_record_files_update(char * path)
 			res = f_mkdir((const char*)path);
 			if(res == FR_OK)
 			{
-				fs_record_obj.fatfs_ok = true;
+				fs_record_obj.fs_stat = true;
 				return;
 			}
 			else
@@ -414,33 +488,41 @@ void func_record_files_update(char * path)
 			}
 		}		
 		
-		fs_record_obj.fatfs_ok = true;
+		fs_record_obj.fs_stat = true;
 		
 		//打开日志路径正常,获取路文件夹内的文件列表
 		while(f_readdir(&fs_record_obj.dir, &fno) == FR_OK)  	//读文件信息到文件状态结构体中
-		{			
-				if(!fno.fname[0]) break; 													//如果文件名为‘\0'，说明读取完成结束		
-			
+		{		
+				fs_record_obj.items_num++;
+				//判定的顺序不能变			
+				if(!fno.fname[0]) break; 													//如果文件名为‘\0'，说明读取完成结束
+
 				if (fno.fattrib & AM_DIR)	continue; 						  //表示目录，跳过	
 			
 				if (fno.fname[0] == '.') continue; 								//点表示当前目录，跳过				
 
 						
-				if(fs_record_obj.file_num < MAX_FILE_COUNT)
+				if( (fs_record_obj.file_num < MAX_FILE_COUNT)
+					&&(strstr(fno.fname,FILE_START) == fno.fname)
+				  &&((strstr(fno.fname,FILE_END) != 0))
+				)
 				{
-						sprintf((char *)fs_record_obj.file_list[fs_record_obj.file_num], "%s/%s", fs_record_obj.path,fno.fname);//将文件名存入列表中
+						sprintf((char *)fs_record_obj.file_list[fs_record_obj.file_num], "%s/%s", fs_record_obj.fold,fno.fname);//将文件名存入列表中
 						fs_record_obj.file_num ++;	
 				}
 				else
-				{
+				{	
 					/* 如果目录已经存在，关闭它 */
-					res = f_closedir(&fs_record_obj.dir);
+					res = f_closedir(&fs_record_obj.dir);	
 					
-					sprintf((char *)file_name,"%s/%s",fs_record_obj.path, fno.fname);								//输出文件名	
+					sprintf((char *)file_name,"%s/%s",fs_record_obj.fold, fno.fname);								//输出文件名	
+					taskENTER_CRITICAL();    /* 临界保护开启 */
 					res = f_unlink(file_name);
+					taskEXIT_CRITICAL();    /* 临界保护关闭 */
 					if(FR_OK != res)
 					{
-						fs_record_obj.fatfs_ok = false;
+											
+						fs_record_obj.fs_stat = false;
 						return;
 					}
 				}
@@ -469,14 +551,19 @@ void func_record_files_update(char * path)
 		sprintf((char *)fs_record_obj.name_send,"%s", fs_record_obj.file_list[max_idx]);			
 		
 		//如果文件个数超限，
-		if(fs_record_obj.file_num > NUM_FILE_SET)
+		if((fs_record_obj.file_num > NUM_FILE_SET)
+			||(fs_record_obj.free_size < 500))
 		{			
 			//删除日期最早的文件
 			sprintf((char *)file_name,"%s",  fs_record_obj.file_list[0]);		
+			
+			taskENTER_CRITICAL();    /* 临界保护开启 */
 			res = f_unlink(file_name);
+			taskEXIT_CRITICAL();    /* 临界保护关闭 */
+			
 			if(FR_OK != res)
 			{
-				fs_record_obj.fatfs_ok = false;
+				fs_record_obj.fs_stat = false;
 				return;
 			}									
 		}		
@@ -503,19 +590,12 @@ void func_record_init(void)
 	
 	memset(fs_record_obj.file_list, 0x00,sizeof(fs_record_obj.file_list));		//清空文件列表
 	fs_record_obj.file_num = 0;
-	fs_record_obj.fatfs_ok = true;
-	func_record_files_update((char *)fs_record_obj.path);
+	fs_record_obj.fs_stat = true;
+	func_record_files_update((char *)fs_record_obj.fold);
 }
-typedef struct record_test_object
-{
-	uint32_t 	cnts;
-	uint8_t 	test_flag;
-	char 			buf[32];
-}record_test_OBJ;
-	
-record_test_OBJ record_test_obj;
 
-void func_record_test(void)
+
+void func_record_fs_test(void)
 {	
 	
 	record_test_obj.cnts++;
@@ -541,13 +621,66 @@ void func_record_test(void)
 	
 }
 
-void func_record_main(void const *argument)
+
+char*  pstr = 0;
+char*  pidx = 0;
+void func_record_str(void)
+{
+	char  str_name[] ="20221112.TXT" ;
+
+	while(1)
+	{
+		pstr =  strstr(str_name,FILE_START);
+		
+		pidx =  strstr(str_name,FILE_END);
+		UNUSED(pstr);
+		UNUSED(pidx);
+	}
+}
+char path_buf[512] = {0};
+void func_record_fatfs_main(void const *argument)
 {
+	//func_record_str();
+
+	
+	//add boly 20221014  SD卡 FATFS组件初始化	
+#if USE_SPI_SD	
+  SDCARD_GPIO_Init();
+  SDCARD_SPI_Init();
+#endif
+	
+#if USE_SPI_FLASH	
+  func_w25q_init();
+	func_w25q_test();
+#endif
+		
+	
+	
+#if USE_FATFS_RECORD	
+	taskENTER_CRITICAL();	
+	func_fatfs_init();
+	func_fatfs_main();
+	taskEXIT_CRITICAL();
+	
+	func_record_queue_init();
+	func_record_queue_update();
+	
+	//while(1)
+	{
+		osDelay(1000);
+	};	
+	//end boly
+#endif
+
 	osDelay(1000);//
 	func_record_init();
 	while(1)
 	{
-		func_record_test();
+		strcpy(path_buf,fs_record_obj.fold);
+		//func_fatfs_scan_files(path_buf);
+		//func_record_fs_test();
+		func_record_queue_test();
+		func_record_work();
 		osDelay(1000);
 	}
 }

func/func_record.h

@@ -18,7 +18,7 @@
   ******************************************************************************
   */
 /* USER CODE END Header */
-
+#if USE_FATFS_RECORDD
 /* Define to prevent recursive inclusion -------------------------------------*/
 #ifndef FUNC_RECORD_H
 #define FUNC_RECORD_H
@@ -53,8 +53,8 @@ extern "C" {
 
 
 /* Exported functions prototypes ---------------------------------------------*/
-void func_record_init(void);											//记录文件初始化
-void func_record_main(void const *argument);			//文件操作主函数
+void func_record_init(void);														//记录文件初始化
+void func_record_fatfs_main(void const *argument);			//文件操作主函数
 void func_record_test(void);
 	
 
@@ -63,6 +63,9 @@ uint32_t func_record_read(uint8_t *buf ,uint32_t len);
 uint32_t func_record_delete(uint8_t *buf,uint32_t len);
 uint8_t func_record_fatfs_set_OK(uint8_t stat);
 uint8_t func_record_fatfs_isOK(void);
+
+
+
 /* Private defines -----------------------------------------------------------*/
 
 
@@ -72,4 +75,6 @@ uint8_t func_record_fatfs_isOK(void);
 
 #endif /* FUNC_RECORD_H */
 
+#endif //-------------------USE_FATFS_RECORDD-----------------------//
+
 /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/

func/func_lfs_record.c

@@ -0,0 +1,658 @@
+/* USER CODE BEGIN Header */
+/**
+  ******************************************************************************
+  * @file           : main.c
+  * @brief          : Main program body
+  ******************************************************************************
+  * @attention
+  *
+  * <h2><center>&copy; Copyright (c) 2019 STMicroelectronics.
+  * All rights reserved.</center></h2>
+  *
+  * This software component is licensed by ST under BSD 3-Clause license,
+  * the "License"; You may not use this file except in compliance with the
+  * License. You may obtain a copy of the License at:
+  *                        opensource.org/licenses/BSD-3-Clause
+  *
+  ******************************************************************************
+  */
+/* USER CODE END Header */
+#include "main.h"
+
+#if USE_LFS_RECORD
+/* Includes ------------------------------------------------------------------*/
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include <stdbool.h>
+#include "dev_spi_sdcard.h"
+#include "func_spi_w25qxx.h"
+#include "mid_littlefs_flash.h"
+#include "func_queue_record.h"
+#include "Data_deal.h"
+/* Private includes ----------------------------------------------------------*/
+/* USER CODE BEGIN Includes */
+
+/* USER CODE END Includes */
+
+/* Private typedef -----------------------------------------------------------*/
+#define MAX_FILE_COUNT  20
+#define NUM_FILE_SET	 	10
+
+
+/* Private define ------------------------------------------------------------*/
+/* USER CODE BEGIN PD */
+
+/* USER CODE END PD */
+
+/* Private macro -------------------------------------------------------------*/
+/* USER CODE BEGIN PM */
+
+/* USER CODE END PM */
+
+/* Private variables ---------------------------------------------------------*/
+
+/* USER CODE BEGIN PV */
+
+/* USER CODE END PV */
+const char FILE_START[] = "20";
+const char FILE_END[] = ".TXT";
+const char FILE_FOLD[] = "JLRECORD";//"";//
+
+/* Private function prototypes -----------------------------------------------*/
+
+#pragma pack(4) /*4字节对齐*/
+
+typedef struct fs_record_struct
+{
+	int8_t    fs_stat;
+	const char *fold;   			//操作路径
+	int8_t *	path[32];   			//操作路径
+	int8_t 		name_new[32];			//最新的文件名
+	int8_t 		name_send[32];			//最老的文件名
+	
+	lfs_file_t	opt_file;				//当前操作的文件
+	lfs_dir_t  dir;							//操作的文件名
+	uint32_t  opt_len;
+	uint32_t  items_num;
+	
+	int8_t 		read_buf[512];	
+	uint32_t 	read_len;
+	
+	int8_t 		write_buf[512];		
+	uint32_t  write_len;
+	
+	uint32_t 	 file_num;
+	int8_t 		 file_list[MAX_FILE_COUNT][32];//保存文件名
+	
+	int8_t     link_ok;
+
+	uint32_t 	 free_size;
+
+}fs_record_OBJ;
+
+
+fs_record_OBJ fs_record_obj = {
+	.fs_stat = true,
+	.fold 		= FILE_FOLD,
+	.items_num= 0,
+	.file_num = 0,
+	.link_ok  = false,
+};
+
+#pragma pack()/*还原默认对齐*/
+void 	func_record_lfs_Get_Capacity(void);
+void func_record_lfs_files_update(char * path);
+void func_record_lfs_dir_qsort(size_t fcount);
+
+extern SDateTime m_datetime;
+/* Private user code ---------------------------------------------------------*/
+
+uint8_t func_record_lfs_stat_get(void)
+{
+		
+		return fs_record_obj.fs_stat;
+}
+
+uint8_t func_record_lfs_stat_set(uint8_t stat)
+{
+		fs_record_obj.fs_stat = stat;
+		return fs_record_obj.fs_stat;
+}
+
+void func_record_lfs_mk_fileName(char *buf)
+{
+		//fs_record_obj.path[12] = 0;		
+#if 0	
+		sprintf(buf,"%s/%04d%02d%02d.TXT",fs_record_obj.fold,
+																			m_datetime.year%100 + 2000,
+																			m_datetime.month%100,
+																			m_datetime.day%100
+																			);
+#elif 0
+		sprintf(buf,"%s/%04d%02d%02d.TXT",fs_record_obj.fold,
+																			m_datetime.day%100 + 2000,
+																			m_datetime.hour%100,
+																			m_datetime.min%100	
+																			);
+#else	
+			sprintf(buf,"%s/%04d%02d%02d.TXT",fs_record_obj.fold,
+																			m_datetime.hour%100 + 2000,
+																			m_datetime.min%100,
+																			m_datetime.sec%100	
+																			);
+	
+#endif	
+
+		return;
+}
+/**
+  * @brief  指定长度len,buf内容写入文件
+  * @retval int
+  */
+uint32_t func_record_lfs_write(void *buf ,uint32_t len)
+{
+		
+	lfs_soff_t res;
+	UINT 		write_len = 0;
+
+	//根据日期生成文件名，用于文件写入
+	func_record_lfs_mk_fileName((char *)fs_record_obj.name_new);
+	
+	//打开当前存在的文件；
+	res = lfs_file_open_static(&lfs_flash, &fs_record_obj.opt_file,(char *)fs_record_obj.name_new , LFS_O_WRONLY);
+	if(LFS_ERR_OK != res)
+	{
+		//检查文件个数是否超限
+		func_record_lfs_files_update((char *)fs_record_obj.fold);
+		
+		if(LFS_ERR_NOENT == res)
+		{			
+			//创建文件并写入
+			res = lfs_file_open_static(&lfs_flash, &fs_record_obj.opt_file, (char*)fs_record_obj.name_new, LFS_O_RDWR| LFS_O_CREAT);
+			if(LFS_ERR_OK != res)
+			{
+				fs_record_obj.fs_stat = false;
+				return 0;
+			}			
+		}		
+		else
+		{
+			return 0;
+		}
+	}
+	//将当前发送文件更新为当前写入文件
+	strcpy((char *)fs_record_obj.name_send,(char *)fs_record_obj.name_new);
+	
+	fs_record_obj.opt_len = lfs_file_size(&lfs_flash, &fs_record_obj.opt_file);
+	
+	//操作指针移动到文件末尾
+	res = lfs_file_seek(&lfs_flash, &fs_record_obj.opt_file, fs_record_obj.opt_len,LFS_SEEK_END);
+	
+	taskENTER_CRITICAL();    /* 临界保护开启 */
+	res = lfs_file_write(&lfs_flash, &fs_record_obj.opt_file, buf, len);	
+	
+	//lfs_file_sync(&lfs_flash, &fs_record_obj.opt_file);
+	
+	res = lfs_file_close(&lfs_flash, &fs_record_obj.opt_file);		//关闭文件	
+	taskEXIT_CRITICAL();    /* 临界保护关闭 */
+	
+ 	return write_len;
+}
+
+void func_record_lfs_get_NameSend(void)
+{
+	//发送文件是否存在
+	if(strlen((char*)fs_record_obj.name_send) > 0)
+	{
+		return;
+	}
+
+	
+	//检查文件个数是否超限
+	func_record_lfs_files_update((char *)fs_record_obj.fold);
+}
+
+/**
+  * @brief  The application entry point.
+  * @retval int
+  */
+uint32_t func_record_lfs_read(uint8_t *buf, uint32_t len)
+{
+	lfs_soff_t res;
+	//uint32_t 		file_len = 0;
+	uint32_t 		read_len = 0;
+	
+	func_record_lfs_get_NameSend();
+	
+	if(strlen((char *)fs_record_obj.name_send) <= 0)
+	{
+		return 0;
+	}
+	
+	res = lfs_file_open_static(&lfs_flash, &fs_record_obj.opt_file, (char*)fs_record_obj.name_send, LFS_O_RDONLY);
+	if(LFS_ERR_OK != res)
+	{	
+		return 0;
+	}		
+	
+	fs_record_obj.opt_len = lfs_file_size(&lfs_flash, &fs_record_obj.opt_file);
+	
+	//如果文件小于数据长度，则删除文件
+	if(fs_record_obj.opt_len < len)
+	{
+			res = lfs_file_close(&lfs_flash, &fs_record_obj.opt_file);
+		
+			taskENTER_CRITICAL();    /* 临界保护开启 */
+			res = lfs_remove(&lfs_flash, (char*)fs_record_obj.name_send);
+			taskEXIT_CRITICAL();    /* 临界保护关闭 */
+		
+			if(res == LFS_ERR_OK)
+			{
+				memset((char*)fs_record_obj.name_send, 0x00,sizeof(fs_record_obj.name_send));
+			}
+			return 0;
+	};
+	res = lfs_file_seek(&lfs_flash, &fs_record_obj.opt_file, 0 - len, LFS_SEEK_END);
+	
+	res = lfs_file_read(&lfs_flash, &fs_record_obj.opt_file, buf, len);
+	
+	res = lfs_file_close(&lfs_flash, &fs_record_obj.opt_file);
+	
+		
+	return read_len;
+}
+
+int32_t func_record_lfs_remove(void *buf, uint32_t len)
+{
+	lfs_soff_t res;
+	uint32_t 		read_len = 0;
+	
+	func_record_lfs_get_NameSend();
+	
+	if(strlen((char *)fs_record_obj.name_send) <= 0)
+	{
+		return 0;
+	}
+	
+	res = lfs_file_open_static(&lfs_flash, &fs_record_obj.opt_file, (char*)fs_record_obj.name_send, LFS_O_RDWR);
+	if(LFS_ERR_OK != res)
+	{	
+		memset((char*)fs_record_obj.name_send, 0x00,sizeof(fs_record_obj.name_send));
+		return 0;
+	}		
+	
+	fs_record_obj.opt_len = lfs_file_size(&lfs_flash, &fs_record_obj.opt_file);
+	
+	//如果文件小于数据长度，则删除文件
+	if(fs_record_obj.opt_len < len)
+	{
+			res = lfs_file_close(&lfs_flash, &fs_record_obj.opt_file);
+			taskENTER_CRITICAL();    /* 临界保护开启 */
+			res = lfs_remove(&lfs_flash, (char*)fs_record_obj.name_send);
+			taskEXIT_CRITICAL();    /* 临界保护关闭 */
+			if(res == LFS_ERR_OK)
+			{
+				memset((char*)fs_record_obj.name_send, 0x00,sizeof(fs_record_obj.name_send));
+			}
+			return 0;
+	};
+	res = lfs_file_seek(&lfs_flash, &fs_record_obj.opt_file, 0 - len, LFS_SEEK_END);	
+	res = lfs_file_read(&lfs_flash, &fs_record_obj.opt_file, buf, len);	
+	
+	taskENTER_CRITICAL();    /* 临界保护开启 */
+	res = lfs_file_truncate(&lfs_flash, &fs_record_obj.opt_file ,fs_record_obj.opt_len - len); 		//截断后面的文件
+	res = lfs_file_close(&lfs_flash, &fs_record_obj.opt_file);	
+	taskEXIT_CRITICAL();    /* 临界保护关闭 */	
+		
+	return read_len;
+}
+
+int32_t func_record_lfs_delete(uint8_t *buf,uint32_t len)
+{
+	lfs_soff_t res;
+	
+	if(strlen((char *)fs_record_obj.name_send) <= 0)
+	{
+		return 0;
+	}
+	//打开文件
+	res = lfs_file_open_static(&lfs_flash, &fs_record_obj.opt_file, (char*)fs_record_obj.name_send, LFS_O_WRONLY | LFS_O_EXCL );
+	
+	if ( res != LFS_ERR_OK ) 
+	{
+		if(res == FR_NO_FILE )
+		{
+			memset((char*)fs_record_obj.name_send, 0x00,sizeof(fs_record_obj.name_send));
+			memset((char*)fs_record_obj.name_new,  0x00,sizeof(fs_record_obj.name_new));
+		}
+		return res;
+	}
+	
+	fs_record_obj.opt_len = lfs_file_size(&lfs_flash, &fs_record_obj.opt_file);
+	//如果文件小于数据长度，则删除文件
+	if(fs_record_obj.opt_len <= len)
+	{
+		res = lfs_file_close(&lfs_flash, &fs_record_obj.opt_file);
+		taskENTER_CRITICAL();    /* 临界保护开启 */
+		res = lfs_remove(&lfs_flash, (char*)fs_record_obj.name_send);
+		taskEXIT_CRITICAL();    /* 临界保护关闭 */
+		if(res == LFS_ERR_OK)
+		{
+			memset((char*)fs_record_obj.name_send, 0x00,sizeof(fs_record_obj.name_send));
+		}
+		return 0;			
+	};
+	
+	taskENTER_CRITICAL();    /* 临界保护开启 */
+	res = lfs_file_truncate(&lfs_flash, &fs_record_obj.opt_file, fs_record_obj.opt_len - len); 		//截断后面的文件
+	taskEXIT_CRITICAL();    /* 临界保护关闭 */	
+	res = lfs_file_close(&lfs_flash, &fs_record_obj.opt_file);	
+	
+	return res;
+}
+
+
+
+/**
+  * 文件信息获取
+  */
+lfs_soff_t func_record_lfs_file_check(void)
+{ 
+	lfs_soff_t res;                    /* 文件操作结果 */	
+  struct lfs_info finfo;
+  /* 获取文件信息 */
+  res=lfs_stat(&lfs_flash,"TestDir/testdir.txt",&finfo);
+	
+  if(res==LFS_ERR_OK)
+  {
+    printf("“testdir.txt”文件信息：\n");
+    printf("》文件大小: %ld(字节)\n", finfo.size);
+    //printf("》时间戳: %u/%02u/%02u, %02u:%02u\n",
+    //       (finfo.fdate >> 9) + 1980, finfo.fdate >> 5 & 15, finfo.fdate & 31,finfo.ftime >> 11, finfo.ftime >> 5 & 63);
+    printf("》属性: %c%c%\n\n",
+           (finfo.type & LFS_TYPE_DIR) ? 'D' : '-',      // 是一个目录
+           (finfo.type & LFS_TYPE_REG) ? 'R' : '-'      // 只读文件
+					);
+
+  }
+  return res;
+}
+
+/**
+  * @brief  scan_files 递归扫描FatFs内的文件
+  * @param  path:初始扫描路径
+  * @retval result:文件系统的返回值
+  */
+lfs_soff_t func_record_lfs_scan_files (char* path) 
+{ 
+  lfs_soff_t res; 		//部分在递归过程被修改的变量，不用全局变量	
+  struct lfs_info fno; 
+	
+	lfs_dir_t		dir;	
+  int i;            
+  char *fn;        // 文件名	
+	
+  //打开目录
+  res = lfs_dir_open(&lfs_flash, &dir, path); 
+  if (res == LFS_ERR_OK) 
+	{ 
+    i = strlen(path); 
+    for (;;) 
+		{ 
+      //读取目录下的内容，再读会自动读下一个文件
+      res = lfs_dir_read(&lfs_flash, &dir, &fno); 								
+      //为空时表示所有项目读取完毕，跳出
+      if (res != true || fno.name[0] == 0) break; 	
+#if _USE_LFN 
+      fn = *fno.lfname ? fno.lfname : fno.name; 
+#else 
+      fn = fno.name; 
+#endif 
+      //点表示当前目录，跳过			
+      if (*fn == '.') continue; 	
+      //目录，递归读取      
+      if (fno.type & LFS_TYPE_DIR)         
+			{ 			
+        //合成完整目录名        
+        sprintf(&path[i], "/%s", fn); 		
+//        //递归遍历         
+//        res = func_record_lfs_scan_files(path);	
+//        path[i] = 0;         
+//        //打开失败，跳出循环        
+//        if (res != LFS_ERR_OK) 
+//					break; 
+      } 
+			else 
+			{ 
+				printf("%s/%s\n", path, fn);								//输出文件名	
+        /* 可以在这里提取特定格式的文件路径 */        
+      }//else
+    } //for
+		
+	} 
+	
+	lfs_dir_close(&lfs_flash, &fs_record_obj.dir);
+  return res; 
+}
+
+
+/*------------------------------------------------------
+ 读取指定目录下所有的文件
+ 说明:
+  lfs_dir_read    按顺序读取目录内文件，
+ 重复调用此函数可读取目录内所有文件；
+---------------------------------------------------------*/
+void func_record_lfs_files_update(char * path)
+{		
+		char file_name[32] = {0};
+	  lfs_soff_t res; 		//部分在递归过程被修改的变量，不用全局变量		
+	  struct lfs_info  fno = {0}; 
+		fs_record_obj.items_num = 0;
+		fs_record_obj.file_num = 0;				
+		memset((void *)fs_record_obj.file_list, 0x00,sizeof(fs_record_obj.file_list));		
+		memset((void *)fs_record_obj.name_send, 0x00,sizeof(fs_record_obj.name_send));
+		
+		//获取fatfs文件系统
+		fs_record_obj.free_size = mid_lfs_flash_get_free();
+		
+#if _USE_LFN//如果使能支持长文件名 先对下面两项初始化
+    fileinfo.lfsize=_MAX_LFN * 2 + 1;//
+    fileinfo.lfname=(TCHAR*)FileName;//
+#endif
+		res = lfs_dir_open(&lfs_flash, &fs_record_obj.dir,(const char*)path);
+    if(res != LFS_ERR_OK)/* 打开文件夹目录成功，目录信息已经在dir结构体中保存 */
+    {
+			res = lfs_mkdir(&lfs_flash, (const char*)path);
+			if(res == LFS_ERR_OK)
+			{
+				fs_record_obj.fs_stat = true;
+				return;
+			}
+			else
+			{				
+				return;
+			}
+		}		
+		
+		fs_record_obj.fs_stat = true;
+		
+		//打开日志路径正常,获取路文件夹内的文件列表
+		while(lfs_dir_read(&lfs_flash, &fs_record_obj.dir, &fno) == true)  	//读文件信息到文件状态结构体中
+		{		
+				fs_record_obj.items_num++;
+				//判定的顺序不能变			
+				if(!fno.name[0]) break; 													//如果文件名为‘\0'，说明读取完成结束
+
+				if (fno.type & LFS_TYPE_DIR)	continue; 					//表示目录，跳过	
+			
+				if (fno.name[0] == '.') continue; 								//点表示当前目录，跳过				
+
+						
+				if( (fs_record_obj.file_num < MAX_FILE_COUNT)
+					&&(strstr(fno.name,FILE_START) == fno.name)
+				  &&((strstr(fno.name,FILE_END) != 0))
+				)
+				{
+						sprintf((char *)fs_record_obj.file_list[fs_record_obj.file_num], "%s/%s", fs_record_obj.fold,fno.name);//将文件名存入列表中
+						fs_record_obj.file_num ++;	
+				}
+				else
+				{	
+					/* 如果目录已经存在，关闭它 */
+					res = lfs_dir_close(&lfs_flash, &fs_record_obj.dir);	
+					
+					sprintf((char *)file_name,"%s/%s",fs_record_obj.fold, fno.name);								//输出文件名	
+					taskENTER_CRITICAL();    /* 临界保护开启 */
+					res = lfs_remove(&lfs_flash, file_name);
+					taskEXIT_CRITICAL();    /* 临界保护关闭 */
+					if(LFS_ERR_OK != res)
+					{
+											
+						fs_record_obj.fs_stat = false;
+						return;
+					}
+				}
+    }
+		
+		/* 如果目录已经存在，关闭它 */
+		res = lfs_dir_close(&lfs_flash, &fs_record_obj.dir);
+		
+		if(fs_record_obj.file_num > 0)
+		{			
+		}
+		else
+		{
+			memset((void *)fs_record_obj.name_send, 0x00,sizeof(fs_record_obj.name_send));
+			return;
+		}
+   
+		//按文件名最小到大排序；
+		if(fs_record_obj.file_num > 1)
+		{
+			func_record_lfs_dir_qsort(fs_record_obj.file_num);
+		}
+				
+		//获取最新的文件；
+		uint8_t max_idx = fs_record_obj.file_num - 1;
+		sprintf((char *)fs_record_obj.name_send,"%s", fs_record_obj.file_list[max_idx]);			
+		
+		//如果文件个数超限，
+		if((fs_record_obj.file_num > NUM_FILE_SET)
+			||(fs_record_obj.free_size < 500))
+		{			
+			//删除日期最早的文件
+			sprintf((char *)file_name,"%s",  fs_record_obj.file_list[0]);		
+			
+			taskENTER_CRITICAL();    /* 临界保护开启 */
+
+			res = lfs_remove(&lfs_flash, file_name);
+			taskEXIT_CRITICAL();    /* 临界保护关闭 */
+			
+			if(LFS_ERR_OK != res)
+			{
+				fs_record_obj.fs_stat = false;
+				return;
+			}									
+		}		
+			
+		UNUSED(res);		
+		return;
+}
+
+
+
+int qsort_cmp(const void *a,const void *b)
+{
+    return strcmp(( char * ) a, (const char* )b);
+}
+//(void * /*base*/, size_t /*nmemb*/, size_t /*size*/, int (* /*compar*/)(const void *, const void *)) __attribute__((__nonnull__(1,4)));
+void func_record_lfs_dir_qsort(size_t fcount)
+{
+	qsort((void *)fs_record_obj.file_list, fcount, sizeof(fs_record_obj.file_list[0]), qsort_cmp);
+}
+
+
+void func_record_lfs_init(void)
+{
+	
+	memset(fs_record_obj.file_list, 0x00,sizeof(fs_record_obj.file_list));		//清空文件列表
+	fs_record_obj.file_num = 0;
+	fs_record_obj.fs_stat = true;
+	func_record_lfs_files_update((char *)fs_record_obj.fold);
+}
+typedef struct record_lfs_object
+{
+	uint32_t 	cnts;
+	uint8_t 	test_flag;
+	char 			buf[LFS_PAGE_SIZE];
+}record_lfs_OBJ;
+	
+record_lfs_OBJ record_lfs_obj;
+
+void func_record_lfs_fs_test(void)
+{	
+	
+	record_lfs_obj.cnts++;
+	sprintf(record_lfs_obj.buf,"XX%08xXX",record_lfs_obj.cnts);
+	switch(record_lfs_obj.test_flag)
+	{
+		case 0:
+		{
+			func_record_lfs_write((uint8_t *)record_lfs_obj.buf ,strlen(record_lfs_obj.buf));
+		}break;
+		case 1:
+		{
+			func_record_lfs_read((uint8_t *)record_lfs_obj.buf ,sizeof(record_lfs_obj.buf));
+			func_record_lfs_delete((uint8_t *)record_lfs_obj.buf ,sizeof(record_lfs_obj.buf));
+			func_record_lfs_read((uint8_t *)record_lfs_obj.buf ,sizeof(record_lfs_obj.buf));
+		}break;
+		default:
+		{
+			func_record_lfs_files_update((char *)fs_record_obj.fold);
+			func_record_lfs_read((uint8_t *)record_lfs_obj.buf ,sizeof(record_lfs_obj.buf));
+		}break;
+		
+	}
+	
+}
+
+
+char path_buf[512] = {0};
+void func_record_lfs_main(void const *argument)
+{
+
+	
+#if USE_SPI_FLASH	
+  func_w25q_init();
+	func_w25q_test();
+#endif
+		
+	
+	
+#if USE_LFS_RECORD	
+	taskENTER_CRITICAL();	
+	mid_lfs_flash_init();
+	mid_lfs_flash_bootcnt();
+	mid_lfs_flash_boot_step();
+	taskEXIT_CRITICAL();
+	
+	func_record_queue_init();
+	func_record_queue_update();
+	
+#endif
+
+	osDelay(1000);//
+	func_record_lfs_init();
+	while(1)
+	{
+		strcpy(path_buf,fs_record_obj.fold);
+		//func_record_lfs_scan_files(path_buf);
+		func_record_lfs_fs_test();
+
+		osDelay(1000);
+	}
+}
+#endif //---------------------------USE_LFS_RECORD----------------------------
+
+/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/

func/func_lfs_record.h

@@ -0,0 +1,80 @@
+/* USER CODE BEGIN Header */
+/**
+  ******************************************************************************
+  * @file           : main.h
+  * @brief          : Header for main.c file.
+  *                   This file contains the common defines of the application.
+  ******************************************************************************
+  * @attention
+  *
+  * <h2><center>&copy; Copyright (c) 2019 STMicroelectronics.
+  * All rights reserved.</center></h2>
+  *
+  * This software component is licensed by ST under BSD 3-Clause license,
+  * the "License"; You may not use this file except in compliance with the
+  * License. You may obtain a copy of the License at:
+  *                        opensource.org/licenses/BSD-3-Clause
+  *
+  ******************************************************************************
+  */
+/* USER CODE END Header */
+
+/* Define to prevent recursive inclusion -------------------------------------*/
+#ifndef FUNC_RECORD_H
+#define FUNC_RECORD_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Includes ------------------------------------------------------------------*/
+#include "stm32f7xx_hal.h"
+#include "fatfs.h"
+/* Private includes ----------------------------------------------------------*/
+/* USER CODE BEGIN Includes */
+
+/* USER CODE END Includes */
+
+/* Exported types ------------------------------------------------------------*/
+/* USER CODE BEGIN ET */
+
+/* USER CODE END ET */
+
+/* Exported constants --------------------------------------------------------*/
+/* USER CODE BEGIN EC */
+
+/* USER CODE END EC */
+
+/* Exported macro ------------------------------------------------------------*/
+/* USER CODE BEGIN EM */
+
+/* USER CODE END EM */
+
+
+
+/* Exported functions prototypes ---------------------------------------------*/
+void func_record_lfs_init(void);											//记录文件初始化
+void func_record_lfs_main(void const *argument);			//文件操作主函数
+void func_record_lfs_test(void);
+	
+
+int32_t func_record_lfs_write(void *buf ,uint32_t len);
+uint32_t func_record_lfs_read(uint8_t *buf ,uint32_t len);
+uint32_t func_record_lfs_delete(uint8_t *buf,uint32_t len);
+int32_t func_record_lfs_remove(void *buf, uint32_t len);
+
+uint8_t func_record_lfs_stat_set(uint8_t stat);
+uint8_t func_record_lfs_stat_get(void);
+
+
+/* Private defines -----------------------------------------------------------*/
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* FUNC_RECORD_H */
+
+
+/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/

func/func_queue_record.c

@@ -0,0 +1,463 @@
+/*********************************************************
+//file		:hd_dev_gpio.c
+//author	:libo
+//date		:2020/05/10
+//version	:V1.0
+//brief		:GSP HARD层GPIO接口C文件
+*********************************************************/
+/* Includes-----------------------------------------------------------------------------------*/
+#include "main.h"
+
+
+#ifdef USE_QUEUE_RECORD
+/* Includes-----------------------------------------------------------------------------------*/
+#include <stdint.h>
+#include <string.h>
+#include <stdlib.h>
+#include <stdbool.h>
+#include "func_queue_record.h"
+#include "func_lfs_record.h"
+#include "func_spi_w25qxx.h"
+#include "obj_hal_w25qxx.h"
+#include "obj_soft_w25qxx.h"
+#include "lib_ringfs_func.h"
+
+/* Private macro------------------------------------------------------------------------------*/
+
+#define DEBUG_RECORD_QUEUE  0
+
+/* Private typedef----------------------------------------------------------------------------*/
+
+record_queue_object lifo_queue_obj = {0};
+record_queue_object fifo_queue_obj = {0};
+
+/* Private define-----------------------------------------------------------------------------*/
+/* Private variables--------------------------------------------------------------------------*/
+/* Private function prototypes----------------------------------------------------------------*/
+
+typedef struct queue_record_object
+{
+	uint8_t 	link_ok; 				//用于标识当前状态是1：读取，0：写入；
+	uint8_t   flash_ok;					//存储器状态标志
+	uint32_t 	running;
+	uint32_t 	wr_idx;
+	uint32_t 	msg_cnt;
+	uint32_t 	wr_cnt;
+	uint32_t 	rd_cnt;
+	uint8_t 	opt_flag;
+	char 			buf[QUEUE_MSG_ITEM_SIZE];
+	uint32_t 	buf_len;
+	int32_t 	(*flash_pop) (void *buf, uint32_t len);
+	int32_t 	(*flash_push)(void *buf, uint32_t len);
+}queue_record_object;
+	
+queue_record_object queue_record_obj = {
+	.link_ok  = false,
+	.flash_ok = false,
+	.wr_cnt		= 0,
+	.rd_cnt		= 0,
+};
+
+
+void func_record_queue_test(void)
+{	
+	uint8_t data = 0;
+	uint32_t *p_data = 0;
+	
+	UNUSED(data);
+	
+	//sprintf(queue_record_obj.buf,"XX%02xXX",queue_record_obj.running%0x100);
+	switch(queue_record_obj.opt_flag)
+	{
+		case 0:
+		{			
+			queue_record_obj.wr_idx++;
+			//queue_record_obj.wr_idx = queue_record_obj.wr_cnt%0x100;
+			//data = (uint8_t) queue_record_obj.wr_idx ;
+			p_data = (uint32_t *)&queue_record_obj.buf[0];
+			for(uint32_t i = 0; i < sizeof(queue_record_obj.buf)/4; i++ )
+			{
+				*p_data = queue_record_obj.wr_idx ;
+				p_data++;
+			}
+			//memset((uint8_t *)queue_record_obj.buf, data ,sizeof(queue_record_obj.buf));
+			func_record_queue_write((uint8_t *)queue_record_obj.buf ,sizeof(queue_record_obj.buf));
+		}break;
+		default:
+		{
+			func_record_queue_read((void *)queue_record_obj.buf ,sizeof(queue_record_obj.buf));
+		}break;		
+	}	
+
+}
+
+//Message_Queue队列初始化
+void func_record_queue_init(void)
+{
+
+	taskENTER_CRITICAL();   //进入临界区
+	
+	lifo_queue_obj.hQueue = xQueueCreate(QUEUE_MSG_Q_NUM,QUEUE_MSG_ITEM_SIZE); //创建消息Message_Queue,队列项长度是串口接收缓冲区长度
+	fifo_queue_obj.hQueue = xQueueCreate(QUEUE_MSG_Q_NUM,QUEUE_MSG_ITEM_SIZE); //创建消息Message_Queue,队列项长度是串口接收缓冲区长度
+
+	taskEXIT_CRITICAL();    //退出临界区
+#if 	USE_LFS_RECORD==1
+	
+	queue_record_obj.flash_pop 	= func_record_lfs_remove;
+	queue_record_obj.flash_push = func_record_lfs_write;
+	
+#elif USE_RFS_RECORD==1
+	queue_record_obj.flash_pop 	= lib_ringfs_pop;
+	queue_record_obj.flash_push = lib_ringfs_push;	
+#endif
+	
+}
+
+
+
+//查询Queue队列中的总队列数量和剩余队列数量
+void func_record_queue_check(record_queue_object * queue_obj)
+{
+	if(queue_obj->hQueue == NULL)
+	{
+		return;
+	}
+	
+	QueueHandle_t xQueue = queue_obj->hQueue;	
+	
+	taskENTER_CRITICAL();   //进入临界区
+
+	queue_obj->remain_size = uxQueueSpacesAvailable(xQueue);//得到队列剩余大小
+	queue_obj->used_size = uxQueueMessagesWaiting(xQueue);//得到队列剩余大小
+	queue_obj->total_size=uxQueueMessagesWaiting(xQueue)+uxQueueSpacesAvailable(xQueue);//得到队列总大小，总大小=使用+剩余的。
+	
+	taskEXIT_CRITICAL();    //退出临界区
+}
+void func_record_queue_empty(record_queue_object * queue_obj)
+{
+	if(queue_obj->hQueue == NULL)
+	{
+		return;
+	}
+	taskENTER_CRITICAL();   //进入临界区
+	
+#if 0	
+	int32_t  num_cnt = QUEUE_MSG_Q_NUM;
+	BaseType_t err = pdPASS;
+
+	do
+	{
+		num_cnt--;
+		if(num_cnt<=0)
+		{
+			break;
+		}
+			
+		err = xQueueReceive(queue_obj->hQueue, (uint8_t *)queue_record_obj.buf, 0);
+	}while(err == pdPASS);
+#endif
+	xQueueReset(queue_obj->hQueue);
+	
+	taskEXIT_CRITICAL();    //退出临界区
+}
+
+void func_record_queue_update(void)
+{
+	func_record_queue_check(&lifo_queue_obj);
+	func_record_queue_check(&fifo_queue_obj);
+	
+	if(fifo_queue_obj.remain_size == 0)			//如果缓冲队列无空闲测请理缓冲区；
+	{	
+			func_record_queue_empty(&fifo_queue_obj);
+	}
+	
+	if(lifo_queue_obj.remain_size == 0)
+	{
+			func_record_queue_empty(&lifo_queue_obj);
+	}
+	
+	return;
+}
+
+
+
+
+//将产生的数据写入内存缓冲区队列
+uint32_t func_record_queue_write(void *buf ,uint32_t len)
+{	
+	BaseType_t err;
+	
+	//有数据写入队列，则说明当前连接断开
+	func_record_queue_link_set(false);
+	
+	if((lifo_queue_obj.hQueue == NULL)||(fifo_queue_obj.hQueue == NULL))
+	{
+		return 0;
+	}
+	
+	if(lifo_queue_obj.used_size == 0)
+	{
+		err=xQueueSend(fifo_queue_obj.hQueue,(uint8_t *)buf,10);
+	}
+	else
+	{
+		err=xQueueSendToFront(lifo_queue_obj.hQueue,(uint8_t *)buf,10);
+	}
+	
+	//写入个数累加
+	queue_record_obj.wr_cnt++;
+	
+	func_record_queue_update();
+	
+	if(err != pdPASS)
+	{
+		return 0;
+	}
+
+	return len;
+}
+
+
+
+void func_record_queue_cpy(record_queue_object * des, record_queue_object * src)
+{
+	BaseType_t xResult = pdPASS;		
+	do{		
+		xResult = xQueueReceive(src->hQueue, (uint8_t *)queue_record_obj.buf, 0);
+		if(xResult == pdPASS)
+		{
+			xResult = xQueueSendToFront(des->hQueue, (uint8_t *)queue_record_obj.buf, 0);
+		}
+	}while(xResult == pdPASS);
+	
+	func_record_queue_update();
+	
+	return;
+}
+
+//从队列中取出数据，发送；
+uint32_t func_record_queue_read(void *buf ,uint32_t len)
+{
+	
+	//从队列读取，则说明当前连接正常
+	func_record_queue_link_set(true);	
+
+	BaseType_t xResult = pdPASS;
+	
+	if((lifo_queue_obj.hQueue == NULL)||(fifo_queue_obj.hQueue == NULL))
+	{
+		return 0;
+	}
+	
+	if(lifo_queue_obj.used_size == 0)
+	{
+		if(fifo_queue_obj.used_size > 0)
+		{
+			func_record_queue_cpy(&lifo_queue_obj, &fifo_queue_obj);
+		}
+	}
+	
+  xResult = xQueueReceive(lifo_queue_obj.hQueue, (uint8_t *)buf, 1);	
+	
+	//读取个数累加
+	queue_record_obj.rd_cnt++;
+	
+	func_record_queue_update();
+	
+	if(xResult != pdPASS)
+	{
+		return 0;
+	}
+
+	return len;
+}
+
+
+//将缓存队列中的数据写入文件
+void func_record_queue_to_flash(record_queue_object * queue_obj)
+{
+	BaseType_t xResult = pdPASS;
+	do{
+		xResult = xQueueReceive(queue_obj->hQueue,queue_record_obj.buf,1);
+		if(xResult == pdPASS)
+		{
+			queue_record_obj.flash_push((uint8_t *)queue_record_obj.buf ,QUEUE_MSG_ITEM_SIZE);
+		}
+	}while(xResult == pdPASS);
+	
+	return;
+}
+
+void func_record_queue_link_set(uint8_t stat)
+{	
+	queue_record_obj.link_ok = stat;
+	return ;
+}
+
+uint8_t func_record_queue_link_get(void)
+{	
+	return queue_record_obj.link_ok;
+}
+
+uint8_t func_record_queue_flash_set(uint8_t stat)
+{	
+	queue_record_obj.flash_ok = stat;
+	return queue_record_obj.flash_ok;
+}
+
+uint8_t func_record_queue_flash_get(void)
+{	
+	//queue_record_obj.flash_ok = func_w25q_stat();
+	
+	return queue_record_obj.flash_ok;
+}
+
+uint32_t func_record_queue_cnt(void)
+{
+	uint32_t cnt_estimate = 0;
+	
+	if(queue_record_obj.wr_cnt > queue_record_obj.rd_cnt)
+	{
+		queue_record_obj.msg_cnt = queue_record_obj.wr_cnt - queue_record_obj.rd_cnt;
+	}
+	else
+	{
+		queue_record_obj.wr_cnt = 0;
+		queue_record_obj.rd_cnt = 0;
+		queue_record_obj.msg_cnt = 0;
+	}
+	
+	//修正估算值
+	cnt_estimate = lib_ringfs_obj_cnt_estimate();
+	if(queue_record_obj.msg_cnt > cnt_estimate)
+	{
+		queue_record_obj.msg_cnt = cnt_estimate;
+	}
+	
+	
+	return queue_record_obj.msg_cnt ;
+}
+
+void func_record_queue_work(void)
+{	
+
+	BaseType_t xResult;
+
+	//更新队列状态
+	func_record_queue_update();	
+	
+	if(func_record_queue_link_get() == true)
+	{
+			//如果连接正常
+			if((lifo_queue_obj.used_size == 0)&&(fifo_queue_obj.used_size == 0))
+			{
+				queue_record_obj.buf_len = queue_record_obj.flash_pop((uint8_t *)queue_record_obj.buf ,QUEUE_MSG_ITEM_SIZE);
+				
+				if(queue_record_obj.buf_len == QUEUE_MSG_ITEM_SIZE)
+				{
+					xResult = xQueueSend(lifo_queue_obj.hQueue,queue_record_obj.buf,10);					
+				}								
+			}	
+	}
+	else
+	{
+			//如果连接断开
+			if(lifo_queue_obj.used_size >= (lifo_queue_obj.total_size/2))
+			{	
+					if(fifo_queue_obj.used_size > 0)
+					{
+						func_record_queue_to_flash(&fifo_queue_obj);
+						func_record_queue_check(&fifo_queue_obj);
+					}
+					
+					if(fifo_queue_obj.used_size == 0)
+					{
+						func_record_queue_cpy(&fifo_queue_obj, &lifo_queue_obj);
+					}					
+			}			
+			
+			if(fifo_queue_obj.used_size >= (fifo_queue_obj.total_size/2))
+			{
+				func_record_queue_to_flash(&fifo_queue_obj);
+			}
+	}
+	
+	func_record_queue_update();	
+	UNUSED(xResult);	
+	
+	return;	
+}
+
+void func_record_queue_main(void const *argument)
+{
+		
+	func_record_queue_init();
+	func_record_queue_update();
+	
+#if USE_LFS_RECORD==1
+	
+#elif USE_RFS_RECORD==1	
+	func_w25q_init();
+
+	if((func_w25q_stat() == false)				//flash ID 异常
+		||(func_w25q_bootcnt() == false))		//启动次数异常；
+	{
+		//设置flash状态为异常
+		func_record_queue_flash_set(false);
+		while(1)
+		{
+			osDelay(10000);
+		}
+	}
+
+	//设置flash状态为正常
+	func_record_queue_flash_set(true);
+	
+	lib_ringfs_init(QUEUE_MSG_ITEM_SIZE);	
+	
+	queue_record_obj.wr_cnt = lib_ringfs_obj_cnt_exact();
+#endif
+	
+	while(1)
+	{
+		queue_record_obj.running++;
+		
+		if(queue_record_obj.running%(60) == 0)
+		{
+			if(func_w25q_stat() == false)			//读取FLASH ID,如果ID异常，则说明FLASH状态异常
+			{
+				//设置flash状态为异常
+				func_record_queue_flash_set(false); 
+			}				
+		}
+		
+		
+		if(queue_record_obj.flash_ok == true)			//flash正常，且处于读取状态时进行数量计算；			
+		{		
+			func_record_queue_cnt();
+			
+			func_record_queue_work();	
+			
+#if  DEBUG_RECORD_QUEUE==1		
+		func_record_queue_test();			
+		osDelay(10);
+#else
+		osDelay(1000);
+#endif					
+			
+		}
+		else
+		{
+			osDelay(10000);
+		}
+		
+
+	}
+	
+
+}
+
+
+#endif    /*************USE_QUEUE_RECORD*******************/
+
+//------------------------the end of file-------------------------//

func/func_queue_record.h

@@ -0,0 +1,47 @@
+/*********************************************************
+//file		:hd_dev_gpio.h
+//author	:libo
+//date		:2020/05/10
+//version	:V1.0
+//brief		:GSP HAL层GPIO接口H文件
+*********************************************************/
+#ifndef FUNC_QUEUE_RECORD_H
+#define FUNC_QUEUE_RECORD_H
+
+/* Includes----------------------------------------------------------------------------------*/
+#include "cmsis_os.h" /* _FS_REENTRANT set to 1 and CMSIS API chosen */
+
+/* Public macro------------------------------------------------------------------------------*/
+#define QUEUE_MSG_Q_NUM 			8    
+#define QUEUE_MSG_ITEM_SIZE		256    
+
+/* Public define-----------------------------------------------------------------------------*/
+
+/* Public typedef----------------------------------------------------------------------------*/
+typedef struct{
+	QueueHandle_t hQueue;				//信息队列句柄
+	uint32_t 			remain_size;	//队列剩余大小
+	uint32_t 			used_size;		//队列使用大小
+	uint32_t 			total_size;		//消息队列总大小
+}record_queue_object;
+
+/* public function---------------------------------------------------------------------------*/
+extern record_queue_object lifo_queue_obj;
+extern record_queue_object fifo_queue_obj;
+
+void 		func_record_queue_init(void);
+void 		func_record_queue_work(void);
+void 		func_record_queue_main(void const *argument);
+void 		func_record_queue_check(record_queue_object * queue_obj);
+void 		func_record_queue_update(void);
+
+uint32_t func_record_queue_write(void *buf ,uint32_t len);
+uint32_t func_record_queue_read(void *buf ,uint32_t len);
+void 		 func_record_queue_link_set(uint8_t stat);
+uint8_t  func_record_queue_link_get(void);
+uint8_t  func_record_queue_flash_get(void);
+uint8_t func_record_queue_flash_set(uint8_t stat);
+void 		func_record_queue_test(void);
+#endif    /*********FUNC_QUEUE_RECORD_H****************/
+/******************************the end of file************************************************/
+

func/func_spi_w25qxx.c

@@ -0,0 +1,323 @@
+/*********************************************************
+//file		:hd_dev_gpio.c
+//author	:libo
+//date		:2020/05/10
+//version	:V1.0
+//brief		:GSP HARD层GPIO接口C文件
+*********************************************************/
+/* Includes-----------------------------------------------------------------------------------*/
+//#define FUNC_SPI_W25QXX_USE
+#include <string.h>
+#include "func_spi_w25qxx.h"
+#include "obj_hal_w25qxx.h"
+#include "obj_soft_w25qxx.h"
+
+#define SPI_FLASH_SECT_BOOT 		0	
+
+#ifdef FUNC_SPI_W25QXX_USE
+/* Includes-----------------------------------------------------------------------------------*/
+#include <string.h>
+#include "dev_spi_sdcard.h"
+#include "obj_spi_w25qxx.h"
+
+
+/* Private macro------------------------------------------------------------------------------*/
+#define domain_add     0x000000
+#define phone_add      0x001000
+/* Private typedef----------------------------------------------------------------------------*/
+/* Private define-----------------------------------------------------------------------------*/
+/* Private variables--------------------------------------------------------------------------*/
+/* Private function prototypes----------------------------------------------------------------*/
+uint8_t func_w25q_disk_ioctl (
+	BYTE pdrv,		/* Physical drive nmuber (0..) */
+	BYTE cmd,			/* Control code */
+	void *buff		/* Buffer to send/receive control data */
+)
+{
+	uint8_t res = RES_PARERR;
+
+	switch(cmd)
+	{
+		case CTRL_SYNC:
+				res = RES_OK; 
+				break;	 
+		case GET_SECTOR_SIZE:
+				*(WORD*)buff = w25qxx.SectorSize;
+				res = RES_OK;
+				break;	 
+		case GET_BLOCK_SIZE:
+				*(WORD*)buff = w25qxx.BlockSize;
+				res = RES_OK;
+				break;	 
+		case GET_SECTOR_COUNT:
+				*(DWORD*)buff = w25qxx.SectorCount;
+				res = RES_OK;
+				break;
+		default:
+				res = RES_PARERR;
+				break;
+	}
+		
+	return res;
+}
+
+void func_w25q_init(void)
+{	
+
+	W25qxx_Cs_Init();		
+	W25qxx_Spi_Init();	
+
+  W25qxx_Init();
+	
+	while(w25qxx.ID != ID_W25Q128)			//检测不到ID_W25Q128
+	{
+		W25qxx_Init();
+		HAL_Delay(100);
+	}
+	return;
+}
+
+
+void func_w25q_spi_flash_bootcnt(void)
+{	
+	uint8_t 	key;
+	uint32_t  boot_cnt = 0;
+	uint8_t write_buff[] = "6686666666";
+	uint8_t read_buff[20] = {0};
+	
+	UNUSED(key);
+	UNUSED(write_buff);
+	UNUSED(read_buff);
+	
+	func_w25q_init();
+	
+	while(w25qxx.ID != ID_W25Q128)			//检测不到W25Q256
+	{
+		W25qxx_Init();
+		HAL_Delay(100);
+	}
+	while(1)
+	{				
+			W25qxx_ReadSector((uint8_t *)&boot_cnt,phone_add,0,sizeof(boot_cnt));
+			boot_cnt++;
+			W25qxx_EraseSector(phone_add);
+		  W25qxx_WriteSector((uint8_t *)&boot_cnt,phone_add,0,sizeof(boot_cnt));
+//		 if(key)
+//		 {
+//				HAL_Delay(100);
+//				W25qxx_WritePage(phone_buff,phone_add,0,strlen((char*)phone_buff));
+//		 }
+//		 else
+//		 {
+//				HAL_Delay(100);
+//				W25qxx_ReadPage(read_buff,phone_add,0,20);
+//		 }	
+				
+			osDelay(1000);			
+	}
+
+}
+
+void func_w25q_spi_flash_buffer(void)
+{	
+	uint8_t 	key;
+
+	uint8_t phone_buff[] = "6686666666";
+	uint8_t read_buff[20] = {0};
+	
+
+	func_w25q_init();
+	
+	while(w25qxx.ID != ID_W25Q128)			//检测不到W25Q256
+	{
+		W25qxx_Init();
+		HAL_Delay(100);
+	}
+	while(1)
+	{				
+
+		 if(key)
+		 {
+				HAL_Delay(100);
+				W25qxx_WritePage(phone_buff,phone_add,0,strlen((char*)phone_buff));
+		 }
+		 else
+		 {
+				HAL_Delay(100);
+				W25qxx_ReadPage(read_buff,phone_add,0,20);
+		 }	
+				
+			osDelay(1000);			
+	}
+
+}
+
+#endif    /*************FUNC_SPI_W25QXX_USE*******************/
+
+#if  defined(USE_OBJ_HAL_W25QXX)  || defined(USE_OBJ_SOFT_W25QXX)
+//要写入到W25Q16的字符串数组
+const uint8_t TEXT_Buffer[]={"STM32 SPI TEST"};
+#define SIZE sizeof(TEXT_Buffer)	 
+	
+void func_w25q_id_check(void)
+{
+	uint32_t W25Q_ReadID = 0xffffffff;
+	while((W25Q_ReadID <= W25Q512)
+			&&(W25Q_ReadID >= W25Q32))		//检测不到W25Q128
+	{
+
+		W25Q_ReadID = W25QXX_ReadID();
+		HAL_Delay(100);
+	}	
+}
+
+void func_w25q_init(void)
+{	
+
+	W25QXX_Init();				    					//W25QXX初始化
+	
+	W25QXX_WAKEUP();
+	
+	HAL_Delay(100);
+	
+	uint8_t erase_flag = 0;
+
+	if(erase_flag)
+	{
+		W25QXX_Erase_Chip();
+	}
+
+	return;
+}
+
+
+
+
+uint8_t func_w25q_disk_ioctl (
+	BYTE pdrv,		/* Physical drive nmuber (0..) */
+	BYTE cmd,			/* Control code */
+	void *buff		/* Buffer to send/receive control data */
+)
+{
+	uint8_t res = RES_PARERR;
+
+	switch(cmd)
+	{
+		case CTRL_SYNC:
+				res = RES_OK; 
+				break;	 
+		case GET_SECTOR_SIZE:
+				*(WORD*)buff = SPI_FLASH_SECTOR_SIZE;
+				res = RES_OK;
+				break;	 
+		case GET_BLOCK_SIZE:
+				*(WORD*)buff = SPI_FLASH_BLOCK_SIZE;
+				res = RES_OK;
+				break;	 
+		case GET_SECTOR_COUNT:
+				*(DWORD*)buff = SPI_FLASH_SECTOR_COUNT;
+				res = RES_OK;
+				break;
+		default:
+				res = RES_PARERR;
+				break;
+	}
+		
+	return res;
+}
+uint32_t boot_cnt[2] = {0};	
+
+uint8_t func_w25q_bootcnt(void)
+{	
+		uint32_t falsh_addr = 0;	
+		uint8_t ret = false;	
+		falsh_addr = SPI_FLASH_SECT_BOOT * w25qxx_obj.SectorSize;	
+		W25QXX_Read((uint8_t*)&boot_cnt[0], falsh_addr, sizeof(uint32_t));
+	
+		boot_cnt[0]++;	
+		W25QXX_Write((uint8_t*)&boot_cnt[0], falsh_addr, sizeof(uint32_t));
+	
+		W25QXX_Read((uint8_t*)&boot_cnt[1], falsh_addr, sizeof(uint32_t));
+	
+		if(boot_cnt[0] == boot_cnt[1])
+    {
+			ret = true;
+		}
+		
+		return ret;		
+}
+
+
+uint32_t FLASH_ReadID = 0xffffffff;
+int func_w25q_hal_main(void)
+{
+		//uint8_t key;
+		uint8_t idx=0;
+
+		uint32_t FLASH_SIZE;	
+
+		uint8_t TXT_WR[64] = {0};
+		uint8_t TXT_RD[64] = {0};
+
+		W25QXX_Init();				    					//W25QXX初始化
+		HAL_Delay(100);
+	
+		FLASH_SIZE=1*1024*1024;	//FLASH 大小为32M字节
+		W25QXX_Read(&idx,FLASH_SIZE-100,sizeof(idx));
+		while(1)
+		{
+				FLASH_ReadID = W25QXX_ReadID();
+				idx++;
+				memset((void *)TXT_WR,idx,sizeof(TXT_WR));
+				W25QXX_Write((uint8_t*)TXT_WR,FLASH_SIZE-100,sizeof(TXT_WR));		//从倒数第100个地址处开始,写入SIZE长度的数据
+				osDelay(100);
+				memset((void *)TXT_RD,0x00,sizeof(TXT_RD));
+				W25QXX_Read(TXT_RD,FLASH_SIZE-100,sizeof(TXT_RD));					//从倒数第100个地址处开始,读出SIZE个字节		
+				
+				if(memcmp(TXT_RD,TXT_WR,sizeof(TXT_RD)) != 0 )
+				{
+					osDelay(2000);
+					memset((void *)TXT_RD,0x00,sizeof(TXT_RD));
+					W25QXX_Read(TXT_RD,FLASH_SIZE-100,sizeof(TXT_RD));					//从倒数第100个地址处开始,读出SIZE个字节		
+				
+				}
+				osDelay(1000);
+		}		    
+}
+#endif
+
+
+uint16_t  func_w25q_stat(void)
+{
+	return W25QXX_ID_OK();
+}
+
+void func_w25q_erase_ship(void)
+{
+	 W25QXX_Erase_Chip();
+}
+void func_w25q_test(void)
+{
+	uint8_t erase_ship = 0;
+	if(erase_ship)
+	{
+		func_w25q_erase_ship();
+	}	
+	
+#if 0
+		while(1)
+		{
+			//add boly 20221107  W25QXX件初始化
+			//func_w25q_spi_flash_bootcnt();
+			//func_w25q_spi_flash_buffer();
+			func_w25q_hal_main();
+			osDelay(1000);
+			
+			//end boly
+		}
+#endif	
+}
+
+
+
+

func/func_spi_w25qxx.h

@@ -0,0 +1,43 @@
+/*********************************************************
+//file		:hd_dev_gpio.h
+//author	:libo
+//date		:2020/05/10
+//version	:V1.0
+//brief		:GSP HAL层GPIO接口H文件
+*********************************************************/
+#ifndef FUNC_SPI_W25QXX_H
+#define FUNC_SPI_W25QXX_H
+
+/* Includes----------------------------------------------------------------------------------*/
+#include "ff_gen_drv.h"
+/* Public macro------------------------------------------------------------------------------*/
+//对于W25Q128
+//前25M字节给fatfs用,25M字节后,用于存放字库,字库占用6.01M.	剩余部分,给客户自己用	 
+#define SPI_FLASH_SECTOR_SIZE 	512	
+#define SPI_FLASH_SECTOR_COUNT 	1024*16*2	//W25Q256,前25M字节给FATFS占用	
+#define SPI_FLASH_BLOCK_SIZE   	8     		//每个BLOCK有8个扇区		
+
+//128Mb == 16M byte == 1024*1024*16 == 1024*4*256*16 == 0x400*0x4*0x100*0x10 == 0x1000 BLOCK
+//sector size 256*16 == 4k ==  4096
+//256*120*24 = 491520 = 0x78000 ==480k
+
+/* Public define-----------------------------------------------------------------------------*/
+
+/* Public typedef----------------------------------------------------------------------------*/
+
+/* public function---------------------------------------------------------------------------*/
+void func_w25q_init(void);
+void func_w25q_test(void);
+void func_w25q_erase_ship(void);
+uint16_t  func_w25q_stat(void);
+uint8_t 	func_w25q_bootcnt(void);
+//void func_w25q_spi_flash(void);
+int  func_w25q_hal_main(void);
+uint8_t func_w25q_disk_ioctl (
+	BYTE pdrv,		/* Physical drive nmuber (0..) */
+	BYTE cmd,			/* Control code */
+	void *buff		/* Buffer to send/receive control data */
+);
+#endif    /*********FUNC_SPI_W25QXX_H****************/
+/******************************the end of file************************************************/
+