LPC2148 embedded上的FAT16库。无法更新集群位置(棘手！)

Question

我的代码使用了适用于FAT16的Roland Riegel自由库，

append函数可以找到文件位置或(集群1)中的位置，并将新数据保存到集群中的正确位置。在无数次文件打开和关闭之后；

在文件中的数据从(Cluster 1)溢出到(Cluster 2)之后，传入的新数据完全可以写入。但是，在关闭并重新打开文件后，仅更新文件位置，而不更新群集。

因此，新数据被保存到(群集1)中的位置和正确的位置，但是！！它应该在(群集2)中。

我已经找了一段时间了，不过我还是要请教专家。这就是我得到的！！

很抱歉有这么大的链条，但是很难看出来。

string_printf(name, "MainLog.txt");
if(!root_file_exists(name)){
  handle = root_open_new(name);
}
else{
handle = root_open_append(name);
}


struct fat16_file_struct * root_open_append(char* name)
{
return(open_file_in_dir_append(fs,dd,name));
}

/

struct fat16_file_struct* open_file_in_dir_append(struct fat16_fs_struct* fs, struct fat16_dir_struct* dd, const char* name)
{

struct fat16_file_struct* result;
struct fat16_dir_entry_struct file_entry;

if(!find_file_in_dir(fs, dd, name, &file_entry))
    return 0;

     result = fat16_open_file(fs, &file_entry);
result->pos = result->dir_entry.file_size;


result->dir_entry.cluster = result->pos_cluster; // <<-Help here


return result;
}

/

struct fat16_file_struct* fat16_open_file(struct fat16_fs_struct* fs, const struct fat16_dir_entry_struct* dir_entry)
{
rprintf("\nF16OpenFile\n\n");
if(!fs || !dir_entry || (dir_entry->attributes & FAT16_ATTRIB_DIR))
    return 0;

struct fat16_file_struct* fd = malloc(sizeof(*fd));
if(!fd)
    return 0;

memcpy(&fd->dir_entry, dir_entry, sizeof(*dir_entry));
fd->fs = fs;
fd->pos = 0;
fd->pos_cluster = dir_entry->cluster;
return fd;
}

/写入命令/

这样叫..。

if(fat16_write_file(handle,(unsigned char *)RX_array1, stringSize) < 0)
{           
sd_raw_sync();
}

实际结构在这里/

int16_t fat16_write_file(struct fat16_file_struct* fd, const uint8_t* buffer, uint16_t buffer_len)
{
#if FAT16_WRITE_SUPPORT
    /* check arguments */
    if(!fd || !buffer || buffer_len < 1)
        return -1;
    if(fd->pos > fd->dir_entry.file_size)
        return -1;

    uint16_t cluster_size = fd->fs->header.cluster_size;
    uint16_t cluster_num = fd->pos_cluster;///////////////////////////
    uint16_t buffer_left = buffer_len;
    uint16_t first_cluster_offset = fd->pos % cluster_size;

        //uint16_t cl = fat16_append_clusters(fd->fs, cluster_num, 1);
        //rprintf("A0 %d\r", cl);




    rprintf("N%d  OS%d \r", cluster_num, first_cluster_offset);



    //uint32_t pos = fd->pos;


    //rprintf("Csiz %d\r", cluster_size);
    //rprintf("Csiz %d\r", first_cluster_offset);
    //rprintf("BLeft %d\r", buffer_left);
    /* find cluster in which to start writing */
    if(!cluster_num)
    {
        cluster_num = fd->dir_entry.cluster;
        rprintf("C0 %d\r", cluster_num);
        if(!cluster_num)
        {
            rprintf("C1 %d\r", cluster_num);
            if(!fd->pos)
            {
            /* empty file */
                fd->dir_entry.cluster = cluster_num = fat16_append_clusters(fd->fs, cluster_num, 1);
                rprintf("C2 %d\r", cluster_num);
                if(!cluster_num){
                    return -1;
                    }
            }
            else
            {
                return -1;
            }
        }

        if(fd->pos)
        {

            uint32_t pos = fd->pos;
            //rprintf("FDPOS %d\r", pos);
            uint16_t cluster_num_next;
            while(pos >= cluster_size)
            {
            //rprintf("FDPOS\r");
                pos -= cluster_size;
                cluster_num_next = fat16_get_next_cluster(fd->fs, cluster_num);
                if(!cluster_num_next && pos == 0)
    /* the file exactly ends on a cluster boundary, and we append to it */
                    cluster_num_next = fat16_append_clusters(fd->fs, cluster_num, 1);
                if(!cluster_num_next)
                    return -1;

                cluster_num = cluster_num_next;
            }
        }
    }

    /* write data */
    do
    {
        /* calculate data size to write to cluster */
        uint32_t cluster_offset = fd->fs->header.cluster_zero_offset +
        (uint32_t) (cluster_num - 2) * cluster_size + first_cluster_offset;
        uint16_t write_length = cluster_size - first_cluster_offset;
        if(write_length > buffer_left)
            write_length = buffer_left;

        /* write data which fits into the current cluster */
        if(!fd->fs->partition->device_write(cluster_offset, buffer, write_length))
            break;

        /* calculate new file position */
        buffer += write_length;
        buffer_left -= write_length;
        fd->pos += write_length;

        if(first_cluster_offset + write_length >= cluster_size)
        {
            rprintf("TEST %d  %d  %d\r", first_cluster_offset, write_length, cluster_size);
            /* we are on a cluster boundary, so get the next cluster */
            uint16_t cluster_num_next = fat16_get_next_cluster(fd->fs, cluster_num);
            if(!cluster_num_next && buffer_left > 0)
    /* we reached the last cluster, append a new one */
                cluster_num_next = fat16_append_clusters(fd->fs, cluster_num, 1);
                rprintf("NewCluster %d\r", cluster_num_next);
            if(!cluster_num_next)
            {
                rprintf("Zero\r");
                fd->pos_cluster = 0;
                break;
            }

            cluster_num = cluster_num_next;
            first_cluster_offset = 0;
        }

        fd->pos_cluster = cluster_num;

    }
    while(buffer_left > 0); /* check if we are done */

    /* update directory entry */
    if(fd->pos > fd->dir_entry.file_size)
    {
        //rprintf("UpdateFilesize\r");
        uint32_t size_old = fd->dir_entry.file_size;

        /* update file size */
        fd->dir_entry.file_size = fd->pos;
        /* write directory entry */
        if(!fat16_write_dir_entry(fd->fs, &fd->dir_entry))
        {
            /* We do not return an error here since we actually wrote
            * some data to disk. So we calculate the amount of data
            * we wrote to disk and which lies within the old file size.
            */
            buffer_left = fd->pos - size_old;
            fd->pos = size_old;
        }
    }

    return buffer_len - buffer_left;

#else
    return -1;
#endif
}

我完全被卡住了，试图弄清楚这个迷宫...任何帮助我们都将不胜感激。如果您需要更多代码，请让我知道。我希望这足够了？

Answer 1

我对这个库一无所知，您很可能需要调试器断点和大量单步执行来找出问题所在，但我会说我得到了efsl (embedded filesystem library) 0.2.x --稳定分支--在另一个小型微控制器上工作得很好。所以你可能会有更多的运气。

Answer 2

查看open函数，它将文件位置设置为0：

fd->pos = 0;
fd->pos_cluster = dir_entry->cluster;

在open_file_in_dir_append函数中，更新位置，但使用与位置0相同的集群：

result = fat16_open_file(fs, &file_entry);
result->pos = result->dir_entry.file_size;

result->dir_entry.cluster = result->pos_cluster; // <<-Help here

查看Documentation，还有一个fat16_seek_file函数，您希望查找到文件的末尾，所以您应该直接调用该函数，我认为它将如下所示：

result = fat16_open_file(fs, &file_entry);
int32_t offset=result->dir_entry.file_size;
fat16_seek_file(result, &offset, FAT16_SEEK_SET);

您还可以查看fat16_seek_file的代码，这里到底做了些什么。