Index: NVDataMgmt.c =================================================================== diff -u -r0170e69752974589e2f3c3507d3fb0ebd771bd89 -r6d7fa72cf0e2a9d6d61b59682ab261826100562e --- NVDataMgmt.c (.../NVDataMgmt.c) (revision 0170e69752974589e2f3c3507d3fb0ebd771bd89) +++ NVDataMgmt.c (.../NVDataMgmt.c) (revision 6d7fa72cf0e2a9d6d61b59682ab261826100562e) @@ -16,7 +16,7 @@ // Includes -#include +#include // For memcpy #include "F021.h" #include "NVDataMgmt.h" @@ -49,6 +49,7 @@ #define BANK7_SECTOR3_START_ADDRESS 0xF020C000 #define BANK7_SECTOR3_END_ADDRESS 0xF020FFFF +#define MAX_EEPROM_WRITE_BUFFER_BYTES 16U //Assert #define MAX_JOB_DATA_SIZE_BYTES 32U #define LOG_DATA_START_INDEX 0U #define MAX_NUM_OF_SECTORS_FOR_LOG_DATA 3U @@ -58,29 +59,25 @@ #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) -// RTC RAM defines -#define BOOTLOADER_FLAG_START_ADDRESS 0x00000000 +// Data addresses in EEPROM and 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_START_ADDRESS 0X00000030 // 48 -#define DG_CONSUMED_WATER_START_ADDRESS 0X00000040 // 64 -#define BUFFER_INDEX_0 0U -#define BUFFER_INDEX_1 1U -#define BUFFER_INDEX_2 2U -#define BUFFER_INDEX_3 3U -#define BUFFER_INDEX_4 4U -#define BUFFER_INDEX_5 5U +#define HD_TREATMENT_TIME_ADDRESS 0X00000030 // 48 +#define DG_CONSUMED_WATER_ADDRESS 0X00000040 // 64 -#define MAX_CRC_LENGTH_BYTES 2U -#define MAX_EEPROM_WRITE_BUFFER_BYTES 16U //Assert +#define CAL_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_MFG_RECORDS, + NVDATAMGMT_SELF_TEST_STATE_READ_TREATMENT_TIME, + NVDATAMGMT_SELF_TEST_STATE_READ_WATER_CONSUMPTION, + NVDATAMGMT_SELF_TEST_STATE_READ_MFG_RECORD, + NVDATAMGMT_SELF_TEST_STATE_READ_CAL_RECORD, NVDATAMGMT_SELF_TEST_STATE_CHECK_CRC, NVDATAMGMT_SELF_TEST_STATE_COMPLETE, NUM_OF_NVDATAMGMT_SELF_TEST_STATES @@ -122,6 +119,7 @@ NVDATAMGMT_LOCATION_STATE_T memoryLocation; U32* startAddress; U08 buffer [ MAX_JOB_DATA_SIZE_BYTES ]; + READ_DATA_T* externalAddress; U32 length; } MEMORY_OPS_T; @@ -130,16 +128,40 @@ U16 recordCount; U16 nextWriteIndex; U16 nextReadIndex; +} LOG_HEADER_T; + +typedef struct +{ + LOG_HEADER_T logHeader; + U16 crc; } LOG_RECORD_T; typedef struct { + U32 treatmentTime; + U16 crc; +} TREATMENT_TIME_RECORD_T; + +typedef struct +{ + U32 waterConsumption; + U16 crc; +} WATER_CONSUPTION_T; + +typedef struct +{ MFG_DATA_T mfgData; U16 crc; } MFG_RECORD_T; typedef struct { + CALIBRATION_DATA_T calData; + U16 crc; +} CALIBRATION_RECORD_T; + +typedef struct +{ U32 epochTime; U32 eventCode; U32 subCode; @@ -154,9 +176,12 @@ // Private functions static NVDATAMGMT_SELF_TEST_STATE_T handleSelfTestStart ( void ); -static NVDATAMGMT_SELF_TEST_STATE_T handleSelfTestReadMfgRecord ( void ); -static NVDATAMGMT_SELF_TEST_STATE_T handleSelfTestReadBootloaderFlag ( void ); +static NVDATAMGMT_SELF_TEST_STATE_T handleSelfTestReadBootloaderFlag ( void ); // TODO: REMOVE THIS FUNCTION static NVDATAMGMT_SELF_TEST_STATE_T handleSelfTestReadLogRecord ( void ); +static NVDATAMGMT_SELF_TEST_STATE_T handleSelfTestReadMfgRecord ( void ); +static NVDATAMGMT_SELF_TEST_STATE_T handleSelfTestReadCalibrationRecord ( void ); +static NVDATAMGMT_SELF_TEST_STATE_T handleSelfTestReadHDTreatmentTime ( void ); +static NVDATAMGMT_SELF_TEST_STATE_T handleSelfTestReadDGWaterConsumption ( void ); static NVDATAMGMT_SELF_TEST_STATE_T handleSelfTestCheckCRC ( void ); static NVDATAMGMT_EXEC_STATE_T handleExecWaitForPostState ( void ); @@ -170,24 +195,27 @@ // Queue functions static void setMemoryOpsStruct ( NVDATAMGMT_OPERATION_STATE_T ops, NVDATAMGMT_LOCATION_STATE_T location, - U32 startAddress, U08* data, U32 length ); + U32 startAddress, U08* data, READ_DATA_T* extAddress, U32 length ); static void enqueue ( NVDATAMGMT_OPERATION_STATE_T ops, NVDATAMGMT_LOCATION_STATE_T location, - U32 startAddress, U08* data, U32 length ); + U32 startAddress, U08* data, READ_DATA_T* extAddress, U32 length ); static void dequeue ( void ); static U32 prepareWriteLogJobAndGetStartAddress ( U08* data ); -static U32 prepareReadLogJobAndGetStartAddress (); +static U32 prepareReadLogJobAndGetStartAddress ( void ); static BOOL isQueueEmpty ( void ); static BOOL isQueueFull ( void ); static U32 getAvailableQueueCount ( void ); // Private variables static MEMORY_OPS_T jobQueue [ QUEUE_MAX_SIZE ]; -static U08 readBuffer [ MAX_JOB_DATA_SIZE_BYTES ]; +static U08 readBuffer [ MAX_JOB_DATA_SIZE_BYTES ]; // TODO: REMOVE THIS static MEMORY_OPS_T currentJob; -static LOG_RECORD_T logRecord; +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; @@ -199,8 +227,9 @@ static U32 bootloaderFlag = 0; // REMOVE THIS CODE -static U08 tempBufferForTest[5] = {'5', 'Y', 'I', 'D', 'P'}; -//static U08 readBufferForTest [ 8 ]; +//static U08 tempBufferForTest[5] = {'5', 'Y', 'I', 'D', 'P'}; +static U08 readBufferForTest [ 36 ]; +static READ_DATA_T mytest; // REMOVE THIS CODE /************************************************************************* @@ -227,32 +256,6 @@ } /************************************************************************* - * @brief handleSelfTestStart - * The handleSelfTestStart enables the EEPROM bank sectors - * @details - * Inputs : none - * Outputs : NVDATAMGMT_SELF_TEST_STATE_T - * @param none - * @return NVDATAMGMT_SELF_TEST_STATE_T - *************************************************************************/ -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 ); - isServiceOnEntry = FALSE; - } - else if ( EEPROMStatus == Fapi_Status_Success ) - { - state = NVDATAMGMT_SELF_TEST_STATE_READ_BOOTLOADER_FLAG; - isServiceOnEntry = TRUE; - } - return state; -} - -/************************************************************************* * @brief setMfgData * The setMfgData updates the struct that holds the manufacturing data, * calls another function to calculate the CRC for the provided data and @@ -274,9 +277,9 @@ //TODO Add min jobs?? if ( !isQueueFull() ) { - enqueue ( NVDATAMGMT_ERASE_SECTOR, NVDATAMGMT_EEPROM, BANK7_SECTOR0_START_ADDRESS, 0, 0 ); + enqueue ( NVDATAMGMT_ERASE_SECTOR, NVDATAMGMT_EEPROM, BANK7_SECTOR0_START_ADDRESS, 0, 0, 0 ); enqueue ( NVDATAMGMT_WRITE, NVDATAMGMT_EEPROM, BANK7_SECTOR0_START_ADDRESS, - (U08*)&mfgRecord, sizeof(MFG_RECORD_T) ); + (U08*)&mfgRecord, 0, sizeof(MFG_RECORD_T) ); status = TRUE; } @@ -315,7 +318,7 @@ if ( availableQueue >= MIN_QUEUE_COUNT_FOR_DATA_LOG ) { - enqueue ( NVDATAMGMT_WRITE, NVDATAMGMT_EEPROM, 0, data, sizeof( LOG_DATA_T ) ); + enqueue ( NVDATAMGMT_WRITE, NVDATAMGMT_EEPROM, 0, data, 0, sizeof(LOG_HEADER_T) ); status = TRUE; } @@ -332,157 +335,66 @@ * @param none * @return BOOL *************************************************************************/ -BOOL readLogData ( U08* buffer ) +BOOL readLogData ( READ_DATA_T* buffer, U32 length ) { BOOL status = FALSE; U32 availableQueue = getAvailableQueueCount(); if ( availableQueue >= MIN_QUEUE_COUNT_FOR_DATA_LOG ) { - enqueue( NVDATAMGMT_READ, NVDATAMGMT_EEPROM, 0, buffer, sizeof(buffer) ); + enqueue( NVDATAMGMT_READ, NVDATAMGMT_EEPROM, 0, 0, buffer, length ); status = TRUE; } return status; } /************************************************************************* - * @brief handleSelfTestReadBootloaderFlag - * The handleSelfTestReadBootloaderFlag reads the bootloader flag - * from RTC RAM + * @brief setTreatmentTime + * The setTreatmentTime sets a queue job to write the treatment time in + * the specified RAM address * @details - * Inputs : none - * Outputs : NVDATAMGMT_SELF_TEST_STATE_T + * Inputs : U32 (mins) + * Outputs : BOOL * @param none - * @return NVDATAMGMT_SELF_TEST_STATE_T + * @return BOOL *************************************************************************/ -static NVDATAMGMT_SELF_TEST_STATE_T handleSelfTestReadBootloaderFlag ( void ) +BOOL setTreatmentTime ( U32 mins ) { - NVDATAMGMT_SELF_TEST_STATE_T state = NVDATAMGMT_SELF_TEST_STATE_READ_BOOTLOADER_FLAG; - if ( isServiceOnEntry && getRTCRAMState() == RTC_RAM_STATE_READY ) - { - readFromRAM( BOOTLOADER_FLAG_START_ADDRESS, BOOTLOADER_FLAG_LENGTH_BYTES ); - isServiceOnEntry= FALSE; - } - if ( getRTCRAMStatus() == RTC_RAM_STATUS_IDLE ) - { - U08 i; - U32 tempValue; - getDataFromRAM( readBuffer, BOOTLOADER_FLAG_LENGTH_BYTES ); - for ( i = 0; i < BOOTLOADER_FLAG_LENGTH_BYTES; i++ ) - { - tempValue = readBuffer [ i ] << i * SHIFT_8_BITS_FOR_BYTE_SHIFT; - bootloaderFlag = bootloaderFlag + tempValue; - } - state = NVDATAMGMT_SELF_TEST_STATE_READ_LOG_RECORD; - isServiceOnEntry= TRUE; - } - return state; -} + BOOL status = FALSE; -/************************************************************************* - * @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 ) + if ( !isQueueFull() ) { - readFromRAM ( LOG_RECORD_START_ADDRESS, sizeof ( LOG_RECORD_T ) ); - isServiceOnEntry= FALSE; + enqueue( NVDATAMGMT_WRITE, NVDATAMGMT_RTC, HD_TREATMENT_TIME_ADDRESS, + (U08*)&mins, 0, sizeof(mins) ); + status = TRUE; } - if ( getRTCRAMStatus() == RTC_RAM_STATUS_IDLE ) - { - U08 i; - U08* logPtr = (U08*)&logRecord; - getDataFromRAM ( readBuffer, sizeof ( LOG_RECORD_T ) ); - for ( i = 0; i < sizeof ( LOG_RECORD_T ); i++ ) - { - *logPtr = ( readBuffer[ i ] & MASK_OFF_MSB ); - logPtr++; - } - state = NVDATAMGMT_SELF_TEST_STATE_READ_MFG_RECORDS; - isServiceOnEntry = TRUE; - } - return state; -} -/************************************************************************* - * @brief handleSelfTestReadMfgRecords - * The handleSelfTestReadMfgRecords reads the manufacturing record from - * EEPROM - * @details - * Inputs : none - * Outputs : NVDATAMGMT_SELF_TEST_STATE_T - * @param none - * @return NVDATAMGMT_SELF_TEST_STATE_T - *************************************************************************/ -static NVDATAMGMT_SELF_TEST_STATE_T handleSelfTestReadMfgRecord ( void ) -{ - NVDATAMGMT_SELF_TEST_STATE_T state = NVDATAMGMT_SELF_TEST_STATE_READ_MFG_RECORDS; - - if ( isServiceOnEntry ) - { - EEPROMStatus = Fapi_doMarginRead ( (U32*)BANK7_SECTOR0_START_ADDRESS, (U32*)readBuffer, - sizeof( MFG_DATA_T ), Fapi_NormalRead ); - isServiceOnEntry = FALSE; - } - else if ( FAPI_CHECK_FSM_READY_BUSY == Fapi_Status_FsmReady ) - { - U08 i; - for ( i = 0; i < MAX_SYS_SERIAL_NUMBER_CHARACTERS; i++ ) - { - mfgRecord.mfgData.SYSSerialNumber [ i ] = readBuffer [ i ]; - } - for ( i = 0; i < MAX_HW_SERIAL_NUMBER_CHARACTERS; i++ ) - { - mfgRecord.mfgData.HWSerialNumber [ i ] = readBuffer [ i + MAX_SYS_SERIAL_NUMBER_CHARACTERS ]; - } - for ( i = 0; i < MAX_MFG_DATE_CHARACTERS; i++ ) - { - mfgRecord.mfgData.mfgDate [ i ] = readBuffer [ i + MAX_SYS_SERIAL_NUMBER_CHARACTERS + MAX_HW_SERIAL_NUMBER_CHARACTERS ]; - } - mfgRecord.crc = ( readBuffer [ MAX_SYS_SERIAL_NUMBER_CHARACTERS + MAX_HW_SERIAL_NUMBER_CHARACTERS + MAX_MFG_DATE_CHARACTERS + 1 ] - << SHIFT_8_BITS_FOR_BYTE_SHIFT ) + - readBuffer [ MAX_SYS_SERIAL_NUMBER_CHARACTERS + MAX_HW_SERIAL_NUMBER_CHARACTERS + MAX_MFG_DATE_CHARACTERS ]; - state = NVDATAMGMT_SELF_TEST_STATE_CHECK_CRC; - isServiceOnEntry = TRUE; - } - - return state; + return status; } /************************************************************************* - * @brief handleSelfTestCheckCRC - * The handleSelfTestCheckCRC calculates the CRC of the records and compares - * them to the CRC that was read. If they don't match, it will fail POST + * @brief setLitersOfFilteredWater + * The setLitersOfFilteredWater sets a queue job to write the amount of water + * that has been consumed in DG * @details - * Inputs : none - * Outputs : NVDATAMGMT_SELF_TEST_STATE_T + * Inputs : U32 (liters) + * Outputs : BOOL * @param none - * @return NVDATAMGMT_SELF_TEST_STATE_T + * @return BOOL *************************************************************************/ -static NVDATAMGMT_SELF_TEST_STATE_T handleSelfTestCheckCRC ( void ) +BOOL setLitersOfFilteredWater ( U32 liters ) { - NVDATAMGMT_SELF_TEST_STATE_T state = NVDATAMGMT_SELF_TEST_STATE_COMPLETE; - U16 calculatedCRC = crc16 ( (U08*)&mfgRecord.mfgData, sizeof( MFG_DATA_T ) ); + BOOL status = FALSE; - if ( calculatedCRC == mfgRecord.crc ) + if ( !isQueueFull() ) { - NVDataMgmtSelfTestResult = SELF_TEST_STATUS_PASSED; + enqueue( NVDATAMGMT_WRITE, NVDATAMGMT_RTC, DG_CONSUMED_WATER_ADDRESS, + (U08*)&liters, 0, sizeof(liters) ); + status = TRUE; } - else - { - NVDataMgmtSelfTestResult = SELF_TEST_STATUS_FAILED; - } - return state; + return status; } /************************************************************************* @@ -503,21 +415,31 @@ NVDataMgmtSelfTestState = handleSelfTestStart(); break; - case NVDATAMGMT_SELF_TEST_STATE_READ_BOOTLOADER_FLAG: + case NVDATAMGMT_SELF_TEST_STATE_READ_LOG_RECORD: - NVDataMgmtSelfTestState = handleSelfTestReadBootloaderFlag(); + NVDataMgmtSelfTestState = handleSelfTestReadLogRecord(); break; - case NVDATAMGMT_SELF_TEST_STATE_READ_LOG_RECORD: + case NVDATAMGMT_SELF_TEST_STATE_READ_TREATMENT_TIME: - NVDataMgmtSelfTestState = handleSelfTestReadLogRecord(); + NVDataMgmtSelfTestState = handleSelfTestReadHDTreatmentTime(); break; - case NVDATAMGMT_SELF_TEST_STATE_READ_MFG_RECORDS: + case NVDATAMGMT_SELF_TEST_STATE_READ_WATER_CONSUMPTION: + NVDataMgmtSelfTestState = handleSelfTestReadDGWaterConsumption(); + break; + + case NVDATAMGMT_SELF_TEST_STATE_READ_MFG_RECORD: + NVDataMgmtSelfTestState = handleSelfTestReadMfgRecord(); break; + case NVDATAMGMT_SELF_TEST_STATE_READ_CAL_RECORD: + + NVDataMgmtSelfTestState = handleSelfTestReadCalibrationRecord(); + break; + case NVDATAMGMT_SELF_TEST_STATE_CHECK_CRC: NVDataMgmtSelfTestState = handleSelfTestCheckCRC(); @@ -600,6 +522,241 @@ } /************************************************************************* + * @brief handleSelfTestStart + * The handleSelfTestStart enables the EEPROM bank sectors + * @details + * Inputs : none + * Outputs : NVDATAMGMT_SELF_TEST_STATE_T + * @param none + * @return NVDATAMGMT_SELF_TEST_STATE_T + *************************************************************************/ +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 ); + isServiceOnEntry = FALSE; + } + else if ( EEPROMStatus == Fapi_Status_Success ) + { +#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; + isServiceOnEntry = TRUE; + } + return state; +} + +/************************************************************************* + * @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 handleSelfTestReadBootloaderFlag ( void ) +{ + NVDATAMGMT_SELF_TEST_STATE_T state; + + if ( isServiceOnEntry && getRTCRAMState() == RTC_RAM_STATE_READY ) + { + readFromRAM( BOOTLOADER_FLAG_ADDRESS, BOOTLOADER_FLAG_LENGTH_BYTES ); + isServiceOnEntry= FALSE; + } + if ( getRTCRAMStatus() == RTC_RAM_STATUS_IDLE ) + { + U08 i; + U32 tempValue; + getDataFromRAM( readBuffer, BOOTLOADER_FLAG_LENGTH_BYTES ); + for ( i = 0; i < BOOTLOADER_FLAG_LENGTH_BYTES; i++ ) + { + tempValue = readBuffer [ i ] << i * SHIFT_8_BITS_FOR_BYTE_SHIFT; + bootloaderFlag = bootloaderFlag + tempValue; + } + 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*)&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++ ) + { + *logPtr = ( readBuffer[ i ] & MASK_OFF_MSB ); + logPtr++; + }*/ + state = NVDATAMGMT_SELF_TEST_STATE_READ_MFG_RECORD; + isServiceOnEntry = TRUE; + } + return state; +} + +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) ); + isServiceOnEntry= FALSE; + } + if ( getRTCRAMStatus() == RTC_RAM_STATUS_IDLE ) + { + getDataFromRAM ( (U08*)&logHeader, sizeof(TREATMENT_TIME_RECORD_T) ); + state = NVDATAMGMT_SELF_TEST_STATE_READ_MFG_RECORD; + isServiceOnEntry = TRUE; + } + + return state; + +} +static NVDATAMGMT_SELF_TEST_STATE_T handleSelfTestReadDGWaterConsumption ( void ) +{ + NVDATAMGMT_SELF_TEST_STATE_T state = NVDATAMGMT_SELF_TEST_STATE_READ_WATER_CONSUMPTION; + + + return state; + +} + +/************************************************************************* + * @brief handleSelfTestReadCalibrationRecord + * The handleSelfTestReadCalibrationRecord reads the calibration record + * from EEPROM + * @details + * Inputs : none + * Outputs : NVDATAMGMT_SELF_TEST_STATE_T + * @param none + * @return NVDATAMGMT_SELF_TEST_STATE_T + *************************************************************************/ +static NVDATAMGMT_SELF_TEST_STATE_T handleSelfTestReadMfgRecord ( void ) +{ + NVDATAMGMT_SELF_TEST_STATE_T state = NVDATAMGMT_SELF_TEST_STATE_READ_MFG_RECORD; + + if ( isServiceOnEntry ) + { + EEPROMStatus = 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; + isServiceOnEntry = TRUE; + } + + return state; +} + +/************************************************************************* + * @brief handleSelfTestReadMfgRecords + * The handleSelfTestReadMfgRecords reads the manufacturing record from + * EEPROM + * @details + * Inputs : none + * Outputs : NVDATAMGMT_SELF_TEST_STATE_T + * @param none + * @return NVDATAMGMT_SELF_TEST_STATE_T + *************************************************************************/ +static NVDATAMGMT_SELF_TEST_STATE_T handleSelfTestReadCalibrationRecord ( void ) +{ + NVDATAMGMT_SELF_TEST_STATE_T state = NVDATAMGMT_SELF_TEST_STATE_READ_CAL_RECORD; + + if ( isServiceOnEntry ) + { + EEPROMStatus = Fapi_doMarginRead ( (U32*)(CAL_RECORD_START_ADDRESS ), (U32*)&calibrationRecord, + sizeof(CALIBRATION_DATA_T), Fapi_NormalRead ); + isServiceOnEntry = FALSE; + } + else if ( FAPI_CHECK_FSM_READY_BUSY == Fapi_Status_FsmReady ) + { + state = NVDATAMGMT_SELF_TEST_STATE_COMPLETE; + isServiceOnEntry = TRUE; + } + + return state; +} + +/************************************************************************* + * @brief handleSelfTestCheckCRC + * The handleSelfTestCheckCRC calculates the CRC of the records and compares + * them to the CRC that was read. If they don't match, it will fail POST + * @details + * Inputs : none + * Outputs : NVDATAMGMT_SELF_TEST_STATE_T + * @param none + * @return NVDATAMGMT_SELF_TEST_STATE_T + *************************************************************************/ +static NVDATAMGMT_SELF_TEST_STATE_T handleSelfTestCheckCRC ( void ) +{ + NVDATAMGMT_SELF_TEST_STATE_T state = NVDATAMGMT_SELF_TEST_STATE_COMPLETE; + BOOL hasCRCPassed = TRUE; + U16 calcCRC; + U16 CRC; + + 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 ) + { + hasCRCPassed = FALSE; + }*/ + + if ( hasCRCPassed ) + { + NVDataMgmtSelfTestResult = SELF_TEST_STATUS_PASSED; + } + else + { + NVDataMgmtSelfTestResult = SELF_TEST_STATUS_FAILED; + } + + return state; +} + +/************************************************************************* * @brief handleExecWaitForPostState * The handleExecWaitForPostState waits for POST to be completed * @details @@ -624,9 +781,12 @@ logData.data4 = 80.125; logData.data5 = 68; - writeLogData ( (U08*)&logData ); - //readLogData ( (U08*)&tempBufferForTest ); + mytest.status = NVDATAMGMT_READ_IDLE; + mytest.externalBuffer = readBufferForTest; + //writeLogData ( (U08*)&logData ); + readLogData ( &mytest, 5 ); + /*MFG_DATA_T test; char sys[7] = {'A', 'B', 'C', 'D', '3', '6', '7'}; char hw[5] = {'3', '4', '5', '6', '7'}; @@ -737,12 +897,15 @@ if ( isServiceOnEntry ) { EEPROMStatus = Fapi_doMarginRead ( currentJob.startAddress, - (U32*)currentJob.buffer, + (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; } else if ( FAPI_CHECK_FSM_READY_BUSY == Fapi_Status_FsmReady ) { + currentJob.externalAddress->status = NVDATAMGMT_READ_COMPLETE; state = NVDATAMGMT_EXEC_STATE_IDLE; isServiceOnEntry = TRUE; } @@ -851,7 +1014,7 @@ * @return none *************************************************************************/ static void setMemoryOpsStruct ( NVDATAMGMT_OPERATION_STATE_T ops, NVDATAMGMT_LOCATION_STATE_T location, - U32 startAddress, U08* data, U32 length ) + U32 startAddress, U08* data, READ_DATA_T* extAddress, U32 length ) { U32 myAddIndex; @@ -860,25 +1023,16 @@ if ( FALSE == isQueueFull() ) { queueCount++; - INC_WRAP( queueRearIndex, 0, QUEUE_MAX_SIZE - 1 ); + queueRearIndex = INC_WRAP( queueRearIndex, 0, QUEUE_MAX_SIZE - 1 ); } _enable_IRQ(); jobQueue [ myAddIndex ].memoryOperation = ops; jobQueue [ myAddIndex ].memoryLocation = location; jobQueue [ myAddIndex ].startAddress = (U32*)startAddress; jobQueue [ myAddIndex ].length = length; + jobQueue [ myAddIndex ].externalAddress = extAddress; memcpy ( jobQueue [ myAddIndex ].buffer, data, length ); - -// if ( !isQueueFull() ) -// { -// queueRearIndex++; -// } -// else -// { -// queueRearIndex = QUEUE_START_INDEX; -// } -// queueCount++; } /************************************************************************* @@ -898,13 +1052,13 @@ U32 modulus = 0; U32 opsStartAddress = 0; U16 readIndexChange = 0; - U16 writeIndexChange = 1; + U16 writeIndexChange = 0; U16 recordCountChange = 1; // 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 = ( logRecord.nextWriteIndex * MAX_JOB_DATA_SIZE_BYTES ) + BANK7_SECTOR1_START_ADDRESS; - modulus = logRecord.nextWriteIndex % MAX_LOG_DATA_PER_SECTOR; + opsStartAddress = ( logHeader.nextWriteIndex * MAX_JOB_DATA_SIZE_BYTES ) + BANK7_SECTOR1_START_ADDRESS; + modulus = logHeader.nextWriteIndex % MAX_LOG_DATA_PER_SECTOR; // Modulus is 0 so it is at any of the edges if ( modulus == 0 ) @@ -913,84 +1067,20 @@ // 1. set readIndexChange = +512 // 2. set recordCountchange = -512 readIndexChange = MAX_LOG_DATA_PER_SECTOR; - logRecord.recordCount = logRecord.recordCount - MAX_LOG_DATA_PER_SECTOR; + logHeader.recordCount = logHeader.recordCount - MAX_LOG_DATA_PER_SECTOR; - // Start of sector 1 - /*if ( writeIndex == 0 ) - { - opsStartAddress = BANK7_SECTOR1_START_ADDRESS; - writeIndexChange++; - recordCountChange++; - // Sector 1 will be erased so if the read index is somewhere is - // sector 1(0 MAX_NUM_OF_DATA_LOGS_IN_SECTOR1 && - readIndex <= MAX_NUM_OF_DATA_LOGS_IN_SECTOR2 ) - { - readIndexChange = MAX_NUM_OF_DATA_LOGS_IN_SECTOR2 + 1; - } - } - // End of sector 2 - else if ( writeIndex == MAX_NUM_OF_DATA_LOGS_IN_SECTOR2 ) - { - // Moving to sector 3 - opsStartAddress = BANK7_SECTOR3_START_ADDRESS; - // Record will be 1024 as the maximum number of logs - // in sector 2. All the logs in sector 3 will be erased - recordCountChange = MAX_NUM_OF_DATA_LOGS_IN_SECTOR2; - writeIndex++; - // If the readIndex is (1024 MAX_NUM_OF_DATA_LOGS_IN_SECTOR2 && - readIndex <= MAX_NUM_OF_DATA_LOGS_IN_SECTOR3 ) - { - readIndexChange = 0; - } - } - // End of sector 3 - else if ( writeIndex == MAX_NUM_OF_DATA_LOGS_IN_SECTOR3 ) - { - // Moving to sector 1 - opsStartAddress = BANK7_SECTOR1_START_ADDRESS; - // Changing the record count to 2 full sectors (1024) - recordCountChange = MAX_NUM_OF_DATA_LOGS_IN_SECTOR2; - // writeIndex will be put at the beginning of sector 1 - writeIndex = 0; - // If the readIndex is somewhere is sector 1 (0= MAX_NUM_OF_DATA_LOGS_IN_SECTOR3 - 1 ) - { - - logRecord.nextReadIndex = LOG_DATA_START_INDEX; - } - else - { - logRecord.nextReadIndex++; - }*/ // Update the log record setMemoryOpsStruct ( NVDATAMGMT_WRITE, NVDATAMGMT_RTC, LOG_RECORD_START_ADDRESS, - (U08*)&logRecord, sizeof( LOG_RECORD_T ) ); + (U08*)&logHeader, 0, sizeof( LOG_HEADER_T ) ); return opsStartAddress; } @@ -1044,7 +1126,7 @@ * @return none *************************************************************************/ static void enqueue ( NVDATAMGMT_OPERATION_STATE_T ops, NVDATAMGMT_LOCATION_STATE_T location, - U32 startAddress, U08* data, U32 length ) + U32 startAddress, U08* data, READ_DATA_T* extAddress, U32 length ) { U32 quotient = 0; U32 modulus = 0; @@ -1064,7 +1146,7 @@ // Setup EEPROM read log event else if ( ops == NVDATAMGMT_READ && location == NVDATAMGMT_EEPROM ) { - maxBufferLength = MAX_JOB_DATA_SIZE_BYTES; + //maxBufferLength = MAX_JOB_DATA_SIZE_BYTES; if ( startAddress == 0 ) { opsStartAddress = prepareReadLogJobAndGetStartAddress(); @@ -1081,18 +1163,18 @@ for ( i = 0; i < quotient; i++ ) { setMemoryOpsStruct ( ops, location, ( opsStartAddress + ( i * maxBufferLength ) ), - data + ( i * maxBufferLength ), maxBufferLength ); + data + ( i * maxBufferLength ), extAddress, maxBufferLength ); } if ( modulus != 0 ) { setMemoryOpsStruct ( ops, location, ( opsStartAddress + ( quotient * maxBufferLength ) ), - data + ( quotient * maxBufferLength ), modulus ); + data + ( quotient * maxBufferLength ), extAddress, modulus ); } } // The length is less than maximum specified, normal operations else { - setMemoryOpsStruct ( ops, location, opsStartAddress, data, length ); + setMemoryOpsStruct ( ops, location, opsStartAddress, data, extAddress, length ); } } @@ -1108,16 +1190,18 @@ *************************************************************************/ static void dequeue ( void ) { - currentJob = jobQueue [ queueFrontIndex ]; + U32 tempIndex; - if ( queueFrontIndex >= QUEUE_MAX_SIZE - 1 ) + _disable_IRQ(); + tempIndex = queueFrontIndex; + if ( FALSE == isQueueFull() ) { - queueFrontIndex = QUEUE_START_INDEX; + queueFrontIndex = INC_WRAP( queueFrontIndex, 0, QUEUE_MAX_SIZE - 1 ); } - else - { - queueFrontIndex++; - } + _enable_IRQ(); + + currentJob = jobQueue [ tempIndex ]; + if ( queueCount > 0 ) { queueCount--; Index: NVDataMgmt.h =================================================================== diff -u -r0170e69752974589e2f3c3507d3fb0ebd771bd89 -r6d7fa72cf0e2a9d6d61b59682ab261826100562e --- NVDataMgmt.h (.../NVDataMgmt.h) (revision 0170e69752974589e2f3c3507d3fb0ebd771bd89) +++ NVDataMgmt.h (.../NVDataMgmt.h) (revision 6d7fa72cf0e2a9d6d61b59682ab261826100562e) @@ -34,13 +34,32 @@ NVDATAMGMT_UI_CRASHED } NVDATAMGMT_LOG_EVENT_T; +typedef enum READ_STATUS +{ + NVDATAMGMT_READ_IDLE = 0, + NVDATAMGMT_READ_IN_PROGRESS, + NVDATAMGMT_READ_COMPLETE +} NVDATAMGMT_READ_STATUS_T; + #pragma pack(push, 1) typedef struct mfg_Data { char SYSSerialNumber [ MAX_SYS_SERIAL_NUMBER_CHARACTERS ]; char HWSerialNumber [ MAX_HW_SERIAL_NUMBER_CHARACTERS ]; char mfgDate [ MAX_MFG_DATE_CHARACTERS ]; } MFG_DATA_T; + +typedef struct calibcation_Data +{ + F32 occSensorOffset; + F32 tempSensorOffset; +} CALIBRATION_DATA_T; + +typedef struct get_data +{ + NVDATAMGMT_READ_STATUS_T status; + U08* externalBuffer; +} READ_DATA_T; #pragma pack(pop) void initNVDataMgmt ( void ); @@ -57,10 +76,12 @@ BOOL setTreatmentTime ( U32 mins ); -BOOL setLitersOfFilteredWater ( U32 liter ); +U32 getTreatmentTime ( void ); +BOOL setLitersOfFilteredWater ( U32 liters ); + BOOL writeLogData ( U08* data ); -BOOL readLogData ( U08* buffer ); +BOOL readLogData ( READ_DATA_T* buffer, U32 length ); #endif /* FWCOMMON_NVDATAMGMT_H_ */