注册
usb

记录:利用U盘直接烧录hex文件到flash来更新app程序

前几天发过一个网上转的hex转换bin的C程序代码,
准备把这个代码移植到先前写过的fat+U+bin+flash
配置:http://www.stm32cube.com/question/514
编程:http://www.stm32cube.com/question/515
改成fatfs+U+hex+flash
这样的话就不用专门把hex转换为bin在去烧写了.
此贴保留,后续慢慢更新.
2016-08-04 添加评论
分享

没有找到相关结果

    已邀请:

    admin

    赞同来自:

    准备工作:
    为了要能更好的观察到生成的bin和用c转换的bin是否一致,准备先将hex放入u盘,在程序中添加一个hex转换bin的过程,然后生成相应的bin文件到u盘,.这样在电脑上就可以打开观察两者的区别
    所以,首先按照配置链接完成fat写文件的配置,
    我利用了上次配置:http://www.stm32cube.com/question/514
    直接诶打开这个工程:
    然后修改原先写入一个文件为写入两个文件,
    正常的写入文件流程是:
    f_mount(&USBDISKFatFs, (TCHAR const*)USBH_Path, 0)
    之后紧跟 创建并打开操作
    f_open(&MyFile, "hextest.txt", FA_CREATE_ALWAYS | FA_WRITE);
    创建完成后,就是写入操作了
    f_write(&MyFile, wtexthex, sizeof(wtexthex), (void *)&byteswritten);
    写入完成了,那么就必须添加一个打开操作的孪生兄弟 关闭操作
    f_close(&MyFile);
    这样一个完成的创建并写入一个文件就完成了.
     
    那么这次我先测试下写入两个文件,所以上面的流程复制一遍即可,于是得到了下面修改后的代码
    static void MSC_Application(void)
    
{
    
    FRESULT res;                                          /* FatFs function common result code */
    
    uint32_t byteswritten;                   /* File write/read counts */
    
    uint8_t wtexthex[] = "hex 1 hex 2 hex 3 hex 4 hex 5"; /* File write buffer */
    
	    uint8_t wtextbin[] = "bin 1 bin 2 bin 3 bin 4 bin 5 bin 6"; /* File write buffer */
    
	
    
	uint8_t write_status;
    
	
    
	
    
//  uint8_t rtext[100];                                   /* File read buffer */
    

    
    /* Register the file system object to the FatFs module */
    
    if(f_mount(&USBDISKFatFs, (TCHAR const*)USBH_Path, 0) != FR_OK)
    
    {
    
        /* FatFs Initialization Error */
    
        Error_Handler();
    
    }
    
    else
    
    {
    
        /* Create and Open a new text file object with write access */
    
			write_status = f_open(&MyFile, "hextest.txt", FA_CREATE_ALWAYS | FA_WRITE);
    
		
    
        if( write_status!= FR_OK)
    
        {
    
            Error_Handler();
    
        }
    
        else
    
        {
    
            /* Write data to the text file */
    
            res = f_write(&MyFile, wtexthex, sizeof(wtexthex), (void *)&byteswritten);
    

    
            if((byteswritten == 0) || (res != FR_OK))
    
            {
    
                /* 'STM32.TXT' file Write or EOF Error */
    
                Error_Handler();
    
            }
    
            else
    
            {
    
                /* Close the open text file */
    
                f_close(&MyFile);
    
            }
    
        }
    
//------------------------------------------------------------------------------------				
    
			write_status = f_open(&MyFile, "bintest.txt", FA_CREATE_ALWAYS | FA_WRITE);
    
		
    
        if( write_status!= FR_OK)
    
        {
    
            Error_Handler();
    
        }
    
        else
    
        {
    
            /* Write data to the text file */
    
            res = f_write(&MyFile, wtextbin, sizeof(wtextbin), (void *)&byteswritten);
    

    
            if((byteswritten == 0) || (res != FR_OK))
    
            {
    
                Error_Handler();
    
            }
    
            else
    
            {
    
                /* Close the open text file */
    
                f_close(&MyFile);
    
            }
    
        }				
    
//----------------------------------------------------------------------------------				
    
				
    
				
    
    }
    
}

    我创建了两个文件分别为 bintest.txt , hextest.txt
    内容分别是:bin 1 bin 2 bin 3 bin 4 bin 5 bin 6
    和
    hex 1 hex 2 hex 3 hex 4 hex 5

    QQ截图20160804111141.png

     
    测试结束,当然有心的人可以将这个流程封装为一个函数,这样每次写文件的时候调用即可.不用重复劳动.
    下面继续!
     
     
    2016-08-04 0 0
    分享

    admin

    赞同来自:

    我们先看下f_read函数声明
    FRESULT f_read (  
    
  FIL* fp,     /* [IN] File object */  
    
  void* buff,  /* [OUT] Buffer to store read data */  
    
  UINT btr,    /* [IN] Number of bytes to read */  
    
  UINT* br     /* [OUT] Number of bytes read */  
    
);
    btr是用户要读的数据量，br是实际读取的数据量，这样当判断到br==0时，文件读完。
     
     
    2016-08-04 0 0
    分享

    admin

    赞同来自:

    修改第一个文件的操作为读出
    将第一个文件hextest.txt的内容读出来,写入到bintest.txt文件里
     
    于是将刚才的程序第一个写入改为读出,
    首先打开以只读模式
    f_open(&MyFile, "hextest.txt", FA_READ)
    读出到rambuff中,个数是buffer_size,真实读出的数据个数为bytesread
    f_read (&MyFile, RAM_Buf, BUFFER_SIZE, (void *)&bytesread);
    关闭文件
    f_close(&MyFile);
    就像前面说的读出的时候可以判断bytesread是否==0,来判断读完
    这里我就不判断了,因为我知道能读的完.哈
    那么另外一个文件的写入要改为
    f_write(&MyFile, RAM_Buf, bytesread, (void *)&byteswritten);

    于是,整个程序被我改为
    #define BUFFER_SIZE        ((uint16_t)512*64)
    

    
static uint8_t RAM_Buf[BUFFER_SIZE] = {0x00};
    

    
static uint32_t TmpReadSize = 0x00;
    

    
static void MSC_Application(void)
    
{
    
    FRESULT res;                                          /* FatFs function common result code */
    
    uint32_t byteswritten,bytesread;                   /* File write/read counts */
    
//    uint8_t wtexthex[] = "hex 1 hex 2 hex 3 hex 4 hex 5"; /* File write buffer */
    
//	    uint8_t wtextbin[] = "bin 1 bin 2 bin 3 bin 4 bin 5 bin 6"; /* File write buffer */
    
	
    
	uint8_t write_status;
    
	
    
	
    
//  uint8_t rtext[100];                                   /* File read buffer */
    

    
    /* Register the file system object to the FatFs module */
    
    if(f_mount(&USBDISKFatFs, (TCHAR const*)USBH_Path, 0) != FR_OK)
    
    {
    
        /* FatFs Initialization Error */
    
        Error_Handler();
    
    }
    
    else
    
    {
    

    
			write_status = f_open(&MyFile, "hextest.txt", FA_READ);
    
		
    
        if( write_status!= FR_OK)
    
        {
    
            Error_Handler();
    
        }
    
        else
    
        {
    
					f_read (&MyFile, RAM_Buf, BUFFER_SIZE, (void *)&bytesread);
    
					TmpReadSize = bytesread;
    
					f_close(&MyFile);
    

    
					
    
					
    
					
    
//            res = f_write(&MyFile, wtexthex, sizeof(wtexthex), (void *)&byteswritten);
    

    
//            if((byteswritten == 0) || (res != FR_OK))
    
//            {
    
//                /* 'STM32.TXT' file Write or EOF Error */
    
//                Error_Handler();
    
//            }
    
//            else
    
//            {
    
//                /* Close the open text file */
    
//                f_close(&MyFile);
    
//            }
    
        }
    
//------------------------------------------------------------------------------------				
    
			write_status = f_open(&MyFile, "bintest.txt", FA_CREATE_ALWAYS | FA_WRITE);
    
		
    
        if( write_status!= FR_OK)
    
        {
    
            Error_Handler();
    
        }
    
        else
    
        {
    
            /* Write data to the text file */
    
            res = f_write(&MyFile, RAM_Buf, TmpReadSize, (void *)&byteswritten);
    

    
            if((byteswritten == 0) || (res != FR_OK))
    
            {
    
                Error_Handler();
    
            }
    
            else
    
            {
    
                /* Close the open text file */
    
                f_close(&MyFile);
    
            }
    
        }				
    
//----------------------------------------------------------------------------------				
    
				
    
				
    
    }
    
}
    烧录测试
     
     
     
    2016-08-04 0 0
    分享

    admin

    赞同来自:

    这个图片是上面的插入U盘后的结果,程序把hextest.txt的内容复制给了bintest.txt ,打开后可以看到
    内容为:hex 1 hex 2 hex 3 hex 4 hex 
    QQ截图20160804130709.png

    那么我们下一步就是,把hex复制到u盘,然后读出这个hex文件,直接复制到bintest.txt文件里进行测试.
    于是我们只修改读取文件的名称试试
    f_open(&MyFile, "USBDisk.hex", FA_READ);
    其中我用到的测试的USBDisk.hex为8.61K
    编译测试.

    QQ截图20160804131816.png

    可以看到大小一致,但是内容一样吗?这个就需要进一步对比
    通过代码对比工具可以看出,完全一致.

    QQ截图20160804132839.png

     
    这样我们就可以在读出数据之后对数据进行一系列的处理,完后在去写入到bintext.txt文件里面了
     
     
     
     
     
    2016-08-04 0 0
    分享

    admin

    赞同来自:

    接下来我利用
    http://www.stm32cube.com/question/516
    这篇文章的程序来对上面我们刚刚测试的程序进行进一步改造.
    我们这里还会用到另外一篇文章
    http://www.stm32cube.com/question/522
    这篇文章是对下面要用到的函数的讲解,一定要看完啊
     
    从这篇文章上看我们要利用
    f_gets()
    而这个函数的含义就如上面链接的介绍里讲的
    f_gets函数当_USE_STRFUNC == 1或者_USE_STRFUNC == 2时可用。如果_USE_STRFUNC == 2，文件中包含的'\r'则被去除。
    
f_gets函数是f_read的一个封装函数。当读取到'\n'、文件结束或缓冲区被填冲了Size - 1个字符时，读操作结束。读取的字符串以'\0'结束。当文件结束或读操作中发生了任何错误，f_gets()返回一个空字符串。可以使用宏f_eof()和f_error()检查EOF和错误状态。
    注意我后面移植的时候出了个错误就是这里没注意看导致的! 等下我会写出这个错误和解决办法!
    f_putc()
    函数的含义:
    f_putc函数当(_FS_READONLY == 0)&&(_USE_STRFUNC == 1 || _USE_STRFUNC == 2)时可用。当_USE_STRFUNC == 2时，字符'\n'被转换为"\r\n"写入文件中。
    
f_putc函数是f_write的一个封装函数。
    好了,我们开始改造,因为我们操作的时候要同时打开和操作两个文件,所以我们要
    FIL MyFileHex;                   /* File object */
    
FIL MyFileBin;                   /* File object */
    一个保存hex文件的打开状态,一个bin文件的打开状态
     
    因为hex文件的内容是字符,我们要转换为ascll码,所以需要特定的一个转换函数,于是我们要
    unsigned char ChartoByte(char c)
    
{
    
    if('a'>=0 ) return('a'+10);
    
    else if('A'>=0 ) return('A'+10);
    
    else return('0');
    
}
    

    
unsigned char Char2toByte(char* s)
    
{
    
    return (ChartoByte(*s)*16+ChartoByte(*(s+1)));
    
}
    这个网站的编辑器会吞代码,所以我再次发一下上面的代码的图片,你可以参照图片的代码研究

    QQ截图20160805110343.png

    接下来我们对
    MSC_Application()
    进行改造
    我们先同时打开两个文件,一个读一个写
            write_status = f_open(&MyFileHex, "USBDisk.hex", FA_READ);
    
        write_status = f_open(&MyFileBin, "bbbintest.bin", FA_CREATE_ALWAYS|FA_WRITE);
    然后对读取到的hex代码进行循环处理,提取出对我们有用的,删掉无用的
                while(1)
    
            {
    
                f_gets(buff,64,&MyFileHex);
    
                if(f_eof(&MyFileHex)) break; //Îļþ½áÊø
    
                else if(buff[0] != ':') continue; //ÎÞЧÐÐ
    
                else if( strcmp(buff,":00000001FF\n") == 0  ) break; //ÎÞЧÐÐ
    
                else
    
                {
    
                    length=Char2toByte(&buff[1]);
    
                    type=Char2toByte(&buff[7]);
    
                    if(type==0)
    
                    {
    
                        for(i=0; i<length; i++)
    
                            f_putc(Char2toByte(&buff[9+2*i]), &MyFileBin);
    
                    }
    

    
                }
    
            }
    同上,我也发个图片版的

    QQ截图20160805110712.png

    处理完成之后,我们要关闭这两个文件
                f_close(&MyFileBin);
    
            f_close(&MyFileHex);
    这样整个处理过程就结束了.
    完整的main函数代码如下:
    /* Includes ------------------------------------------------------------------*/
    
#include "stm32f4xx_hal.h"
    
#include "fatfs.h"
    
#include "usb_host.h"
    
#include "gpio.h"
    

    
/* USER CODE BEGIN Includes */
    

    
/* USER CODE END Includes */
    

    
/* Private variables ---------------------------------------------------------*/
    

    
/* USER CODE BEGIN PV */
    
/* Private variables ---------------------------------------------------------*/
    
extern ApplicationTypeDef Appli_state;
    
extern USBH_HandleTypeDef hUsbHostFS;
    
extern char USBH_Path[4];  /* USBH logical drive path */
    
/* USER CODE END PV */
    

    
/* Private function prototypes -----------------------------------------------*/
    
void SystemClock_Config(void);
    
void Error_Handler(void);
    
void MX_USB_HOST_Process(void);
    

    
/* USER CODE BEGIN PFP */
    
/* Private function prototypes -----------------------------------------------*/
    
static void MSC_Application(void);
    
/* USER CODE END PFP */
    

    
/* USER CODE BEGIN 0 */
    
FATFS USBDISKFatFs;           /* File system object for USB disk logical drive */
    
FIL MyFileHex;                   /* File object */
    
FIL MyFileBin;                   /* File object */
    

    
/* USER CODE END 0 */
    

    
int main(void)
    
{
    

    
    /* USER CODE BEGIN 1 */
    

    
    /* USER CODE END 1 */
    

    
    /* MCU Configuration----------------------------------------------------------*/
    

    
    /* Reset of all peripherals, Initializes the Flash interface and the Systick. */
    
    HAL_Init();
    

    
    /* Configure the system clock */
    
    SystemClock_Config();
    

    
    /* Initialize all configured peripherals */
    
    MX_GPIO_Init();
    
    MX_FATFS_Init();
    
    MX_USB_HOST_Init();
    

    
    /* USER CODE BEGIN 2 */
    

    
    /* USER CODE END 2 */
    

    
    /* Infinite loop */
    
    /* USER CODE BEGIN WHILE */
    
    while (1)
    
    {
    
        /* USER CODE END WHILE */
    
        MX_USB_HOST_Process();
    

    
        /* USER CODE BEGIN 3 */
    
        switch(Appli_state)
    
        {
    
        case APPLICATION_READY:
    
            MSC_Application();
    
            HAL_GPIO_WritePin(GPIOD,GPIO_PIN_12,GPIO_PIN_SET);
    
            Appli_state = APPLICATION_START;
    
            break;
    

    
        case APPLICATION_START:
    
            f_mount(NULL, (TCHAR const*)"", 0);
    

    
            break;
    
        case APPLICATION_DISCONNECT:
    
            HAL_GPIO_WritePin(GPIOD,GPIO_PIN_12,GPIO_PIN_RESET);
    
            Appli_state = APPLICATION_IDLE;
    
        default:
    
            break;
    
        }
    
    }
    
    /* USER CODE END 3 */
    

    
}
    

    
/** System Clock Configuration
    
*/
    
void SystemClock_Config(void)
    
{
    

    
    RCC_OscInitTypeDef RCC_OscInitStruct;
    
    RCC_ClkInitTypeDef RCC_ClkInitStruct;
    

    
    __HAL_RCC_PWR_CLK_ENABLE();
    

    
    __HAL_PWR_VOLTAGESCALING_CONFIG(PWR_REGULATOR_VOLTAGE_SCALE1);
    

    
    RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSE;
    
    RCC_OscInitStruct.HSEState = RCC_HSE_ON;
    
    RCC_OscInitStruct.PLL.PLLState = RCC_PLL_ON;
    
    RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_HSE;
    
    RCC_OscInitStruct.PLL.PLLM = 4;
    
    RCC_OscInitStruct.PLL.PLLN = 168;
    
    RCC_OscInitStruct.PLL.PLLP = RCC_PLLP_DIV2;
    
    RCC_OscInitStruct.PLL.PLLQ = 7;
    
    if (HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK)
    
    {
    
        Error_Handler();
    
    }
    

    
    RCC_ClkInitStruct.ClockType = RCC_CLOCKTYPE_HCLK|RCC_CLOCKTYPE_SYSCLK
    
                                  |RCC_CLOCKTYPE_PCLK1|RCC_CLOCKTYPE_PCLK2;
    
    RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_PLLCLK;
    
    RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;
    
    RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV4;
    
    RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV2;
    
    if (HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_5) != HAL_OK)
    
    {
    
        Error_Handler();
    
    }
    

    
    HAL_SYSTICK_Config(HAL_RCC_GetHCLKFreq()/1000);
    

    
    HAL_SYSTICK_CLKSourceConfig(SYSTICK_CLKSOURCE_HCLK);
    

    
    /* SysTick_IRQn interrupt configuration */
    
    HAL_NVIC_SetPriority(SysTick_IRQn, 0, 0);
    
}
    

    
/* USER CODE BEGIN 4 */
    
//-------------------------------
    
//:10C21000030A4FF00F090BF1040E00BF0B6808FA78
    
unsigned char ChartoByte(char c)
    
{
    
    if('a'>=0 ) return('a'+10);
    
    else if('A'>=0 ) return('A'+10);
    
    else return('0');
    
}
    

    
unsigned char Char2toByte(char* s)
    
{
    
    return (ChartoByte(*s)*16+ChartoByte(*(s+1)));
    
}
    

    
//------------------------------------
    
static void MSC_Application(void)
    
{
    

    
    uint8_t write_status;
    
    char buff[64] = "" ;
    
    unsigned char length = 0;
    
    unsigned char type = 0;
    
    unsigned char i = 0;
    

    
    /* Register the file system object to the FatFs module */
    
    if(f_mount(&USBDISKFatFs, (TCHAR const*)USBH_Path, 0) != FR_OK)
    
    {
    
        /* FatFs Initialization Error */
    
        Error_Handler();
    
    }
    
    else
    
    {
    

    
        write_status = f_open(&MyFileHex, "USBDisk.hex", FA_READ);
    
        write_status = f_open(&MyFileBin, "bbbintest.bin", FA_CREATE_ALWAYS|FA_WRITE);
    
        if( write_status!= FR_OK)
    
        {
    
            Error_Handler();
    
        }
    
        else
    
        {
    

    
            while(1)
    
            {
    
                f_gets(buff,64,&MyFileHex);
    
                if(f_eof(&MyFileHex)) break; //Îļþ½áÊø
    
                else if(buff[0] != ':') continue; //ÎÞЧÐÐ
    
                else if( strcmp(buff,":00000001FF\n") == 0  ) break; //ÎÞЧÐÐ
    
                else
    
                {
    
                    length=Char2toByte(&buff[1]);
    
                    type=Char2toByte(&buff[7]);
    
                    if(type==0)
    
                    {
    
                        for(i=0; i<length; i++)
    
                            f_putc(Char2toByte(&buff[9+2*i]), &MyFileBin);
    
                    }
    

    
                }
    
            }
    
            f_close(&MyFileBin);
    
            f_close(&MyFileHex);
    

    
        }
    
    }
    
}
    
/* USER CODE END 4 */
    如果上面的代码有错误的地方,肯定是被编辑器给吞了,那么请参考我中间发布的代码图片
     
    2016-08-05 0 0
    分享

    admin

    赞同来自: 坑自己星人

    此时如果我们进行编译烧写,
    首先将我们先前生成的那个用户app的USBDisk.hex文件拷入U盘,
    然后将u盘插入板卡,观察到LED绿色灯亮,说明烧写完毕,拔出U盘,绿色灯灭
    我们把U盘插入电脑,看到里面多了一个名字为:bbbintest.bin 的文件
    这个文明大小为3.05K 
    然而我们用keil自带的hex转bin软件将hex转换为bin后的代码大小为3.04K
    说明我们程序转换的不正确,
    此时我打开这个bbbintest.bin 和软件生成的USBDisk.bin
    观察他们有什么不同.

    QQ截图20160805112049.png


    左边的是软件转换的结果,右边是我们程序生成的结果
    可以看到右边的比左边的多出来好多个 0D 
    同时我们也看到每次多出来的0D 之后必然根了一个 0A
    我们再去看我们前面文章学习hex和bin区别的时候这句话:
    HEX格式文件以行为单位，每行由“：”（0x3a）开始，以回车键结束(0x0d,0x0a)
    所以判断这个应该是系统转换的时候把回车和换行都转换了,于是我去程序中查看

    QQ截图20160805112432.png



    QQ截图20160805114143.png


    QQ截图20160805114215.png

    于是我们找到了上面那句话,
    我赶紧去查看
    _USE_STRFUNC
    这个定义,我们定义的是 2
    所以导致了问题存在,于是,将
    其改为 1 即可.

    QQ截图20160805114409.png

     
    重新编译,按照上面的操作拔插u盘,然后看到,文件大小一致了.

    QQ截图20160805114505.png

    对比代码完全一致,测试成功.
    2016-08-05 1 0
    分享

    admin

    赞同来自:

     
    现在真正的重点开始操作.
    由于我们要操作flash,而且需要做用户app跳转所以我们打开以前fatfs+bin文件更新程序的那个工程文件夹,将里面的flash_if.c和flash_if.h文件复制到现在的工程中,
    我们在main.c文件中添加flash文件引用
    #include "flash_if.h"
    添加跳转定义
    uint32_t JumpAddress;
    
pFunction Jump_To_Application;
    上面的代码有木有很眼熟?
    对了,这个我们在dfu和串口的iap里面都用到了,U盘+bin也用到了.这里也不例外
    我们参考串口iap添加相应的按键检测跳转指令
        if(HAL_GPIO_ReadPin(GPIOA,GPIO_PIN_0) == GPIO_PIN_RESET)
    
    {
    
        /* Check Vector Table: Test if user code is programmed starting from address
    
        "APPLICATION_ADDRESS" */
    
        if (((*(__IO uint32_t*)APPLICATION_ADDRESS) & 0x2FFE0000 ) == 0x20000000)
    
        {
    
            /* Jump to user application */
    
            JumpAddress = *(__IO uint32_t*) (APPLICATION_ADDRESS + 4);
    
            Jump_To_Application = (pFunction) JumpAddress;
    
            /* Initialize user application's Stack Pointer */
    
            __set_MSP(*(__IO uint32_t*) APPLICATION_ADDRESS);
    
            Jump_To_Application();
    
        }
    

    
    }
    如果我们按键按下那么进行fat和Usb的初始化
    所以我们先将这两个函数注释掉,然后添加到上面代码的后面去
        MX_FATFS_Init();
    
    MX_USB_HOST_Init();
    
    FLASH_If_FlashUnlock();
    因为flash烧写我准备用word 32位
    HAL_FLASH_Program(FLASH_TYPEPROGRAM_WORD, LastPGAddress, hexdata)
    所以首先我们先增加定义一个函数,函数的作用就是将hex的有效数据分解为32位word数据
    unsigned int Char8toWord(char* s)
    
{
    
    return (	\
    
                (ChartoByte(*(s+6))<<28) + (ChartoByte(*(s+7))<<24) + (ChartoByte(*(s+4))<<20) + (ChartoByte(*(s+5))<<16)	\
    
                + (ChartoByte(*(s+2))<<12) + (ChartoByte(*(s+3))<<8) + (ChartoByte(*s)<<4) + ChartoByte(*(s+1))		\
    
           );
    
}
    我说一下这个地方,比较关键,为什么这么写?
    这个地方是根据我对flash的操作来写的,如果你的flash操作不同那么这个地方也要改.
    起先我上面的函数是7-6-5-4-3-2-1-0这个顺序,但是写入的效果不对,
    于是我利用stm32f407discovery板卡的stlink工具stlink utility
    连接查看烧录后的0x800c000地址的数据,和我导入的相应的hex文件里面的数据对比
    发现数据是对的,但是顺序是反的,所以几经周折才写出上面顺序.
    后面要用到应用app地址即0x800c000
    所以先定义一个
    static __IO uint32_t LastPGAddress = APPLICATION_ADDRESS;
    意思是下一个需要写入的地址
    上面都完成之后,我们需要在
    MSC_Application()
    这个函数里进行改造
    我们在成功打开文件之后
    f_open()
    增加一个清除flash块的操作
                /* Erase FLASH sectors to download image */
    
            if(FLASH_If_EraseSectors(APPLICATION_ADDRESS) != 0x00)
    
            {
    
                Error_Handler();
    
            }
    然后我们将原来写入到bin文件的代码为flash 写入操作

    
 
                        if(type==0)
    
                    {
    
                        for(i=0; i<length/4; i++)	//除以4是为了取得"字"的个数
    
                        {
    
                            hexdata = Char8toWord(&buff[9+8*i]);
    
                            /* Device voltage range supposed to be [2.7V to 3.6V], the operation will
    
                               be done by byte */
    
                            if(HAL_FLASH_Program(FLASH_TYPEPROGRAM_WORD, LastPGAddress, hexdata) != HAL_OK)
    
                            {
    
                                /* Check the written value */
    
                                Error_Handler();
    
                            }
    
                            LastPGAddress += 4;
    
                        }
    

    
                    }
    之后关闭fat和锁定flash
                f_close(&MyFileHex);
    
            HAL_FLASH_Lock();

    编译烧写代码到板卡
    然后u盘里面拷贝基地址为0x800c000的用户app的hex文件, 然后u盘插入板卡,灯亮之后拔出,然后重启
    可以看到效果.
    ok,利用 cubemx+USB+Fatfs+hex 脱机升级程序完成.
     
     
     
     
     
    2016-08-05 0 1
    分享

    admin

    赞同来自: 江小鱼

    更新一下:
    同上次那个帖子一样,为了更灵活更方便使用,我们可以增加一句重启的代码到程序中,
    这样当u盘拔掉之后,2秒后系统重启,就可以自动运行用户app了
            case APPLICATION_DISCONNECT:
    
            f_mount(NULL, (TCHAR const*)"", 0);
    
            HAL_Delay(2000);
    
            NVIC_SystemReset();
    
            break;
    ok,此次实验完整结束.
     
    下一个实验是利用片子的内部flash模拟一个U盘,然后利用usb线连接到电脑上,直接拷贝bin文件到这个虚拟U盘来直接完成flash的编程.
    这样就可以像使用U盘一个来更新程序了.
    2016-08-05 1 0
    分享

    admin

    赞同来自: boss 、随枫

    更新记录:

    从上面的程序中看到我们用来判断的依据是一个PA0上面的按键,但是实际应用中是没有按键给用户按的.

    那么应该怎么判断呢?

    最简单的办法就是上电的时候判断U盘是否已经插在了端口上.

    于是,我们要更新程序的时候要这样:

    1,断电

    2,插入u盘

    3,上电

    4,检测到有u盘已经插入

    5,系统更新程序

    6,拔掉u盘之后系统自动重启

    7,完成升级操作

    这样的话,我们就需要有一个判断U盘是否插入了的标准,恰好Hal库已经提供了此判断

    hUsbHostFS.device.is_connected

    他的值为:1或者0

    所以我们可以在程序开始的时候先判断

    例如:

       /* Reset of all peripherals, Initializes the Flash interface and the Systick. */
    
    HAL_Init();
    

    
    /* Configure the system clock */
    
    SystemClock_Config();
    

    
    /* Initialize all configured peripherals */
    
    MX_GPIO_Init();
    
    MX_FATFS_Init();
    
    MX_USB_HOST_Init();
    
    if(hUsbHostFS.device.is_connected)
    
		{
    
			while(1)
    
			{
    
				HAL_Delay(3000);
    
        HAL_GPIO_TogglePin(GPIOA,GPIO_PIN_1);
    
			}
    
		}

    或者在if中写入自己想要实现的代码,比如上面我们进行的程序升级操作.


    2017-03-06 2 0
    分享

    boss

    赞同来自:

    这个好玩

    2017-03-22 0 0
    分享

    yhz

    赞同来自:

    赞赞赞赞赞赞赞赞赞赞赞赞赞赞赞赞

    2017-11-15 0 0
    分享

    渔舟唱晚

    赞同来自:

    你为何这么叼

    2017-12-15 0 0
    分享

    zzj_zzj_zzj - stm32

    赞同来自:

    你为何这么叼赞赞赞赞赞赞赞赞赞赞赞赞赞赞赞赞

    2018-01-30 0 0
    分享

    翻滚吧小乌龟 - 90后TI

    赞同来自:

    厉害了我的哥

    2018-05-28 0 0
    分享

    BSXC

    赞同来自:

    厉害了我的哥

    2018-11-07 0 0
    分享

    luscu

    赞同来自:

    厉害   我的偶像了 

    2018-12-14 0 0
    分享

    寂静の烛光

    赞同来自:

    学习了，感谢分享

    2019-06-21 0 0
    分享

    坑自己星人

    赞同来自:

    一脸懵逼，stm32f407 keil环境 代码有吗

    2020-02-27 0 0
    分享
    为什么被折叠? 0 个回复被折叠

    要回复问题请先登录或注册

    
    Copyright © 2020