void LearnNewID()
{
// Check if ID already exists
u8 i;
_Bool flag_IDfound = FALSE;
for(i = 0; i < (*(u8*)(&(Receivers.NumLrndRcv))); i++)
{
if( RcvRFmsg.RFmsgmember.RFNodeId == (*(u8*)(&(Receivers.ID[i]))) )
{
flag_IDfound = TRUE;
break;
}
}
if(!flag_IDfound)
{
// Store Received ID in flash
FLASH_Unlock(FLASH_MemType_Program);
FLASH_ProgramByte( (u16)(u8*)(&Receivers.ID[Receivers.NumLrndRcv]), (u8)RcvRFmsg.RFmsgmember.RFNodeId );
FLASH_ProgramByte( (u16)(u8*)(&Receivers.NumLrndRcv), Receivers.NumLrndRcv + 1);
FLASH_Lock(FLASH_MemType_Program);
/* Check what was written */
if( RcvRFmsg.RFmsgmember.RFNodeId != (*(u8*)(&(Receivers.ID[(*(u8*)(&(Receivers.NumLrndRcv))) - 1]))) )
{
Errors_SetError(ERROR_FLASH_WRITE);
}
}
LrnModeActive = FALSE;
BLINKSTOP_GREENLED;
}
/*!
* Mark a block as being obsolete
*/
static int vrom_mark_obsolete(const struct vrom_data_block_t* block)
{
/* Blank out the CRC */
if (FLASH_ProgramWord((uint32_t)(&(block->header.crc32)), 0)
!= FLASH_COMPLETE)
return -EIO;
/* Blank out the ROM ID */
if (FLASH_ProgramByte((uint32_t)(&(block->header.rom)), 0)
!= FLASH_COMPLETE)
return -EIO;
/* Blank out the index */
if (FLASH_ProgramByte((uint32_t)(&(block->header.idx)), 0)
!= FLASH_COMPLETE)
return -EIO;
/* Blank out the size */
if (FLASH_ProgramByte((uint32_t)&(block->header.size), 0)
!= FLASH_COMPLETE)
return -EIO;
/* Blank out the reserved byte */
if (FLASH_ProgramByte((uint32_t)&(block->header.reserved), 0)
!= FLASH_COMPLETE)
return -EIO;
/* Blank out the flags */
return vrom_set_flags(block, -1);
}
void Retrieve_Check_ROM_Timer_Val()
{
u8 cnt, i;
/* Retrieve Timer Stored value index */
cnt = 0;
for(i=0; i<ROM_LOCATIONS_TIMER; i++) {
tmp_adr = (u16)&(timer_val_stored[i]);
if(READROM_U16(tmp_adr)) {
ROM_location_timer_idx = i;
cnt++;
break;
}
}
if(cnt != 1) {
// timer_val_stored corrupt, all 0 values or more than one value != 0 were read
tmp_adr = (u16)&(timer_val_stored[0]);
FLASH_Unlock(FLASH_MemType_Program);
FLASH_ProgramByte((u16)(tmp_adr)+0, (u8)(TIMER_VAL_DEFAULT >> 8));
FLASH_ProgramByte((u16)(tmp_adr)+1, (u8)(TIMER_VAL_DEFAULT & (u16)0x00FF));
if(READROM_U16(tmp_adr) != TIMER_VAL_DEFAULT) {
Errors_SetError(ERROR_FLASH_WRITE);
}
for(i=1; i<ROM_LOCATIONS_TIMER; i++) {
tmp_adr = (u16)&(timer_val_stored[i]);
FLASH_ProgramByte((u16)(tmp_adr)+0, (u8)0x00);
FLASH_ProgramByte((u16)(tmp_adr)+1, (u8)0x00);
if(READROM_U16(tmp_adr) != 0) {
Errors_SetError(ERROR_FLASH_WRITE);
}
}
FLASH_Lock(FLASH_MemType_Program);
ROM_location_timer_idx = 0;
BLINK_GREENLED(5);
while(ISBLINKING_GREENLED);
}
//Store the computed offsets to internal FLASH
void store_offsets()
{
union
{
float val;
struct
{
uint8_t bytes[4];
};
}extract_float;
uint32_t ADDRESS = BACKUP_ADDRESS;
uint8_t i,j;
IWDG_ReloadCounter();
FLASH_Unlock(); //unlock FLASH to enable writing
FLASH_ClearFlag(FLASH_FLAG_EOP | FLASH_FLAG_OPERR | FLASH_FLAG_WRPERR | FLASH_FLAG_PGAERR | FLASH_FLAG_PGPERR|FLASH_FLAG_PGSERR); //clear any pending flags
FLASH_EraseSector(BACKUP_SECTOR,VoltageRange_3); //Erase the sector where data is to be written too
FLASH_ProgramHalfWord(ADDRESS, ASI_ZERO);
ADDRESS+=2;
for(j=0;j<6;j++)
{
extract_float.val = AN_OFFSET[j];
for(i=0;i<4;i++)
{
FLASH_ProgramByte(ADDRESS, extract_float.bytes[i]);
ADDRESS+=1;
}
}
for(i=0;i<3;i++)
{
FLASH_ProgramHalfWord(ADDRESS, MAG_OFFSET[i]);
ADDRESS+=2;
}
for(j=0;j<3;j++)
{
extract_float.val = MAG_SCALE[j];
for(i=0;i<4;i++)
{
FLASH_ProgramByte(ADDRESS, extract_float.bytes[i]);
ADDRESS+=1;
}
}
FLASH_ProgramHalfWord(ADDRESS, ground_alt_offset);
ADDRESS+=2;
for(i=0;i<8;i++)
{
FLASH_ProgramHalfWord(ADDRESS, RC_trim[i]);
ADDRESS+=2;
}
FLASH_Lock();
}
uint16_t flash_helper_write_new_app_data(uint32_t offset, uint8_t *data, uint32_t len) {
FLASH_Unlock();
FLASH_ClearFlag(FLASH_FLAG_OPERR | FLASH_FLAG_WRPERR | FLASH_FLAG_PGAERR |
FLASH_FLAG_PGPERR | FLASH_FLAG_PGSERR);
mc_interface_unlock();
mc_interface_release_motor();
utils_sys_lock_cnt();
timeout_configure_IWDT_slowest();
for (uint32_t i = 0;i < len;i++) {
uint16_t res = FLASH_ProgramByte(flash_addr[NEW_APP_BASE] + offset + i, data[i]);
if (res != FLASH_COMPLETE) {
FLASH_Lock();
return res;
}
}
FLASH_Lock();
timeout_configure_IWDT();
utils_sys_unlock_cnt();
return FLASH_COMPLETE;
}
//void SD_TEST(void)
//{
// u8 res;
// UINT bw,index;
// res=f_mount( &fatfs_SDCARD,"0:/",1 );
// res=f_open(&file_sdif, "0:/sdif.dat",FA_OPEN_EXISTING|FA_WRITE|FA_READ);
// res=f_write(&file_sdif,SDTEST_WriteBuffer,512,&bw);
// res=f_close(&file_sdif);
// res=f_open(&file_sdif, "0:/sdif.dat",FA_OPEN_EXISTING |FA_WRITE);
// res=f_write(&file_sdif,SDTEST_WriteBuffer,512,&bw);
// res=f_close(&file_sdif);
// res=f_open(&file_sdif, "0:/sdif.dat",FA_OPEN_EXISTING | FA_READ);
// index=0;
// while(SDTEST_ReadBuffer[31]!=0x04)
// {
// index++;
// res=f_read(&file_sdif,SDTEST_ReadBuffer,512,&bw);
// }
// f_close(&file_sdif);
//
//
//}
u8 bsp_ChangeAPPtoRun(u8 App_Select)
{
u8 status=0;
u8 Flash_status=0;
FLASH_Unlock(); //解锁
FLASH_DataCacheCmd(DISABLE);//FLASH擦除期间,必须禁止数据缓存
FLASH_ClearFlag(FLASH_FLAG_EOP|FLASH_FLAG_OPERR|FLASH_FLAG_WRPERR| FLASH_FLAG_PGAERR | FLASH_FLAG_PGPERR|FLASH_FLAG_PGSERR);
status=FLASH_EraseSector(FLASH_Sector_3 ,VoltageRange_3);//VCC=2.7~3.6V之间!!
if(status==FLASH_COMPLETE)
{
__set_PRIMASK(1);
status=FLASH_ProgramByte(App_ToRun_Flag,App_Select); //SysID
__set_PRIMASK(0);
}
FLASH_DataCacheCmd(ENABLE); //FLASH擦除结束,开启数据缓存
FLASH_Lock();//上锁
if(status==FLASH_COMPLETE)
{
Flash_status=0;
}
else
{
Flash_status=status;
}
return Flash_status;
}
/**-----------------------------------------------------------------------------
* @brief Ecriture d'un buffer.
*
* @param[in] Address Adresse du debut de l'ecriture.
* @param[in] pBuffer Donnees a ecrire.
* @param[in] Size Nombre de donnees a ecrire.
*
* @return Status Statut de l'ecriture.
*/
uint8_t FLASH_Write(uint32_t Address, uint8_t* pBuffer, uint16_t Size)
{
uint8_t Status = Status_OK;
// Desactivation des interruptions
__disable_irq();
// Deverrouillage de la flash
FLASH_Unlock();
// Ecriture des octets
for (int i=0; i<Size; i++)
{
//TODO : OPTIMISATION DU TIMING POSSIBLE EN UTILISANT : FLASH_ProgramWord(uint32_t Address, uint32_t Data);
if (FLASH_ProgramByte(Address + i, (uint8_t) *(pBuffer + i)) != FLASH_COMPLETE)
Status = Status_KO;
}
// Verrouillage de la flash
FLASH_Lock();
// ReActivation des interruptions
__enable_irq();
return Status;
}
u8* bsp_Firmware_Write(u8* writebuffer,u32 writeaddress,u16 writelength)
{
u8 status=0;
u16 index=0;
SleepTime=0;
FLASH_Unlock(); //解锁
FLASH_DataCacheCmd(DISABLE);//FLASH擦除期间,必须禁止数据缓存
FLASH_ClearFlag(FLASH_FLAG_EOP|FLASH_FLAG_OPERR|FLASH_FLAG_WRPERR| FLASH_FLAG_PGAERR | FLASH_FLAG_PGPERR|FLASH_FLAG_PGSERR);
__set_PRIMASK(1);
for(index=0;index<writelength;index++)
{
status=FLASH_ProgramByte(writeaddress+index,writebuffer[index]);
}
__set_PRIMASK(0);
FLASH_DataCacheCmd(ENABLE); //FLASH擦除结束,开启数据缓存
FLASH_Lock();//上锁
if(status==FLASH_COMPLETE)
{
MCU_WriteStatus=0;
}
else
{
MCU_WriteStatus=status;
}
return &MCU_WriteStatus;
}
uint8_t DataMem_Write(uint32_t addr, uint8_t * pu8Buffer, uint8_t size)
{
uint32_t timeout = 10000;
uint8_t i = 0;
uint8_t state = 1;
usr_assert(pu8Buffer != NULL);
// Unlock flash data eeprom memory
FLASH_Unlock(FLASH_MemType_Data);
// Wait until Data EEPROM area unlocked flag is set
while ((FLASH_GetFlagStatus(FLASH_FLAG_PUL) == RESET) && (timeout--))
{}
if(timeout)
{
for(i = 0;i < size;i ++)
{
FLASH_ProgramByte(addr + i, *(pu8Buffer + i));
}
state = 1;
}
else
{
state = 0;
}
// Lock flash data eeprom memory
FLASH_Lock(FLASH_MemType_Data);
return (state);
}
void setPHYAddress(uint16 address)
{
FLASH_Unlock(FLASH_MemType_Data);
FLASH_ProgramByte(EEPROM_START,address>>8);
FLASH_ProgramByte(EEPROM_START+1,address);
FLASH_Lock(FLASH_MemType_Data);
}
static const DC3Error_t FLASH_writeUint8(
const uint32_t addr,
const uint8_t data
)
{
uint8_t data_read = 0;
FLASH_Status flash_status = FLASH_COMPLETE;
DC3Error_t status = ERR_NONE;
/* These flags have to be cleared before any operation can be done on the
* flash memory */
FLASH_ClearFlag(
FLASH_FLAG_PGSERR | FLASH_FLAG_PGPERR | FLASH_FLAG_PGAERR |
FLASH_FLAG_WRPERR | FLASH_FLAG_OPERR | FLASH_FLAG_EOP
);
flash_status = FLASH_ProgramByte(addr, data);
if (FLASH_COMPLETE != flash_status) {
status = FLASH_statusToErrorCode( flash_status );
ERR_printf("Flash Error %d writing 0x%02x to addr 0x%08x. Error: 0x%08x\n",
flash_status, data, addr, status);
return( status );
} else {
data_read = *((uint8_t *)addr);
if (data_read != data) {
status = ERR_FLASH_READ_VERIFY_FAILED;
ERR_printf("Failed to verify write at addr 0x%08x : Wrote 0x%02x and "
"read back 0x%02x. Error: 0x%08x\n", addr, data, data_read, status);
return( status );
}
}
return( status );
}
/**
* @brief Write in Non-Volatile Memory.
*
* The function writes in Non-Volatile Memory.
*
* @param[in] params params for the connection.
* @param[out] handle valid pointer toward a HAL_NVM_HANDLE handle
*
* @return #HAL_NVM_E_SUCCESS if the operation is successful,
* #HAL_NVM_E_INVAL if one argument is invalid
* #HAL_NVM_E_ERROR otherwise.
*/
int hal_nvm_write(HAL_NVM_HANDLE handle,
void *dst, void *src, int length)
{
unsigned char *d = (unsigned char *)dst;
unsigned char *s = (unsigned char *)src;
/* Enable the flash control register access */
FLASH_Unlock();
do
{
FLASH_ProgramByte((unsigned int)d, *s);
d++;
s++;
}
while(length--);
/* Lock the Flash to disable the flash control register access (recommended
to protect the FLASH memory against possible unwanted operation) */
FLASH_Lock();
return HAL_NVM_E_SUCCESS;
//error:
// return HAL_NVM_E_ERROR;
}
void write_2bytes_to_flash(uint32_t address, uint16_t data)
{
if(VoltageRange_x == VoltageRange_4 ||
VoltageRange_x == VoltageRange_3 ||
VoltageRange_x == VoltageRange_2){
FLASH_ProgramHalfWord(address, data);
}
else if(VoltageRange_x == VoltageRange_1){
union{
uint16_t half_word;
uint8_t byte[2];
} x = {data};
FLASH_ProgramByte(address, x.byte[0]);
FLASH_ProgramByte(address+1, x.byte[1]);
}
}
void Flash_SaveByte(uint8_t data)
{
// This takes 4us to execute at 168Mhz
FLASH_Unlock();
FLASH_ProgramByte(_flash_address, data);
++_flash_address;
FLASH_Lock();
}
/**
* @brief How to Read / Write / Erase one Byte on FLASH memory.
* @par Examples description
* - Read one byte at address 0x40A5
* - Write its complement value at adress + 1
* - Check programed value
* - Erase 2 byte (address 40A5 & 40A6)
* - Check the 2 bytes value is 0x00.
* @param None
* @retval None
*/
void main(void)
{
uint8_t val = 0x00, val_comp = 0x00;
uint32_t add = 0x00;
/* Define FLASH programming time */
FLASH_SetProgrammingTime(FLASH_PROGRAMTIME_STANDARD);
/* Unlock Data memory */
FLASH_Unlock(FLASH_MEMTYPE_DATA);
/* Read a byte at a specified address */
add = 0x40A5;
val = FLASH_ReadByte(add);
/* Program complement value (of previous read byte) at previous address + 1 */
val_comp = (uint8_t)(~val);
FLASH_ProgramByte((add + 1), val_comp);
/* Check program action */
val = FLASH_ReadByte((add + 1));
if (val != val_comp)
{
/* Error */
OperationStatus = FAILED;
/* OperationStatus = PASSED, if the data written/read to/from DATA EEPROM memory is correct */
/* OperationStatus = FAILED, if the data written/read to/from DATA EEPROM memory is corrupted */
while (1)
{
}
}
/* Erase byte at a specified address & address + 1 */
FLASH_EraseByte(add);
FLASH_EraseByte((add + 1));
/* Erase action */
val = FLASH_ReadByte(add);
val_comp = FLASH_ReadByte((add + 1));
if ((val != 0x00) & (val_comp != 0x00))
{
/* Error */
OperationStatus = FAILED;
/* OperationStatus = PASSED, if the data written/read to/from DATA EEPROM memory is correct */
/* OperationStatus = FAILED, if the data written/read to/from DATA EEPROM memory is corrupted */
while (1)
{
}
}
/* Pass */
OperationStatus = PASSED;
/* OperationStatus = PASSED, if the data written/read to/from DATA EEPROM memory is correct */
/* OperationStatus = FAILED, if the data written/read to/from DATA EEPROM memory is corrupted */
while (1)
{
}
}
void bsp_SysinfoSave(void)
{
u8 status=0;
u16 index=0;
SleepTime=0;
memcpy(MCU_ROM_Write,(u8*)ADDR_FLASH_SECTOR_7,1024+16); //?????,???????????buffer
memcpy(MCU_ROM_Write+1024,&char_SysID_Length,1);
memcpy(MCU_ROM_Write+1024+1,char_SysID,char_SysID_Length);
memcpy(MCU_ROM_Write+1024+9,&Battery_Threshold,1);
memcpy(MCU_ROM_Write+1024+10,&Key_Sound,1);
FLASH_Unlock(); //??
FLASH_DataCacheCmd(DISABLE);//FLASH????,????????
FLASH_ClearFlag(FLASH_FLAG_EOP|FLASH_FLAG_OPERR|FLASH_FLAG_WRPERR| FLASH_FLAG_PGAERR | FLASH_FLAG_PGPERR|FLASH_FLAG_PGSERR);
status=FLASH_EraseSector(FLASH_Sector_7 ,VoltageRange_3);//VCC=2.7~3.6V??!!
if(status==FLASH_COMPLETE)
{
for(index=0;index<(1024+16);index++)
{
status=FLASH_ProgramByte(ADDR_FLASH_SECTOR_7+index,MCU_ROM_Write[index]); //SysID
}
}
FLASH_DataCacheCmd(ENABLE); //FLASH????,??????
FLASH_Lock();//??
if(status==FLASH_COMPLETE)
{
MCU_WriteStatus=0;
}
else
{
MCU_WriteStatus=status;
}
// FLASH_Unlock(); //??
// FLASH_DataCacheCmd(DISABLE);//FLASH????,????????
// FLASH_ClearFlag(FLASH_FLAG_EOP|FLASH_FLAG_OPERR|FLASH_FLAG_WRPERR| FLASH_FLAG_PGAERR | FLASH_FLAG_PGPERR|FLASH_FLAG_PGSERR);
// status=FLASH_EraseSector(FLASH_Sector_7 ,VoltageRange_3);//VCC=2.7~3.6V??!!
// if(status==FLASH_COMPLETE)
// {
// status=FLASH_ProgramByte(ADDR_FLASH_SECTOR_7+1024,char_SysID_Length);//????
// for(index=0;index<char_SysID_Length;index++)
// {
// status=FLASH_ProgramByte(ADDR_FLASH_SECTOR_7+1024+index+1,char_SysID[index]); //SysID
// }
// status=FLASH_ProgramByte(ADDR_FLASH_SECTOR_7+1024+9,Battery_Threshold);
// status=FLASH_ProgramByte(ADDR_FLASH_SECTOR_7+1024+10,Key_Sound);
//
// }
// FLASH_DataCacheCmd(ENABLE); //FLASH????,??????
// FLASH_Lock();//??
}
void eepromWriteBytes(uint32_t eepromAddr,unsigned char *bytes,unsigned char cnt)
{
unsigned char u8Loop;
FLASH_Unlock(FLASH_MEMTYPE_DATA);
for(u8Loop = 0;u8Loop < cnt;u8Loop ++)
{
FLASH_ProgramByte((uint32_t)eepromAddr + u8Loop, bytes[u8Loop]);
}
FLASH_Lock(FLASH_MEMTYPE_DATA);
}
void Flash_SaveString(char* string)
{
FLASH_Unlock();
while(*string)
{
FLASH_ProgramByte(_flash_address, *string);
++_flash_address;
++string;
}
FLASH_Lock();
}
void config_save(void) {
u8 *ptr = (u8 *) &Config;
u8 i;
Config.saved = CONFIG_SAVED;
for (i = 0; i < sizeof(t_Config); i++) {
FLASH_ProgramByte(CONFIG_BASE + i, *(ptr + i));
}
}
void write_array_to_eeprom(uint32_t addr,uint8_t* array)
{
uint8_t i = 0;
while(array[i] != '\0')
{
FLASH_EraseByte(addr);
FLASH_ProgramByte((addr),array[i]);
addr++;
i++;
}
}
/*
*********************************************************************************************************
* 函 数 名: bsp_WriteCpuFlash
* 功能说明: 写数据到CPU 内部Flash。
* 形 参: _ulFlashAddr : Flash地址
* _ucpSrc : 数据缓冲区
* _ulSize : 数据大小（单位是字节）
* 返 回 值: 0-成功，1-数据长度或地址溢出，2-写Flash出错(估计Flash寿命到)
*********************************************************************************************************
*/
uint8_t bsp_WriteCpuFlash(uint32_t _ulFlashAddr, uint8_t *_ucpSrc, uint32_t _ulSize)
{
uint32_t i;
uint8_t ucRet;
/* 如果偏移地址超过芯片容量，则不改写输出缓冲区 */
if (_ulFlashAddr + _ulSize > FLASH_BASE_ADDR + FLASH_SIZE)
{
return 1;
}
/* 长度为0时不继续操作 */
if (_ulSize == 0)
{
return 0;
}
ucRet = bsp_CmpCpuFlash(_ulFlashAddr, _ucpSrc, _ulSize);
if (ucRet == FLASH_IS_EQU)
{
return 0;
}
__set_PRIMASK(1); /* 关中断 */
/* FLASH 解锁 */
FLASH_Unlock();
/* Clear pending flags (if any) */
FLASH_ClearFlag(FLASH_FLAG_EOP | FLASH_FLAG_OPERR | FLASH_FLAG_WRPERR |
FLASH_FLAG_PGAERR | FLASH_FLAG_PGPERR|FLASH_FLAG_PGSERR);
/* 需要擦除 */
if (ucRet == FLASH_REQ_ERASE)
{
FLASH_EraseSector(bsp_GetSector(_ulFlashAddr), VoltageRange_3);
}
/* 按字节模式编程（为提高效率，可以按字编程，一次写入4字节） */
for (i = 0; i < _ulSize; i++)
{
FLASH_ProgramByte(_ulFlashAddr++, *_ucpSrc++);
}
/* Flash 加锁，禁止写Flash控制寄存器 */
FLASH_Lock();
__set_PRIMASK(0); /* 开中断 */
return 0;
}
/**
\fn uint32_t FLASH_write(uint32_t addr, char *data, uint32_t size)
\brief Ecrit dans l'EEPROM.
\param uint32_t addr
L'adresse de debut.
\param char * data
Le pointeur sur la premiere donnee.
\param uint32_t size
Le nombre d'octets a ecrire.
\return uint32_t
Le nombre de donnees ecrites.
**/
uint32_t FLASH_write(uint32_t addr, char *data, uint32_t size) {
uint32_t i = 0;
FLASH_Unlock(FLASH_MEMTYPE_DATA);
while( size ) {
FLASH_ProgramByte(addr+i, data[i] );
i++;
size--;
}
FLASH_Lock(FLASH_MEMTYPE_DATA);
return (i);
}
/*====================================================================================================*/
void Flash_WriteDataU8( u32 WriteAddr, uc8 *WriteData, u32 DataLen )
{
u16 Count = 0;
FLASH_Status FLASHStatus;
FLASH_Unlock();
while(Count < DataLen) {
FLASHStatus = FLASH_ProgramByte(WriteAddr+Count, WriteData[Count]);
while(FLASHStatus != FLASH_COMPLETE);
Count++;
}
FLASH_Lock();
}
const DC3Error_t FLASH_writeBuffer(
const uint32_t startAddr,
const uint8_t *buffer,
const uint16_t size,
uint16_t *bytesWritten
)
{
DC3Error_t status = ERR_NONE;
*bytesWritten = 0;
uint8_t data_read_back = 0;
FLASH_Status flash_status;
uint32_t addr = startAddr;
/* These flags have to be cleared before any operation can be done on the
* flash memory */
FLASH_ClearFlag(
FLASH_FLAG_PGSERR | FLASH_FLAG_PGPERR | FLASH_FLAG_PGAERR |
FLASH_FLAG_WRPERR | FLASH_FLAG_OPERR | FLASH_FLAG_EOP
);
for ( uint16_t i = 0; i < size; i++, addr++ ) {
flash_status = FLASH_ProgramByte(addr, buffer[i]);
if (FLASH_COMPLETE != flash_status) {
status = FLASH_statusToErrorCode( flash_status );
ERR_printf("Flash Error %d (error 0x%08x) writing %x to address %lx\n",
flash_status, status, buffer[i], addr);
return( status );
} else {
data_read_back = *((uint8_t *)addr);
if (data_read_back != buffer[i]) {
status = ERR_FLASH_READ_VERIFY_FAILED;
ERR_printf("Failed to verify write at address %lx : Wrote %2x and "
"read back %2ux. Error: 0x%08x\n",
addr, buffer[i], data_read_back, status);
return( status );
}
*bytesWritten += 1; /* Increment the return value for bytes written */
}
}
if (*bytesWritten != size) {
status = ERR_FLASH_WRITE_INCOMPLETE;
ERR_printf("Bytes written (%d) != number of bytes requested to be "
"written (%d). Error: 0x%08x\n", bytesWritten, size, status);
}
return (status);
}
/*=====================================================================================================*/
int8_t Flash_WritePageU8( uint32_t writeAddr, const uint8_t *writeData, uint32_t lens )
{
int8_t status = ERROR;
uint32_t count = 0;
FLASH_Unlock();
FLASH_ClearFlag(FLASH_FLAG_EOP | FLASH_FLAG_OPERR | FLASH_FLAG_WRPERR |
FLASH_FLAG_PGAERR | FLASH_FLAG_PGPERR | FLASH_FLAG_PGSERR);
do {
status = FLASH_ProgramByte(writeAddr + count, writeData[count]);
} while((++count < lens) && (status == FLASH_COMPLETE));
FLASH_Lock();
return status;
}
u8* bsp_MCU_Write(u8* writebuffer,u8 blockid,u16 writelength)
{
u8 status=0;
u16 index=0;
SleepTime=0;
__set_PRIMASK(1);
memcpy(MCU_ROM_Write,(u8*)ADDR_FLASH_SECTOR_7,1024+16); //在擦除之前，先把数据读出来放在内存buffer
__set_PRIMASK(0);
if(blockid==1)
{
memcpy(MCU_ROM_Write,writebuffer,writelength); //将512byte数据写入第一个block区域
}
if(blockid==2)
{
memcpy(MCU_ROM_Write+512,writebuffer,writelength); //将512byte数据写入第二个block区域
}
FLASH_Unlock(); //解锁
FLASH_DataCacheCmd(DISABLE);//FLASH擦除期间,必须禁止数据缓存
FLASH_ClearFlag(FLASH_FLAG_EOP|FLASH_FLAG_OPERR|FLASH_FLAG_WRPERR| FLASH_FLAG_PGAERR | FLASH_FLAG_PGPERR|FLASH_FLAG_PGSERR);
status=FLASH_EraseSector(FLASH_Sector_7 ,VoltageRange_3);//VCC=2.7~3.6V之间!!
if(status==FLASH_COMPLETE)
{
__set_PRIMASK(1);
for(index=0;index<(1024+16);index++)
{
status=FLASH_ProgramByte(ADDR_FLASH_SECTOR_7+index,MCU_ROM_Write[index]); //SysID
}
__set_PRIMASK(0);
}
FLASH_DataCacheCmd(ENABLE); //FLASH擦除结束,开启数据缓存
FLASH_Lock();//上锁
if(status==FLASH_COMPLETE)
{
MCU_WriteStatus=0;
}
else
{
MCU_WriteStatus=status;
}
return &MCU_WriteStatus;
}
void TIM3_IRQHandler(void)
{
__IO uint8_t data;
__IO uint8_t *addr;
if (TIM_GetITStatus(TIM3, TIM_IT_CC1) == RESET)
return;
TIM_ClearITPendingBit(TIM3, TIM_IT_CC1);
if (mode == 0) // Read cycle
{
STM_EVAL_LEDToggle(LED4);
addr = (__IO uint8_t *)(base_addr + counter);
if (*addr)
STM_EVAL_LEDOn(LED6);
else
STM_EVAL_LEDOff(LED6);
}
else // Write cycle
{
if (counter == 0) // Flash address before programming
{
FLASH_Unlock();
FLASH_ClearFlag(FLASH_FLAG_EOP | FLASH_FLAG_OPERR |
FLASH_FLAG_WRPERR | FLASH_FLAG_PGAERR |
FLASH_FLAG_PGPERR | FLASH_FLAG_PGSERR);
FLASH_EraseSector(sector, VoltageRange_3);
}
STM_EVAL_LEDToggle(LED5);
FLASH_ProgramByte(base_addr + counter,
GPIO_ReadInputDataBit(GPIOA, GPIO_Pin_0));
}
counter++;
if (counter == 50)
{
mode++;
counter = 0;
}
if (mode > 1)
{
TIM_Cmd(TIM3, DISABLE);
STM_EVAL_LEDOn(LED3);
}
}
OSStatus internalFlashByteWrite(__IO uint32_t* FlashAddress, uint8_t* Data ,uint32_t DataLength)
{
uint32_t i = 0;
uint32_t dataInRam;
OSStatus err = kNoErr;
for (i = 0; (i < DataLength) && (*FlashAddress <= (FLASH_END_ADDRESS)); i++)
{
/* Device voltage range supposed to be [2.7V to 3.6V], the operation will
be done by word */
dataInRam = *(uint8_t*)(Data+i);
require_action(FLASH_ProgramByte(*FlashAddress, dataInRam) == FLASH_COMPLETE, exit, err = kWriteErr);
require_action(*(uint8_t*)*FlashAddress == dataInRam, exit, err = kChecksumErr);
*FlashAddress +=1;
}
exit:
return err;
}
uint16_t flash_helper_write_new_app_data(uint32_t offset, uint8_t *data, uint32_t len) {
FLASH_ClearFlag(FLASH_FLAG_OPERR | FLASH_FLAG_WRPERR | FLASH_FLAG_PGAERR |
FLASH_FLAG_PGPERR | FLASH_FLAG_PGSERR);
mcpwm_unlock();
mcpwm_release_motor();
utils_sys_lock_cnt();
RCC_APB1PeriphClockCmd(RCC_APB1Periph_WWDG, DISABLE);
for (uint32_t i = 0;i < len;i++) {
uint16_t res = FLASH_ProgramByte(flash_addr[NEW_APP_BASE] + offset + i, data[i]);
if (res != FLASH_COMPLETE) {
return res;
}
}
RCC_APB1PeriphClockCmd(RCC_APB1Periph_WWDG, ENABLE);
utils_sys_unlock_cnt();
return FLASH_COMPLETE;
}
/*!
* Write a new block.
*/
static int vrom_write_block(uint8_t rom, uint8_t idx, uint8_t size,
const uint8_t* in)
{
/* Find a new home for the block */
const struct vrom_data_block_t* block = vrom_find_free(0);
struct vrom_data_block_t new_block;
uint8_t* out = (uint8_t*)(block);
uint32_t rem = sizeof(new_block);
int res;
if (!block)
return -ENOSPC;
/* Prepare the new block */
memset(&new_block, 0xff, sizeof(new_block));
new_block.header.rom = rom;
new_block.header.idx = idx;
new_block.header.size = size;
memcpy(new_block.data, in, size);
new_block.header.crc32 = vrom_crc32(&new_block);
/* Start writing out the block */
in = (uint8_t*)(&new_block);
rem = VROM_BLOCK_SZ;
while(rem) {
if (*out != *in) {
if (FLASH_ProgramByte((uint32_t)out, *in)
!= FLASH_COMPLETE)
/* Failed! */
return -EIO;
}
in++;
out++;
rem--;
}
res = vrom_set_flags(block, VROM_SFLAGS_USED);
if (res < 0)
return res;
return size;
}
