【文件系统学习】+小燕+基于STM32F407ZG开发板运行文件系统

发布于 2018-07-28 00:08:19 浏览：2270 订阅该版

```/*
 * File      : main.c
 * This file is part of RT-Thread RTOS
 * COPYRIGHT (C) 2009, RT-Thread Development Team
 *
 * The license and distribution terms for this file may be
 * found in the file LICENSE in this distribution or at
 * http://www.rt-thread.org/license/LICENSE
 *
 * Change Logs:
 * Date           Author       Notes
 * 2015-07-29     Arda.Fu      first implementation
 */
#include <rtthread.h>
#include <board.h>
#include <dfs_fs.h>
#include <dfs_posix.h>
#include <dfs_private.h>

// 监听通讯口相关定义
#define RT_COMM_DEVICE_NAME    "uart2"
// 监听数据存储文件
#define DATA_FILE_NAME         "dongle.dat"

// 数据监听任务
#define STK_DONGLE_SIZE        1024
#define TASK_DONGLE_PRIORITY   1
rt_thread_t s_dongle_thread = RT_NULL;

// 接收缓存
typedef struct {
	uint8_t buf[RT_SERIAL_RB_BUFSZ];
	uint8_t len;
} _uart_recv;
_uart_recv s_uart_recv = {0};

// 中断callback
static rt_err_t rt_uart_callback(rt_device_t dev, rt_size_t size)
{
	uint8_t readSize;

// 防止任务处理不及时溢出
	if (s_uart_recv.len >= RT_SERIAL_RB_BUFSZ) {
		s_uart_recv.len = 0;
	}
	readSize = (size > RT_SERIAL_RB_BUFSZ) ? RT_SERIAL_RB_BUFSZ : size;

if (s_uart_recv.len + readSize > RT_SERIAL_RB_BUFSZ) {
		readSize = RT_SERIAL_RB_BUFSZ - s_uart_recv.len;
	}
	s_uart_recv.len += rt_device_read(dev, 0, &s_uart_recv.buf[s_uart_recv.len], readSize);

return RT_EOK;
}

// 写文件
static void data_file_write(uint8_t *data, uint8_t len)
{
	char *fullpath, *path;
	struct dfs_fd fd;
	struct stat file_stat;

// 文件路径
	#ifdef DFS_USING_WORKDIR
	path = rt_strdup(working_directory);
	#else
	path = rt_strdup("/");
	#endif
	if (NULL == path) {
		return;
	}
	// 路径+文件名
	fullpath = dfs_normalize_path(path, DATA_FILE_NAME);
	if (NULL == fullpath) {
		rt_free(path);
		return;
	}
	// 打开文件
    if (dfs_file_open(&fd, fullpath, O_CREAT | O_RDWR)) {
		rt_free(path);
		rt_free(fullpath);
		return;
	}

// 获取文件信息
	if (dfs_file_stat(fullpath, &file_stat)) {
		dfs_file_close(&fd);
		rt_free(path);
		rt_free(fullpath);
		return;
	}
	// 定位到文件末尾
	if (dfs_file_lseek(&fd, file_stat.st_size) < 0) {
		dfs_file_close(&fd);
		rt_free(path);
		rt_free(fullpath);
		return;
	}
	// 写数据
	if (dfs_file_write(&fd, data, len) < 0) {
		dfs_file_close(&fd);
		rt_free(path);
		rt_free(fullpath);
		return;
	}

dfs_file_close(&fd);
	rt_free(path);
	rt_free(fullpath);
}

// 监听任务
void dongle_task(void *parameter)
{
    // 监听接收
    while (1) {
        if (s_uart_recv.len) {
            data_file_write(s_uart_recv.buf, s_uart_recv.len);
            s_uart_recv.len = 0;
        }
        rt_thread_delay(10);
    }
}

// user main
int main(void)
{
    rt_device_t comm_uart;
    uint8_t send_buf[] = "lillian test send. <br>";
	
    // 挂载文件系统
    if (dfs_mount("sd0", "/", "elm", 0, 0) == 0)
    {
        rt_kprintf("file system initialization done!<br>");
    } else {
        rt_kprintf("file system initialization failed!<br>");
    }

// 打开UART2
	comm_uart = rt_device_find(RT_COMM_DEVICE_NAME);
	// 设置中断callback
	rt_device_set_rx_indicate(comm_uart, rt_uart_callback); 
	rt_device_open(comm_uart, RT_DEVICE_OFLAG_RDWR | RT_DEVICE_FLAG_INT_RX);

// 测试UART2发送
	rt_device_write(comm_uart, 0, send_buf, strlen((const char *)send_buf));
	
	s_dongle_thread = rt_thread_create("dongle", 
									 dongle_task, 
									 RT_NULL,
									 STK_DONGLE_SIZE, 
									 TASK_DONGLE_PRIORITY, 
									 20);
		
	RT_ASSERT(s_dongle_thread != RT_NULL);
	rt_thread_startup(s_dongle_thread);
	
	return 0;
}
```

下载附件 [第二周：开发板跑文件系统.docx](https://oss-club.rt-thread.org/uploads/201807/28/000751i36xa9x9a3x6w3rv.attach)

13 个回答

lillian 2018-07-28

这家伙很懒，什么也没写！

lillian 2018-07-28

这家伙很懒，什么也没写！

lillian 2018-07-28

这家伙很懒，什么也没写！

lillian 2018-07-28

这家伙很懒，什么也没写！

lillian 2018-07-28

这家伙很懒，什么也没写！

lillian 2018-07-28

这家伙很懒，什么也没写！

lillian 2018-07-28

这家伙很懒，什么也没写！

[i=s] 本帖最后由 lillian 于 2018-7-28 13:36 编辑 [/i]

另外还要纠正一个问题：
我之前的串口数据处理有问题，没有考虑到在任务里面处理数据的时候，接收中断会随时打断任务，修改接收数据，所以会丢包；我现在加了一个缓存来处理数据，修改后的源码如下：

```

```
// 接收缓存
#define RECV_BUF_MAX           1024
typedef struct {
	uint8_t buf[RECV_BUF_MAX];
	uint8_t len;
} _uart_recv;
_uart_recv s_uart_recv = {0};
_uart_recv s_uart_data = {0};

// 中断callback
static rt_err_t rt_uart_callback(rt_device_t dev, rt_size_t size)
{
	uint8_t readSize;

// 防止任务处理不及时溢出
	if (s_uart_recv.len >= RECV_BUF_MAX) {
		s_uart_recv.len = 0;
	}
	readSize = (size > RECV_BUF_MAX) ? RECV_BUF_MAX : size;

if ((s_uart_recv.len + readSize) > RECV_BUF_MAX) {
		readSize = RECV_BUF_MAX - s_uart_recv.len;
	}
	s_uart_recv.len += rt_device_read(dev, 0, &s_uart_recv.buf[s_uart_recv.len], readSize);

return RT_EOK;
}

// 监听任务
void dongle_task(void *parameter)
{
    // 监听接收
    while (1) {
        rt_enter_critical();
        if (s_uart_recv.len) {
            s_uart_data.len = s_uart_recv.len;
            memcpy(s_uart_data.buf, s_uart_recv.buf, s_uart_recv.len);
            s_uart_recv.len = 0;
        }
        rt_exit_critical();
		
        if (s_uart_data.len) {
            data_file_write(s_uart_data.buf, s_uart_data.len);
            s_uart_data.len = 0;
        }
        rt_thread_delay(10);
    }
}
```