Index: NVDataMgmt.c =================================================================== diff -u -re865487e2b48d708713b2bcce3d03f378a3d5207 -r2ef5e5a21d6f81900fed686b68d07da8d31f1d6d --- NVDataMgmt.c (.../NVDataMgmt.c) (revision e865487e2b48d708713b2bcce3d03f378a3d5207) +++ NVDataMgmt.c (.../NVDataMgmt.c) (revision 2ef5e5a21d6f81900fed686b68d07da8d31f1d6d) @@ -30,6 +30,7 @@ #define QUEUE_MAX_SIZE 20U #define QUEUE_START_INDEX 0U #define MIN_QUEUE_COUNT_FOR_DATA_LOG 3U +#define MIN_QUEUE_COUNT_FOR_SECTOR_0 4U // The clock frequency comes from HCLK_FREQ and it has to be rounded up to the // nearest number @@ -59,20 +60,22 @@ #define MAX_NUM_OF_DATA_LOGS_IN_SECTOR2 ((MAX_NUM_OF_SECTORS_FOR_LOG_DATA - 1) * MAX_LOG_DATA_PER_SECTOR) #define MAX_NUM_OF_DATA_LOGS_IN_SECTOR1 ((MAX_NUM_OF_SECTORS_FOR_LOG_DATA - 2) * MAX_LOG_DATA_PER_SECTOR) -// Data addresses in EEPROM and RTC RAM +// Data addresses and length in RTC RAM #define BOOTLOADER_FLAG_ADDRESS 0x00000000 #define BOOTLOADER_FLAG_LENGTH_BYTES 4U #define LOG_RECORD_START_ADDRESS 0x00000010 // 16 #define MFG_RECORD_START_ADDRESS 0X00000020 // 32 #define HD_TREATMENT_TIME_ADDRESS 0X00000030 // 48 #define DG_CONSUMED_WATER_ADDRESS 0X00000040 // 64 +#define SERVICE_DATE_START_ADDRESS 0X00000050 // 80 -#define CAL_RECORD_START_ADDRESS (BANK7_SECTOR0_START_ADDRESS + 0x100) +// Data addresses in EEPROM +#define CALIBRATION_RECORD_START_ADDRESS (BANK7_SECTOR0_START_ADDRESS + 0x100) - typedef enum NVDataMgmt_Self_Test_States { NVDATAMGMT_SELF_TEST_STATE_START = 0, + NVDATAMGMT_SELF_TEST_STATE_READ_BOOTLOADER_FLAG, NVDATAMGMT_SELF_TEST_STATE_READ_LOG_RECORD, NVDATAMGMT_SELF_TEST_STATE_READ_TREATMENT_TIME, NVDATAMGMT_SELF_TEST_STATE_READ_WATER_CONSUMPTION, @@ -146,7 +149,7 @@ { U32 waterConsumption; U16 crc; -} WATER_CONSUPTION_T; +} WATER_CONSUMPTION_RECORD_T; typedef struct { @@ -173,9 +176,29 @@ } LOG_DATA_T; #pragma pack(pop) +// Private variables + +static MEMORY_OPS_T jobQueue [ QUEUE_MAX_SIZE ]; +static MEMORY_OPS_T currentJob; +static LOG_RECORD_T logRecord; +static TREATMENT_TIME_RECORD_T treatmentTimeRecord; +static WATER_CONSUMPTION_RECORD_T waterConsumptionRecord; +static LOG_DATA_T logData; +static MFG_RECORD_T mfgRecord; +static CALIBRATION_RECORD_T calibrationRecord; +static U08 queueRearIndex = QUEUE_START_INDEX; +static U08 queueFrontIndex = QUEUE_START_INDEX; +static U08 queueCount = 0; +static NVDATAMGMT_SELF_TEST_STATE_T NVDataMgmtSelfTestState = NVDATAMGMT_SELF_TEST_STATE_START; +static NVDATAMGMT_EXEC_STATE_T NVDataMgmtExecState = NVDATAMGMT_EXEC_STATE_WAIT_FOR_POST; +static SELF_TEST_STATUS_T NVDataMgmtSelfTestResult = SELF_TEST_STATUS_IN_PROGRESS; +static BOOL isServiceOnEntry = TRUE; +static U32 bootloaderFlag = 0; + // Private functions static NVDATAMGMT_SELF_TEST_STATE_T handleSelfTestStart ( void ); +static NVDATAMGMT_SELF_TEST_STATE_T handleSelfTestReadBootloaderFlag ( void ); static NVDATAMGMT_SELF_TEST_STATE_T handleSelfTestReadLogRecord ( void ); static NVDATAMGMT_SELF_TEST_STATE_T handleSelfTestReadMfgRecord ( void ); static NVDATAMGMT_SELF_TEST_STATE_T handleSelfTestReadCalibrationRecord ( void ); @@ -203,32 +226,15 @@ static BOOL isQueueEmpty ( void ); static BOOL isQueueFull ( void ); static U32 getAvailableQueueCount ( void ); +static BOOL enqueueBank7Sector0Records( void ); -// Private variables -static MEMORY_OPS_T jobQueue [ QUEUE_MAX_SIZE ]; -static U08 readBuffer [ MAX_JOB_DATA_SIZE_BYTES ]; // TODO: REMOVE THIS -static MEMORY_OPS_T currentJob; -static LOG_HEADER_T logHeader; // Change this -static TREATMENT_TIME_RECORD_T treatmentTimeRecord; -static WATER_CONSUPTION_T waterConsumptionRecord; -static LOG_DATA_T logData; -static MFG_RECORD_T mfgRecord; -static CALIBRATION_RECORD_T calibrationRecord; -static U08 queueRearIndex = QUEUE_START_INDEX; -static U08 queueFrontIndex = QUEUE_START_INDEX; -static U08 queueCount = 0; -static Fapi_StatusType EEPROMStatus = Fapi_Status_Success; -static NVDATAMGMT_SELF_TEST_STATE_T NVDataMgmtSelfTestState = NVDATAMGMT_SELF_TEST_STATE_START; -static NVDATAMGMT_EXEC_STATE_T NVDataMgmtExecState = NVDATAMGMT_EXEC_STATE_WAIT_FOR_POST; -static SELF_TEST_STATUS_T NVDataMgmtSelfTestResult = SELF_TEST_STATUS_IN_PROGRESS; -static BOOL isServiceOnEntry = TRUE; -static U32 bootloaderFlag = 0; // REMOVE THIS CODE //static U08 tempBufferForTest[5] = {'5', 'Y', 'I', 'D', 'P'}; static U08 readBufferForTest [ 36 ]; static READ_DATA_T mytest; +static CALIBRATION_DATA_T calTest; // REMOVE THIS CODE /************************************************************************* @@ -244,14 +250,13 @@ { // TODO: initialize all the necessary variables NVDataMgmtSelfTestState = NVDATAMGMT_SELF_TEST_STATE_START; - EEPROMStatus = Fapi_Status_Success; NVDataMgmtExecState = NVDATAMGMT_EXEC_STATE_WAIT_FOR_POST; NVDataMgmtSelfTestResult = SELF_TEST_STATUS_IN_PROGRESS; isServiceOnEntry = TRUE; queueRearIndex = QUEUE_START_INDEX; queueFrontIndex = QUEUE_START_INDEX; - EEPROMStatus = Fapi_initializeFlashBanks( ROUNDED_HCLK_FREQ ); - EEPROMStatus = Fapi_setActiveFlashBank( Fapi_FlashBank7 ); + Fapi_initializeFlashBanks( ROUNDED_HCLK_FREQ ); + Fapi_setActiveFlashBank( Fapi_FlashBank7 ); } /************************************************************************* @@ -261,27 +266,16 @@ * calls another function to erase sector 0 and write the new manufacturing * data. * @details - * Inputs : data - * Outputs : status (BOOL) + * Inputs : MFG_DATA_T (data) + * Outputs : BOOL * @param none - * @return status (BOOL) + * @return BOOL *************************************************************************/ BOOL setMfgData ( MFG_DATA_T data ) { - BOOL status = FALSE; mfgRecord.mfgData = data; - U16 calculateCRC = crc16 ( (U08*)&mfgRecord.mfgData, sizeof( MFG_DATA_T ) ); - mfgRecord.crc = calculateCRC; - - //TODO Add min jobs?? - if ( !isQueueFull() ) - { - enqueue ( NVDATAMGMT_ERASE_SECTOR, NVDATAMGMT_EEPROM, BANK7_SECTOR0_START_ADDRESS, 0, 0, 0 ); - enqueue ( NVDATAMGMT_WRITE, NVDATAMGMT_EEPROM, BANK7_SECTOR0_START_ADDRESS, - (U08*)&mfgRecord, 0, sizeof(MFG_RECORD_T) ); - status = TRUE; - } - + mfgRecord.crc = crc16 ( (U08*)&mfgRecord.mfgData, sizeof(MFG_DATA_T) ); + BOOL status = enqueueBank7Sector0Records(); return status; } @@ -290,34 +284,54 @@ * The getMfgData returns the data in the struct that hold manufacturing * record to buffer that the caller has provided * @details - * Inputs : buffer + * Inputs : U08* (buffer) * Outputs : none * @param none * @return none *************************************************************************/ void getMfgData ( U08* buffer ) { - memcpy ( buffer, (U08*)&mfgRecord, sizeof(MFG_RECORD_T) ); + memcpy ( buffer, (U08*)&mfgRecord.mfgData, sizeof(MFG_DATA_T) ); } /************************************************************************* + * @brief setCalibrationData + * The setCalibrationData updates the struct that holds the calibration data, + * calls another function to calculate the CRC for the provided data and + * calls another function to erase sector 0 and write the new manufacturing + * data. + * @details + * Inputs : MFG_DATA_T (data) + * Outputs : BOOL + * @param none + * @return BOOL + *************************************************************************/ +BOOL setCalibrationData ( CALIBRATION_DATA_T data ) +{ + calibrationRecord.calData = data; + calibrationRecord.crc = crc16 ( (U08*)&calibrationRecord.calData, + sizeof(CALIBRATION_RECORD_T) ); + BOOL status = enqueueBank7Sector0Records(); + return status; +} + +/************************************************************************* * @brief writeLogData * The writeLogData checks if the queue is not full and if it is not, it calls * enqueue to schedule a job for writing the log data * @details - * Inputs : data + * Inputs : U08* (data) * Outputs : BOOL * @param none * @return BOOL *************************************************************************/ BOOL writeLogData ( U08* data ) { BOOL status = FALSE; - U32 availableQueue = getAvailableQueueCount(); - if ( availableQueue >= MIN_QUEUE_COUNT_FOR_DATA_LOG ) + if ( !isQueueFull() ) { - enqueue ( NVDATAMGMT_WRITE, NVDATAMGMT_EEPROM, 0, data, 0, sizeof(LOG_HEADER_T) ); + enqueue ( NVDATAMGMT_WRITE, NVDATAMGMT_RTC, 0, data, 0, sizeof(LOG_HEADER_T) ); status = TRUE; } @@ -329,7 +343,7 @@ * The readLogData checks if the queue is not full and if it is not, it calls * enqueue to schedule a job for writing the log data * @details - * Inputs : data + * Inputs : READ_DATA_T* (buffer), U32 (length) * Outputs : BOOL * @param none * @return BOOL @@ -361,42 +375,60 @@ BOOL setTreatmentTime ( U32 mins ) { BOOL status = FALSE; + treatmentTimeRecord.treatmentTime = mins; + treatmentTimeRecord.crc = crc16 ( (U08*)&treatmentTimeRecord.treatmentTime, sizeof(U32) ); if ( !isQueueFull() ) { enqueue( NVDATAMGMT_WRITE, NVDATAMGMT_RTC, HD_TREATMENT_TIME_ADDRESS, - (U08*)&mins, 0, sizeof(mins) ); + (U08*)&treatmentTimeRecord, 0, sizeof(TREATMENT_TIME_RECORD_T) ); status = TRUE; } return status; } /************************************************************************* - * @brief setLitersOfFilteredWater - * The setLitersOfFilteredWater sets a queue job to write the amount of water + * @brief setWaterConsumption + * The setWaterConsumption sets a queue job to write the amount of water * that has been consumed in DG * @details * Inputs : U32 (liters) * Outputs : BOOL * @param none * @return BOOL *************************************************************************/ -BOOL setLitersOfFilteredWater ( U32 liters ) +BOOL setWaterConsumption ( U32 liters ) { BOOL status = FALSE; + waterConsumptionRecord.waterConsumption = liters; + waterConsumptionRecord.crc = crc16 ( (U08*)&waterConsumptionRecord.waterConsumption, sizeof(U32) ); if ( !isQueueFull() ) { enqueue( NVDATAMGMT_WRITE, NVDATAMGMT_RTC, DG_CONSUMED_WATER_ADDRESS, - (U08*)&liters, 0, sizeof(liters) ); + (U08*)&waterConsumptionRecord, 0, sizeof(WATER_CONSUMPTION_RECORD_T) ); status = TRUE; } return status; } /************************************************************************* + * @brief getWaterConsumption + * The getWaterConsumption returns the amount of consumed water + * @details + * Inputs : none + * Outputs : U32 + * @param none + * @return U32 + *************************************************************************/ +U32 getWaterConsumption ( void ) +{ + return waterConsumptionRecord.waterConsumption; +} + +/************************************************************************* * @brief execNVDataMgmtSelfTest * The execNVDataMgmtSelfTest runs the NVDataMgmt POST during the self test * @details @@ -414,6 +446,11 @@ NVDataMgmtSelfTestState = handleSelfTestStart(); break; + case NVDATAMGMT_SELF_TEST_STATE_READ_BOOTLOADER_FLAG: + + NVDataMgmtSelfTestState = handleSelfTestReadBootloaderFlag(); + break; + case NVDATAMGMT_SELF_TEST_STATE_READ_LOG_RECORD: NVDataMgmtSelfTestState = handleSelfTestReadLogRecord(); @@ -460,6 +497,43 @@ } /************************************************************************* + * @brief setBootloaderFlag + * The setBootloaderFlag sets the bootloader flag to RTC RAM + * @details + * Inputs : U32 (flag) + * Outputs : BOOL + * @param none + * @return BOOL + *************************************************************************/ +BOOL setBootloaderFlag ( U32 flag ) +{ + BOOL status = FALSE; + + if ( !isQueueFull() ) + { + enqueue ( NVDATAMGMT_WRITE, NVDATAMGMT_RTC, BOOTLOADER_FLAG_ADDRESS, + (U08*)&flag, 0, BOOTLOADER_FLAG_LENGTH_BYTES ); + status = TRUE; + } + + return status; +} + +/************************************************************************* + * @brief getBootloaderFlag + * The getBootloaderFlag gets the bootloader flag from RTC RAM + * @details + * Inputs : none + * Outputs : U32 (flag value) + * @param none + * @return U32 (flag value) + *************************************************************************/ +U32 getBootloaderFlag( void ) +{ + return bootloaderFlag; +} + +/************************************************************************* * @brief execNVDataMgmt * The execNVDataMgmt runs the NVDataMgmt main tasks * @details @@ -520,6 +594,8 @@ } } +// Private functions + /************************************************************************* * @brief handleSelfTestStart * The handleSelfTestStart enables the EEPROM bank sectors @@ -532,92 +608,158 @@ static NVDATAMGMT_SELF_TEST_STATE_T handleSelfTestStart ( void ) { NVDATAMGMT_SELF_TEST_STATE_T state = NVDATAMGMT_SELF_TEST_STATE_START; + if ( isServiceOnEntry ) { - EEPROMStatus = Fapi_enableEepromBankSectors( BANK7_SECTOR_0_31_ENABLE_BIT_MASK, - BANK7_SECTOR_32_63_ENABLE_BIT_MASK ); + Fapi_enableEepromBankSectors( BANK7_SECTOR_0_31_ENABLE_BIT_MASK, + BANK7_SECTOR_32_63_ENABLE_BIT_MASK ); isServiceOnEntry = FALSE; } - else if ( EEPROMStatus == Fapi_Status_Success ) + else if ( FAPI_CHECK_FSM_READY_BUSY == Fapi_Status_FsmReady ) { -/*#ifdef _HD_ - state = NVDATAMGMT_SELF_TEST_STATE_READ_TREATMENT_TIME; -#else - state = NVDATAMGMT_SELF_TEST_STATE_READ_WATER_CONSUMPTION; -#endif*/ - - state = NVDATAMGMT_SELF_TEST_STATE_READ_LOG_RECORD; + state = NVDATAMGMT_SELF_TEST_STATE_READ_BOOTLOADER_FLAG; isServiceOnEntry = TRUE; } return state; } /************************************************************************* - * @brief handleSelfTestReadLogRecord - * The handleSelfTestReadLogRecord reads the log record from RTC RAM + * @brief handleSelfTestReadBootloaderFlag + * The handleSelfTestReadBootloaderFlag reads the bootloader flag + * from RTC RAM * @details * Inputs : none * Outputs : NVDATAMGMT_SELF_TEST_STATE_T * @param none * @return NVDATAMGMT_SELF_TEST_STATE_T *************************************************************************/ -static NVDATAMGMT_SELF_TEST_STATE_T handleSelfTestReadLogRecord ( void ) +static NVDATAMGMT_SELF_TEST_STATE_T handleSelfTestReadBootloaderFlag ( void ) { - NVDATAMGMT_SELF_TEST_STATE_T state = NVDATAMGMT_SELF_TEST_STATE_READ_LOG_RECORD; + NVDATAMGMT_SELF_TEST_STATE_T state = NVDATAMGMT_SELF_TEST_STATE_READ_BOOTLOADER_FLAG; + if ( isServiceOnEntry && getRTCRAMState() == RTC_RAM_STATE_READY ) { - readFromRAM ( LOG_RECORD_START_ADDRESS, sizeof(LOG_HEADER_T) ); + readFromRAM( BOOTLOADER_FLAG_ADDRESS, BOOTLOADER_FLAG_LENGTH_BYTES ); isServiceOnEntry= FALSE; } if ( getRTCRAMStatus() == RTC_RAM_STATUS_IDLE ) { - getDataFromRAM ( (U08*)&logHeader, sizeof(LOG_HEADER_T) ); - /*U08 i; - U08* logPtr = (U08*)&logRecord; - getDataFromRAM ( readBuffer, sizeof(LOG_HEADER_T) ); - for ( i = 0; i < sizeof(LOG_HEADER_T); i++ ) + U08 i; + U08 tempBuffer [ BOOTLOADER_FLAG_LENGTH_BYTES ]; + U32 tempValue; + getDataFromRAM( tempBuffer, BOOTLOADER_FLAG_LENGTH_BYTES ); + for ( i = 0; i < BOOTLOADER_FLAG_LENGTH_BYTES; i++ ) { - *logPtr = ( readBuffer[ i ] & MASK_OFF_MSB ); - logPtr++; - }*/ - state = NVDATAMGMT_SELF_TEST_STATE_READ_MFG_RECORD; - isServiceOnEntry = TRUE; + tempValue = tempBuffer [ i ] << i * SHIFT_8_BITS_FOR_BYTE_SHIFT; + bootloaderFlag = bootloaderFlag + tempValue; + } +#ifdef _HD_ + state = NVDATAMGMT_SELF_TEST_STATE_READ_TREATMENT_TIME; +#else + state = NVDATAMGMT_SELF_TEST_STATE_READ_WATER_CONSUMPTION; +#endif + isServiceOnEntry= TRUE; } + return state; } +/************************************************************************* + * @brief handleSelfTestReadHDTreatmentTime + * The handleSelfTestReadHDTreatmentTime reads the HD treatment time + * from RTC RAM + * @details + * Inputs : none + * Outputs : NVDATAMGMT_SELF_TEST_STATE_T + * @param none + * @return NVDATAMGMT_SELF_TEST_STATE_T + *************************************************************************/ static NVDATAMGMT_SELF_TEST_STATE_T handleSelfTestReadHDTreatmentTime ( void ) { NVDATAMGMT_SELF_TEST_STATE_T state = NVDATAMGMT_SELF_TEST_STATE_READ_TREATMENT_TIME; if ( isServiceOnEntry && getRTCRAMState() == RTC_RAM_STATE_READY ) { - readFromRAM ( LOG_RECORD_START_ADDRESS, sizeof(TREATMENT_TIME_RECORD_T) ); + readFromRAM ( HD_TREATMENT_TIME_ADDRESS, sizeof(TREATMENT_TIME_RECORD_T) ); isServiceOnEntry= FALSE; } if ( getRTCRAMStatus() == RTC_RAM_STATUS_IDLE ) { - getDataFromRAM ( (U08*)&logHeader, sizeof(TREATMENT_TIME_RECORD_T) ); - state = NVDATAMGMT_SELF_TEST_STATE_READ_MFG_RECORD; + getDataFromRAM ( (U08*)&treatmentTimeRecord, sizeof(TREATMENT_TIME_RECORD_T) ); + state = NVDATAMGMT_SELF_TEST_STATE_READ_LOG_RECORD; isServiceOnEntry = TRUE; } return state; - } + +/************************************************************************* + * @brief handleSelfTestReadDGWaterConsumption + * The handleSelfTestReadDGWaterConsumption reads the DG water consumption + * from RTC RAM + * @details + * Inputs : none + * Outputs : NVDATAMGMT_SELF_TEST_STATE_T + * @param none + * @return NVDATAMGMT_SELF_TEST_STATE_T + *************************************************************************/ static NVDATAMGMT_SELF_TEST_STATE_T handleSelfTestReadDGWaterConsumption ( void ) { NVDATAMGMT_SELF_TEST_STATE_T state = NVDATAMGMT_SELF_TEST_STATE_READ_WATER_CONSUMPTION; + if ( isServiceOnEntry && getRTCRAMState() == RTC_RAM_STATE_READY ) + { + readFromRAM ( DG_CONSUMED_WATER_ADDRESS, sizeof(WATER_CONSUMPTION_RECORD_T) ); + isServiceOnEntry= FALSE; + } + if ( getRTCRAMStatus() == RTC_RAM_STATUS_IDLE ) + { + getDataFromRAM ( (U08*)&waterConsumptionRecord, sizeof(WATER_CONSUMPTION_RECORD_T) ); + state = NVDATAMGMT_SELF_TEST_STATE_READ_LOG_RECORD; + isServiceOnEntry = TRUE; + } return state; +} +/************************************************************************* + * @brief handleSelfTestReadLogRecord + * The handleSelfTestReadLogRecord reads the log record from RTC RAM + * @details + * Inputs : none + * Outputs : NVDATAMGMT_SELF_TEST_STATE_T + * @param none + * @return NVDATAMGMT_SELF_TEST_STATE_T + *************************************************************************/ +static NVDATAMGMT_SELF_TEST_STATE_T handleSelfTestReadLogRecord ( void ) +{ + NVDATAMGMT_SELF_TEST_STATE_T state = NVDATAMGMT_SELF_TEST_STATE_READ_LOG_RECORD; + if ( isServiceOnEntry && getRTCRAMState() == RTC_RAM_STATE_READY ) + { + readFromRAM ( LOG_RECORD_START_ADDRESS, sizeof(LOG_HEADER_T) ); + isServiceOnEntry= FALSE; + } + if ( getRTCRAMStatus() == RTC_RAM_STATUS_IDLE ) + { + getDataFromRAM ( (U08*)&logRecord, sizeof(LOG_RECORD_T) ); + /*U08 i; + U08* logPtr = (U08*)&logRecord; + getDataFromRAM ( readBuffer, sizeof(LOG_HEADER_T) ); + for ( i = 0; i < sizeof(LOG_HEADER_T); i++ ) + { + *logPtr = ( readBuffer[ i ] & MASK_OFF_MSB ); + logPtr++; + }*/ + state = NVDATAMGMT_SELF_TEST_STATE_READ_MFG_RECORD; + isServiceOnEntry = TRUE; + } + return state; } /************************************************************************* - * @brief handleSelfTestReadCalibrationRecord - * The handleSelfTestReadCalibrationRecord reads the calibration record - * from EEPROM + * @brief handleSelfTestReadMfgRecords + * The handleSelfTestReadMfgRecords reads the manufacturing record from + * EEPROM * @details * Inputs : none * Outputs : NVDATAMGMT_SELF_TEST_STATE_T @@ -630,24 +772,23 @@ if ( isServiceOnEntry ) { - EEPROMStatus = Fapi_doMarginRead ( (U32*)BANK7_SECTOR0_START_ADDRESS, (U32*)&mfgRecord, - sizeof(MFG_DATA_T), Fapi_NormalRead ); + Fapi_doMarginRead ( (U32*)BANK7_SECTOR0_START_ADDRESS, (U32*)&mfgRecord, + sizeof(MFG_DATA_T), Fapi_NormalRead ); isServiceOnEntry = FALSE; } else if ( FAPI_CHECK_FSM_READY_BUSY == Fapi_Status_FsmReady ) { - // TODO: Change this to the next state to read - state = NVDATAMGMT_SELF_TEST_STATE_CHECK_CRC; + state = NVDATAMGMT_SELF_TEST_STATE_READ_CAL_RECORD; isServiceOnEntry = TRUE; } return state; } /************************************************************************* - * @brief handleSelfTestReadMfgRecords - * The handleSelfTestReadMfgRecords reads the manufacturing record from - * EEPROM + * @brief handleSelfTestReadCalibrationRecord + * The handleSelfTestReadCalibrationRecord reads the calibration record + * from EEPROM * @details * Inputs : none * Outputs : NVDATAMGMT_SELF_TEST_STATE_T @@ -660,13 +801,13 @@ if ( isServiceOnEntry ) { - EEPROMStatus = Fapi_doMarginRead ( (U32*)(CAL_RECORD_START_ADDRESS ), (U32*)&calibrationRecord, - sizeof(CALIBRATION_DATA_T), Fapi_NormalRead ); + Fapi_doMarginRead ( (U32*)(CALIBRATION_RECORD_START_ADDRESS ), (U32*)&calibrationRecord, + sizeof(CALIBRATION_RECORD_T), Fapi_NormalRead ); isServiceOnEntry = FALSE; } else if ( FAPI_CHECK_FSM_READY_BUSY == Fapi_Status_FsmReady ) { - state = NVDATAMGMT_SELF_TEST_STATE_COMPLETE; + state = NVDATAMGMT_SELF_TEST_STATE_CHECK_CRC; isServiceOnEntry = TRUE; } @@ -688,24 +829,21 @@ NVDATAMGMT_SELF_TEST_STATE_T state = NVDATAMGMT_SELF_TEST_STATE_COMPLETE; BOOL hasCRCPassed = TRUE; U16 calcCRC; - U16 CRC; + U16 recordCRC; - calcCRC = crc16 ( (U08*)&mfgRecord.mfgData, sizeof(MFG_DATA_T) ); - CRC = mfgRecord.crc; - //hasCRCPassed = (calcCRC==CRC ? TRUE : FALSE); - //if ( calcCRC != CRC ) - // { - // hasCRCPassed = FALSE; - //} - - // Disabled since there is no data - // TODO: enable this code - /*calcCRC = crc16 ( (U08*)&calibrationRecord.calData, sizeof(CALIBRATION_RECORD_T) ); - CRC = calibrationRecord.crc; - if ( calcCRC != CRC ) + calcCRC = crc16 ( (U08*)&mfgRecord.mfgData, sizeof(MFG_DATA_T) ); + recordCRC = mfgRecord.crc; + if ( calcCRC != recordCRC ) { hasCRCPassed = FALSE; - }*/ + SET_ALARM_WITH_2_U32_DATA( ALARM_ID_NVDATA_MFG_RECORD_CRC_ERROR, recordCRC, calcCRC ); + } + calcCRC = crc16 ( (U08*)&calibrationRecord.calData, sizeof(CALIBRATION_RECORD_T) ); + recordCRC = calibrationRecord.crc; + if ( calcCRC != recordCRC ) + { + hasCRCPassed = FALSE; + } if ( hasCRCPassed ) { @@ -731,8 +869,7 @@ static NVDATAMGMT_EXEC_STATE_T handleExecWaitForPostState ( void ) { NVDATAMGMT_EXEC_STATE_T state = NVDATAMGMT_EXEC_STATE_WAIT_FOR_POST; - if ( NVDataMgmtSelfTestState == NVDATAMGMT_SELF_TEST_STATE_COMPLETE && - NVDataMgmtSelfTestResult == SELF_TEST_STATUS_PASSED ) + if ( NVDataMgmtSelfTestState == NVDATAMGMT_SELF_TEST_STATE_COMPLETE ) { // TODO: REMOVE THIS CODE logData.epochTime = 1582583436; @@ -748,8 +885,14 @@ mytest.externalBuffer = readBufferForTest; //writeLogData ( (U08*)&logData ); - readLogData ( &mytest, 5 ); + //readLogData ( &mytest, 5 ); + //calTest.occSensorOffset = 3.4; + //calTest.tempSensorOffset = 13.2; + //setCalibrationData(calTest); + + //setTreatmentTime(750); + /*MFG_DATA_T test; char sys[7] = {'A', 'B', 'C', 'D', '3', '6', '7'}; char hw[5] = {'3', '4', '5', '6', '7'}; @@ -762,10 +905,7 @@ // TODO: REMOVE THIS CODE state = NVDATAMGMT_EXEC_STATE_IDLE; } - else if ( NVDataMgmtSelfTestState == NVDATAMGMT_SELF_TEST_STATE_COMPLETE ) - { - state = NVDATAMGMT_EXEC_STATE_IDLE; - } + return state; } @@ -827,19 +967,19 @@ static NVDATAMGMT_EXEC_STATE_T handleExecWriteToEEPROMState ( void ) { NVDATAMGMT_EXEC_STATE_T state = NVDATAMGMT_EXEC_STATE_WRITE_TO_EEPROM; + if ( isServiceOnEntry ) { - EEPROMStatus = Fapi_issueProgrammingCommand ( currentJob.startAddress, - currentJob.buffer, - currentJob.length, - 0x00, 0, Fapi_DataOnly ); + Fapi_issueProgrammingCommand ( currentJob.startAddress, currentJob.buffer, + currentJob.length, 0x00, 0, Fapi_DataOnly ); isServiceOnEntry = FALSE; } else if ( FAPI_CHECK_FSM_READY_BUSY == Fapi_Status_FsmReady ) { state = NVDATAMGMT_EXEC_STATE_IDLE; isServiceOnEntry = TRUE; } + return state; } @@ -859,9 +999,9 @@ if ( isServiceOnEntry ) { - EEPROMStatus = Fapi_doMarginRead ( currentJob.startAddress, - (U32*)currentJob.externalAddress->externalBuffer, - currentJob.length, Fapi_NormalRead ); + Fapi_doMarginRead ( currentJob.startAddress, + (U32*)currentJob.externalAddress->externalBuffer, + currentJob.length, Fapi_NormalRead ); // Change the status to in progress until the read operation is done currentJob.externalAddress->status = NVDATAMGMT_READ_IN_PROGRESS; isServiceOnEntry = FALSE; @@ -892,8 +1032,7 @@ if ( isServiceOnEntry ) { - EEPROMStatus = Fapi_issueAsyncCommandWithAddress ( Fapi_EraseSector, - currentJob.startAddress ); + Fapi_issueAsyncCommandWithAddress ( Fapi_EraseSector, currentJob.startAddress ); isServiceOnEntry = FALSE; } else if ( FAPI_CHECK_FSM_READY_BUSY == Fapi_Status_FsmReady ) @@ -922,8 +1061,7 @@ if ( isServiceOnEntry && getRTCRAMState() == RTC_RAM_STATE_READY ) { - writeToRAM ( (U32)( currentJob.startAddress ), - currentJob.buffer, + writeToRAM ( (U32)( currentJob.startAddress ), currentJob.buffer, currentJob.length ); isServiceOnEntry= FALSE; } @@ -953,14 +1091,12 @@ NVDATAMGMT_EXEC_STATE_T state = NVDATAMGMT_EXEC_STATE_READ_FROM_RTC; if ( isServiceOnEntry && getRTCRAMState() == RTC_RAM_STATE_READY ) { - readFromRAM( (U32)( currentJob.startAddress ), - currentJob.length ); + readFromRAM( (U32)( currentJob.startAddress ), currentJob.length ); isServiceOnEntry= FALSE; } if ( getRTCRAMStatus() == RTC_RAM_STATUS_IDLE ) { - getDataFromRAM( currentJob.buffer, - currentJob.length ); + getDataFromRAM( currentJob.buffer, currentJob.length ); state = NVDATAMGMT_EXEC_STATE_IDLE; isServiceOnEntry = TRUE; } @@ -971,7 +1107,9 @@ * @brief setMemoryOpsStruct * The setMemoryOpsStruct fills up the job struct * @details - * Inputs : none + * Inputs : NVDATAMGMT_OPERATION_STATE_T (ops), NVDATAMGMT_LOCATION_STATE_T + * (location), U32 (startAddress), U08* (data), READ_DATA_T* (extAddress) + * U32 (length) * Outputs : none * @param none * @return none @@ -1005,10 +1143,10 @@ * header accordingly. If the write is not at the edge, it will prepare a * normal write to EEPROM job. * @details - * Inputs : data - * Outputs : opsStartAddress + * Inputs : U08* (data) + * Outputs : U32 (opsStartAddress) * @param none - * @return opsStartAddress + * @return U32 (opsStartAddress) *************************************************************************/ static U32 prepareWriteLogJobAndGetStartAddress ( U08* data ) { @@ -1020,8 +1158,8 @@ // The write address is calculated using the next write index and is and offset from // the start of sector 1. Sectors 1,2, and 3 have been allocated for logging data - opsStartAddress = ( logHeader.nextWriteIndex * MAX_JOB_DATA_SIZE_BYTES ) + BANK7_SECTOR1_START_ADDRESS; - modulus = logHeader.nextWriteIndex % MAX_LOG_DATA_PER_SECTOR; + opsStartAddress = ( logRecord.logHeader.nextWriteIndex * MAX_JOB_DATA_SIZE_BYTES ) + BANK7_SECTOR1_START_ADDRESS; + modulus = logRecord.logHeader.nextWriteIndex % MAX_LOG_DATA_PER_SECTOR; // Modulus is 0 so it is at any of the edges if ( modulus == 0 ) @@ -1030,20 +1168,21 @@ // 1. set readIndexChange = +512 // 2. set recordCountchange = -512 readIndexChange = MAX_LOG_DATA_PER_SECTOR; - logHeader.recordCount = logHeader.recordCount - MAX_LOG_DATA_PER_SECTOR; - + logRecord.logHeader.recordCount = logRecord.logHeader.recordCount - MAX_LOG_DATA_PER_SECTOR; setMemoryOpsStruct ( NVDATAMGMT_ERASE_SECTOR, NVDATAMGMT_EEPROM, opsStartAddress, 0, 0, 0 ); } // Check for wrap in 1536 which is at the end of sector 3 - writeIndexChange = INC_WRAP( logHeader.nextWriteIndex, LOG_DATA_START_INDEX, MAX_NUM_OF_DATA_LOGS_IN_SECTOR3 - 1 ); - logHeader.nextWriteIndex = writeIndexChange; - logHeader.recordCount = logHeader.recordCount + recordCountChange; - logHeader.nextReadIndex = logHeader.nextReadIndex + readIndexChange; + writeIndexChange = INC_WRAP( logRecord.logHeader.nextWriteIndex, LOG_DATA_START_INDEX, MAX_NUM_OF_DATA_LOGS_IN_SECTOR3 - 1 ); + logRecord.logHeader.nextWriteIndex = writeIndexChange; + logRecord.logHeader.recordCount = logRecord.logHeader.recordCount + recordCountChange; + logRecord.logHeader.nextReadIndex = logRecord.logHeader.nextReadIndex + readIndexChange; + // Calculate the CRC for the new record + logRecord.crc = crc16 ( (U08*)&logRecord.logHeader, sizeof(LOG_HEADER_T) ); // Update the log record setMemoryOpsStruct ( NVDATAMGMT_WRITE, NVDATAMGMT_RTC, LOG_RECORD_START_ADDRESS, - (U08*)&logHeader, 0, sizeof( LOG_HEADER_T ) ); + (U08*)&logRecord, 0, sizeof(LOG_RECORD_T) ); return opsStartAddress; } @@ -1054,22 +1193,23 @@ * address of the EEPROM. * @details * Inputs : none - * Outputs : opsStartAddress + * Outputs : U32 (opsStartAddress) * @param none - * @return opsStartAddress + * @return U32 (opsStartAddress) *************************************************************************/ static U32 prepareReadLogJobAndGetStartAddress( void ) { // The write address is calculated using the next write index and is and offset from // the start of sector 1. Sectors 1,2, and 3 have been allocated for logging data - U32 opsStartAddress = ( logHeader.nextReadIndex * MAX_JOB_DATA_SIZE_BYTES ) + BANK7_SECTOR1_START_ADDRESS; + U32 opsStartAddress = ( logRecord.logHeader.nextReadIndex * MAX_JOB_DATA_SIZE_BYTES ) + BANK7_SECTOR1_START_ADDRESS; - U16 readIndexChange = INC_WRAP( logHeader.nextReadIndex, LOG_DATA_START_INDEX, MAX_NUM_OF_DATA_LOGS_IN_SECTOR3 - 1 ); - logHeader.nextReadIndex = readIndexChange; + U16 readIndexChange = INC_WRAP( logRecord.logHeader.nextReadIndex, LOG_DATA_START_INDEX, MAX_NUM_OF_DATA_LOGS_IN_SECTOR3 - 1 ); + logRecord.logHeader.nextReadIndex = readIndexChange; + logRecord.crc = crc16 ( (U08*)&logRecord.logHeader, sizeof(LOG_RECORD_T) ); // Update the log record setMemoryOpsStruct ( NVDATAMGMT_WRITE, NVDATAMGMT_RTC, LOG_RECORD_START_ADDRESS, - (U08*)&logHeader, 0, sizeof( LOG_HEADER_T ) ); + (U08*)&logRecord, 0, sizeof(LOG_RECORD_T) ); return opsStartAddress; } @@ -1083,7 +1223,9 @@ * it schedules the write jobs. The function breaks the write to EEPROM jobs to * 16 bytes at the time * @details - * Inputs : ops, location, startAddress, data, length + * Inputs : NVDATAMGMT_OPERATION_STATE_T (ops), NVDATAMGMT_LOCATION_STATE_T + * (location), U32 (startAddress), U08* (data), READ_DATA_T* (extAddress) + * U32 (length) * Outputs : none * @param none * @return none @@ -1222,10 +1364,40 @@ * Inputs : none * Outputs : U32 * @param none - * @return BOOL + * @return U32 *************************************************************************/ static U32 getAvailableQueueCount ( void ) { return QUEUE_MAX_SIZE - queueCount - 1; } +/************************************************************************* + * @brief enqueueBank7Sector0Records + * The enqueueBank7Sector0Records checks whether there are enough number of + * queues for erasing and setting the records. If there are enough queues, + * it schedules an erase job and then schdules jobs to write all the records + * back to Bank 7 Sector 0 + * @details + * Inputs : none + * Outputs : BOOL + * @param none + * @return BOOL + *************************************************************************/ +static BOOL enqueueBank7Sector0Records( void ) +{ + BOOL status = FALSE; + U32 currentQueueCount = getAvailableQueueCount(); + + if ( currentQueueCount >= MIN_QUEUE_COUNT_FOR_SECTOR_0 ) + { + // Sector 0 must be erased first + enqueue ( NVDATAMGMT_ERASE_SECTOR, NVDATAMGMT_EEPROM, BANK7_SECTOR0_START_ADDRESS, 0, 0, 0 ); + enqueue ( NVDATAMGMT_WRITE, NVDATAMGMT_EEPROM, BANK7_SECTOR0_START_ADDRESS, + (U08*)&mfgRecord, 0, sizeof(MFG_RECORD_T) ); + enqueue ( NVDATAMGMT_WRITE, NVDATAMGMT_EEPROM, CALIBRATION_RECORD_START_ADDRESS, + (U08*)&calibrationRecord, 0, sizeof(CALIBRATION_RECORD_T) ); + status = TRUE; + } + + return status; +}