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