/**
* @brief Writes more than one byte to the EEPROM with a single WRITE cycle
* (Page WRITE sequence).
* @note The number of byte can't exceed the EEPROM page size.
* @param pBuffer: pointer to the buffer containing the data to be written
* to the EEPROM.
* @param WriteAddr: EEPROM's internal address to write to.
* @param NumByteToWrite: number of bytes to write to the EEPROM, must be equal
* or less than "sEE_PAGESIZE" value.
* @retval None
*/
uint32_t sEE_WritePage(uint8_t* pBuffer, uint16_t WriteAddr, uint16_t* NumByteToWrite)
{
/*!< Enable the write access to the EEPROM */
sEE_WriteEnable();
/*!< Select the EEPROM: Chip Select low */
sEE_CS_LOW();
/*!< Send "Write to Memory" instruction and MSB of WriteAddr */
sEE_SendByte(sEE_CMD_WRITE | (uint8_t)((WriteAddr & 0x0100)>>5));
/*!< Send WriteAddr address byte to write to */
sEE_SendByte(WriteAddr & 0xFF);
/*!< while there is data to be written on the EEPROM */
while ((*NumByteToWrite)--)
{
/*!< Send the current byte */
sEE_SendByte(*pBuffer);
/*!< Point on the next byte to be written */
pBuffer++;
}
/*!< Deselect the EEPROM: Chip Select high */
sEE_CS_HIGH();
/*!< Wait the end of EEPROM writing */
sEE_WaitEepromStandbyState();
/*!< Disable the write access to the EEROM */
sEE_WriteDisable();
return 0;
}
/**
* @brief Handle EEPROM Write operation
* @param Device : sEE CPAL device instance
* @retval None
*/
uint32_t sEE_WriteHandler(CPAL_DevTypeDef Device)
{
uint32_t DataNum = 0;
/* wait until EEPROM ready for transfer */
while (sEE_WaitEepromStandbyState(Device) == CPAL_FAIL) ;
/* if there are remaining data for write */
if (sEE_WriteStructures[Device]->sEENextWrite != 0) {
sEE_WriteStructures[Device]->sEEWriteAddr +=
sEE_WriteStructures[Device]->sEEDataNum;
sEE_WriteStructures[Device]->sEEpBuffer +=
sEE_WriteStructures[Device]->sEEDataNum;
sEE_WriteStructures[Device]->sEENextWrite = 0;
/* if page must be written in EEPROM */
if (sEE_WriteStructures[Device]->sEENumOfPage != 0) {
sEE_WriteStructures[Device]->sEEDataNum =
(uint32_t) ((uint16_t) sEE_DevStructures[Device]->
sEEPageSize);
sEE_WriteStructures[Device]->sEENumOfPage--;
}
/* if single byte must be written in EEPROM */
else if (sEE_WriteStructures[Device]->sEENumOfSingle != 0) {
sEE_WriteStructures[Device]->sEEDataNum =
(uint32_t) ((uint8_t) sEE_WriteStructures[Device]->
sEENumOfSingle);
sEE_WriteStructures[Device]->sEENumOfSingle = 0;
sEE_WriteStructures[Device]->sEENextWrite = 0;
}
/* update number of date for write */
DataNum = sEE_WriteStructures[Device]->sEEDataNum;
/* if another data must be written */
if ((sEE_WriteStructures[Device]->sEENumOfPage != 0)
|| (sEE_WriteStructures[Device]->sEENumOfSingle != 0)) {
sEE_WriteStructures[Device]->sEENextWrite = 1;
}
/* write data in EEPROM */
sEE_WritePage(sEE_DevStructures[Device],
(uint8_t *) sEE_WriteStructures[Device]->
sEEpBuffer,
sEE_WriteStructures[Device]->sEEWriteAddr,
DataNum);
} else {
if (sEE_DevStructures[Device]->sEEState != sEE_STATE_ERROR) {
/* Reset EEPROM State */
sEE_DevStructures[Device]->sEEState = sEE_STATE_IDLE;
}
}
return CPAL_PASS;
}
extern hal_result_t hal_eeprom_hid_waitstandbystate(hal_eeprom_t eep)
{
if(hal_true != s_hal_eeprom_initted_is(eep))
{
return(hal_res_NOK_generic);
}
sEE_WaitEepromStandbyState();
return(hal_res_OK);
}
void PFO_EXTI(void)
{
uint8_t i = 0;
if(EXTI_GetITStatus(PFO_EXTI_LINE) != RESET)
{
EXTI_ClearITPendingBit(PFO_EXTI_LINE);
Led_Drive(0x0F);
// while(1)
// {
// i++;
// printf("%d",i);
// }
sEE_WriteBuffer(gl_Store,sEE_WRITE_ADDRESS1,BUFFER_SIZE);
sEE_WaitEepromStandbyState();
}
}
/**
* @brief Writes buffer of data to the I2C EEPROM.
* @param pBuffer : pointer to the buffer containing the data to be written
* to the EEPROM.
* @param WriteAddr : EEPROM's internal address to write to.
* @param NumByteToWrite : number of bytes to write to the EEPROM.
* @retval None
*/
void sEE_WriteBuffer(uint8_t* pBuffer, uint16_t WriteAddr, uint16_t NumByteToWrite)
{
uint16_t NumOfPage = 0, NumOfSingle = 0, count = 0;
uint16_t Addr = 0;
Addr = WriteAddr % sEE_PAGESIZE;
count = sEE_PAGESIZE - Addr;
NumOfPage = NumByteToWrite / sEE_PAGESIZE;
NumOfSingle = NumByteToWrite % sEE_PAGESIZE;
/*!< If WriteAddr is sEE_PAGESIZE aligned */
if(Addr == 0)
{
/*!< If NumByteToWrite < sEE_PAGESIZE */
if(NumOfPage == 0)
{
/* Store the number of data to be written */
sEEDataNum = NumOfSingle;
/* Start writing data */
sEE_WritePage(pBuffer, WriteAddr, (uint8_t*)(&sEEDataNum));
/* Wait transfer through DMA to be complete */
sEETimeout = sEE_LONG_TIMEOUT;
while (sEEDataNum > 0)
{
if((sEETimeout--) == 0) {sEE_TIMEOUT_UserCallback(); return;};
}
sEE_WaitEepromStandbyState();
}
/*!< If NumByteToWrite > sEE_PAGESIZE */
else
{
while(NumOfPage--)
{
/* Store the number of data to be written */
sEEDataNum = sEE_PAGESIZE;
sEE_WritePage(pBuffer, WriteAddr, (uint8_t*)(&sEEDataNum));
/* Wait transfer through DMA to be complete */
sEETimeout = sEE_LONG_TIMEOUT;
while (sEEDataNum > 0)
{
if((sEETimeout--) == 0) {sEE_TIMEOUT_UserCallback(); return;};
}
sEE_WaitEepromStandbyState();
WriteAddr += sEE_PAGESIZE;
pBuffer += sEE_PAGESIZE;
}
if(NumOfSingle!=0)
{
/* Store the number of data to be written */
sEEDataNum = NumOfSingle;
sEE_WritePage(pBuffer, WriteAddr, (uint8_t*)(&sEEDataNum));
/* Wait transfer through DMA to be complete */
sEETimeout = sEE_LONG_TIMEOUT;
while (sEEDataNum > 0)
{
if((sEETimeout--) == 0) {sEE_TIMEOUT_UserCallback(); return;};
}
sEE_WaitEepromStandbyState();
}
}
}
/*!< If WriteAddr is not sEE_PAGESIZE aligned */
else
{
/*!< If NumByteToWrite < sEE_PAGESIZE */
if(NumOfPage== 0)
{
/*!< If the number of data to be written is more than the remaining space
in the current page: */
if (NumByteToWrite > count)
{
/* Store the number of data to be written */
sEEDataNum = count;
/*!< Write the data contained in same page */
sEE_WritePage(pBuffer, WriteAddr, (uint8_t*)(&sEEDataNum));
/* Wait transfer through DMA to be complete */
sEETimeout = sEE_LONG_TIMEOUT;
while (sEEDataNum > 0)
{
if((sEETimeout--) == 0) {sEE_TIMEOUT_UserCallback(); return;};
}
sEE_WaitEepromStandbyState();
/* Store the number of data to be written */
sEEDataNum = (NumByteToWrite - count);
/*!< Write the remaining data in the following page */
sEE_WritePage((uint8_t*)(pBuffer + count), (WriteAddr + count), (uint8_t*)(&sEEDataNum));
/* Wait transfer through DMA to be complete */
sEETimeout = sEE_LONG_TIMEOUT;
while (sEEDataNum > 0)
{
if((sEETimeout--) == 0) {sEE_TIMEOUT_UserCallback(); return;};
}
sEE_WaitEepromStandbyState();
}
else
{
/* Store the number of data to be written */
sEEDataNum = NumOfSingle;
sEE_WritePage(pBuffer, WriteAddr, (uint8_t*)(&sEEDataNum));
/* Wait transfer through DMA to be complete */
sEETimeout = sEE_LONG_TIMEOUT;
while (sEEDataNum > 0)
{
if((sEETimeout--) == 0) {sEE_TIMEOUT_UserCallback(); return;};
}
sEE_WaitEepromStandbyState();
}
}
/*!< If NumByteToWrite > sEE_PAGESIZE */
else
{
NumByteToWrite -= count;
NumOfPage = NumByteToWrite / sEE_PAGESIZE;
NumOfSingle = NumByteToWrite % sEE_PAGESIZE;
if(count != 0)
{
/* Store the number of data to be written */
sEEDataNum = count;
sEE_WritePage(pBuffer, WriteAddr, (uint8_t*)(&sEEDataNum));
/* Wait transfer through DMA to be complete */
sEETimeout = sEE_LONG_TIMEOUT;
while (sEEDataNum > 0)
{
if((sEETimeout--) == 0) {sEE_TIMEOUT_UserCallback(); return;};
}
sEE_WaitEepromStandbyState();
WriteAddr += count;
pBuffer += count;
}
while(NumOfPage--)
{
/* Store the number of data to be written */
sEEDataNum = sEE_PAGESIZE;
sEE_WritePage(pBuffer, WriteAddr, (uint8_t*)(&sEEDataNum));
/* Wait transfer through DMA to be complete */
sEETimeout = sEE_LONG_TIMEOUT;
while (sEEDataNum > 0)
{
if((sEETimeout--) == 0) {sEE_TIMEOUT_UserCallback(); return;};
}
sEE_WaitEepromStandbyState();
WriteAddr += sEE_PAGESIZE;
pBuffer += sEE_PAGESIZE;
}
if(NumOfSingle != 0)
{
/* Store the number of data to be written */
sEEDataNum = NumOfSingle;
sEE_WritePage(pBuffer, WriteAddr, (uint8_t*)(&sEEDataNum));
/* Wait transfer through DMA to be complete */
sEETimeout = sEE_LONG_TIMEOUT;
while (sEEDataNum > 0)
{
if((sEETimeout--) == 0) {sEE_TIMEOUT_UserCallback(); return;};
}
sEE_WaitEepromStandbyState();
}
}
}
}
/**
* @brief Main program.
* @param None
* @retval None
*/
void SPI_EEPROM_Example(void)
{
/*!< At this stage the microcontroller clock setting is already configured,
this is done through SystemInit() function which is called from startup
file (startup_stm32f30x.s) before to branch to application main.
To reconfigure the default setting of SystemInit() function, refer to
system_stm32f30x.c file
*/
/* Initialize the SPI EEPROM driver ----------------------------------------*/
sEE_Init();
/* First write in the memory followed by a read of the written data --------*/
/* Write on SPI EEPROM from sEE_WRITE_ADDRESS1 */
sEE_WriteBuffer(Tx1Buffer, sEE_WRITE_ADDRESS1, BUFFER_SIZE1);
/* Wait for EEPROM standby state */
sEE_WaitEepromStandbyState();
/* Set the Number of data to be read */
NumDataRead = BUFFER_SIZE1;
/* Read from SPI EEPROM from sEE_READ_ADDRESS1 */
sEE_ReadBuffer(Rx1Buffer, sEE_READ_ADDRESS1, (uint16_t *)(&NumDataRead));
/* Check if the data written to the memory is read correctly */
TransferStatus1 = Buffercmp(Tx1Buffer, Rx1Buffer, BUFFER_SIZE1);
/* Second write in the memory followed by a read of the written data -------*/
/* Write on SPI EEPROM from sEE_WRITE_ADDRESS2 */
sEE_WriteBuffer(Tx2Buffer, sEE_WRITE_ADDRESS2, BUFFER_SIZE2);
/* Wait for EEPROM standby state */
sEE_WaitEepromStandbyState();
/* Set the Number of data to be read */
NumDataRead = BUFFER_SIZE2;
/* Read from SPI EEPROM from sEE_READ_ADDRESS2 */
sEE_ReadBuffer(Rx2Buffer, sEE_READ_ADDRESS2, (uint16_t *)(&NumDataRead));
/* Check if the data written to the memory is read correctly */
TransferStatus2 = Buffercmp(Tx2Buffer, Rx2Buffer, BUFFER_SIZE2);
#ifdef ENABLE_LCD_MSG_DISPLAY
/* Initialize the LCD screen for information display */
STM32303C_LCD_Init();
LCD_Clear(LCD_COLOR_BLUE);
LCD_SetBackColor(LCD_COLOR_BLUE);
LCD_SetTextColor(LCD_COLOR_WHITE);
LCD_DisplayStringLine(LCD_LINE_0, "SMT32F30x FW Library");
LCD_DisplayStringLine(LCD_LINE_1, " EEPROM Example ");
/* TransferStatus1 = PASSED, if the transmitted and received data
to/from the EEPROM are the same */
/* TransferStatus1 = FAILED, if the transmitted and received data
to/from the EEPROM are different */
if (TransferStatus1 == PASSED)
{
LCD_DisplayStringLine(LCD_LINE_3, " Transfer 1 PASSED ");
}
else
{
LCD_DisplayStringLine(LCD_LINE_3, " Transfer 1 FAILED ");
}
/* TransferStatus2 = PASSED, if the transmitted and received data
to/from the EEPROM are the same */
/* TransferStatus2 = FAILED, if the transmitted and received data
to/from the EEPROM are different */
if (TransferStatus2 == PASSED)
{
LCD_DisplayStringLine(LCD_LINE_5, " Transfer 2 PASSED ");
}
else
{
LCD_DisplayStringLine(LCD_LINE_5, " Transfer 2 FAILED ");
}
#endif /* ENABLE_LCD_MSG_DISPLAY */
/* Free all used resources */
sEE_DeInit();
while (1)
{
}
}
/**
* @brief Main program
* @param None
* @retval None
*/
int main(void)
{
/*!< At this stage the microcontroller clock setting is already configured,
this is done through SystemInit() function which is called from startup
file (startup_stm32l1xx_xx.s) before to branch to application main.
To reconfigure the default setting of SystemInit() function, refer to
system_stm32l1xx.c file
*/
#ifdef ENABLE_LCD_MSG_DISPLAY
/* Initialize the LCD screen for information display */
#ifdef USE_STM32L152D_EVAL
STM32L152D_LCD_Init();
#else
STM32L152_LCD_Init();
#endif
LCD_Clear(LCD_COLOR_BLUE);
LCD_SetBackColor(LCD_COLOR_BLUE);
LCD_SetTextColor(LCD_COLOR_WHITE);
LCD_DisplayStringLine(LCD_LINE_0, "SMT32L1xx FW Library");
LCD_DisplayStringLine(LCD_LINE_1, " EEPROM Example ");
#endif /* ENABLE_LCD_MSG_DISPLAY */
/* Initialize the I2C EEPROM driver ----------------------------------------*/
sEE_Init();
/* First write in the memory followed by a read of the written data --------*/
/* Write on I2C EEPROM from sEE_WRITE_ADDRESS1 */
sEE_WriteBuffer(Tx1_Buffer, sEE_WRITE_ADDRESS1, BUFFER_SIZE1);
/* Wait for EEPROM standby state */
sEE_WaitEepromStandbyState();
/* Set the Number of data to be read */
NumDataRead = BUFFER_SIZE1;
/* Read from I2C EEPROM from sEE_READ_ADDRESS1 */
sEE_ReadBuffer(Rx1_Buffer, sEE_READ_ADDRESS1, (uint16_t *)(&NumDataRead));
/* Starting from this point, if the requested number of data is higher than 1,
then only the DMA is managing the data transfer. Meanwhile, CPU is free to
perform other tasks:
// Add your code here:
//...
//...
For simplicity reasons, this example is just waiting till the end of the
transfer. */
#ifdef ENABLE_LCD_MSG_DISPLAY
LCD_DisplayStringLine(LCD_LINE_3, " Transfer 1 Ongoing ");
#endif /* ENABLE_LCD_MSG_DISPLAY */
/* Wait till DMA transfer is compelete (Tranfer complete interrupt handler
resets the variable holding the number of data to be read) */
while (NumDataRead > 0)
{}
/* Check if the data written to the memory is read correctly */
TransferStatus1 = Buffercmp(Tx1_Buffer, Rx1_Buffer, BUFFER_SIZE1);
/* TransferStatus1 = PASSED, if the transmitted and received data
to/from the EEPROM are the same */
/* TransferStatus1 = FAILED, if the transmitted and received data
to/from the EEPROM are different */
#ifdef ENABLE_LCD_MSG_DISPLAY
if (TransferStatus1 == PASSED)
{
LCD_DisplayStringLine(LCD_LINE_3, " Transfer 1 PASSED ");
}
else
{
LCD_DisplayStringLine(LCD_LINE_3, " Transfer 1 FAILED ");
}
#endif /* ENABLE_LCD_MSG_DISPLAY */
/* Second write in the memory followed by a read of the written data -------*/
/* Write on I2C EEPROM from sEE_WRITE_ADDRESS2 */
sEE_WriteBuffer(Tx2_Buffer, sEE_WRITE_ADDRESS2, BUFFER_SIZE2);
/* Wait for EEPROM standby state */
sEE_WaitEepromStandbyState();
/* Set the Number of data to be read */
NumDataRead = BUFFER_SIZE2;
/* Read from I2C EEPROM from sEE_READ_ADDRESS2 */
sEE_ReadBuffer(Rx2_Buffer, sEE_READ_ADDRESS2, (uint16_t *)(&NumDataRead));
/* Starting from this point, if the requested number of data is higher than 1,
then only the DMA is managing the data transfer. Meanwhile, CPU is free to
perform other tasks:
// Add your code here:
//...
//...
For simplicity reasons, this example is just waiting till the end of the
transfer. */
#ifdef ENABLE_LCD_MSG_DISPLAY
LCD_DisplayStringLine(LCD_LINE_5, " Transfer 2 Ongoing ");
#endif /* ENABLE_LCD_MSG_DISPLAY */
/* Wait till DMA transfer is compelete (Tranfer complete interrupt handler
resets the variable holding the number of data to be read) */
while (NumDataRead > 0)
{}
/* Check if the data written to the memory is read correctly */
TransferStatus2 = Buffercmp(Tx2_Buffer, Rx2_Buffer, BUFFER_SIZE2);
/* TransferStatus2 = PASSED, if the transmitted and received data
to/from the EEPROM are the same */
/* TransferStatus2 = FAILED, if the transmitted and received data
to/from the EEPROM are different */
#ifdef ENABLE_LCD_MSG_DISPLAY
if (TransferStatus2 == PASSED)
{
LCD_DisplayStringLine(LCD_LINE_5, " Transfer 2 PASSED ");
}
else
{
LCD_DisplayStringLine(LCD_LINE_5, " Transfer 2 FAILED ");
}
#endif /* ENABLE_LCD_MSG_DISPLAY */
/* Free all used resources */
sEE_DeInit();
while (1)
{
}
}
int main(void){
//configure push-button interrupts
PB_Config();
/* LCD initiatization */
LCD_Init();
/* LCD Layer initiatization */
LCD_LayerInit();
/* Enable the LTDC */
LTDC_Cmd(ENABLE);
/* Set LCD foreground layer */
LCD_SetLayer(LCD_FOREGROUND_LAYER);
//======You need to develop the following functions======
//Note: these are just placeholders; function definitions are at bottom of this file
//configure real-time clock
RTC_Config();
//configure external push-buttons and interrupts
ExtPB_Config();
ExtPBNum2();
//main program
LCD_Clear(LCD_COLOR_WHITE);
//line=0;
//Display a string in one line, on the first line (line=0)
//LCD_DisplayStringLine(LINE(line), (uint8_t *) "Init EEPROM...");
//line++;
//i2c_init(); //initialize the i2c chip
sEE_Init();
//LCD_DisplayStringLine(LINE(line), (uint8_t *) "done...");
//line++;
//LCD_DisplayStringLine(LINE(line), (uint8_t *) "Writing...");
//line++;
/* First write in the memory followed by a read of the written data --------*/
/* Write on I2C EEPROM from memLocation */
//sEE_WriteBuffer(&Tx1_Buffer, memLocation,1);
/* Wait for EEPROM standby state */
//sEE_WaitEepromStandbyState();
//LCD_DisplayStringLine(LINE(line), (uint8_t *) "Reading...");
/* Read from I2C EEPROM from memLocation */
//sEE_ReadBuffer(&Rx1_Buffer, memLocation, (uint16_t *)(&NumDataRead));
//line++;
//LCD_DisplayStringLine(LINE(line), (uint8_t *) "Comparing...");
//line++;
//if(Tx1_Buffer== Rx1_Buffer){
//LCD_DisplayStringLine(LINE(line), (uint8_t *) "Success!");
//}else{
//LCD_DisplayStringLine(LINE(line), (uint8_t *) "Mismatch!");
//}
//main loop
while(1){
RTC_GetTime(RTC_Format_BIN,&RTC_TimeStructure);
hours = RTC_TimeStructure.RTC_Hours;
minutes = RTC_TimeStructure.RTC_Minutes;
seconds = RTC_TimeStructure.RTC_Seconds;
sprintf(time,"%0.2d:%0.2d:%0.2d",hours,minutes,seconds);
LCD_DisplayStringLine(LINE(6), (uint8_t *) time);
if(UBPressed == 1){
toBeSaved = time[7];
sEE_WriteBuffer(&toBeSaved, memLocation+1,1);
sEE_WaitEepromStandbyState();
sEE_ReadBuffer(&Rx1_Buffer, memLocation+1, (uint16_t *)(&NumDataRead));
saved[0] = Rx1_Buffer;
LCD_DisplayStringLine(LINE(7), (uint8_t *) saved);
UBPressed = 0;
PB_Config();
}
if(EB1Pressed == 1 && state == 0){
state = 1;
EB1Pressed = 0;
ExtPB_Config();
}
if(EB1Pressed == 1 && state == 1){
state = 2;
EB1Pressed = 0;
ExtPB_Config();
}
if(EB1Pressed == 1 && state == 2){
state = 3;
EB1Pressed = 0;
ExtPB_Config();
}
if(EB1Pressed == 1 && state == 3){
state = 0;
EB1Pressed = 0;
ExtPB_Config();
}
if(EB2Pressed == 1 && state == 1){
RTC_TimeStructure.RTC_Hours = hours + 1;
RTC_SetTime(RTC_Format_BCD, &RTC_TimeStructure);
EB2Pressed = 0;
ExtPBNum2();
}
if(EB2Pressed == 1 && state == 2){
RTC_TimeStructure.RTC_Minutes = minutes + 1;
RTC_SetTime(RTC_Format_BCD, &RTC_TimeStructure);
EB2Pressed = 0;
ExtPBNum2();
}
if(EB2Pressed == 1 && state == 3){
RTC_TimeStructure.RTC_Seconds = seconds + 1;
RTC_SetTime(RTC_Format_BCD, &RTC_TimeStructure);
EB2Pressed = 0;
ExtPBNum2();
}
}
}
