请问ST公司的STM32F407，在RT-Thread开发环境下，如何用U盘离线更新MCU程序

发布于 2023-10-09 10:42:55 浏览：739 订阅该版

sync 2023-10-09

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

Tonyk 2023-10-09

Find it

sync 2023-10-09

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

Tonyk 2023-10-09

Find it

请登录后再发布评论，点击登录

追加回复

9 个回答

Hunt 2023-10-09

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

嚜軒公告 2023-10-09

努力中

Tonyk 2023-10-09

Find it

xiaorui 认证专家 2023-10-09

小睿手办 https://item.taobao.com/item.htm?id=674889867009

Tonyk 2023-10-09

Find it

请登录后再发布评论，点击登录

追加回复

梦笑真美 2023-10-09

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

Tonyk 2023-10-09

Find it

梦笑真美 2023-10-09

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

请登录后再发布评论，点击登录

追加回复

小狼 2023-10-10

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

StackYuan 认证专家 2023-10-11

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

ThinkCode 2024-04-02

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

```C
/*
 * Copyright (c) 2006-2021, RT-Thread Development Team
 *
 * SPDX-License-Identifier: Apache-2.0
 *
 * Change Logs:
 * Date           Author       Notes
 * 2024-02-01     admin       the first version
 */

#include <rtthread.h>
#include "rtconfig.h"
#include <fal.h>
#include <dirent.h>
#include <string.h>
#include <qboot.h>

#define DBG_TAG "FW"
#define DBG_LVL DBG_LOG
#include <rtdbg.h>

#define DOWNLOAD_PART QBOOT_DOWNLOAD_PART_NAME
#define FILE_BUFF_SIZE (4*1024)
static char file_buf[FILE_BUFF_SIZE] = {0};
static const struct fal_partition * dl_part = RT_NULL;

static rt_err_t check_mount(){
    rt_device_t dev = rt_device_find("udisk0");
    if(dev != RT_NULL){
        return RT_EOK;
    }
    else{
        return RT_ERROR;
    }
}

static size_t get_file_size(FILE *f){
    fseek(f, 0, SEEK_END);
    size_t ret = ftell(f);
    rewind(f);
    return ret;
}

rt_err_t fw_load(const char* fw_path){
    rt_err_t ret = RT_EOK;
    char* recv_partition = DOWNLOAD_PART;

FILE *f = fopen(fw_path, "rd");
    if(f == NULL){
        LOG_E("Open file error!");
        ret = RT_ERROR;
        goto _exit;
    }
    size_t fw_file_size = get_file_size(f);
    LOG_I("Firmware file size:%d byte", fw_file_size);

if ((dl_part = fal_partition_find(recv_partition)) == RT_NULL)
    {
        LOG_E("Partition (%s) find error!\n", recv_partition);
        ret = RT_ERROR;
        goto _exit;
    }

if(fw_file_size > dl_part->len){
        LOG_E("Firmware is too large! File size (%d), '%s' partition size (%d)", fw_file_size, dl_part->name, dl_part->len);;
        ret = RT_ERROR;
        goto _exit;
    }

if (fal_partition_erase(dl_part, 0, fw_file_size) < 0)
    {
        LOG_E("Firmware download failed! Partition (%s) erase error!", dl_part->name);
        ret = RT_ERROR;
        goto _exit;
    }

int buff_block_len = fw_file_size / FILE_BUFF_SIZE;
    int buff_block_count = 0;
    size_t update_file_cur_size = 0;
    do{
        int read_size = fw_file_size > FILE_BUFF_SIZE? FILE_BUFF_SIZE:fw_file_size;
        fread(file_buf, 1, read_size, f);
        if (fal_partition_write(dl_part, update_file_cur_size, (uint8_t*)file_buf, read_size) < 0)
        {
            LOG_E("Firmware download failed! Partition (%s) write data error!", dl_part->name);
            ret = RT_ERROR;
            goto _exit;
        }
        update_file_cur_size += read_size;
        fw_file_size -= read_size;
        rt_kprintf("\r[%d/%d] %s=>download, replicating firmware file...", buff_block_count, buff_block_len, fw_path);
        buff_block_count ++;
    }while(fw_file_size != 0);

_exit:
    if(f != NULL)
        fclose(f);

return ret;
}

rt_err_t src_load(const char* src_path){
    rt_err_t ret = RT_EOK;
    DIR *dir = opendir(src_path);
    struct dirent *ent;
    if(dir == NULL){
        LOG_E("Not found dir: %s", src_path);
        ret = RT_ERROR;
        goto _exit;
    }

while((ent = readdir(dir)) != NULL){
        if(strcmp(ent->d_name, "System Volume Information") == 0)
            continue;
        rt_kprintf("copy %s ", ent->d_name);
        FILE *f_in;
        {
            char path_buff[64] = {0};
            strcat(path_buff,src_path);
            strcat(path_buff,"/");
            strcat(path_buff,ent->d_name);
            f_in = fopen(path_buff, "rb");
        }
        FILE *f_out;
        {
            char path_buff[32] = {0};
            strcat(path_buff,"/");
            strcat(path_buff,ent->d_name);
            f_out = fopen(path_buff, "wb");
        }
        size_t file_size = get_file_size(f_in);
        rt_kprintf("size: %d byte\n", file_size);

do{
            int read_size = file_size > FILE_BUFF_SIZE? FILE_BUFF_SIZE:file_size;
            fread(file_buf, 1, read_size, f_in);
            fwrite(file_buf, 1, read_size, f_out);
            if(file_size > FILE_BUFF_SIZE)
                fseek(f_out, read_size, SEEK_CUR);
            file_size -= read_size;
        }while(fseek(f_in, FILE_BUFF_SIZE, SEEK_CUR) == 0 && file_size != 0);
        fclose(f_in);
        fclose(f_out);
    }

_exit:
    if(dir != NULL)
        closedir(dir);
    return ret;
}

extern int access(const char *path, int amode);

int fw_from_udisk(){

if(check_mount() != RT_EOK){
        return 0;
    }

const char* fw_path = UDISK_MOUNTPOINT"/new.fw";
    const char* fw_path_old = UDISK_MOUNTPOINT"/old.fw";
    const char* src_path = UDISK_MOUNTPOINT"/new_i18n";
    const char* src_path_old = UDISK_MOUNTPOINT"/old_i18n";

LOG_I("Check the firmware in the Udisk");

if(access(fw_path, 4)!= 0){
        LOG_E("not found %s", fw_path);
    }
    else{
        if(fw_load(fw_path) == RT_EOK){
            rename(fw_path, fw_path_old);
            remove(fw_path);
            LOG_I("success: %s -> %s", fw_path, fw_path_old);
        }
        else{
            LOG_E("load fw failed!");
        }
    }

if(access(src_path, 4)!= 0){
        LOG_E("not found %s", src_path);
    }
    else{
        if(src_load(src_path) == RT_EOK){
            rename(src_path, src_path_old);
            remove(src_path);
            LOG_I("success: %s -> %s", src_path, src_path_old);
        }
        else{
            LOG_E("load src failed!");
        }
    }

return 0;
}

int fw_copy_init(){
    qbt_hook_register(fw_from_udisk);
    return 0;
}

INIT_ENV_EXPORT(fw_copy_init);

int copy_fw(int argc, char **argv){
    if(strcmp(argv[1], "src") == 0){
        src_load(argv[2]);
    }
    else if(strcmp(argv[1], "fw") == 0) {
        fw_load(argv[2]);
    }
    else{
        rt_kprintf("src [dir_path]\n");
        rt_kprintf("fw [fw_path]\n");
    }

return 0;
}

MSH_CMD_EXPORT(copy_fw, download firmware from disk);

```
这是我写的固件复制的代码, 就是挂载U盘或是SD卡, 然后把固件拷贝到指定flash扇区, 之后就让qboot启动, qboot我做了一些改造, 加了一个函数能把复制固件的代码加到它的启动流程中  
另外, 使用能挂载文件系统的程序会使固件增加150KB的体积.