#include <string.h>\r
#include "Dem.h"\r
//#include "Fim.h"\r
-//#include "NvM.h"\r
+#include "NvM.h"\r
//#include "SchM_Dem.h"\r
#include "MemMap.h"\r
#include "Cpu.h"\r
+#include "DEM_Types.h"\r
+#include "DEM_Lcfg.h"\r
\r
+#define USE_DEBUG_PRINTF\r
+#include "debug.h"\r
/*\r
* Local defines\r
*/\r
* Local types\r
*/\r
\r
-typedef uint16 ChecksumType;\r
-\r
// DtcFilterType\r
typedef struct {\r
Dem_EventStatusExtendedType dtcStatusMask;\r
boolean errorStatusChanged;\r
} EventStatusRecType;\r
\r
-\r
-// Types for storing different event data on event memory\r
+// Types for storing different event aging counter\r
typedef struct {\r
Dem_EventIdType eventId;\r
- uint16 occurrence;\r
+ uint8 agingCounter;/** @req Dem019 */\r
ChecksumType checksum;\r
-} EventRecType;\r
+} AgingRecType;\r
\r
-//lint -save -e43 //PC-Lint misunderstanding: Array of size 0 is OK.\r
+// Types for storing different event data on event memory\r
typedef struct {\r
- Dem_EventIdType eventId;\r
- uint16 occurrence;\r
- uint16 dataSize;\r
- sint8 data[DEM_MAX_SIZE_FF_DATA];\r
- ChecksumType checksum;\r
-} FreezeFrameRecType;\r
-//lint -restore\r
+ Dem_EventIdType eventId;\r
+ uint16 occurrence;\r
+ Dem_EventStatusExtendedType eventStatusExtended;\r
+ ChecksumType checksum;\r
+} EventRecType;\r
\r
typedef struct {\r
Dem_EventIdType eventId;\r
* Allocation of primary event memory ramlog (after init) in uninitialized memory\r
*/\r
/** @req DEM162 */\r
-static EventRecType priMemEventBuffer[DEM_MAX_NUMBER_EVENT_PRI_MEM] __attribute__ ((section (".dem_eventmemory_pri")));\r
+EventRecType priMemEventBuffer[DEM_MAX_NUMBER_EVENT_PRI_MEM] __attribute__ ((section (".dem_eventmemory_pri")));\r
static FreezeFrameRecType priMemFreezeFrameBuffer[DEM_MAX_NUMBER_FF_DATA_PRI_MEM] __attribute__ ((section (".dem_eventmemory_pri")));\r
+//FreezeFrameRecType FreezeFrameMirrorBuffer[DEM_MAX_NUMBER_FF_DATA_PRI_MEM] __attribute__ ((section (".dem_eventmemory_pri")));\r
+extern FreezeFrameRecType* FreezeFrameMirrorBuffer[];\r
static ExtDataRecType priMemExtDataBuffer[DEM_MAX_NUMBER_EXT_DATA_PRI_MEM] __attribute__ ((section (".dem_eventmemory_pri")));\r
+AgingRecType priMemAgingBuffer[DEM_MAX_NUMBER_AGING_PRI_MEM] __attribute__ ((section (".dem_eventmemory_pri")));\r
+AgingRecType AgingMirrorBuffer[DEM_MAX_NUMBER_AGING_PRI_MEM] __attribute__ ((section (".dem_eventmemory_pri")));\r
+/*\r
+*Allocation of freezeFrame storage timestamp,record the time order\r
+*/\r
+/**private variable for freezeframe */\r
+static uint32 FF_TimeStamp = 0;\r
\r
+/*\r
+ * TRUE: priMemFreezeFrameBuffer changed,\r
+ * FALSE: priMemFreezeFrameBuffer not changed\r
+ */\r
+static boolean FFIsModified = FALSE;\r
+\r
+/*\r
+ * TRUE: priMemAgingBuffer changed,\r
+ * FALSE: priMemAgingBuffer not changed\r
+ */\r
+static boolean AgingIsModified = FALSE;\r
\r
/*\r
* Procedure: zeroPriMemBuffers\r
{\r
const Dem_EventParameterType *EventIdParamList = configSet->EventParameter;\r
\r
- // Lookup the correct event id parameters\r
+ /* Lookup the correct event id parameters */\r
uint16 i=0;\r
while ((EventIdParamList[i].EventID != eventId) && (!EventIdParamList[i].Arc_EOL)) {\r
i++;\r
static void updateEventStatusRec(const Dem_EventParameterType *eventParam, Dem_EventStatusType eventStatus, boolean createIfNotExist, EventStatusRecType *eventStatusRec)\r
{\r
EventStatusRecType *eventStatusRecPtr;\r
+ sint8 faultCounterBeforeDebounce = 0;\r
+ sint8 faultCounterAfterDebounce = 0;\r
imask_t state;\r
Irq_Save(state);\r
\r
- // Lookup event ID\r
lookupEventStatusRec(eventParam->EventID, &eventStatusRecPtr);\r
\r
if ((eventStatusRecPtr == NULL) && (createIfNotExist)) {\r
- // Search for free position\r
lookupEventStatusRec(DEM_EVENT_ID_NULL, &eventStatusRecPtr);\r
-\r
if (eventStatusRecPtr != NULL) {\r
- // Create new event record\r
eventStatusRecPtr->eventId = eventParam->EventID;\r
eventStatusRecPtr->eventParamRef = eventParam;\r
eventStatusRecPtr->faultDetectionCounter = 0;\r
eventStatusRecPtr->errorStatusChanged = FALSE;\r
}\r
else {\r
- // Error: Event status buffer full\r
DET_REPORTERROR(MODULE_ID_DEM, 0, DEM_UPDATE_EVENT_STATUS_ID, DEM_E_EVENT_STATUS_BUFF_FULL);\r
}\r
}\r
\r
\r
if (eventStatusRecPtr != NULL) {\r
- // Handle debouncing\r
+ faultCounterBeforeDebounce = eventStatusRecPtr->faultDetectionCounter;\r
+\r
if (eventParam->EventClass->PreDebounceAlgorithmClass != NULL) {\r
switch (eventParam->EventClass->PreDebounceAlgorithmClass->PreDebounceName) { /** @req DEM004 */ /** @req DEM342 */\r
case DEM_NO_PRE_DEBOUNCE:\r
break;\r
\r
default:\r
- // Don't know how to handle this.\r
DET_REPORTERROR(MODULE_ID_DEM, 0, DEM_UPDATE_EVENT_STATUS_ID, DEM_E_NOT_IMPLEMENTED_YET);\r
break;\r
}\r
}\r
-\r
+ faultCounterAfterDebounce = eventStatusRecPtr->faultDetectionCounter;\r
+ \r
eventStatusRecPtr->errorStatusChanged = FALSE;\r
\r
- // Check test failed\r
if (eventStatus == DEM_EVENT_STATUS_FAILED) {\r
if (!(eventStatusRecPtr->eventStatusExtended & DEM_TEST_FAILED)) {\r
eventStatusRecPtr->occurrence++;\r
eventStatusRecPtr->errorStatusChanged = TRUE;\r
}\r
/** @req DEM036 */ /** @req DEM379.PendingSet */\r
- eventStatusRecPtr->eventStatusExtended |= (DEM_TEST_FAILED | DEM_TEST_FAILED_THIS_OPERATION_CYCLE | DEM_TEST_FAILED_SINCE_LAST_CLEAR | DEM_PENDING_DTC);\r
+ eventStatusRecPtr->eventStatusExtended |= (DEM_TEST_FAILED | DEM_TEST_FAILED_THIS_OPERATION_CYCLE | DEM_TEST_FAILED_SINCE_LAST_CLEAR | DEM_PENDING_DTC | DEM_CONFIRMED_DTC);\r
eventStatusRecPtr->eventStatusExtended &= (Dem_EventStatusExtendedType)~(DEM_TEST_NOT_COMPLETED_SINCE_LAST_CLEAR | DEM_TEST_NOT_COMPLETED_THIS_OPERATION_CYCLE);\r
}\r
\r
- // Check test passed\r
if (eventStatus == DEM_EVENT_STATUS_PASSED) {\r
if (eventStatusRecPtr->eventStatusExtended & DEM_TEST_FAILED) {\r
eventStatusRecPtr->errorStatusChanged = TRUE;\r
eventStatusRecPtr->eventStatusExtended &= (Dem_EventStatusExtendedType)~(DEM_TEST_NOT_COMPLETED_SINCE_LAST_CLEAR | DEM_TEST_NOT_COMPLETED_THIS_OPERATION_CYCLE);\r
}\r
\r
- // Copy the record\r
+ if ((eventStatus == DEM_EVENT_STATUS_PREFAILED)\\r
+ && (faultCounterBeforeDebounce <= 0) && (faultCounterAfterDebounce > 0)){\r
+ eventStatusRecPtr->errorStatusChanged = TRUE;\r
+ }\r
+\r
memcpy(eventStatusRec, eventStatusRecPtr, sizeof(EventStatusRecType));\r
}\r
else {\r
- // Copy an empty record to return data\r
eventStatusRec->eventId = DEM_EVENT_ID_NULL;\r
eventStatusRec->faultDetectionCounter = 0;\r
eventStatusRec->occurrence = 0;\r
lookupEventStatusRec(eventRec->eventId, &eventStatusRecPtr);\r
\r
if (eventStatusRecPtr != NULL) {\r
- // Update occurrence counter, rest of pre init state is kept.\r
+ // Update occurrence counter.\r
eventStatusRecPtr->occurrence += eventRec->occurrence;\r
+ // Merge event status extended with stored\r
+ // TEST_FAILED_SINCE_LAST_CLEAR should be set if set if set in either\r
+ eventStatusRecPtr->eventStatusExtended |= (Dem_EventStatusExtendedType)(eventRec->eventStatusExtended & DEM_TEST_FAILED_SINCE_LAST_CLEAR);\r
+ // DEM_TEST_NOT_COMPLETED_SINCE_LAST_CLEAR should cleared if cleared in either\r
+ eventStatusRecPtr->eventStatusExtended |= (Dem_EventStatusExtendedType)(eventRec->eventStatusExtended & eventStatusRecPtr->eventStatusExtended & DEM_TEST_NOT_COMPLETED_SINCE_LAST_CLEAR);\r
+ // DEM_PENDING_DTC and DEM_CONFIRMED_DTC should be set if set in either\r
+ eventStatusRecPtr->eventStatusExtended |= (Dem_EventStatusExtendedType)(eventRec->eventStatusExtended & (DEM_PENDING_DTC | DEM_CONFIRMED_DTC));\r
\r
}\r
else {\r
imask_t state;\r
Irq_Save(state);\r
\r
- // Lookup event ID\r
lookupEventStatusRec(eventParam->EventID, &eventStatusRecPtr);\r
\r
if (eventStatusRecPtr != NULL) {\r
- // Delete event record\r
memset(eventStatusRecPtr, 0, sizeof(EventStatusRecType));\r
}\r
\r
Irq_Restore(state);\r
}\r
\r
+/*\r
+ * Procedure: resetEventStatusRec\r
+ * Description: Reset the status record of "eventParam->eventId" from "eventStatusBuffer".\r
+ */\r
+static void resetEventStatusRec(const Dem_EventParameterType *eventParam)\r
+{\r
+ EventStatusRecType *eventStatusRecPtr;\r
+ imask_t state;\r
+ Irq_Save(state);\r
+\r
+ // Lookup event ID\r
+ lookupEventStatusRec(eventParam->EventID, &eventStatusRecPtr);\r
+\r
+ if (eventStatusRecPtr != NULL) {\r
+ // Reset event record\r
+ eventStatusRecPtr->faultDetectionCounter = 0;\r
+ eventStatusRecPtr->eventStatusExtended = (DEM_TEST_NOT_COMPLETED_THIS_OPERATION_CYCLE | DEM_TEST_NOT_COMPLETED_SINCE_LAST_CLEAR);\r
+ eventStatusRecPtr->errorStatusChanged = FALSE;\r
+ eventStatusRecPtr->occurrence = 0;\r
+ }\r
+\r
+ Irq_Restore(state);\r
+}\r
\r
/*\r
* Procedure: getEventStatusRec\r
\r
return dtcMatch;\r
}\r
+/*\r
+ * Procedure: bubbleSort\r
+ * Description: bubble sort\r
+ */\r
+static void bubbleSort(FreezeFrameRecType *freezeFrameBuf, uint16 length)\r
+{\r
+ FreezeFrameRecType temp;\r
+ uint16 i = 0;\r
+ uint16 j = 0;\r
+\r
+ //Bubble sort:rearrange priMemFreezeFrameBuffer from little to big\r
+ for(i=0;i<length;i++){\r
+ for(j=length-1; j > i; j--){\r
+ if(freezeFrameBuf[i].timeStamp > freezeFrameBuf[j].timeStamp){\r
+ //exchange buffer data\r
+ memcpy(&temp,&freezeFrameBuf[i],sizeof(FreezeFrameRecType));\r
+ memcpy(&freezeFrameBuf[i],&freezeFrameBuf[j],sizeof(FreezeFrameRecType));\r
+ memcpy(&freezeFrameBuf[j],&temp,sizeof(FreezeFrameRecType)); \r
+ }\r
+ }\r
+ }\r
\r
+}\r
\r
-// PC-Lint (715 etc): Remove errors until function is filled.\r
-//lint -e{715} Symbol not referenced\r
-static void getFreezeFrameData(const Dem_EventParameterType *eventParam, FreezeFrameRecType *freezeFrame)\r
+/*\r
+ * Procedure: retrieveEventStatusBit\r
+ * Description: retrieve Event Status Bit\r
+ */\r
+static boolean retrieveEventStatusBit(FreezeFrameRecType *freezeFrameBuf, \r
+ uint16 length , \r
+ Dem_EventStatusExtendedType nBit, \r
+ FreezeFrameRecType **freezeFrame)\r
{\r
- // TODO: Fill out\r
- freezeFrame->eventId = DEM_EVENT_ID_NULL; // Not supported yet\r
+ boolean freezeFrameFound = FALSE;\r
+ uint16 i = 0;\r
+ uint16 j = 0;\r
+\r
+ for(i=0;i<length;i++){\r
+ for(j=0; (j < DEM_MAX_NUMBER_EVENT) && (!freezeFrameFound); j++){\r
+ freezeFrameFound = (eventStatusBuffer[j].eventId == freezeFrameBuf[i].eventId)\\r
+ && (!(eventStatusBuffer[j].eventStatusExtended & nBit));\r
+ if(freezeFrameFound == TRUE){\r
+ *freezeFrame = &freezeFrameBuf[i];\r
+ }\r
+ } \r
+ }\r
+\r
+ return freezeFrameFound;\r
+\r
}\r
\r
+/*\r
+ * Procedure: lookupFreezeFrameForDisplacementPreInit\r
+ * Description: implement displacement strategy preinit:1.find out the oldest "not confirmed" DTC\r
+ * 2.find out the oldest inactive DTC,inactive:testFailed is not set\r
+ * 3.find ou the oldest active DTC,active:testFailed is set\r
+ */\r
+static boolean lookupFreezeFrameForDisplacementPreInit(FreezeFrameRecType **freezeFrame)\r
+{\r
+ boolean freezeFrameFound = FALSE;\r
+ \r
+ /* Bubble sort:rearrange priMemFreezeFrameBuffer from little to big */\r
+ bubbleSort(preInitFreezeFrameBuffer, DEM_MAX_NUMBER_FF_DATA_PRE_INIT);\r
+\r
+ /* find out the oldest not confirmed dtc */\r
+ freezeFrameFound = retrieveEventStatusBit(preInitFreezeFrameBuffer, DEM_MAX_NUMBER_FF_DATA_PRE_INIT, DEM_CONFIRMED_DTC, freezeFrame);\r
\r
-// PC-Lint (715 etc): Remove errors until function is filled.\r
-//lint -e{715} Symbol not referenced\r
+ /* if all confirmed,lookup the oldest inactive dtc */\r
+ if(freezeFrameFound == FALSE){\r
+ freezeFrameFound = retrieveEventStatusBit(preInitFreezeFrameBuffer, DEM_MAX_NUMBER_FF_DATA_PRE_INIT, DEM_TEST_FAILED, freezeFrame);\r
+ }\r
+ \r
+ /* if all confirmed,lookup the oldest active dtc */\r
+ if(freezeFrameFound == FALSE){\r
+ *freezeFrame = &preInitFreezeFrameBuffer[0];\r
+ freezeFrameFound = TRUE;\r
+ } \r
+\r
+ return freezeFrameFound;\r
+}\r
+\r
+/*\r
+ * Procedure: lookupFreezeFrameForDisplacement\r
+ * Description: implement displacement strategy:1.find out the oldest "not confirmed" DTC\r
+ * 2.find out the oldest inactive DTC,inactive:testFailed is not set\r
+ * 3.find ou the oldest active DTC,active:testFailed is set\r
+ */\r
+static boolean lookupFreezeFrameForDisplacement(FreezeFrameRecType **freezeFrame)\r
+{\r
+ boolean freezeFrameFound = FALSE;\r
+ \r
+ bubbleSort(priMemFreezeFrameBuffer, DEM_MAX_NUMBER_FF_DATA_PRI_MEM);\r
+\r
+ /* Find out the oldest not confirmed dtc */\r
+ freezeFrameFound = retrieveEventStatusBit(priMemFreezeFrameBuffer, DEM_MAX_NUMBER_FF_DATA_PRI_MEM, DEM_CONFIRMED_DTC, freezeFrame);\r
+\r
+ /* If all confirmed, lookup the oldest inactive dtc */\r
+ if(freezeFrameFound == FALSE){\r
+ freezeFrameFound = retrieveEventStatusBit(priMemFreezeFrameBuffer, DEM_MAX_NUMBER_FF_DATA_PRI_MEM, DEM_TEST_FAILED, freezeFrame);\r
+ }\r
+\r
+ /* If all confirmed,lookup the oldest active dtc */\r
+ if(freezeFrameFound == FALSE){ \r
+ *freezeFrame = &priMemFreezeFrameBuffer[0];\r
+ freezeFrameFound = TRUE; \r
+ }\r
+\r
+ return freezeFrameFound;\r
+}\r
+/*\r
+ * Procedure: rearrangeFreezeFrameTimeStamp\r
+ * Description: rearrange FF timestamp when timestamp is beyond DEM_MAX_TIMESTAMP_FOR_REARRANGEMENT \r
+ */\r
+static void rearrangeFreezeFrameTimeStamp(uint32 *timeStamp)\r
+{\r
+ FreezeFrameRecType temp;\r
+ uint32 i = 0;\r
+ uint32 j = 0;\r
+ uint32 k = 0;\r
+ \r
+ /* Bubble sort:rearrange priMemFreezeFrameBuffer from little to big */\r
+ for(i=0;i<DEM_MAX_NUMBER_FF_DATA_PRI_MEM;i++){\r
+ if(priMemFreezeFrameBuffer[i].eventId != DEM_EVENT_ID_NULL){\r
+ for(j=DEM_MAX_NUMBER_FF_DATA_PRI_MEM-1; j > i; j--){\r
+ if(priMemFreezeFrameBuffer[j].eventId != DEM_EVENT_ID_NULL){\r
+ if(priMemFreezeFrameBuffer[i].timeStamp > priMemFreezeFrameBuffer[j].timeStamp){\r
+ //exchange buffer data\r
+ memcpy(&temp,&priMemFreezeFrameBuffer[i],sizeof(FreezeFrameRecType));\r
+ memcpy(&priMemFreezeFrameBuffer[i],&priMemFreezeFrameBuffer[j],sizeof(FreezeFrameRecType));\r
+ memcpy(&priMemFreezeFrameBuffer[j],&temp,sizeof(FreezeFrameRecType)); \r
+ }\r
+\r
+ }\r
+ \r
+ }\r
+ priMemFreezeFrameBuffer[i].timeStamp = k++;\r
+ }\r
+ \r
+ }\r
+ /* update the current timeStamp */\r
+ *timeStamp = k;\r
+\r
+}\r
+/*\r
+ * Procedure: getFreezeFrameData\r
+ * Description: get FF data according configuration \r
+ */\r
+static void getFreezeFrameData(const Dem_EventParameterType *eventParam, \r
+ FreezeFrameRecType *freezeFrame,\r
+ Dem_EventStatusType eventStatus,\r
+ EventStatusRecType *eventStatusRec)\r
+{\r
+ Dem_FreezeFrameStorageConditonType prefailedOrFailed;\r
+ Std_ReturnType callbackReturnCode;\r
+ uint16 i = 0;\r
+ uint16 storeIndex = 0;\r
+ uint16 recordSize = 0;\r
+ imask_t state;\r
+ const Dem_FreezeFrameClassType *FreezeFrameLocal = NULL;\r
+ Dcm_NegativeResponseCodeType errorCode;//should include Dcm_Lcfg.h\r
+\r
+ /* clear FF data record */\r
+ memset(freezeFrame, 0, sizeof(FreezeFrameRecType ));\r
+\r
+ /* check if prefailed or failed */\r
+ if(eventStatusRec->eventStatusExtended & DEM_TEST_FAILED){\r
+ prefailedOrFailed = FAILED;//confirm the FF is stored for failed\r
+\r
+ }\r
+ else{\r
+ if(eventStatus == DEM_EVENT_STATUS_PREFAILED){\r
+ prefailedOrFailed = PREFAILED;//confirm the FF is stored for prefailed\r
+ }\r
+ else{\r
+ prefailedOrFailed = FF_STORAGE_CONDITION_WRONG;\r
+ freezeFrame->eventId = DEM_EVENT_ID_NULL;\r
+ return;\r
+ }\r
+ }\r
+\r
+ /* Find out the corresponding FF class */\r
+ for(i = 0;(i<DEM_MAX_NR_OF_CLASSES_IN_FREEZEFRAME_DATA) && (eventParam->FreezeFrameClassRef[i] != NULL);i++){\r
+ if(eventParam->FreezeFrameClassRef[i]->FFStorageConditon == prefailedOrFailed){\r
+ FreezeFrameLocal = eventParam->FreezeFrameClassRef[i];\r
+ break;\r
+ }\r
+ }\r
+ /* get the dids */\r
+ if(FreezeFrameLocal != NULL){\r
+ if(FreezeFrameLocal->FFIdClassRef != NULL){\r
+ for (i = 0; (i < DEM_MAX_NR_OF_RECORDS_IN_FREEZEFRAME_DATA) && (!(FreezeFrameLocal->FFIdClassRef[i].Arc_EOL)); i++) {\r
+ if(FreezeFrameLocal->FFIdClassRef[i].PidOrDidUsePort == FALSE){\r
+ if(FreezeFrameLocal->FFIdClassRef[i].DidReadDataLengthFnc != NULL){\r
+ callbackReturnCode = FreezeFrameLocal->FFIdClassRef[i].DidReadDataLengthFnc(&recordSize);\r
+ if(callbackReturnCode != E_OK){\r
+ //if fail to read data length,discard the storage of FF\r
+ freezeFrame->eventId = DEM_EVENT_ID_NULL;\r
+ DET_REPORTERROR(MODULE_ID_DEM, 0, DEM_GET_FREEZEFRAME_ID, DEM_READ_DATA_LENGTH_FAILED);\r
+ return;\r
+ }\r
+ }\r
+ /* if no readDidDataLengthFunction, then try the PidOrDidSize. */\r
+ else{\r
+ recordSize = FreezeFrameLocal->FFIdClassRef[i].PidOrDidSize;\r
+ }\r
+ /* read out the did data */\r
+ if ((storeIndex + recordSize + DEM_DID_IDENTIFIER_SIZE_OF_BYTES) <= DEM_MAX_SIZE_FF_DATA) {\r
+ /* store DID */\r
+ freezeFrame->data[storeIndex] = (FreezeFrameLocal->FFIdClassRef[i].DidIdentifier>> 8) & 0xFFu;\r
+ storeIndex++;\r
+ freezeFrame->data[storeIndex] = FreezeFrameLocal->FFIdClassRef[i].DidIdentifier & 0xFFu;\r
+ storeIndex++;\r
+ /* store data */\r
+ if(FreezeFrameLocal->FFIdClassRef[i].DidConditionCheckReadFnc != NULL){\r
+ callbackReturnCode = FreezeFrameLocal->FFIdClassRef[i].DidConditionCheckReadFnc(&errorCode);\r
+ if ((callbackReturnCode == E_OK) && (errorCode == DCM_E_POSITIVERESPONSE)) {\r
+ if(FreezeFrameLocal->FFIdClassRef[i].DidReadFnc!= NULL){\r
+ callbackReturnCode = FreezeFrameLocal->FFIdClassRef[i].DidReadFnc(&freezeFrame->data[storeIndex]);\r
+ if (callbackReturnCode != E_OK) {\r
+ memset(&freezeFrame->data[storeIndex], DEM_FREEZEFRAME_DEFAULT_VALUE, recordSize);\r
+ }\r
+ storeIndex += recordSize;\r
+\r
+ }\r
+ else{\r
+ memset(&freezeFrame->data[storeIndex], DEM_FREEZEFRAME_DEFAULT_VALUE, recordSize);\r
+ storeIndex += recordSize;\r
+ }\r
+\r
+ }\r
+ else{\r
+ memset(&freezeFrame->data[storeIndex], DEM_FREEZEFRAME_DEFAULT_VALUE, recordSize);\r
+ storeIndex += recordSize;\r
+ }\r
+ }\r
+ else{\r
+ memset(&freezeFrame->data[storeIndex], DEM_FREEZEFRAME_DEFAULT_VALUE, recordSize);\r
+ storeIndex += recordSize;\r
+ }\r
+\r
+ }\r
+ else{\r
+ DET_REPORTERROR(MODULE_ID_DEM, 0, DEM_GET_FREEZEFRAME_ID, DEM_E_FF_TOO_BIG);\r
+ break;\r
+ } \r
+ }\r
+ else{\r
+ //TODO:RTE should provide the port\r
+ DET_REPORTERROR(MODULE_ID_DEM, 0, DEM_GET_FREEZEFRAME_ID, DEM_DSP_DID_USE_PORT_IS_TRUE);\r
+ }\r
+ } \r
+ }\r
+\r
+ }\r
+ else{\r
+ /* create an empty FF */\r
+ freezeFrame->eventId = DEM_EVENT_ID_NULL;\r
+ }\r
+\r
+ /* Check if any data has been stored */\r
+ if (storeIndex != 0) {\r
+ freezeFrame->eventId = eventParam->EventID;\r
+ freezeFrame->occurrence = eventStatusRec->occurrence;\r
+ freezeFrame->dataSize = storeIndex;\r
+ freezeFrame->recordNumber = FreezeFrameLocal->FFRecordNumber;\r
+ Irq_Save(state);\r
+\r
+ if(FF_TimeStamp > DEM_MAX_TIMESTAMP_FOR_REARRANGEMENT){\r
+ rearrangeFreezeFrameTimeStamp(&FF_TimeStamp);\r
+ }\r
+ \r
+ freezeFrame->timeStamp = FF_TimeStamp;\r
+\r
+ FF_TimeStamp++;\r
+\r
+ Irq_Restore(state);\r
+\r
+ freezeFrame->checksum = calcChecksum(freezeFrame, sizeof(FreezeFrameRecType)-sizeof(ChecksumType));\r
+ }\r
+ else{\r
+ freezeFrame->eventId = DEM_EVENT_ID_NULL;\r
+ freezeFrame->dataSize = storeIndex;\r
+ freezeFrame->checksum = 0;\r
+ } \r
+}\r
+\r
+\r
+/*\r
+ * Procedure: storeFreezeFrameDataPreInit\r
+ * Description: store FF in before preInitFreezeFrameBuffer DEM's full initialization \r
+ */\r
static void storeFreezeFrameDataPreInit(const Dem_EventParameterType *eventParam, const FreezeFrameRecType *freezeFrame)\r
{\r
- // TODO: Fill out\r
+ boolean eventIdFound = FALSE;\r
+ boolean eventIdFreePositionFound=FALSE;\r
+ FreezeFrameRecType *freezeFrameLocal = NULL;\r
+ uint16 i;\r
+ imask_t state;\r
+\r
+ Irq_Save(state);\r
+\r
+ /* Check if already stored */\r
+ for (i = 0; (i<DEM_MAX_NUMBER_FF_DATA_PRE_INIT) && (!eventIdFound); i++){\r
+ eventIdFound = ((preInitFreezeFrameBuffer[i].eventId == eventParam->EventID) && (preInitFreezeFrameBuffer[i].recordNumber== freezeFrame->recordNumber));\r
+ }\r
+\r
+ if(eventIdFound){\r
+ /* overwrite existing */\r
+ memcpy(&preInitFreezeFrameBuffer[i-1], freezeFrame, sizeof(FreezeFrameRecType));\r
+ }\r
+ else{\r
+ /* lookup first free position */\r
+ for (i = 0; (i<DEM_MAX_NUMBER_FF_DATA_PRE_INIT) && (!eventIdFreePositionFound); i++){\r
+ if(preInitFreezeFrameBuffer[i].eventId == DEM_EVENT_ID_NULL){\r
+ eventIdFreePositionFound=TRUE;\r
+ }\r
+ }\r
+\r
+ if (eventIdFreePositionFound) {\r
+ memcpy(&preInitFreezeFrameBuffer[i-1], freezeFrame, sizeof(FreezeFrameRecType));\r
+ }\r
+ else { \r
+ /* do displacement */\r
+ if(lookupFreezeFrameForDisplacementPreInit(&freezeFrameLocal)){\r
+ memcpy(freezeFrameLocal, freezeFrame, sizeof(FreezeFrameRecType));\r
+ }\r
+ else{\r
+ DET_REPORTERROR(MODULE_ID_DEM, 0, DEM_STORE_FF_DATA_PRE_INIT_ID, DEM_E_PRE_INIT_FF_DATA_BUFF_FULL);\r
+ }\r
+ }\r
+ }\r
+\r
+ Irq_Restore(state);\r
}\r
\r
\r
-// PC-Lint (715 etc): Remove errors until function is filled.\r
-//lint -e{715} Symbol not referenced\r
+/*\r
+ * Procedure: updateFreezeFrameOccurrencePreInit\r
+ * Description: update the occurrence in preInitFreezeFrameBuffer according to the occurrence stored in priMemEventBuffer \r
+ */\r
static void updateFreezeFrameOccurrencePreInit(const EventRecType *EventBuffer)\r
{\r
- // TODO: Fill out\r
+ uint16 i;\r
+\r
+ for (i = 0; i<DEM_MAX_NUMBER_FF_DATA_PRE_INIT; i++){\r
+ if(preInitFreezeFrameBuffer[i].eventId == EventBuffer->eventId){\r
+ preInitFreezeFrameBuffer[i].occurrence += EventBuffer->occurrence;\r
+ }\r
+ }\r
+ \r
}\r
+/*\r
+ * Procedure: initCurrentFreezeFrameTimeStamp\r
+ * Description: initialize current timestamp and update the corresponding timestamp in preInitFreezeFrameBuffer \r
+ */\r
+static void initCurrentFreezeFrameTimeStamp(uint32 *timeStampPtr)\r
+{\r
+ uint16 i = 0;\r
+ uint32 temp = 0;\r
+ imask_t state;\r
+\r
+ Irq_Save(state);\r
\r
+ /* Find out the biggest timestamp in the last power on */\r
+ for (i = 0; i<DEM_MAX_NUMBER_FF_DATA_PRI_MEM; i++){\r
+ if((priMemFreezeFrameBuffer[i].eventId != DEM_EVENT_ID_NULL) && \r
+ (priMemFreezeFrameBuffer[i].timeStamp > temp)){\r
+ temp = priMemFreezeFrameBuffer[i].timeStamp;\r
+ }\r
+ }\r
+ temp++;\r
+ for (i = 0; i<DEM_MAX_NUMBER_FF_DATA_PRE_INIT; i++){\r
+ if(preInitFreezeFrameBuffer[i].eventId != DEM_EVENT_ID_NULL){\r
+ preInitFreezeFrameBuffer[i].timeStamp += temp;\r
+ }\r
+ }\r
+ *timeStampPtr += temp; \r
+ Irq_Restore(state);\r
+}\r
\r
/*\r
* Procedure: getExtendedData\r
if (eventIdFound) {\r
// Update event found\r
priMemEventBuffer[i-1].occurrence = eventStatus->occurrence;\r
+ priMemEventBuffer[i-1].eventStatusExtended = eventStatus->eventStatusExtended;\r
priMemEventBuffer[i-1].checksum = calcChecksum(&priMemEventBuffer[i-1], sizeof(EventRecType)-sizeof(ChecksumType));\r
}\r
else {\r
if (eventIdFreePositionFound) {\r
priMemEventBuffer[i-1].eventId = eventStatus->eventId;\r
priMemEventBuffer[i-1].occurrence = eventStatus->occurrence;\r
+ priMemEventBuffer[i-1].eventStatusExtended = eventStatus->eventStatusExtended;\r
priMemEventBuffer[i-1].checksum = calcChecksum(&priMemEventBuffer[i-1], sizeof(EventRecType)-sizeof(ChecksumType));\r
}\r
else {\r
imask_t state;\r
Irq_Save(state);\r
\r
-\r
- // Lookup event ID\r
for (i = 0; (i < DEM_MAX_NUMBER_EVENT_ENTRY_PRI) && (!eventIdFound); i++){\r
eventIdFound = (priMemEventBuffer[i].eventId == eventParam->EventID);\r
}\r
\r
if (eventIdFound) {\r
- // Delete event found\r
memset(&priMemEventBuffer[i-1], 0, sizeof(EventRecType));\r
}\r
\r
\r
return eventIdFound;\r
}\r
+/*\r
+ * Procedure: storeAgingRecPerMem\r
+ * Description: store aging records in NVRam\r
+ */\r
+static void storeAgingRecPerMem(const Dem_NvramBlockIdType *AgingBlockIdPtr)\r
+{\r
+ NvM_RequestResultType requestResult = NVM_REQ_OK;\r
+ imask_t state;\r
\r
-// PC-Lint (715 etc): Remove errors until function is filled.\r
-//lint -e{715} Symbol not referenced\r
+ Irq_Save(state);\r
+\r
+ if (AgingBlockIdPtr->BlockDescriptor != NULL){\r
+ /* check the status,whether it's busy or not? */\r
+ NvM_GetErrorStatus(AgingBlockIdPtr->BlockDescriptor->NvramBlockIdentifier,&requestResult);\r
+ /* if writing is not busy,copy priMemFreezeFrameBuffer to NVRam permanent RAM*/\r
+ if (requestResult != NVM_REQ_PENDING){\r
+ memcpy(AgingMirrorBuffer, priMemAgingBuffer, sizeof(priMemAgingBuffer));\r
+ (void)NvM_WriteBlock(AgingBlockIdPtr->BlockDescriptor->NvramBlockIdentifier, (const uint8 *)AgingMirrorBuffer);\r
+ AgingIsModified = FALSE; \r
+ }\r
+ else{\r
+ AgingIsModified = TRUE;\r
+ }\r
+ }\r
+ else{\r
+ //TODO:report error or doing nothing,assume that doing nothing\r
+\r
+ }\r
+\r
+ Irq_Restore(state);\r
+}\r
+/*\r
+ * Procedure: deleteAgingRecPriMem\r
+ * Description: delete aging record in primary memory\r
+ */\r
+static void deleteAgingRecPriMem(const Dem_EventParameterType *eventParam)\r
+{\r
+ uint16 i;\r
+ imask_t state;\r
+\r
+ Irq_Save(state);\r
+\r
+ for (i = 0; i<DEM_MAX_NUMBER_FF_DATA_PRI_MEM; i++){\r
+ if (priMemAgingBuffer[i].eventId == eventParam->EventID){\r
+ memset(&priMemAgingBuffer[i], 0, sizeof(AgingRecType));\r
+ }\r
+ }\r
+\r
+ Irq_Restore(state);\r
+}\r
+\r
+/*\r
+ * Procedure: storeFreezeFrameDataPriMem\r
+ * Description: store FreezeFrame data record in primary memory\r
+ */\r
static void storeFreezeFrameDataPriMem(const Dem_EventParameterType *eventParam, const FreezeFrameRecType *freezeFrame)\r
{\r
- // TODO: Fill out\r
+ boolean eventIdFound = FALSE;\r
+ boolean eventIdFreePositionFound=FALSE;\r
+ boolean displacementPositionFound=FALSE;\r
+ FreezeFrameRecType *freezeFrameLocal;\r
+ uint16 i;\r
+ imask_t state;\r
+\r
+ Irq_Save(state);\r
+\r
+ /* Check if already stored */\r
+ for (i = 0; (i<DEM_MAX_NUMBER_FF_DATA_PRI_MEM) && (!eventIdFound); i++){\r
+ eventIdFound = ((priMemFreezeFrameBuffer[i].eventId == eventParam->EventID) && (priMemFreezeFrameBuffer[i].recordNumber == freezeFrame->recordNumber));\r
+ }\r
+\r
+ if (eventIdFound) {\r
+ memcpy(&priMemFreezeFrameBuffer[i-1], freezeFrame, sizeof(FreezeFrameRecType));\r
+ }\r
+ else {\r
+ for (i = 0; (i < DEM_MAX_NUMBER_FF_DATA_PRI_MEM) && (!eventIdFreePositionFound); i++){\r
+ eventIdFreePositionFound = (priMemFreezeFrameBuffer[i].eventId == DEM_EVENT_ID_NULL);\r
+ }\r
+ if (eventIdFreePositionFound) {\r
+ memcpy(&priMemFreezeFrameBuffer[i-1], freezeFrame, sizeof(FreezeFrameRecType));\r
+ }\r
+ else {\r
+ displacementPositionFound = lookupFreezeFrameForDisplacement(&freezeFrameLocal);\r
+ if(displacementPositionFound){\r
+ memcpy(freezeFrameLocal, freezeFrame, sizeof(FreezeFrameRecType));\r
+ }\r
+ else{\r
+ DET_REPORTERROR(MODULE_ID_DEM, 0, DEM_STORE_FF_DATA_PRI_MEM_ID, DEM_E_PRI_MEM_FF_DATA_BUFF_FULL);\r
+ } \r
+ }\r
+ }\r
+\r
+ Irq_Restore(state);\r
}\r
+/*\r
+ * Procedure: storeFreezeFrameDataPerMem\r
+ * Description: Store the freeze frame data in NVRam\r
+ * \r
+ */\r
+static void storeFreezeFrameDataPerMem(const Dem_NvramBlockIdType *FFBlockIdPtr)\r
+{\r
+ NvM_RequestResultType requestResult = NVM_REQ_OK;\r
+ uint16 i = 0;\r
+ boolean FFIsModifiedLocal = FALSE;\r
+ imask_t state;\r
+\r
+ Irq_Save(state);\r
+\r
+ for(i = 0; i < DEM_MAX_NUMBER_FF_DATA_PRI_MEM; i++){\r
+ if(memcmp(&priMemFreezeFrameBuffer[i], FreezeFrameMirrorBuffer[i], sizeof(FreezeFrameRecType))){\r
+ if(FFBlockIdPtr->BlockDescriptor != NULL){\r
+ NvM_GetErrorStatus(FFBlockIdPtr->BlockDescriptor->NvramBlockIdentifier,&requestResult);\r
+\r
+ if(requestResult != NVM_REQ_PENDING ){\r
+ memcpy(FreezeFrameMirrorBuffer[i], &priMemFreezeFrameBuffer[i], sizeof(FreezeFrameRecType));\r
+ (void)NvM_WriteBlock(FFBlockIdPtr->BlockDescriptor->NvramBlockIdentifier, (const uint8 *)(FreezeFrameMirrorBuffer[i]));\r
+ FFIsModifiedLocal = FALSE;\r
+ }\r
+ else{\r
+ FFIsModifiedLocal = TRUE;\r
+ }\r
+\r
+ FFIsModified |= FFIsModifiedLocal;\r
+ }\r
+ else{\r
+ //TODO:report error or doing nothing,assume that doing nothing\r
+ }\r
+ }\r
+ FFBlockIdPtr++;\r
+ }\r
\r
+ Irq_Restore(state);\r
+}\r
\r
// PC-Lint (715 etc): Remove errors until function is filled.\r
//lint -e{715} Symbol not referenced\r
static void deleteFreezeFrameDataPriMem(const Dem_EventParameterType *eventParam)\r
{\r
- // TODO: Fill out\r
+ uint16 i;\r
+ imask_t state;\r
+\r
+ Irq_Save(state);\r
+\r
+ for (i = 0; i<DEM_MAX_NUMBER_FF_DATA_PRI_MEM; i++){\r
+ if (priMemFreezeFrameBuffer[i].eventId == eventParam->EventID){\r
+ memset(&priMemFreezeFrameBuffer[i], 0, sizeof(FreezeFrameRecType));\r
+\r
+ }\r
+ }\r
+\r
+ Irq_Restore(state);\r
+}\r
+\r
+/*\r
+ * Procedure: deleteFreezeFrameDataPerMem\r
+ * Description: delete the freeze frame data in event memory according to\r
+ * "FFBlockId" destination option,it must be used after deleteFreezeFrameDataPriMem()\r
+ */\r
+static void deleteFreezeFrameDataPerMem(const Dem_NvramBlockIdType *FFBlockIdPtr)\r
+{\r
+ NvM_RequestResultType requestResult = NVM_REQ_OK;\r
+ uint16 i = 0;\r
+ boolean FFIsModifiedLocal = FALSE;\r
+ imask_t state;\r
+\r
+ Irq_Save(state);\r
+\r
+ for(i = 0; i < DEM_MAX_NUMBER_FF_DATA_PRI_MEM; i++){\r
+ if(memcmp(&priMemFreezeFrameBuffer[i], FreezeFrameMirrorBuffer[i], sizeof(FreezeFrameRecType))){\r
+ if(FFBlockIdPtr->BlockDescriptor != NULL){\r
+ NvM_GetErrorStatus(FFBlockIdPtr->BlockDescriptor->NvramBlockIdentifier,&requestResult);\r
+ if(requestResult != NVM_REQ_PENDING){\r
+ memcpy(FreezeFrameMirrorBuffer[i], &priMemFreezeFrameBuffer[i], sizeof(FreezeFrameRecType));\r
+ (void)NvM_WriteBlock(FFBlockIdPtr->BlockDescriptor->NvramBlockIdentifier, (const uint8 *)(FreezeFrameMirrorBuffer[i]));\r
+ FFIsModifiedLocal = FALSE;\r
+ }\r
+ else{\r
+ FFIsModifiedLocal = TRUE;\r
+ }\r
+ FFIsModified |= FFIsModifiedLocal;\r
+\r
+ }\r
+ else{\r
+ //TODO:report error or doing nothing,assume that doing nothing\r
+ }\r
+ }\r
+ FFBlockIdPtr++;\r
+\r
+ }\r
+\r
+ Irq_Restore(state);\r
}\r
\r
\r
{\r
case DEM_DTC_ORIGIN_PRIMARY_MEMORY:\r
storeFreezeFrameDataPriMem(eventParam, freezeFrame);\r
+ storeFreezeFrameDataPerMem(FreezeFrameBlockId);\r
break;\r
\r
- case DEM_DTC_ORIGIN_SECONDARY_MEMORY:\r
case DEM_DTC_ORIGIN_PERMANENT_MEMORY:\r
+ case DEM_DTC_ORIGIN_SECONDARY_MEMORY:\r
case DEM_DTC_ORIGIN_MIRROR_MEMORY:\r
// Not yet supported\r
DET_REPORTERROR(MODULE_ID_DEM, 0, DEM_GLOBAL_ID, DEM_E_NOT_IMPLEMENTED_YET);\r
}\r
}\r
\r
+/*\r
+ * Procedure: lookupFreezeFrameDataRecNumParam\r
+ * Description: Returns TRUE if the requested freezeFrame data number was found among the configured records for the event.\r
+ * "freezeFrameClassPtr" returns a pointer to the record class.\r
+ */\r
+static boolean lookupFreezeFrameDataRecNumParam(uint8 recordNumber, const Dem_EventParameterType *eventParam, Dem_FreezeFrameClassType const **freezeFrameClassPtr)\r
+{\r
+ boolean recNumFound = FALSE;\r
+ uint16 i;\r
+\r
+ if (eventParam->FreezeFrameClassRef != NULL) {\r
+ for (i = 0; (i < DEM_MAX_NR_OF_CLASSES_IN_FREEZEFRAME_DATA) && (eventParam->FreezeFrameClassRef[i] != NULL) && (!recNumFound); i++) {\r
+ if (eventParam->FreezeFrameClassRef[i]->FFRecordNumber == recordNumber) {\r
+ *freezeFrameClassPtr = eventParam->FreezeFrameClassRef[i];\r
+ recNumFound = TRUE;\r
+ }\r
+ }\r
+ }\r
+\r
+ return recNumFound;\r
+}\r
+\r
+/*\r
+ * Procedure: lookupFreezeFrameDataSize\r
+ * Description: Returns TRUE if the requested freezeFrame data size was obtained successfully from the configuration.\r
+ * "dataSize" returns a pointer to the data size.\r
+ */\r
+static boolean lookupFreezeFrameDataSize(uint8 recordNumber, Dem_FreezeFrameClassType const **freezeFrameClassPtr, uint16 *dataSize)\r
+{\r
+ Std_ReturnType callbackReturnCode;\r
+ boolean dataSizeFound = TRUE;\r
+ uint16 dataSizeLocal = 0;\r
+ uint16 i;\r
+\r
+ if (*freezeFrameClassPtr != NULL) {\r
+ for (i = 0; (i < DEM_MAX_NR_OF_RECORDS_IN_FREEZEFRAME_DATA) && ((*freezeFrameClassPtr)->FFIdClassRef[i].Arc_EOL != TRUE); i++) { \r
+ if((*freezeFrameClassPtr)->FFIdClassRef[i].DidReadDataLengthFnc != NULL){\r
+ callbackReturnCode = (*freezeFrameClassPtr)->FFIdClassRef[i].DidReadDataLengthFnc(&dataSizeLocal);\r
+ if(callbackReturnCode != E_OK){\r
+ return (dataSizeFound = FALSE); \r
+ }\r
+ }\r
+ else{\r
+ dataSizeLocal = (*freezeFrameClassPtr)->FFIdClassRef[i].PidOrDidSize;\r
+ }\r
+ \r
+ *dataSize += dataSizeLocal + DEM_DID_IDENTIFIER_SIZE_OF_BYTES;\r
+ }\r
+\r
+ }\r
+\r
+ return dataSizeFound;\r
+}\r
+\r
+/*\r
+ * Procedure: lookupFreezeFrameDataPriMem\r
+ * Description: Returns TRUE if the requested event id is found, "freezeFrame" points to the found data.\r
+ */\r
+static boolean lookupFreezeFrameDataPriMem(Dem_EventIdType eventId,uint8 recordNumber, FreezeFrameRecType **freezeFrame)\r
+{\r
+ boolean eventIdFound = FALSE;\r
+ uint16 i;\r
+\r
+ for (i = 0; (i < DEM_MAX_NUMBER_FF_DATA_PRI_MEM) && (!eventIdFound); i++) {\r
+ eventIdFound = ((priMemFreezeFrameBuffer[i].eventId == eventId) && (priMemFreezeFrameBuffer[i].recordNumber == recordNumber));\r
+ }\r
+\r
+ if (eventIdFound) {\r
+ *freezeFrame = &priMemFreezeFrameBuffer[i-1];\r
+ }\r
+\r
+ return eventIdFound;\r
+}\r
\r
/*\r
* Procedure: handlePreInitEvent\r
FreezeFrameRecType freezeFrameLocal;\r
ExtDataRecType extendedDataLocal;\r
\r
- // Find configuration for this event\r
lookupEventIdParameter(eventId, &eventParam);\r
if (eventParam != NULL) {\r
if (eventParam->EventClass->OperationCycleRef < DEM_OPERATION_CYCLE_ID_ENDMARK) {\r
}\r
\r
if (eventStatusLocal.errorStatusChanged) {\r
-\r
if (eventStatusLocal.eventStatusExtended & DEM_TEST_FAILED) {\r
- // Collect freeze frame data\r
- getFreezeFrameData(eventParam, &freezeFrameLocal);\r
- if (freezeFrameLocal.eventId != DEM_EVENT_ID_NULL) {\r
- storeFreezeFrameDataPreInit(eventParam, &freezeFrameLocal);\r
- }\r
-\r
- // Collect extended data\r
getExtendedData(eventParam, &extendedDataLocal);\r
if (extendedDataLocal.eventId != DEM_EVENT_ID_NULL) {\r
storeExtendedDataPreInit(eventParam, &extendedDataLocal);\r
}\r
+ getFreezeFrameData(eventParam, &freezeFrameLocal,eventStatus,&eventStatusLocal);\r
+ if (freezeFrameLocal.eventId != DEM_EVENT_ID_NULL) {\r
+ storeFreezeFrameDataPreInit(eventParam, &freezeFrameLocal);\r
+ }\r
}\r
}\r
+\r
+ \r
}\r
else {\r
// Operation cycle not started\r
EventStatusRecType eventStatusLocal;\r
FreezeFrameRecType freezeFrameLocal;\r
ExtDataRecType extendedDataLocal;\r
+ Dem_EventStatusType eventStatusTemp = eventStatus;\r
\r
- // Find configuration for this event\r
lookupEventIdParameter(eventId, &eventParam);\r
if (eventParam != NULL) {\r
if (eventParam->EventClass->OperationCycleRef < DEM_OPERATION_CYCLE_ID_ENDMARK) {\r
if (operationCycleStateList[eventParam->EventClass->OperationCycleRef] == DEM_CYCLE_STATE_START) {\r
if ((!((disableDtcStorage.storageDisabled) && (checkDtcGroup(disableDtcStorage.dtcGroup, eventParam)) && (checkDtcKind(disableDtcStorage.dtcKind, eventParam))))) {\r
updateEventStatusRec(eventParam, eventStatus, TRUE, &eventStatusLocal);\r
- if (eventStatusLocal.errorStatusChanged) {\r
- if (eventStatusLocal.eventStatusExtended & DEM_TEST_FAILED) {\r
- storeEventEvtMem(eventParam, &eventStatusLocal); /** @req DEM184 */\r
- // Collect freeze frame data\r
- getFreezeFrameData(eventParam, &freezeFrameLocal);\r
- if (freezeFrameLocal.eventId != DEM_EVENT_ID_NULL) {\r
- storeFreezeFrameDataEvtMem(eventParam, &freezeFrameLocal); /** @req DEM190 */\r
- }\r
-\r
- // Collect extended data\r
+ if (eventStatusLocal.errorStatusChanged) {\r
+ if (eventStatusLocal.eventStatusExtended & DEM_TEST_FAILED) {\r
+ storeEventEvtMem(eventParam, &eventStatusLocal); /** @req DEM184 */\r
getExtendedData(eventParam, &extendedDataLocal);\r
if (extendedDataLocal.eventId != DEM_EVENT_ID_NULL)\r
{\r
storeExtendedDataEvtMem(eventParam, &extendedDataLocal);\r
}\r
}\r
- }\r
+\r
+ if (eventStatusTemp == DEM_EVENT_STATUS_PREFAILED\r
+ || eventStatusLocal.eventStatusExtended & DEM_TEST_FAILED){\r
+ getFreezeFrameData(eventParam, &freezeFrameLocal,eventStatus,&eventStatusLocal);\r
+ if (freezeFrameLocal.eventId != DEM_EVENT_ID_NULL) {\r
+ storeFreezeFrameDataEvtMem(eventParam, &freezeFrameLocal); /** @req DEM190 */\r
+ }\r
+ }\r
+ else{\r
+ // do nothing\r
+ }\r
+ } \r
}\r
}\r
else {\r
\r
return returnCode;\r
}\r
+/*\r
+ * Procedure: deleteEventMemory\r
+ * Description: If aging of an event occurs, the Dem module shall delete the event from \r
+ * the event memory including its event related data\r
+ */\r
+static void deleteEventMemory(const Dem_EventParameterType *eventParam)\r
+{\r
+ uint16 i;\r
+\r
+ for (i = 0; (i < DEM_MAX_NR_OF_EVENT_DESTINATION) && (eventParam->EventClass->EventDestination[i] != DEM_EVENT_DESTINATION_END_OF_LIST); i++) {\r
+ switch (eventParam->EventClass->EventDestination[i])\r
+ {\r
+ case DEM_DTC_ORIGIN_PRIMARY_MEMORY:\r
+ deleteEventPriMem(eventParam);\r
+ deleteFreezeFrameDataPriMem(eventParam);\r
+ deleteExtendedDataPriMem(eventParam);\r
+ deleteFreezeFrameDataPerMem(FreezeFrameBlockId);\r
+ break;\r
+\r
+ case DEM_DTC_ORIGIN_PERMANENT_MEMORY:\r
+ //TODO:need to add corresponding event and extended deleting functions\r
+\r
+ break;\r
+\r
+ case DEM_DTC_ORIGIN_SECONDARY_MEMORY:\r
+ case DEM_DTC_ORIGIN_MIRROR_MEMORY:\r
+ // Not yet supported\r
+ DET_REPORTERROR(MODULE_ID_DEM, 0, DEM_GLOBAL_ID, DEM_E_NOT_IMPLEMENTED_YET);\r
+ break;\r
+\r
+ default:\r
+ break;\r
+ }\r
+\r
+ }\r
+\r
+}\r
+/*\r
+ * Procedure: lookupAgingRecPriMem\r
+ * Description: Returns the pointer to event id parameters of "eventId" in "*priMemAgingBuffer",\r
+ * if not found NULL is returned.\r
+ */\r
+static boolean lookupAgingRecPriMem(Dem_EventIdType eventId, const AgingRecType **agingRec)\r
+{\r
+ uint16 i;\r
+ boolean agingRecFound = FALSE;\r
+ \r
+ for (i = 0; i < DEM_MAX_NUMBER_AGING_PRI_MEM && (!agingRecFound); i++) {\r
+ if(priMemAgingBuffer[i].eventId == eventId){\r
+ agingRecFound = TRUE;\r
+ }\r
+\r
+ }\r
+\r
+ if(agingRecFound){\r
+ *agingRec = &priMemAgingBuffer[i-1];\r
+ }\r
+ else{\r
+ *agingRec = NULL;\r
+ }\r
+\r
+ return agingRecFound;\r
+\r
+}\r
+\r
+\r
+/*\r
+ * Procedure: handleAging\r
+ * Description: according to the operation state of "operationCycleId" to "cycleState" , handle the aging relatived data\r
+ * Returns E_OK if operation was successful else E_NOT_OK.\r
+ */\r
+static Std_ReturnType handleAging(Dem_OperationCycleIdType operationCycleId, Dem_OperationCycleStateType cycleState)\r
+{\r
+ uint16 i;\r
+ Std_ReturnType returnCode = E_OK;\r
+ AgingRecType *agingRecLocal = NULL;\r
+ boolean agingRecFound = FALSE;\r
+\r
+ if (operationCycleId < DEM_OPERATION_CYCLE_ID_ENDMARK) {\r
+ switch (cycleState)\r
+ {\r
+ case DEM_CYCLE_STATE_START:\r
+ break;\r
+\r
+ case DEM_CYCLE_STATE_END:/** @req Dem490 */\r
+ for (i = 0; i < DEM_MAX_NUMBER_EVENT; i++) {\r
+ if(eventStatusBuffer[i].eventId != DEM_EVENT_ID_NULL){\r
+ if(eventStatusBuffer[i].eventParamRef != NULL){\r
+ if(eventStatusBuffer[i].eventParamRef->EventClass != NULL){\r
+ if((eventStatusBuffer[i].eventParamRef->EventClass->AgingAllowed == TRUE)\\r
+ && (eventStatusBuffer[i].eventParamRef->EventClass->AgingCycleRef == operationCycleId)){ \r
+ if((eventStatusBuffer[i].eventStatusExtended & DEM_CONFIRMED_DTC)\\r
+ && (!(eventStatusBuffer[i].eventStatusExtended & DEM_TEST_FAILED))\\r
+ && (!(eventStatusBuffer[i].eventStatusExtended & DEM_TEST_NOT_COMPLETED_THIS_OPERATION_CYCLE))){\r
+ agingRecFound = lookupAgingRecPriMem(eventStatusBuffer[i].eventId, (const AgingRecType **)(&agingRecLocal));\r
+ if(agingRecFound){\r
+ agingRecLocal->agingCounter++;/** @req Dem489 */\r
+ agingRecLocal->checksum = calcChecksum(agingRecLocal,sizeof(AgingRecType) - sizeof(ChecksumType));\r
+ if(agingRecLocal->agingCounter > eventStatusBuffer[i].eventParamRef->EventClass->AgingCounterThreshold){\r
+ //deleteEventMemory(eventStatusBuffer[i].eventParamRef); /** @req Dem497 */\r
+\r
+ deleteAgingRecPriMem(eventStatusBuffer[i].eventParamRef);\r
+\r
+ eventStatusBuffer[i].eventStatusExtended &= (Dem_EventStatusExtendedType)(~DEM_CONFIRMED_DTC);\r
+ eventStatusBuffer[i].eventStatusExtended &= (Dem_EventStatusExtendedType)(~DEM_PENDING_DTC);\r
+ eventStatusBuffer[i].eventStatusExtended &= (Dem_EventStatusExtendedType)(~DEM_WARNING_INDICATOR_REQUESTED);\r
+ }\r
+ /* Set the flag,start up the storage of NVRam in main function. */\r
+ AgingIsModified = TRUE;\r
+ }\r
+ else{\r
+ /* If it does exist,establish a new record for the corresponding event */\r
+ agingRecFound = lookupAgingRecPriMem(DEM_EVENT_ID_NULL, (const AgingRecType **)(&agingRecLocal));\r
+ if(agingRecFound){\r
+ agingRecLocal->eventId = eventStatusBuffer[i].eventId;\r
+ agingRecLocal->agingCounter++;\r
+ agingRecLocal->checksum = calcChecksum(agingRecLocal,sizeof(AgingRecType) - sizeof(ChecksumType));\r
+ AgingIsModified = TRUE;\r
+ }\r
+ else{\r
+ /* primary memory of aging records is full. */\r
+ }\r
+ }\r
+ }\r
+ else{\r
+ /* If the status bit testFailed (bit 0) is set during the operation cycle, the counter shall be reset. */\r
+ if(eventStatusBuffer[i].eventStatusExtended & DEM_TEST_FAILED){\r
+ agingRecFound = lookupAgingRecPriMem(eventStatusBuffer[i].eventId, (const AgingRecType **)(&agingRecLocal));\r
+ if(agingRecFound){\r
+ if(agingRecLocal->agingCounter){\r
+ agingRecLocal->agingCounter = 0;\r
+ agingRecLocal->checksum = calcChecksum(agingRecLocal,sizeof(AgingRecType) - sizeof(ChecksumType));\r
+ AgingIsModified = TRUE;\r
+ }\r
+ }\r
+ }\r
+ }\r
+ }\r
+ }\r
+ }\r
+ }\r
+ }\r
+ break;\r
+ default:\r
+ DET_REPORTERROR(MODULE_ID_DEM, 0, DEM_SETOPERATIONCYCLESTATE_ID, DEM_E_PARAM_DATA);\r
+ returnCode = E_NOT_OK;\r
+ break;\r
+ }\r
+ }\r
+ else {\r
+ DET_REPORTERROR(MODULE_ID_DEM, 0, DEM_SETOPERATIONCYCLESTATE_ID, DEM_E_PARAM_DATA);\r
+ returnCode = E_NOT_OK;\r
+ }\r
+\r
+ return returnCode;\r
\r
+}\r
\r
/*\r
* Procedure: setOperationCycleState\r
if ((eventStatusBuffer[i].eventId != DEM_EVENT_ID_NULL) && (eventStatusBuffer[i].eventParamRef->EventClass->OperationCycleRef == operationCycleId)) {\r
if ((!(eventStatusBuffer[i].eventStatusExtended & DEM_TEST_FAILED_THIS_OPERATION_CYCLE)) && (!(eventStatusBuffer[i].eventStatusExtended & DEM_TEST_NOT_COMPLETED_THIS_OPERATION_CYCLE))) {\r
eventStatusBuffer[i].eventStatusExtended &= (Dem_EventStatusExtendedType)~DEM_PENDING_DTC; // Clear pendingDTC bit /** @req DEM379.PendingClear\r
+ storeEventEvtMem(eventStatusBuffer[i].eventParamRef, &eventStatusBuffer[i]);\r
}\r
}\r
}\r
/** @req DEM180 */\r
uint16 i, j;\r
\r
+ EventStatusRecType *eventStatusRecPtr;\r
+ const Dem_EventParameterType *eventIdParamList;\r
+\r
VALIDATE_NO_RV(DEM_Config.ConfigSet != NULL, DEM_PREINIT_ID, DEM_E_CONFIG_PTR_INVALID);\r
\r
configSet = DEM_Config.ConfigSet;\r
eventStatusBuffer[i].errorStatusChanged = FALSE;\r
}\r
\r
+ // Insert all supported events into event status buffer\r
+ uint16 index = 0;\r
+ eventIdParamList = configSet->EventParameter;\r
+ while( !eventIdParamList[index].Arc_EOL ) {\r
+ // Find next free position in event status buffer\r
+ lookupEventStatusRec(DEM_EVENT_ID_NULL, &eventStatusRecPtr);\r
+ if(NULL != eventStatusRecPtr) {\r
+ eventStatusRecPtr->eventId = eventIdParamList[index].EventID;\r
+ eventStatusRecPtr->eventParamRef = &eventIdParamList[index];\r
+ } else {\r
+ // event status buffer is full\r
+ DET_REPORTERROR(MODULE_ID_DEM, 0, DEM_PREINIT_ID, DEM_E_EVENT_STATUS_BUFF_FULL);\r
+ }\r
+ index++;\r
+ }\r
+\r
//lint -save\r
//lint -e568 -e685 //PC-Lint exception.\r
//lint -e681 //PC-Lint exception to MISRA 14.1: Loop is not entered. This only happens when config variable is zero. Keep as it is for less complex code.\r
uint16 i;\r
ChecksumType cSum;\r
const Dem_EventParameterType *eventParam;\r
+ NvM_RequestResultType requestResult = NVM_REQ_OK;\r
+ if(DEM_PREINITIALIZED != demState){\r
+ /*\r
+ * Dem_PreInit was has not been called since last time Dem_Shutdown was called.\r
+ * This suggests that we are resuming from sleep. According to section 5.7 in\r
+ * EcuM specification, RAM content is assumed to be still valid from the previous cycle.\r
+ * Do not read from saved error log since buffers already contains this data.\r
+ */\r
+ (void)setOperationCycleState(DEM_ACTIVE, DEM_CYCLE_STATE_START);\r
\r
- /*\r
- * Validate and read out saved error log from non volatile memory\r
- */\r
+ } else {\r
\r
- // Validate event records stored in primary memory\r
- for (i = 0; i < DEM_MAX_NUMBER_EVENT_PRI_MEM; i++) {\r
- cSum = calcChecksum(&priMemEventBuffer[i], sizeof(EventRecType)-sizeof(ChecksumType));\r
- if ((cSum != priMemEventBuffer[i].checksum) || (priMemEventBuffer[i].eventId == DEM_EVENT_ID_NULL)) {\r
- // Unlegal record, clear the record\r
- memset(&priMemEventBuffer[i], 0, sizeof(EventRecType));\r
+ for(i = 0; i < DEM_MAX_NUMBER_FF_DATA_PRI_MEM; i++){\r
+ if(FreezeFrameBlockId[i].BlockDescriptor != NULL){\r
+ NvM_GetErrorStatus(FreezeFrameBlockId[i].BlockDescriptor->NvramBlockIdentifier,&requestResult);\r
+ if(requestResult != NVM_REQ_PENDING){\r
+ memcpy(&priMemFreezeFrameBuffer[i], FreezeFrameMirrorBuffer[i], sizeof(FreezeFrameRecType));\r
+ }\r
+ else{\r
+ //TODO:NVM is busy,report error or what?\r
+ }\r
+ }\r
}\r
- else {\r
- // Valid, update current status\r
- mergeEventStatusRec(&priMemEventBuffer[i]);\r
+ //recover Aging from NVRam to RAM\r
+ if(AgingBlockId.BlockDescriptor != NULL)\r
+ {\r
+ //check the status\r
+ NvM_GetErrorStatus(AgingBlockId.BlockDescriptor->NvramBlockIdentifier,&requestResult);\r
+\r
+ //recover Aging from NVRam to RAM\r
+ if(AgingBlockId.BlockDescriptor != NULL){//check the status\r
+ NvM_GetErrorStatus(AgingBlockId.BlockDescriptor->NvramBlockIdentifier, &requestResult);\r
+\r
+ //judge whether NVM is busy\r
+ if(!(requestResult & NVM_REQ_PENDING)){\r
+ //copy the permanent RAM to priMemAgingBuffer\r
+ memcpy(priMemAgingBuffer, AgingMirrorBuffer, sizeof(priMemAgingBuffer));\r
+ }\r
+ else{\r
+\r
+ }\r
\r
- // Update occurrence counter on pre init stored freeze frames\r
- updateFreezeFrameOccurrencePreInit(&priMemEventBuffer[i]);\r
+ }\r
}\r
- }\r
+ // Validate aging records stored in primary memory\r
+ for (i = 0; i < DEM_MAX_NUMBER_AGING_PRI_MEM; i++){\r
+ cSum = calcChecksum(&priMemAgingBuffer[i], sizeof(AgingRecType) - sizeof(ChecksumType));\r
+ if ((cSum != priMemAgingBuffer[i].checksum) || (priMemAgingBuffer[i].eventId == DEM_EVENT_ID_NULL)) {\r
+ // Unlegal record, clear the record\r
+ memset(&priMemAgingBuffer[i], 0, sizeof(AgingRecType));\r
+ AgingIsModified = TRUE;\r
+ }\r
\r
- // Validate extended data records stored in primary memory\r
- for (i = 0; i < DEM_MAX_NUMBER_EXT_DATA_PRI_MEM; i++) {\r
- cSum = calcChecksum(&priMemExtDataBuffer[i], sizeof(ExtDataRecType)-sizeof(ChecksumType));\r
- if ((cSum != priMemExtDataBuffer[i].checksum) || (priMemExtDataBuffer[i].eventId == DEM_EVENT_ID_NULL)) {\r
- // Unlegal record, clear the record\r
- memset(&priMemExtDataBuffer[i], 0, sizeof(ExtDataRecType));\r
+ // Validate event records stored in primary memory\r
+ for (i = 0; i < DEM_MAX_NUMBER_EVENT_PRI_MEM; i++) {\r
+ cSum = calcChecksum(&priMemEventBuffer[i], sizeof(EventRecType)-sizeof(ChecksumType));\r
+ if ((cSum != priMemEventBuffer[i].checksum) || (priMemEventBuffer[i].eventId == DEM_EVENT_ID_NULL)) {\r
+ // Unlegal record, clear the record\r
+ memset(&priMemEventBuffer[i], 0, sizeof(EventRecType));\r
+ }\r
+ else {\r
+ // Valid, update current status\r
+ mergeEventStatusRec(&priMemEventBuffer[i]);\r
+\r
+ // Update occurrence counter on pre init stored freeze frames\r
+ updateFreezeFrameOccurrencePreInit(&priMemEventBuffer[i]);\r
+ }\r
+ }\r
+\r
+ //initialize the current timestamp and update the timestamp in pre init\r
+ initCurrentFreezeFrameTimeStamp(&FF_TimeStamp);//add by i-soft\r
+\r
+ // Validate extended data records stored in primary memory\r
+ for (i = 0; i < DEM_MAX_NUMBER_EXT_DATA_PRI_MEM; i++) {\r
+ cSum = calcChecksum(&priMemExtDataBuffer[i], sizeof(ExtDataRecType)-sizeof(ChecksumType));\r
+ if ((cSum != priMemExtDataBuffer[i].checksum) || (priMemExtDataBuffer[i].eventId == DEM_EVENT_ID_NULL)) {\r
+ // Unlegal record, clear the record\r
+ memset(&priMemExtDataBuffer[i], 0, sizeof(ExtDataRecType));\r
+ }\r
+ }\r
}\r
- }\r
\r
- //lint -save\r
- //lint -e568 //PC-Lint exception.\r
- //lint -e685 //PC-Lint exception.\r
- //lint -e681 //PC-Lint exception to MISRA 14.1: Loop is not entered. This only happens when DEM_MAX_NUMBER_FF_DATA_PRE_INIT is zero. Keep as it is for less complex code.\r
- // Validate freeze frame records stored in primary memory\r
- for (i = 0; i < DEM_MAX_NUMBER_FF_DATA_PRI_MEM; i++) {\r
+ //initialize the current timestamp and update the timestamp in pre init\r
+ initCurrentFreezeFrameTimeStamp(&FF_TimeStamp);\r
+\r
+ //lint -save\r
+ //lint -e568 //PC-Lint exception.\r
+ //lint -e685 //PC-Lint exception.\r
+ //lint -e681 //PC-Lint exception to MISRA 14.1: Loop is not entered. This only happens when DEM_MAX_NUMBER_FF_DATA_PRE_INIT is zero. Keep as it is for less complex code.\r
+ // Validate freeze frame records stored in primary memory\r
+ for (i = 0; i < DEM_MAX_NUMBER_FF_DATA_PRI_MEM; i++) {\r
+ cSum = calcChecksum(&priMemFreezeFrameBuffer[i], sizeof(FreezeFrameRecType)-sizeof(ChecksumType));\r
+ if ((cSum != priMemFreezeFrameBuffer[i].checksum) || (priMemFreezeFrameBuffer[i].eventId == DEM_EVENT_ID_NULL)) {\r
+ // Unlegal record, clear the record\r
+ memset(&priMemFreezeFrameBuffer[i], 0, sizeof(FreezeFrameRecType));\r
+ }\r
+ }\r
+ //lint -restore\r
+\r
+ //lint -save\r
+ //lint -e568 //PC-Lint exception.\r
+ //lint -e685 //PC-Lint exception.\r
+ //lint -e681 //PC-Lint exception to MISRA 14.1: Loop is not entered. This only happens when DEM_MAX_NUMBER_FF_DATA_PRE_INIT is zero. Keep as it is for less complex code.\r
+ // Validate freeze frame records stored in primary memory\r
+ // LuYuan: no checksum is needed.\r
+ /* for (i = 0; i < DEM_MAX_NUMBER_FF_DATA_PRI_MEM; i++) {\r
+ // Bug report by iSOFT, data structure is not byte aligned, use "sizeof is not SAFE! \r
cSum = calcChecksum(&priMemFreezeFrameBuffer[i], sizeof(FreezeFrameRecType)-sizeof(ChecksumType));\r
if ((cSum != priMemFreezeFrameBuffer[i].checksum) || (priMemFreezeFrameBuffer[i].eventId == DEM_EVENT_ID_NULL)) {\r
// Unlegal record, clear the record\r
memset(&priMemFreezeFrameBuffer[i], 0, sizeof(FreezeFrameRecType));\r
}\r
}\r
- //lint -restore\r
+ */\r
+ //lint -restore\r
\r
- /*\r
- * Handle errors stored in temporary buffer (if any)\r
- */\r
-\r
- // Transfer updated event data to event memory\r
+ /* Transfer updated event data to event memory */\r
for (i = 0; i < DEM_MAX_NUMBER_EVENT; i++) {\r
if (eventStatusBuffer[i].eventId != DEM_EVENT_ID_NULL) {\r
- // Update the event memory\r
lookupEventIdParameter(eventStatusBuffer[i].eventId, &eventParam);\r
storeEventEvtMem(eventParam, &eventStatusBuffer[i]);\r
}\r
}\r
\r
- // Transfer extended data to event memory if necessary\r
+ /* Transfer extended data to event memory if necessary */\r
for (i = 0; i < DEM_MAX_NUMBER_EXT_DATA_PRE_INIT; i++) {\r
if (preInitExtDataBuffer[i].eventId != DEM_EVENT_ID_NULL) {\r
lookupEventIdParameter(preInitExtDataBuffer[i].eventId, &eventParam);\r
}\r
}\r
\r
- //lint -save\r
- //lint -e568 //PC-Lint exception.\r
- //lint -e685 //PC-Lint exception.\r
- //lint -e681 //PC-Lint exception to MISRA 14.1: Loop is not entered. This only happens when DEM_MAX_NUMBER_FF_DATA_PRE_INIT is zero. Keep as it is for less complex code.\r
- // Transfer freeze frames to event memory\r
- for (i = 0; i < DEM_MAX_NUMBER_FF_DATA_PRE_INIT; i++) {\r
- if (preInitFreezeFrameBuffer[i].eventId != DEM_EVENT_ID_NULL) {\r
- lookupEventIdParameter(preInitFreezeFrameBuffer[i].eventId, &eventParam);\r
- storeFreezeFrameDataEvtMem(eventParam, &preInitFreezeFrameBuffer[i]);\r
+ //lint -save\r
+ //lint -e568 //PC-Lint exception.\r
+ //lint -e685 //PC-Lint exception.\r
+ //lint -e681 //PC-Lint exception to MISRA 14.1: Loop is not entered. This only happens when DEM_MAX_NUMBER_FF_DATA_PRE_INIT is zero. Keep as it is for less complex code.\r
+ /* Transfer freeze frames to event memory */\r
+ for (i = 0; i < DEM_MAX_NUMBER_FF_DATA_PRE_INIT; i++) {\r
+ if (preInitFreezeFrameBuffer[i].eventId != DEM_EVENT_ID_NULL) {\r
+ lookupEventIdParameter(preInitFreezeFrameBuffer[i].eventId, &eventParam);\r
+ storeFreezeFrameDataEvtMem(eventParam, &preInitFreezeFrameBuffer[i]);\r
+ }\r
}\r
+ //lint -restore\r
}\r
- //lint -restore\r
\r
// Init the dtc filter\r
dtcFilter.dtcStatusMask = DEM_DTC_STATUS_MASK_ALL; // All allowed\r
{\r
(void)setOperationCycleState(DEM_ACTIVE, DEM_CYCLE_STATE_END); /** @req DEM047 */\r
\r
+ /* handleAging() should be called behind setOperationCycleState() */\r
+ (void)handleAging(DEM_ACTIVE, DEM_CYCLE_STATE_END);\r
+\r
demState = DEM_UNINITIALIZED; /** @req DEM368 */\r
}\r
\r
/*\r
* Interface for basic software scheduler\r
*/\r
-void Dem_MainFunction(void)\r
-{\r
- /** @req DEM125 */\r
+void Dem_MainFunction(void)/** @req DEM125 */\r
+{ \r
+ if (FFIsModified) {\r
+ storeFreezeFrameDataPerMem(FreezeFrameBlockId);\r
+ }\r
\r
+ if (AgingIsModified) {\r
+ storeAgingRecPerMem(&AgingBlockId);\r
+ }\r
}\r
\r
\r
if (demState == DEM_INITIALIZED) // No action is taken if the module is not started\r
{\r
returnCode = setOperationCycleState(operationCycleId, cycleState);\r
+ (void)handleAging(operationCycleId, cycleState);\r
\r
}\r
else\r
* Procedure: Dem_ReportErrorStatus\r
* Reentrant: Yes\r
*/\r
-void Dem_ReportErrorStatus( Dem_EventIdType eventId, Dem_EventStatusType eventStatus ) /** @req DEM107 */\r
+void Dem_ReportErrorStatus( Dem_EventIdType eventId, Dem_EventStatusType eventStatus ) /** @req DEM107 *//** @req DEM206 */\r
{\r
\r
switch (demState) {\r
*dtcStatusMask &= DEM_TEST_FAILED // Mask with supported bits /** @req DEM060 */\r
| DEM_TEST_FAILED_THIS_OPERATION_CYCLE\r
| DEM_PENDING_DTC\r
-// | DEM_CONFIRMED_DTC TODO: Add support for this bit\r
+ | DEM_CONFIRMED_DTC\r
| DEM_TEST_NOT_COMPLETED_SINCE_LAST_CLEAR\r
| DEM_TEST_FAILED_SINCE_LAST_CLEAR\r
| DEM_TEST_NOT_COMPLETED_THIS_OPERATION_CYCLE\r
* Procedure: Dem_ClearDTC\r
* Reentrant: No\r
*/\r
-Dem_ReturnClearDTCType Dem_ClearDTC(uint32 dtc, Dem_DTCKindType dtcKind, Dem_DTCOriginType dtcOrigin) /** @req DEM009 */\r
+Dem_ReturnClearDTCType Dem_ClearDTC(uint32 dtc, Dem_DTCKindType dtcKind, Dem_DTCOriginType dtcOrigin) /** @req DEM009 *//** @req DEM241 */\r
{\r
Dem_ReturnClearDTCType returnCode = DEM_CLEAR_OK;\r
Dem_EventIdType eventId;\r
uint16 i, j;\r
\r
if (demState == DEM_INITIALIZED) {\r
- // Loop through the event buffer\r
for (i = 0; i < DEM_MAX_NUMBER_EVENT; i++) {\r
eventId = eventStatusBuffer[i].eventId;\r
if (eventId != DEM_EVENT_ID_NULL) {\r
for (j = 0; (j < DEM_MAX_NR_OF_EVENT_DESTINATION) && (!dtcOriginFound) ; j++){\r
dtcOriginFound =(eventParam->EventClass->EventDestination[j] == dtcOrigin);\r
}\r
- //if (j-1 < DEM_MAX_NR_OF_EVENT_DESTINATION) {\r
if (dtcOriginFound) {\r
- // Yes! All conditions met.\r
switch (dtcOrigin)\r
{\r
case DEM_DTC_ORIGIN_PRIMARY_MEMORY:\r
deleteEventPriMem(eventParam);\r
deleteFreezeFrameDataPriMem(eventParam);\r
deleteExtendedDataPriMem(eventParam);\r
- deleteEventStatusRec(eventParam); // TODO: Shall this be done or just resetting the status?\r
+ resetEventStatusRec(eventParam);\r
+ deleteFreezeFrameDataPerMem(FreezeFrameBlockId);\r
break;\r
-\r
- case DEM_DTC_ORIGIN_SECONDARY_MEMORY:\r
+ \r
case DEM_DTC_ORIGIN_PERMANENT_MEMORY:\r
+ \r
+ break;\r
+ \r
+ case DEM_DTC_ORIGIN_SECONDARY_MEMORY: \r
case DEM_DTC_ORIGIN_MIRROR_MEMORY:\r
// Not yet supported\r
returnCode = DEM_CLEAR_WRONG_DTCORIGIN;\r
return returnCode;\r
}\r
\r
+/*\r
+ * Procedure: Dem_GetFreezeFrameDataByDTC\r
+ * Reentrant: No\r
+ */\r
+/** @req DEM236 */ \r
+Dem_ReturnGetFreezeFrameDataByDTCType Dem_GetFreezeFrameDataByDTC(uint32 dtc,Dem_DTCKindType dtcKind,Dem_DTCOriginType dtcOrigin,uint8 recordNumber,uint8* destBuffer,uint8* bufSize)\r
+{\r
+ Dem_ReturnGetFreezeFrameDataByDTCType returnCode = DEM_GET_FFDATABYDTC_WRONG_DTC;\r
+ EventStatusRecType *eventRec;\r
+ Dem_FreezeFrameClassType const *FFDataRecordClass = NULL;\r
+ FreezeFrameRecType *freezeframe;\r
+ uint16 FFDataSize = 0;\r
+\r
+ if (demState == DEM_INITIALIZED) {\r
+ if (lookupDtcEvent(dtc, &eventRec)) {\r
+ if (checkDtcKind(dtcKind, eventRec->eventParamRef)) {\r
+ if (checkDtcOrigin(dtcOrigin, eventRec->eventParamRef)) {\r
+ if (lookupFreezeFrameDataRecNumParam(recordNumber, eventRec->eventParamRef, &FFDataRecordClass)) {\r
+ if(lookupFreezeFrameDataSize(recordNumber, &FFDataRecordClass, &FFDataSize)){\r
+ if (*bufSize >= FFDataSize) {\r
+ switch (dtcOrigin)\r
+ {\r
+ case DEM_DTC_ORIGIN_PRIMARY_MEMORY:\r
+ if (lookupFreezeFrameDataPriMem(eventRec->eventId,recordNumber, &freezeframe)) {\r
+ memcpy(destBuffer, freezeframe->data, FFDataSize); /** @req DEM071 */\r
+ *bufSize = FFDataSize;\r
+ returnCode = DEM_GET_FFDATABYDTC_OK;\r
+ }\r
+ else {\r
+ *bufSize = 0;\r
+ returnCode = DEM_GET_FFDATABYDTC_OK;\r
+ }\r
+ break;\r
+\r
+ case DEM_DTC_ORIGIN_SECONDARY_MEMORY:\r
+ case DEM_DTC_ORIGIN_PERMANENT_MEMORY:\r
+ case DEM_DTC_ORIGIN_MIRROR_MEMORY:\r
+ // Not yet supported\r
+ returnCode = DEM_GET_FFDATABYDTC_WRONG_DTCORIGIN;\r
+ DET_REPORTERROR(MODULE_ID_DEM, 0, DEM_GETFREEZEFRAMEDATARECORDBYDTC_ID, DEM_E_NOT_IMPLEMENTED_YET);\r
+ break;\r
+ default:\r
+ returnCode = DEM_GET_FFDATABYDTC_WRONG_DTCORIGIN;\r
+ break;\r
+ }\r
+ }\r
+ else{\r
+ returnCode = DEM_GET_FFDATABYDTC_BUFFERSIZE;\r
+ }\r
+ }\r
+ else {\r
+ returnCode = DEM_GET_FFDATABYDTC_BUFFERSIZE;\r
+ }\r
+ }\r
+ else {\r
+ returnCode = DEM_GET_FFDATABYDTC_RECORDNUMBER;\r
+ }\r
+ }\r
+ else {\r
+ returnCode = DEM_GET_FFDATABYDTC_WRONG_DTCORIGIN;\r
+ }\r
+ }\r
+ else {\r
+ returnCode = DEM_GET_FFDATABYDTC_WRONG_DTCKIND;\r
+ }\r
+ }\r
+ else{\r
+ returnCode = DEM_GET_FFDATABYDTC_WRONG_DTC;\r
+\r
+ }\r
+ } else {\r
+ DET_REPORTERROR(MODULE_ID_DEM, 0, DEM_GETFREEZEFRAMEDATARECORDBYDTC_ID, DEM_E_UNINIT);\r
+ returnCode = DEM_GET_ID_PENDING;\r
+ }\r
+\r
+ return returnCode;\r
+\r
+\r
+}\r
+\r
+/*\r
+ * Procedure: Dem_GetFreezeFrameDataIdentifierByDTC\r
+ * Reentrant: No\r
+ */\r
+Dem_GetFreezeFameDataIdentifierByDTCType Dem_GetFreezeFrameDataIdentifierByDTC(uint32 dtc,\r
+ Dem_DTCKindType dtcKind,\r
+ Dem_DTCOriginType dtcOrigin,\r
+ uint8 recordNumber,\r
+ uint8* arraySize,\r
+ const uint16** dataId )/** @req DEM237 */\r
+{\r
+ Dem_GetFreezeFameDataIdentifierByDTCType returnCode = DEM_GET_ID_WRONG_FF_TYPE;\r
+ Dem_FreezeFrameClassType const *FFDataRecordClass = NULL;\r
+ EventStatusRecType *eventRec;\r
+ uint8 didNum = 0;\r
+ uint16 i = 0;\r
+ if (demState == DEM_INITIALIZED) {\r
+ if (lookupDtcEvent(dtc, &eventRec)) {\r
+ if (checkDtcKind(dtcKind, eventRec->eventParamRef)) {\r
+ if (checkDtcOrigin(dtcOrigin, eventRec->eventParamRef)) {\r
+ if (lookupFreezeFrameDataRecNumParam(recordNumber, eventRec->eventParamRef, &FFDataRecordClass)) {\r
+ if(FFDataRecordClass->FFIdClassRef != NULL){\r
+ for(i=0; (i < DEM_MAX_NR_OF_RECORDS_IN_FREEZEFRAME_DATA) && (!(FFDataRecordClass->FFIdClassRef[i].Arc_EOL)); i++){\r
+ if(didNum < *arraySize){\r
+ dataId[didNum] = &FFDataRecordClass->FFIdClassRef[i].DidIdentifier;/** @req DEM073 */\r
+ didNum++;\r
+ returnCode = DEM_GET_ID_OK;\r
+ }else{\r
+ returnCode = DEM_GET_ID_WRONG_FF_TYPE;\r
+ }\r
+ }\r
+ *arraySize = didNum;\r
+ }\r
+ \r
+ }\r
+ else{\r
+ returnCode = DEM_GET_ID_WRONG_FF_TYPE;\r
+ }\r
+ }\r
+ else{\r
+ returnCode = DEM_GET_ID_WRONG_DTCORIGIN;\r
+ }\r
+ }\r
+ else{\r
+ returnCode = DEM_GET_ID_WRONG_DTCKIND;\r
+ }\r
+ }\r
+ else{\r
+ returnCode = DEM_GET_ID_WRONG_DTC;\r
+ }\r
+ \r
+ } \r
+ else{\r
+ DET_REPORTERROR(MODULE_ID_DEM, 0, DEM_GETFREEZEFRAMEDATAIDENTIFIERBYDTC_ID, DEM_E_UNINIT);\r
+ }\r
+\r
+ return returnCode;\r
+\r
+}\r
+\r
+/*\r
+ * Procedure: Dem_GetSizeOfFreezeFrame\r
+ * Reentrant: No\r
+ */\r
+ /** @req DEM238 */\r
+Dem_ReturnGetSizeOfFreezeFrameType Dem_GetSizeOfFreezeFrame(uint32 dtc,Dem_DTCKindType dtcKind,Dem_DTCOriginType dtcOrigin,uint8 recordNumber,uint16* sizeOfFreezeFrame) \r
+{\r
+ Dem_ReturnGetSizeOfFreezeFrameType returnCode = DEM_GET_SIZEOFFF_PENDING;\r
+ Dem_FreezeFrameClassType const *FFDataRecordClass = NULL;\r
+ Std_ReturnType callbackReturnCode;\r
+ EventStatusRecType *eventRec;\r
+ uint16 dataSize = 0;\r
+ uint16 i = 0;\r
+ \r
+ if (demState == DEM_INITIALIZED) {\r
+ if (lookupDtcEvent(dtc, &eventRec)) {\r
+ if (checkDtcKind(dtcKind, eventRec->eventParamRef)) {\r
+ if (checkDtcOrigin(dtcOrigin, eventRec->eventParamRef)) {\r
+ if (lookupFreezeFrameDataRecNumParam(recordNumber, eventRec->eventParamRef, &FFDataRecordClass)) {\r
+ if(FFDataRecordClass->FFIdClassRef != NULL){\r
+ for(i = 0; (i < DEM_MAX_NR_OF_RECORDS_IN_FREEZEFRAME_DATA) && (!(FFDataRecordClass->FFIdClassRef[i].Arc_EOL)); i++){\r
+ /* read out the did size */\r
+ if(FFDataRecordClass->FFIdClassRef[i].DidReadDataLengthFnc != NULL){\r
+ callbackReturnCode = FFDataRecordClass->FFIdClassRef[i].DidReadDataLengthFnc(&dataSize);\r
+ if(callbackReturnCode != E_OK){\r
+ return (returnCode = DEM_GET_SIZEOFFF_PENDING);\r
+ }\r
+ }\r
+ else{\r
+ dataSize = FFDataRecordClass->FFIdClassRef[i].PidOrDidSize;\r
+ }\r
+ *sizeOfFreezeFrame += dataSize+DEM_DID_IDENTIFIER_SIZE_OF_BYTES;/** @req DEM074 */\r
+ returnCode = DEM_GET_SIZEOFFF_OK; \r
+ } \r
+ }\r
+ }\r
+ else{\r
+ returnCode = DEM_GET_SIZEOFFF_WRONG_RNUM;\r
+ }\r
+ }\r
+ else{\r
+ returnCode = DEM_GET_SIZEOFFF_WRONG_DTCOR;\r
+ }\r
+ }\r
+ else{\r
+ returnCode = DEM_GET_SIZEOFFF_WRONG_DTCKIND;\r
+ }\r
+ }\r
+ else{\r
+ returnCode = DEM_GET_SIZEOFFF_WRONG_DTC;\r
+ }\r
+ \r
+ } \r
+ else{\r
+ DET_REPORTERROR(MODULE_ID_DEM, 0, DEM_GETFREEZEFRAMEDATAIDENTIFIERBYDTC_ID, DEM_E_UNINIT);\r
+ returnCode = DEM_GET_SIZEOFFF_PENDING;\r
+ }\r
+\r
+ return returnCode;\r
+\r
+\r
+}\r
+\r
+\r
+#ifdef DEM_UNIT_TEST\r
+void getFFDataPreInit(FreezeFrameRecType **buf)\r
+{\r
+ *buf = &preInitFreezeFrameBuffer[0];\r
+ return;\r
+}\r
+void getPriMemFFBufPtr(FreezeFrameRecType **buf)\r
+{\r
+ *buf = &priMemFreezeFrameBuffer[0];\r
+ return;\r
+}\r
+\r
+uint32 getCurTimeStamp()\r
+{\r
+ return FF_TimeStamp;\r
+}\r
+\r
+void getPriMemEventRecBufPtr(EventStatusRecType **buf)\r
+{\r
+ *buf = &eventStatusBuffer[0];\r
+ return;\r
+}\r
+\r
+void getPriMemAgingBufPtr(AgingRecType **buf)\r
+{\r
+ *buf = &priMemAgingBuffer[0];\r
+ return;\r
+}\r
+#endif\r
+\r
+\r
+\r
+\r
+\r
/***********************************\r
* OBD-specific Interfaces (8.3.6) *\r
***********************************/\r