C++ 嵌入式LPC2148上的FAT16库。Can'；t更新群集位置（棘手！）

我的代码是使用Roland Riegel针对FAT16的免费库

append函数可以找到文件位置或（集群1）中的位置，并将新数据保存到集群中的正确位置。经过无数次的文件打开和关闭

在文件中的数据从（集群1）溢出到（集群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;
}

/////////////////////////////写入命令///////////////////

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();
}

if（fat16写入文件（句柄，（无符号字符*）RX_数组1，字符串大小）<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
}

int16\t fat16\u写入文件（结构fat16\u文件\u结构*fd、常量uint8\u t*buffer、uint16\u t buffer\u len）
{
#如果FAT16\u写入\u支持
/*检查参数*/
如果（！fd | | |！buffer | buffer|u len<1）
返回-1；
if（fd->pos>fd->dir\u entry.file\u size）
返回-1；
uint16\u t cluster\u size=fd->fs->header.cluster\u size；
uint16\u t cluster\u num=fd->pos\u cluster///////////////////////////
uint16\u t buffer\u left=buffer\u len；
uint16第一簇偏移量=fd->pos%簇大小；
//uint16\u t cl=fat16\u追加\u簇（fd->fs，簇数，1）；
//rprintf（“A0%d\r”，cl）；
rprintf（“N%d操作系统%d\r”，群集数量，第一个群集偏移量）；
//uint32_t pos=fd->pos；
//rprintf（“Csiz%d\r”，集群大小）；
//rprintf（“Csiz%d\r”，第一个集群偏移量）；
//rprintf（“BLeft%d\r”，缓冲区左）；
/*查找要开始写入的集群*/
如果（！cluster_num）
{
cluster\u num=fd->dir\u entry.cluster；
rprintf（“C0%d\r”，集群数量）；
如果（！cluster_num）
{
rprintf（“C1%d\r”，集群数量）；
如果（！fd->pos）
{
/*空文件*/
fd->dir\u entry.cluster=cluster\u num=fat16\u append\u clusters（fd->fs，cluster\u num，1）；
rprintf（“C2%d\r”，集群数量）；
如果（！cluster_num）{
返回-1；
}
}
其他的
{
返回-1；
}
}
如果（fd->pos）
{
uint32_t pos=fd->pos；
//rprintf（“FDPOS%d\r”，pos）；
uint16\u t集群\u num\u next；
而（位置>=群集大小）
{
//rprintf（“FDPOS\r”）；
pos-=集群大小；
cluster_num_next=fat16_get_next_cluster（fd->fs，cluster_num）；
如果（！cluster_num_next&&pos==0）
/*该文件正好在集群边界上结束，我们将其追加*/
cluster_num_next=fat16_append_clusters（fd->fs，cluster_num，1）；
如果（！cluster_num_next）
返回-1；
cluster_num=cluster_num_next；
}
}
}
/*写入数据*/
做
{
/*计算要写入群集的数据大小*/
uint32\u t cluster\u offset=fd->fs->header.cluster\u zero\u offset+
（uint32_t）（cluster_num-2）*cluster_size+first_cluster_offset；
uint16\u t write\u length=簇大小-第一簇偏移量；
如果（写入长度>缓冲区左）
写入长度=缓冲区左；
/*写入适合当前集群的数据*/
如果（！fd->fs->partition->device\u write（集群偏移量、缓冲区、写入长度））
打破
/*计算新文件位置*/
缓冲区+=写入长度；
缓冲区左-=写入长度；
fd->pos+=写入长度；
if（第一个簇的偏移量+写入长度>=簇的大小）
{
rprintf（“测试%d%d%d\r”，第一个群集偏移量，写入长度，群集大小）；
/*我们在一个集群边界上，所以获取下一个集群*/
uint16_t cluster_num_next=fat16_get_next_cluster（fd->fs，cluster_num）；
如果（！cluster\u num\u next&&buffer\u left>0）
/*我们到达了最后一个集群，添加了一个新集群*/
cluster_num_next=fat16_append_clusters（fd->fs，cluster_num，1）；
rprintf（“NewCluster%d\r”，cluster\u num\u next）；
如果（！cluster_num_next）
{
rprintf（“零\r”）；
fd->pos_集群=0；
打破
}
cluster_num=cluster_num_next；
第一簇偏移量=0；
}
fd->pos\u cluster=集群数量；
}
while（buffer_left>0）；/*检查是否完成*/
/*更新目录项*/
if（fd->pos>fd->dir\u entry.file\u size）
{
//rprintf（“UpdateFilesize\r”）；
uint32\u t size\u old=fd->dir\u entry.file\u size；
/*更新文件大小*/
fd->dir\u entry.file\u size=fd->pos；
/*写入目录项*/
如果（！fat16写入目录项（fd->fs和fd->目录项））
{
/*我们在这里不返回错误，因为我们实际编写了
*一些数据存储到磁盘。因此我们计算数据量
*我们将数据写入磁盘，该数据位于旧文件大小内。
*/
缓冲区左=fd->pos-大小旧；
fd->pos=尺寸（旧）；
}
}
返回buffer_len-buffer_left；
#否则
返回-1；
#恩迪夫
}

---

我被困在迷宫里了。。。。任何帮助都将不胜感激。如果你需要更多的代码，请告诉我。我希望这就足够了？

我对该库一无所知，很可能您需要调试器断点和

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