AUTOSAR Classic Memory Services

Die Memory Services verwalten nicht-flüchtige Datenblöcke (NvM), abstrahieren Flash- und EEPROM-Technologien (MemIf, Fee, Ea) und gewährleisten Datenkonsistenz und Datensicherheit über ECU-Abschaltzyklen hinweg.

Themenkarte

Detailansicht

Wähle in der Gliederung einen Eintrag aus.

Für dieses Release liegen keine Elementdaten vor

BndM

BndM_Init function

Initializes or reinitializes this module.

void BndM_Init(const BndM_ConfigType* ConfigPtr);

BndM_JobEndNotification function

This callback function is called when a FLS job has been finished with positive result.

void BndM_JobEndNotification(void);

BndM_JobErrorNotification function

This callback function is called when a FLS job has been canceled or finished with negative result.

void BndM_JobErrorNotification(void);

BndM_MainFunction function

Schedule function for the background processing.

void BndM_MainFunction(void);

BndM_WriteCancel function

Cancels the writing

void BndM_WriteCancel(void);

BndM_BlockIdType type

Unique identification of an bulk nv block. The BndM_BlockId is assigned by the BndM.

BndM_Block{BlockId.Shortname}Type type

The elements of this structure data type is the C-structured representation of the configured ImplementationDataPrototype.

BndM_ConfigType type

This type of the external data structure shall contain the post build initialization data for the BndM.

BndM_ResultType type

Result of the asynchronous job finish notifications

Ea

Ea_Cancel function

Cancels the ongoing asynchronous operation.

void Ea_Cancel (void);

Ea_EraseImmediateBlock function

Erases the block Block Number.

Std_ReturnType Ea_EraseImmediateBlock (uint16 BlockNumber);

Ea_GetJobResult function

Service to return the Job Result.

MemIf_JobResultType Ea_GetJobResult (void);

Ea_GetStatus function

Service to return the Status.

MemIf_StatusType Ea_GetStatus (void);

Ea_GetVersionInfo function

Service to get the version information of this module.

void Ea_GetVersionInfo (Std_VersionInfoType* VersionInfoPtr);

Ea_Init function

Initializes the EEPROM abstraction module.

void Ea_Init (const Ea_ConfigType* ConfigPtr);

Ea_InvalidateBlock function

Invalidates the block Block Number.

Std_ReturnType Ea_InvalidateBlock (uint16 BlockNumber);

Ea_JobEndNotification function

Service to report to this module the successful end of an asynchronous operation.

void Ea_JobEndNotification (void);

Ea_JobErrorNotification function

Service to report to this module the failure of an asynchronous operation.

void Ea_JobErrorNotification (void);

Ea_MainFunction function

Service to handle the requested jobs and the internal management operations.

void Ea_MainFunction (void);

Ea_Read function

Reads Length bytes of block Blocknumber at offset Block Offset into the buffer Data Buffer Ptr.

Std_ReturnType Ea_Read (uint16 BlockNumber, uint16 BlockOffset, uint8* DataBufferPtr, uint16 Length);

Ea_SetMode function

Function to switch the mode of the underlying EEPROM Driver

void Ea_SetMode (MemIf_ModeType Mode);

Ea_Write function

Writes the contents of the Data Buffer Ptr to the block Block Number.

Std_ReturnType Ea_Write (uint16 BlockNumber, const uint8* DataBufferPtr);

NvM_JobEndNotification function

Function to be used by the underlying memory abstraction to signal end of job without error.

void NvM_JobEndNotification (void);

NvM_JobErrorNotification function

Function to be used by the underlying memory abstraction to signal end of job with error.

void NvM_JobErrorNotification (void);

Ea_ConfigType type

Configuration data structure of the Ea module.

Eep

Eep_Cancel function

Cancels a running job.

void Eep_Cancel(void);

Eep_Compare function

Compares a data block in EEPROM with an EEPROM block in the memory.

Std_ReturnType Eep_Compare(Eep_AddressType EepromAddress, const uint8* DataBufferPtr, Eep_LengthType Length);

Eep_Erase function

Service for erasing EEPROM sections.

Std_ReturnType Eep_Erase(Eep_AddressType EepromAddress, Eep_LengthType Length);

Eep_GetJobResult function

This service returns the result of the last job.

MemIf_JobResultType Eep_GetJobResult(void);

Eep_GetStatus function

Returns the EEPROM status.

MemIf_StatusType Eep_GetStatus(void);

Eep_GetVersionInfo function

Service to get the version information of this module.

void Eep_GetVersionInfo(Std_VersionInfoType* versioninfo);

Eep_Init function

Service for EEPROM initialization.

void Eep_Init(const Eep_ConfigType* ConfigPtr);

Eep_JobEndNotification function

This callback function provided by the module user is called when a job has been completed with a positive result.

void Eep_JobEndNotification(void);

Eep_JobErrorNotification function

This callback function provided by the module user is called when a job has been canceled or finished with negative result.

void Eep_JobErrorNotification(void);

Eep_MainFunction function

Service to perform the processing of the EEPROM jobs (read/write/erase/compare) .

void Eep_MainFunction(void);

Eep_Read function

Reads from EEPROM.

Std_ReturnType Eep_Read(Eep_AddressType EepromAddress, uint8* DataBufferPtr, Eep_LengthType Length);

Eep_SetMode function

Sets the mode.

void Eep_SetMode(MemIf_ModeType Mode);

Eep_Write function

Writes to EEPROM.

Std_ReturnType Eep_Write(Eep_AddressType EepromAddress, const uint8* DataBufferPtr, Eep_LengthType Length);

Eep_AddressType type

Used as address offset from the configured EEPROM base address to access a certain EEPROM memory area.

Eep_ConfigType type

This is the type of the external data structure containing the initialization data for the EEPROM driver.

Eep_LengthType type

Specifies the number of bytes to read/write/erase/compare.

Fee

Fee_Cancel function

Service to call the cancel function of the underlying flash driver.

void Fee_Cancel (void);

Fee_EraseImmediateBlock function

Service to erase a logical block.

Std_ReturnType Fee_EraseImmediateBlock (uint16 BlockNumber);

Fee_GetJobResult function

Service to query the result of the last accepted job issued by the upper layer software.

MemIf_JobResultType Fee_GetJobResult (void);

Fee_GetStatus function

Service to return the status. AUTOSAR CP R20 - of Document ID : AUTOSAR_SWS_FlashEEPROMEmulation

MemIf_StatusType Fee_GetStatus (void);

Fee_GetVersionInfo function

Service to return the version information of the FEE module.

void Fee_GetVersionInfo (Std_VersionInfoType* VersionInfoPtr);

Fee_Init function

Service to initialize the FEE module.

void Fee_Init (const Fee_ConfigType* ConfigPtr);

Fee_InvalidateBlock function

Service to invalidate a logical block.

Std_ReturnType Fee_InvalidateBlock (uint16 BlockNumber);

Fee_JobEndNotification function

Service to report to this module the successful end of an asynchronous operation. AUTOSAR CP R20 - of Document ID : AUTOSAR_SWS_FlashEEPROMEmulation

void Fee_JobEndNotification (void);

Fee_JobErrorNotification function

Service to report to this module the failure of an asynchronous operation.

void Fee_JobErrorNotification (void);

Fee_MainFunction function

Service to handle the requested read / write / erase jobs and the internal management operations.

void Fee_MainFunction (void);

Fee_Read function

Service to initiate a read job.

Std_ReturnType Fee_Read (uint16 BlockNumber, uint16 BlockOffset, uint8* DataBufferPtr, uint16 Length);

Fee_SetMode function

Function to switch the mode of the underlying Flash Driver

void Fee_SetMode (MemIf_ModeType Mode);

Fee_Write function

Service to initiate a write job.

Std_ReturnType Fee_Write (uint16 BlockNumber, const uint8* DataBufferPtr);

NvM_JobEndNotification (Fee) function

void NvM_JobEndNotification (void);

NvM_JobErrorNotification (Fee) function

void NvM_JobErrorNotification (void);

Fee_ConfigType type

Configuration data structure of the Fee module.

Fls

Fee_JobEndNotification (Fls) function

This callback function is called when a job has been completed with a positive result.

void Fee_JobEndNotification(void);

Fee_JobErrorNotification (Fls) function

This callback function is called when a job has been canceled or finished with negative result.

void Fee_JobErrorNotification(void);

Fls_BlankCheck function

The function Fls_BlankCheck shall verify, whether a given memory area has been erased but not (yet) programmed. The function shall limit the maximum number of checked flash cells per main function cycle to the configured value FlsMaxReadNormalMode or FlsMaxReadFastMode respectively.

Std_ReturnType Fls_BlankCheck(Fls_AddressType TargetAddress, Fls_LengthType Length);

Fls_Cancel function

Cancels an ongoing job.

void Fls_Cancel(void);

Fls_Compare function

Compares the contents of an area of flash memory with that of an application data buffer.

Std_ReturnType Fls_Compare(Fls_AddressType SourceAddress, const uint8* TargetAddressPtr, Fls_LengthType Length);

Fls_Erase function

Erases flash sector(s).

Std_ReturnType Fls_Erase(Fls_AddressType TargetAddress, Fls_LengthType Length);

Fls_GetJobResult function

Returns the result of the last job.

MemIf_JobResultType Fls_GetJobResult(void);

Fls_GetStatus function

Returns the driver state.

MemIf_StatusType Fls_GetStatus(void);

Fls_GetVersionInfo function

Returns the version information of this module.

void Fls_GetVersionInfo(Std_VersionInfoType* VersioninfoPtr);

Fls_Init function

Initializes the Flash Driver.

void Fls_Init(const Fls_ConfigType* ConfigPtr);

Fls_MainFunction function

Performs the processing of jobs.

void Fls_MainFunction(void);

Fls_Read function

Reads from flash memory.

Std_ReturnType Fls_Read(Fls_AddressType SourceAddress, uint8* TargetAddressPtr, Fls_LengthType Length);

Fls_SetMode function

Sets the flash driver's operation mode.

void Fls_SetMode(MemIf_ModeType Mode);

Fls_Write function

Writes one or more complete flash pages.

Std_ReturnType Fls_Write(Fls_AddressType TargetAddress, const uint8* SourceAddressPtr, Fls_LengthType Length);

Fls_AddressType type

Used as address offset from the configured flash base address to access a certain flash memory area.

Fls_ConfigType type

A pointer to such a structure is provided to the flash driver initialization routine for configuration of the driver and flash memory hardware.

Fls_LengthType type

Specifies the number of bytes to read/write/erase/compare.

FlsTst

FlsTst_Abort function

Service for aborting the Flash Test.

void FlsTst_Abort(void);

FlsTst_DeInit function

Service for Flash Test De - Initialization.

void FlsTst_DeInit(void);

FlsTst_GetVersionInfo function

Service returns the version information of this module.

void FlsTst_GetVersionInfo(Std_VersionInfoType* versioninfo);

FlsTst_Init function

Service for Flash Test initialization.

void FlsTst_Init(const FlsTst_ConfigType* ConfigPtr);

FlsTst_MainFunction function

Service for executing the Flash Test in background mode.

void FlsTst_MainFunction(void);

FlsTst_Resume function

Service for continuing the Flash Test at the point it was suspended.

void FlsTst_Resume(void);

FlsTst_StartFgnd function

Service for executing foreground Flash Test.

Std_ReturnType FlsTst_StartFgnd(FlsTst_BlockIdFgndType FgndBlockId);

FlsTst_Suspend function

Service for suspending current operation of the Flash Test, until Fls Tst_ Resume is called.

void FlsTst_Suspend(void);

FlsTst_TestCompletedNotification function

The function Fls Tst_ Test Completed shall be called every time when a complete test cycle had been tested.

void FlsTst_TestCompletedNotification(void);

FlsTst_TestEcc function

Service executes a test of ECC hardware. This is only applicable in case the hardware provices such functionality.

Std_ReturnType FlsTst_TestEcc(void);

Tst_ErrorDetailsTypeFlsTst_GetErrorDetails function

Service returns error detais monitored from the Flash module.

FlsTst_ErrorDetailsType FlsTst_GetErrorDetails(void);

Tst_StateTypeFlsTst_GetCurrentState function

Service returns the current Flash Test exection state.

FlsTst_StateType FlsTst_GetCurrentState(void);

Tst_TestResultBgndTypeFlsTst_GetTestResultBgnd function

Service returns the Background Flash Test result.

FlsTst_TestResultBgndType FlsTst_GetTestResultBgnd(void);

Tst_TestResultFgndTypeFlsTst_GetTestResultFgnd function

Service returns the Foreground Flash Test result.

FlsTst_TestResultFgndType FlsTst_GetTestResultFgnd(void);

Tst_TestSignatureBgndTypeFlsTst_GetTestSignatureBgnd function

Service returns the Flash Test result in background mode.

FlsTst_TestSignatureBgndType FlsTst_GetTestSignatureBgnd(void);

Tst_TestSignatureFgndTypeFlsTst_GetTestSignatureFgnd function

Service returns the Flash Test result in foreground mode.

FlsTst_TestSignatureFgndType FlsTst_GetTestSignatureFgnd(void);

FlsTst_BlockIdFgndType type

This type specifies the identification (ID) for a Flash block to be tested in foreground mode, which is configured in the configuration structure.

FlsTst_ConfigType type

This type of external data structure shall contain the initialization data for the Flash Test.

FlsTst_ErrorDetailsType type

This type shall specify implementation specific error information monitored in the Flash test module.

FlsTst_StateType type

This is a state value returned by the API service Fls Tst_ Get Current State().

FlsTst_TestResultBgndType type

Return type of API service Fls Tst_ Get Test Result Bgnd().

FlsTst_TestResultFgndType type

Return type of API service Fls Tst_ Get Result Fgnd().

FlsTst_TestResultType type

FlsTst_TestSignatureBgndType type

Type for test signature in background mode.

FlsTst_TestSignatureFgndType type

Type for test signature in foreground mode

Mem

Mem_BlankCheck function

Triggers a job to check the erased state of the page which is referenced by targetAddress. The result of this service can be retrieved using the Mem_GetJobResult API. If the checked page is blank, the result of the job is MEM_JOB_OK. Otherwise, if the page is not blank, the result is MEM_INCONSISTENT.

Std_ReturnType Mem_BlankCheck(Mem_InstanceIdType instanceId, Mem_AddressType targetAddress, Mem_LengthType length);

Mem_DeInit function

De-initialize module. If there is still an access job pending, it is immediately terminated (using hardware cancel operation) and the Mem driver module state is set to unitialized. Therefore, Mem must be re-initialized before it will accept any new job requests after this service is processed.

void Mem_DeInit(void);

Mem_Erase function

Triggers an erase job of the given sector/sector batch defined by targetAddress and length. The result of this service can be retrieved using the Mem_GetJobResult API. If the erase operation was successful, the result of the job is MEM_JOB_OK. If the erase operation failed, e.g. due to a hardware issue, the result of the job is MEM_JOB_FAILED.

Std_ReturnType Mem_Erase(Mem_InstanceIdType instanceId, Mem_AddressType targetAddress, Mem_LengthType length);

Mem_GetJobResult function

Service to return results of the most recent job.

Mem_JobResultType Mem_GetJobResult(Mem_InstanceIdType instanceId);

Mem_GetVersionInfo function

Service to return the version information of the Mem module.

void Mem_GetVersionInfo(Std_VersionInfoType* versionInfoPtr);

Mem_HwSpecificService function

Triggers a hardware specific memory driver job. dataPtr can be used to pass and return data to/ from this service. This service is just a dispatcher to the hardware specific service implementation referenced by hwServiceId. The result of this service can be retrieved using the Mem_GetJobResult API. If the hardware specific operation was successful, the result of the job is MEM_JOB_OK. If the hardware specific operation failed, the result of the job is MEM_JOB_ FAILED. Tags: atp.Status=draft

Std_ReturnType Mem_HwSpecificService(Mem_InstanceIdType instanceId, Mem_HwServiceIdType hwServiceId, Mem_DataType* dataPtr, Mem_LengthType* lengthPtr);

Mem_Init function

Initialization function - initializes all variables and sets the module state to initialized.

void Mem_Init(const Mem_ConfigType* configPtr);

Mem_MainFunction function

Service to handle the requested jobs and the internal management operations.

void Mem_MainFunction(void);

Mem_PropagateError function

This service can be used to report an access error in case the Mem driver cannot provide the access error information - typically for ECC faults. It is called by the system ECC handler to propagate an ECC error to the memory upper layers..

void Mem_PropagateError(Mem_InstanceIdType instanceId);

Mem_Read function

Triggers a read job to copy the from the source address into the referenced destination data buffer. The result of this service can be retrieved using the Mem_GetJobResult API. If the read operation was successful, the result of the job is MEM_JOB_OK. If the read operation failed, the result of the job is either MEM_JOB_FAILED in case of a general error or MEM_ECC_ CORRECTED/MEM_ECC_UNCORRECTED in case of a correctable/uncorrectable ECC error.

Std_ReturnType Mem_Read(Mem_InstanceIdType instanceId, Mem_AddressType sourceAddress, Mem_DataType* destinationDataPtr, Mem_LengthType length);

Mem_Resume function

Resume suspended memory operation using hardware mechanism. Tags: atp.Status=draft

void Mem_Resume(Mem_InstanceIdType instanceId);

Mem_Suspend function

Suspend active memory operation using hardware mechanism. Tags: atp.Status=draft

void Mem_Suspend(Mem_InstanceIdType instanceId);

Mem_Write function

Triggers a write job to store the passed data to the provided address area with given address and length. The result of this service can be retrieved using the Mem_GetJobResult API. If the write operation was successful, the job result is MEM_JOB_OK. If there was an issue writing the data, the result is MEM_FAILED.

Std_ReturnType Mem_Write(Mem_InstanceIdType instanceId, Mem_AddressType targetAddress, const Mem_DataType* sourceDataPtr, Mem_LengthType length);

Mem_AddressType type

Physical memory device address type

Mem_ConfigType type

Postbuild configuration structure type

Mem_DataType type

Read data user buffer type

Mem_HwServiceIdType type

Hardware specific service request identifier type

Mem_InstanceIdType type

Job end notification function called by Mem in case the job processing is configured for job end notification.

Mem_JobResultType type

Asynchronous job result type

Mem_LengthType type

Physical memory device length type

MemAcc

<AddressAreaJobEndNotification> function

MemAcc application job end notification callback. The function name is configurable. Tags: atp.Status=draft

void <AddressAreaJobEndNotification>(MemAcc_AddressAreaIdType addressAreaId, MemAcc_JobResultType jobResult);

<ApplicationLockNotification> function

Address area lock application callback. The function name is configurable. Tags: atp.Status=draft

void <ApplicationLockNotification>(void);

MemAcc_ActivateMem function

Dynamic activation and initialization of a Mem driver referenced by hwId and headerAddress.

Std_ReturnType MemAcc_ActivateMem(MemAcc_AddressType headerAddress, MemAcc_HwIdType hwId);

MemAcc_BlankCheck function

Checks if the passed address space is blank, i.e. erased and writeable. The result of this service can be retrieved using the MemAcc_GetJobResult API. If the address area defined by targetAddress and length is blank, the result is MEMACC_MEM_OK, otherwise the result is MEMACC_MEM_INCONSISTENT.

Std_ReturnType MemAcc_BlankCheck(MemAcc_AddressAreaIdType addressAreaId, MemAcc_AddressType targetAddress, MemAcc_LengthType length);

MemAcc_Cancel function

Triggers a cancel operation of the pending job for the address area referenced by the address AreaId. Cancelling affects only jobs in pending state. For any other states, the request will be ignored.

void MemAcc_Cancel(MemAcc_AddressAreaIdType addressAreaId);

MemAcc_Compare function

Triggers a job to compare the passed data to the memory content of the provided address area. The job terminates, if all bytes matched or a difference was detected. The result of this service can be retrieved using the MemAcc_GetJobResult() API. If the compare operation determined a mismatch, the result code is MEMACC_MEM_INCONSISTENT. Tags: atp.Status=draft

Std_ReturnType MemAcc_Compare(MemAcc_AddressAreaIdType addressAreaId, MemAcc_AddressType sourceAddress, const MemAcc_DataType* dataPtr, MemAcc_LengthType length);

MemAcc_DeactivateMem function

Dynamic deactivation of a Mem driver referenced by hwId and headerAddress.

Std_ReturnType MemAcc_DeactivateMem(MemAcc_HwIdType hwId, MemAcc_AddressType headerAddress);

MemAcc_DeInit function

Deinitialize module. If there are still access jobs pending, they are immediately terminated and the module state is set to unitialized. Therefore, MemAcc must be re-initialized before it will accept any new job requests after this service is processed.

void MemAcc_DeInit(void);

MemAcc_Erase function

Triggers an erase job of the given area. Triggers an erase job of the given area defined by targetAddress and length. The result of this service can be retrieved using the Mem_GetJobResult API. If the erase operation was successful, the result of the job is MEM_JOB_OK. If the erase operation failed, e.g. due to a hardware issue, the result of the job is MEM_JOB_FAILED.

Std_ReturnType MemAcc_Erase(MemAcc_AddressAreaIdType addressAreaId, MemAcc_AddressType targetAddress, MemAcc_LengthType length);

MemAcc_GetJobInfo function

Returns detailed information of the current memory job like memory device ID, job type, job processing state or job result, address area as well as address and length.

void MemAcc_GetJobInfo(MemAcc_AddressAreaIdType addressAreaId, MemAcc_JobInfoType* jobInfoPtr);

MemAcc_GetJobResult function

Returns the consolidated job result of the address area referenced by addressAreaId.

MemAcc_JobResultType MemAcc_GetJobResult(MemAcc_AddressAreaIdType addressAreaId);

MemAcc_GetJobStatus function

Returns the status of the MemAcc job referenced by addressAreaId.

MemAcc_JobStatusType MemAcc_GetJobStatus(MemAcc_AddressAreaIdType addressAreaId);

MemAcc_GetMemoryInfo function

This service function retrieves the physical memory device information of a specific address area. It can be used by an upper layer to get all necessary information to align the start address and trim the length for erase/write jobs.

Std_ReturnType MemAcc_GetMemoryInfo(MemAcc_AddressAreaIdType addressAreaId, MemAcc_AddressType address, MemAcc_MemoryInfoType* memoryInfoPtr);

MemAcc_GetProcessedLength function

Returns the accumulated number of bytes that have already been processed in the current job.

MemAcc_LengthType MemAcc_GetProcessedLength(MemAcc_AddressAreaIdType addressAreaId);

MemAcc_GetVersionInfo function

Service to return the version information of the MemAcc module.

void MemAcc_GetVersionInfo(Std_VersionInfoType* versionInfoPtr);

MemAcc_HwSpecificService function

Triggers a hardware specific job request referenced by hwServiceId. Service specific data can be passed/retrieved by dataPtr. The result of this service can be retrieved using the MemAcc_GetJobResult API. If the hardware specific operation was successful, the result of the job is MEMACC_MEM_OK. If the hardware specific operation failed, the result of the job is MEMACC_MEM_FAILED.

Std_ReturnType MemAcc_HwSpecificService(MemAcc_AddressAreaIdType addressAreaId, MemAcc_HwIdType hwId, MemAcc_MemHwServiceIdType hwServiceId, MemAcc_DataType* dataPtr, MemAcc_LengthType* lengthPtr);

MemAcc_Init function

Initialization function - initializes all variables and sets the module state to initialized.

void MemAcc_Init(const MemAcc_ConfigType* configPtr);

MemAcc_MainFunction function

Service to handle the requested jobs and the internal management operations. Depending on the configuration MemAcc will call the Mem driver main functions.

void MemAcc_MainFunction(void);

MemAcc_Read function

Triggers a read job to copy data from the source address into the referenced destination data buffer. The result of this service can be retrieved using the MemAcc_GetJobResult API. If the read operation was successful, the result of the job is MEMACC_MEM_OK. If the read operation failed, the result of the job is either MEMACC_MEM_FAILED in case of a general error or MEMACC_MEM_ECC_CORRECTED/MEMACC_MEM_ECC_UNCORRECTED in case of a correctable/uncorrectable ECC error.

Std_ReturnType MemAcc_Read(MemAcc_AddressAreaIdType addressAreaId, MemAcc_AddressType sourceAddress, MemAcc_DataType* destinationDataPtr, MemAcc_LengthType length);

MemAcc_ReleaseLock function

Release access lock of provided address area. Tags: atp.Status=draft

Std_ReturnType MemAcc_ReleaseLock(MemAcc_AddressAreaIdType addressAreaId, MemAcc_AddressType address, MemAcc_LengthType length);

MemAcc_RequestLock function

Request lock of an address area for exclusive access. Once the lock is granted, the referenced lock notification function is called by MemAcc.

Std_ReturnType MemAcc_RequestLock(MemAcc_AddressAreaIdType addressAreaId, MemAcc_AddressType address, MemAcc_AddressType length, void* lockNotificationFctPtr);

MemAcc_Write function

Triggers a write job to store the passed data to the provided address area with given address and length. The result of this service can be retrieved using the MemAcc_GetJobResult API. If the write operation was successful, the job result is MEMACC_MEM_OK. If there was an issue writing the data, the result is MEMACC_MEM_FAILED.

Std_ReturnType MemAcc_Write(MemAcc_AddressAreaIdType addressAreaId, MemAcc_AddressType targetAddress, const MemAcc_DataType* sourceDataPtr, MemAcc_LengthType length);

MemAcc_AddressAreaIdType type

Unique address area ID type.

MemAcc_AddressType type

Logical memory address type.

MemAcc_ApplicationLockNotificationType type

Type of the function pointer to register an application callback to be notified once the address area lock was successfully acquired.

MemAcc_ConfigType type

Postbuild configuration structure type.

MemAcc_DataType type

General data type.

MemAcc_HwIdType type

Type for the unique numeric identifiers of all Mem hardware instances used for hardware specific requests.

MemAcc_JobInfoType type

This structure contains information the current processing state of the MemAcc module.

MemAcc_JobResultType type

Asynchronous job result type.

MemAcc_JobStatusType type

Asynchronous job status type.

MemAcc_JobType type

Type for asynchronous jobs.

MemAcc_LengthType type

Job length type.

MemAcc_MemAddressType type

Physical memory device address type

MemAcc_MemBinaryHeaderType type

This structure contains elements for accessing the Mem driver service functions and consistency information. Tags: atp.Status=draft

MemAcc_MemBlankCheckFuncType type

Function pointer for the Mem_BlankCheck service for the invocation of the Mem driver API via function pointer interface. Tags: atp.Status=draft

MemAcc_MemConfigType type

Memory driver configuration structure type

MemAcc_MemDataType type

General data type

MemAcc_MemDeInitFuncType type

Function pointer for the Mem_DeInit service for the invocation of the Mem driver API via function pointer interface.

MemAcc_MemEraseFuncType type

Function pointer for the Mem_Erase service for the invocation of the Mem driver API via function pointer interface. Tags: atp.Status=draft

MemAcc_MemGetJobResultFuncType type

Function pointer for the Mem_JobResultType service for the invocation of the Mem driver API via function pointer interface.

MemAcc_MemHwServiceIdType type

Index type for Mem driver hardware specific service table.

MemAcc_MemHwSpecificServiceFuncType type

Function pointer for the Mem_HwSpecificService function for the invocation of the Mem driver API via function pointer interface. Tags: atp.Status=draft

MemAcc_MemInitFuncType type

Function pointer for the Mem_Init service for the invocation of the Mem driver API via function pointer interface.

MemAcc_MemInstanceIdType type

Memory driver instance ID type

MemAcc_MemJobResultType type

Asynchronous job result type

MemAcc_MemLengthType type

Physical memory device length type

MemAcc_MemMainFuncType type

Function pointer for the Mem_MainFunction service for the invocation of the Mem driver API via function pointer interface.

MemAcc_MemoryInfoType type

This structure contains information of Mem device characteristics. It can be accessed via the MemAcc_GetMemoryInfo() service. Tags: atp.Status=draft

MemAcc_MemPropagateErrorFuncType type

Function pointer for the Mem_PropagateError service for the invocation of the Mem driver API via function pointer interface.

MemAcc_MemReadFuncType type

Function pointer for the Mem_Read service for the invocation of the Mem driver API via function pointer interface. Tags: atp.Status=draft

MemAcc_MemResumeFuncType type

Function pointer for the Mem_Resume service for the invocation of the Mem driver API via function pointer interface. Tags: atp.Status=draft

MemAcc_MemSuspendFuncType type

Function pointer for the Mem_Suspend service for the invocation of the Mem driver API via function pointer interface. Tags: atp.Status=draft

MemAcc_MemWriteFuncType type

Function pointer for the Mem_Write service for the invocation of the Mem driver API via function pointer interface. Tags: atp.Status=draft

MemIf

MemIf_Cancel function

Invokes the "Cancel" function of the underlying memory abstraction module selected by the parameter Device Index.

void MemIf_Cancel (uint8 DeviceIndex);

MemIf_EraseImmediateBlock function

Invokes the "Erase Immediate Block" function of the underlying memory abstraction module selected by the parameter Device Index.

Std_ReturnType MemIf_EraseImmediateBlock (uint8 DeviceIndex, uint16 BlockNumber);

MemIf_GetJobResult function

Invokes the "Get Job Result" function of the underlying memory abstraction module selected by the parameter Device Index. Available v ia Mem If.h

MemIf_JobResultType MemIf_GetJobResult (uint8 DeviceIndex);

MemIf_GetStatus function

Invokes the "Get Status" function of the underlying memory abstraction module selected by the parameter Device Index.

MemIf_StatusType MemIf_GetStatus (uint8 DeviceIndex);

MemIf_GetVersionInfo function

Returns version information.

void MemIf_GetVersionInfo (Std_VersionInfoType* VersionInfoPtr);

MemIf_InvalidateBlock function

Invokes the "Invalidate Block" function of the underlying memory abstraction module AUTOSAR CP R20 - of Document ID : AUTOSAR_SWS_MemoryAbstractionInterface selected by the parameter Device Index.

Std_ReturnType MemIf_InvalidateBlock (uint8 DeviceIndex, uint16 BlockNumber);

MemIf_Read function

Invokes the "Read" function of the underlying memory abstraction module selected by the parameter Device Index.

Std_ReturnType MemIf_Read (uint8 DeviceIndex, uint16 BlockNumber, uint16 BlockOffset, uint8* DataBufferPtr, uint16 Length);

MemIf_SetMode function

Invokes the "Set Mode" functions of all underlying memory abstraction modules.

void MemIf_SetMode (MemIf_ModeType Mode);

MemIf_Write function

Invokes the "Write" function of the underlying memory abstraction module selected by the parameter Device Index.

Std_ReturnType MemIf_Write (uint8 DeviceIndex, uint16 BlockNumber, const uint8* DataBufferPtr);

MemIf_JobResultType type

Denotes the result of the last job.

MemIf_ModeType type

Denotes the operation mode of the underlying abstraction mod ules and device drivers.

MemIf_StatusType type

Denotes the current status of the underlying abstraction module and device drive. AUTOSAR CP R20 - of Document ID : AUTOSAR_SWS_MemoryAbstractionInterface

NvM

NvM_CancelJobs function

Service to cancel all jobs pending for a NV block.

Std_ReturnType NvM_CancelJobs (NvM_BlockIdType BlockId);

NvM_CancelWriteAll function

Service to cancel a running Nv M_ Write All request.

void NvM_CancelWriteAll (void);

NvM_EraseNvBlock function

Service to erase a NV block.

Std_ReturnType NvM_EraseNvBlock (NvM_BlockIdType BlockId);

NvM_FirstInitAll function

The function initiates a multi block first initialization request. The job of the function does not care if a block exists in the non - volatile memory or not OR if it is valid (i.e. not corrupted) or not, when processing it.

void NvM_FirstInitAll (void);

NvM_GetDataIndex function

Service for getting the currently set Data Index of a datase t NVRAM block

Std_ReturnType NvM_GetDataIndex (NvM_BlockIdType BlockId, uint8* DataIndexPtr);

NvM_GetErrorStatus function

Service to read the block dependent error/ status information.

Std_ReturnType NvM_GetErrorStatus (NvM_BlockIdType BlockId, NvM_RequestResultType* RequestResultPtr);

NvM_GetVersionInfo function

Service to get the version information of the Nv M module.

void NvM_GetVersionInfo (Std_VersionInfoType* versioninfo);

NvM_Init function

Service for resetting all internal variables.

void NvM_Init (const NvM_ConfigType* ConfigPtr);

NvM_InitBlockCallbackFunction function

Per block callback routine which shall be called by the Nv M module when default data needs to be restored in RAM, and a RO M block is not configured. AUTOSAR CP R20 - of Document ID : AUTOSAR_SWS_NVRAMManager

Std_ReturnType NvM_InitBlockCallbackFunction (NvM_InitBlockRequestType InitBlockRequest);

NvM_InvalidateNvBlock function

Service to invalidate a NV block.

Std_ReturnType NvM_InvalidateNvBlock (NvM_BlockIdType BlockId);

NvM_JobEndNotification (NvM) function

Function to be used by the underlying memory abstraction to signal end of job without error.

void NvM_JobEndNotification (void);

NvM_JobErrorNotification (NvM) function

Function to be used by the underlying memory abstraction to signal end of job with error.

void NvM_JobErrorNotification (void);

NvM_MainFunction function

Service for performing the processing of the Nv M jobs.

void NvM_MainFunction (void);

NvM_MultiBlockCallbackFunction function

Common callback routine to notify the upper layer that an asynchronous multi block request has been finished. Available v ia Nv M_ Externals.h

Std_ReturnType NvM_MultiBlockCallbackFunction (NvM_MultiBlockRequestType MultiBlockRequest, NvM_RequestResultType JobResult);

NvM_ReadAll function

Initiates a multi block read request.

void NvM_ReadAll (void);

NvM_ReadBlock function

Service to copy the data of the NV block to its corresponding RAM block.

Std_ReturnType NvM_ReadBlock (NvM_BlockIdType BlockId, void* NvM_DstPtr);

NvM_ReadPRAMBlock function

Service to copy the data of the NV block to its corresponding permanent RAM block.

Std_ReturnType NvM_ReadPRAMBlock (NvM_BlockIdType BlockId);

NvM_ReadRamBlockFromNvm function

Block specific callback routine which shall be called in order to let the application copy data from Nv M module's mirror to RAM block.

Std_ReturnType NvM_ReadRamBlockFromNvm (const void* NvMBuffer);

NvM_RestoreBlockDefaults function

Service to restore the default data to its corr esponding RAM block.

Std_ReturnType NvM_RestoreBlockDefaults (NvM_BlockIdType BlockId, void* NvM_DestPtr);

NvM_RestorePRAMBlockDefaults function

Service to restore the default data to its corresponding permanent RAM block.

Std_ReturnType NvM_RestorePRAMBlockDefaults (NvM_BlockIdType BlockId);

NvM_SetBlockLockStatus function

Service for setting the lock status of a permanent RAM block or of the explicit synchronization of a NVRAM block.

void NvM_SetBlockLockStatus (NvM_BlockIdType BlockId, boolean BlockLocked);

NvM_SetBlockProtection function

Service for setting/ resetting the write protection for a NV block. Availabl e via Nv M.h

Std_ReturnType NvM_SetBlockProtection (NvM_BlockIdType BlockId, boolean ProtectionEnabled);

NvM_SetDataIndex function

Service for setting the Data Inde x of a dataset NVRAM block.

Std_ReturnType NvM_SetDataIndex (NvM_BlockIdType BlockId, uint8 DataIndex);

NvM_SetRamBlockStatus function

Service for setting the RAM block status of a permanent RAM block or the status of the explicit synchronization of a NVRAM block.

Std_ReturnType NvM_SetRamBlockStatus (NvM_BlockIdType BlockId, boolean BlockChanged);

NvM_SingleBlockCallbackFunction function

Per block callback routine to notify the upper layer that an asynchronous single block request has been finished.

Std_ReturnType NvM_SingleBlockCallbackFunction (NvM_BlockRequestType BlockRequest, NvM_RequestResultType JobResult);

NvM_ValidateAll function

Initiates a multi block validation request.

void NvM_ValidateAll (void);

NvM_WriteAll function

Initiates a multi block write request.

void NvM_WriteAll (void);

NvM_WriteBlock function

Service to copy the data of the RAM block to its corresponding NV block. Available vi a Nv M.h

Std_ReturnType NvM_WriteBlock (NvM_BlockIdType BlockId, const void* NvM_SrcPtr);

NvM_WritePRAMBlock function

Service to copy the data of the permanent RAM block to its corresponding NV block.

Std_ReturnType NvM_WritePRAMBlock (NvM_BlockIdType BlockId);

NvM_WriteRamBlockToNvm function

Block specific callback routine which shall be called in order to let the application copy data from RAM block to Nv M module's mirror.

Std_ReturnType NvM_WriteRamBlockToNvm (void* NvMBuffer);

NvM_BlockIdType type

Identification of a NVRAM block via a unique block identifier. Reserved NVRAM block IDs: 0 - > to derive multi block request results via Nv M_ Get Error Status 1 - > redundant NVRAM block which holds the configuration ID

NvM_BlockRequestType type

Identifies the type of reques t performed on a block when signaled via the callback function

NvM_ConfigType type

Configuration data structure of the Nv M module.

NvM_InitBlockRequestType type

Identifies the type of request performed on a block when signaled via the callback function

NvM_MultiBlockRequestType type

Identifies the type of request performed on multi block when signaled via the callback function or when reporting to Bsw M

NvM_RequestResultType type

Type NvM_RequestResultType.

RamTst

RamTst_Allow function

Service for continuing the RAM Test after calling 'Ram Tst_ Stop.

void RamTst_Allow(void);

RamTst_ChangeNumberOfTestedCells function

Service changes the current number of tested cells.

void RamTst_ChangeNumberOfTestedCells(RamTst_NumberOfTestedCellsType NewNumberOfTestedCells);

RamTst_DeInit function

Service for RAM Test deinitialization.

void RamTst_DeInit(void);

RamTst_ErrorNotification function

The function Ram Tst_ Error shall be called every time when a RAM failure has been detected by the selected test algorithm in the background.

void RamTst_ErrorNotification(void);

RamTst_GetVersionInfo function

Service returns the version information of this module.

void RamTst_GetVersionInfo(Std_VersionInfoType* versioninfo);

RamTst_Init function

Service for RAM Test initialization.

void RamTst_Init(const RamTst_ConfigType* ConfigPtr);

RamTst_MainFunction function

Scheduled function for executing the RAM Test in the background.

void RamTst_MainFunction(void);

RamTst_Resume function

Service for allowing to continue the background RAM Test at the point is was suspended.

void RamTst_Resume(void);

RamTst_RunFullTest function

Service for executing the full RAM Test in the foreground.

void RamTst_RunFullTest(void);

RamTst_RunPartialTest function

Service for testing one RAM block in the foreground.

void RamTst_RunPartialTest(RamTst_NumberOfBlocksType BlockId);

RamTst_SelectAlgParams function

Service used to set the test algorithm and its parameter set.

void RamTst_SelectAlgParams(RamTst_AlgParamsIdType NewAlgParamsId);

RamTst_Stop function

Service for stopping the RAM Test.

void RamTst_Stop(void);

RamTst_Suspend function

Service for suspending current operation of background RAM Test, until RESUME is called.

void RamTst_Suspend(void);

RamTst_TestCompletedNotification function

The function Ram Tst_ Test Completed shall be called every time when all RAM blocks of the current test configuration have been tested in the background.

void RamTst_TestCompletedNotification(void);

Tst_AlgorithmTypeRamTst_GetTestAlgorithm function

Service returns the current RAM Test algorithm.

RamTst_AlgorithmType RamTst_GetTestAlgorithm(void);

Tst_AlgParamsIdTypeRamTst_GetAlgParams function

Service returns the ID of the current RAM Test algorithm parameter set.

RamTst_AlgParamsIdType RamTst_GetAlgParams(void);

Tst_ExecutionStatusTypeRamTst_GetExecutionStatus function

Service returns the current RAM Test execution status.

RamTst_ExecutionStatusType RamTst_GetExecutionStatus(void);

Tst_NumberOfTestedCellsTypeRamTst_GetNumberOfTestedCells function

Service returns the current number of tested cells per main - function cycle.

RamTst_NumberOfTestedCellsType RamTst_GetNumberOfTestedCells(void);

Tst_TestResultTypeRamTst_GetTestResult function

Service returns the current RAM Test result.

RamTst_TestResultType RamTst_GetTestResult(void);

Tst_TestResultTypeRamTst_GetTestResultPerBlock function

Service returns the current RAM Test result for the specified block.

RamTst_TestResultType RamTst_GetTestResultPerBlock(RamTst_NumberOfBlocksType BlockID);

RamTst_AlgorithmType type

This is a value returned by the API service Ram Tst_ Get Test Algorithm().

RamTst_AlgParamsIdType type

Data type used to identify a set of configuration parameters for a test algorithm.

RamTst_ConfigType type

Configuration data structure of the Ram Tst module.

RamTst_ExecutionStatusType type

This is a status value returned by the API service Ram Tst_ Get Execution Status().

RamTst_NumberOfBlocksType type

Data type used to identify or count RAM blocks given in the test configuration parameters.

RamTst_NumberOfTestedCellsType type

Data type of number of tested RAM cells

RamTst_TestResultType type

This is a status value returned by the API service Ram Tst_ Get Test Result().

Klicke auf einen Eintrag, um seine Bezüge zu sehen.

Cluster GuideKI-GENERIERT

Sichert und verwaltet persistente Daten hardwareunabhängig über strukturierte NVRAM-Blöcke und Abstraktionstreiber.

KI-GENERIERT ungeprüft Modell: gemini-3.8-flash-medium · Aufwand: medium · Temperatur: nicht steuerbar · Prompt: 34f2477a24b6 Herkunft Offene Fragen (1)

KI-generiertgemini-3.8-flash-medium · 2026-10-13

Sichert und verwaltet persistente Daten hardwareunabhängig über strukturierte NVRAM-Blöcke und Abstraktionstreiber.

Das Modulcluster 'Memory Services' realisiert die hardwareunabhängige Speicherung und Konsistenzsicherung nichtflüchtiger Anwendungsdaten über den NVRAM Manager sowie die hardwareabstrahierenden Module MemIf, Fee und Ea ([SWS_NvM_00447], [SWS_MemIf_00039]). Asynchrone Lese- und Schreiboperationen werden über zyklische MainFunctions abgewickelt und während des Steuergeräte-Starts (NvM_ReadAll) sowie beim Shutdown (NvM_WriteAll) gebündelt ausgeführt ModemanagementGuide S. 54. Bei Hardwarefehlern greifen mehrstufige Wiederholungs-, Redundanz- und ROM-Wiederherstellungsmechanismen mit automatischer Berichterstattung an das DEM ([SWS_NvM_00470]).

Das Cluster 'Memory Services' stellt die persistente Speicherung und Verwaltung nichtflüchtiger Daten im AUTOSAR Classic BSW-Stack bereit. Es umfasst den NVRAM Manager ([SWS_NvM_00447]) auf der Service-Ebene sowie das Memory Abstraction Interface ([SWS_MemIf_00039]) mit den Modulen Flash EEPROM Emulation ([SWS_Fee_00085]) und EEPROM Abstraction ([SWS_Ea_00083]) auf der Hardware-Abstraktionsebene AUTOSAR SWS NVRAMManager S. 10.

Architekturdiagramm: Schichtenaufbau und Modulbeziehungen im Memory Services Cluster. Quellen: [SWS_MemIf_00039], AUTOSAR SWS NVRAMManager S. 10

Der Datenaustausch erfolgt über synchrone Steuer-APIs und asynchrone Schreib- bzw. Leseaufträge. Daten werden entweder implizit über permanente RAM-Blöcke oder explizit über modulleitende RAM-Spiegel ausgetauscht ([SWS_NvM_00455], [SWS_NvM_00514]) NVDataHandling S. 12. Die zyklische Bearbeitung eingereihter Aufträge erfolgt über periodisch ausgeführte BSW-Hauptfunktionen (NvM_MainFunction, Fee_MainFunction), während das MemIf Aufrufe zustandslos an die unterlagerten Treiber delegiert ([SWS_MemIf_00040]) AUTOSAR CP SWS FlashEEPROMEmulation S. 42.

Im Betriebszyklus koordiniert der BswM die Multi-Block-Aktionen: Beim Systemstart liest NvM_ReadAll die persistenten Daten aus dem NV-Speicher in den RAM ([SWS_NvM_00460]), während beim Herunterfahren NvM_WriteAll geänderte Daten sichert ([SWS_NvM_00461]) ModemanagementGuide S. 54. Fehlerhafte Lese- oder Schreibzugriffe werden durch Wiederholversuche sowie redundante Kopien oder ROM-Rückfallwerte abgefangen; dauerhafte Fehler meldet das System an das DEM ([SWS_NvM_00470], [SWS_NvM_00279]) ErrorDescription S. 62.

Systemarchitektur & Rolle des Modulclusters

Das Modulcluster der Speicherdienste (Memory Services) der AUTOSAR Classic Platform stellt die standardisierte, hardwareunabhängige Verwaltung und Persistierung von Anwendungs- und Basissoftware-Daten im nichtflüchtigen Speicher sicher. Das Cluster gliedert sich vertikal in zwei Schichten der AUTOSAR-Basissoftwarearchitektur: den NVRAM Manager ([SWS_NvM_00447]) auf der Dienstebene (Services Layer) sowie das Memory Abstraction Interface ([SWS_MemIf_00039]) mit den darunterliegenden Abstraktionsmodulen Flash EEPROM Emulation ([SWS_Fee_00085]) und EEPROM Abstraction ([SWS_Ea_00083]) auf der Hardware-Abstraktionsebene (Memory Hardware Abstraction Layer) AUTOSAR SWS NVRAMManager S. 10.

Der NVRAM Manager (NvM) bildet den zentralen Einstiegspunkt für Software-Komponenten (SW-C) sowie BSW-Module wie das Diagnostic Event Manager-Modul (Dem) SWS DiagnosticEventManager S. 238. Er verwaltet logische Speicherblöcke, die sich aus NV-Blöcken im nichtflüchtigen Speicher, RAM-Blöcken im flüchtigen Speicher sowie optionalen ROM-Blöcken für Initialisierungsdaten zusammensetzen ([SWS_NvM_00137], [SWS_NvM_00128]). Je nach Anforderung werden die Blockverwaltungstypen native (NVM_BLOCK_NATIVE), redundant (NVM_BLOCK_REDUNDANT) oder dataset (NVM_BLOCK_DATASET) unterstützt AUTOSAR CP RS MemoryServices S. 10.

Die Module Fee und Ea kapseln die Besonderheiten der jeweiligen physikalischen Speichermedien (Flash bzw. EEPROM) und bilden logische Blocknummern und Adressoffsets auf die linearen Adressräume der jeweiligen MCAL-Treiber (Fls bzw. Eep) ab ([SWS_Fee_00087], [SWS_Ea_00086]) AUTOSAR SWS EEPROMAbstraction S. 23. Das Modul MemIf dient hierbei als reine Routing-Schicht, die anhand des Parameters DeviceIndex Zugriffe an das Zielmodul weiterleitet, ohne eigene Pufferstrukturen vorzuhalten ([SWS_MemIf_00040]).

Architekturdiagramm: Schichtenaufbau und Modulbeziehungen im Memory Services Cluster. Quellen: [SWS_MemIf_00039], AUTOSAR SWS NVRAMManager S. 10

Zusammenspiel & Interaktionspfade zwischen den Modulen

Die Interaktion zwischen den Modulen erfolgt über strikt standardisierte synchrone und asynchrone Pfade. Initiiert ein Benutzer eine Schreiboperation über NvM_WriteBlock, wird die Anforderung zunächst im administrativen Block des NvM registriert ([SWS_NvM_00455]). Bei synchronem Aufruf erfolgt die Weiterleitung an das MemIf über MemIf_Write ([SWS_MemIf_00040]), welches den Aufruf an Fee_Write oder Ea_Write übergibt ([SWS_Fee_00088], [SWS_Ea_00087]) AUTOSAR SWS NVRAMManager S. 160.

Hinsichtlich der Datenhaltung und Synchronisation zwischen Anwendung und NVRAM Manager existieren zwei Kernkonzepte: die implizite Synchronisation über permanente RAM-Blöcke (NvMRamBlockDataAddress) und die explizite Synchronisation über spiegelbasierte Puffer (NvMBlockUseSyncMechanism) NVDataHandling S. 12. Bei expliziter Synchronisation kopiert der NvM die Nutzdaten über die konfigurierten Callback-Routinen NvMWriteRamBlockToNvCallback bzw. NvMReadRamBlockFromNvCallback zwischen dem Anwendungs-RAM und dem internen RAM-Spiegel ([SWS_NvM_00514], [SWS_NvM_00515]) EXP NVDataHandling S. 30.

Bei der Verwendung von Dataset-Blöcken (NVM_BLOCK_DATASET) selektiert der Aufrufer vorab über NvM_SetDataIndex den gewünschten Datensatzindex ([SWS_NvM_00448]). Die Abstraktionsmodule berechnen daraufhin aus der logischen Blocknummer und dem Index den exakten Adressoffset für den MCAL-Treiber ([SWS_NvM_00123]) AUTOSAR SWS Flash EEPROM Emulation S. 21. Abbruchanforderungen werden über MemIf_Cancel direkt an die Untermodule Fee_Cancel bzw. Ea_Cancel durchgereicht ([SWS_MemIf_00041], [SWS_Fee_00089]).

Sequenzdiagramm: Asynchroner Schreibauftrag mit Callback-Benachrichtigung und Polling. Quellen: [SWS_NvM_00455], AUTOSAR SWS NVRAMManager S. 160

Synchronisation, Reentranz und Task-Kontexte

Die meisten Kontroll- und Status-APIs des Clusters, darunter NvM_GetErrorStatus ([SWS_NvM_00451]), NvM_SetBlockProtection ([SWS_NvM_00450]) und MemIf_GetVersionInfo ([SWS_MemIf_00045]), sind synchron ausgeführt und können direkt im Task-Kontext des Aufrufers abgearbeitet werden AUTOSAR SWS NVRAMManager S. 157. Die datenübertragenden Funktionen (NvM_ReadBlock, NvM_WriteBlock, Ea_Write) sind hingegen asynchron und nicht reentrant ausgelegt ([SWS_MemIf_00040], [SWS_Ea_00087]).

Die zyklische Fortschreibung laufender Aufträge obliegt den periodisch vom Schedule Manager (SchM) bzw. einem BSW-Task aufgerufenen Hauptfunktionen NvM_MainFunction und Fee_MainFunction AUTOSAR CP SWS FlashEEPROMEmulation S. 42. Bei asynchronen Meldungen aus dem MCAL-Treiber kann die Benachrichtigung Fee_JobEndNotification bzw. Fee_JobErrorNotification direkt auf Interrupt-Ebene erfolgen ([SWS_Fee_00095]). Diese setzt den Status auf MEMIF_JOB_OK bzw. ruft konfigurierte Benachrichtigungsroutinen auf ([SWS_Fee_00142], [SWS_Fee_00194]) SWS FlashEEPROMEmulation S. 37.

Interpretation: Um Race Conditions zwischen API-Aufrufern auf Task-Ebene und der schrittweisen Weiterverarbeitung in den MainFunctions zu unterbinden, dürften die internen Warteschlangen und administrativen Attribute durch exklusive Bereiche geschützt werden, während das MemIf als zustandslose Weiterleitungsschicht agiert AUTOSAR SWS NVRAMManager S. 160. Frage Q-a50c3362a14b9e6d (offen)

Typische Lebenszyklen und Betriebsmodi

Der Lebenszyklus des Clusters wird eng durch den Basic Software Mode Manager (BswM) und den ECU State Manager (EcuM) orchestriert. Während des Steuergerätehochlaufs (Startup Phase) werden nach den Treibern zunächst die Abstraktionsmodule über Fee_Init bzw. Ea_Init ([SWS_Fee_00085], [SWS_Ea_00083]) und anschließend der NVRAM Manager über NvM_Init ([SWS_NvM_00447]) synchron initialisiert AUTOSAR SWS NVRAMManager S. 156.

Im Anschluss an die Initialisierung stößt der BswM die Multi-Block-Leseoperation NvM_ReadAll an, um sämtliche als persistent markierten RAM-Blöcke aus dem nichtflüchtigen Speicher zu restaurieren ([SWS_NvM_00460]) ModemanagementGuide S. 54. Den Fortschritt und das Endergebnis meldet der NvM über die Callback-Funktion BswM_NvM_CurrentJobMode an den BswM zurück ([SWS_NvM_00745], [SWS_NvM_00888]). Einzelblockzustände werden über BswM_NvM_CurrentBlockMode signalisiert ([SWS_NvM_00746], [SWS_NvM_00890]) ModemanagementGuide S. 28.

In der Shutdown-Phase veranlasst das System über NvM_WriteAll das persistente Zurückschreiben aller geänderten RAM-Blöcke in den NV-Speicher ([SWS_NvM_00461]). Um die Anzahl der Flash-Schreibzyklen zu optimieren, kann über NvM_SetRamBlockStatus gezielt markiert werden, ob ein Block modifiziert wurde ([SWS_NvM_00453]) EXP NVDataHandling S. 18. Ein laufender Schreibvorgang kann bei vorzeitigen Wakeup-Ereignissen über NvM_CancelWriteAll abgebrochen werden ([SWS_NvM_00238]) AUTOSAR SWS NVRAMManager S. 161.

Fehlerbehandlung, DET-Tracing und Degradation

Das Cluster besitzt ein mehrstufiges Fehlererkennungs- und Degradationskonzept. Auf Treiber- und Abstraktionsebene auftretende Fehler werden über den Rückgabestatus MEMIF_JOB_FAILED mittels MemIf_GetJobResult abgefragt oder über NvM_JobErrorNotification gemeldet ([SWS_Fee_00091], [SWS_Ea_00095]) ErrorDescription S. 49.

Beim Auftreten von Lesefehlern greift der NvM auf konfigurierte Wiederherstellungsmechanismen zurück: Zunächst werden Wiederholversuche (Read Retries) unternommen ([SWS_NvM_00390]). Schlagen diese fehl, wird bei redundanten Blöcken (NVM_BLOCK_REDUNDANT) die redundante Kopie gelesen ([SWS_NvM_00171], [SWS_NvM_00531]). Wird hierbei ein Redundanzverlust festgestellt, setzt der NvM das Job-Ergebnis auf NVM_REQ_REDUNDANCY_FAILED und meldet den Produktionsfehler NVM_E_LOSS_OF_REDUNDANCY an das DEM ([SWS_NvM_00470], [SWS_NvM_00546]) ErrorDescription S. 62.

Gelingt die Wiederherstellung über ROM-Standardwerte, meldet der NvM das Ergebnis NVM_REQ_RESTORED_FROM_ROM ([SWS_NvM_00470]). Scheitern alle Wiederherstellungsmaßnahmen, wird NVM_E_REQ_FAILED an das DEM berichtet ([SWS_NvM_00279], [SWS_NvM_00288]) und das Abfrageergebnis auf NVM_REQ_NOT_OK gesetzt ([SWS_NvM_00451]). Bei Schreibfehlern steuert der NvM Schreibwiederholungen (NvMMaxNumOfWriteRetries), bevor die Anforderung abgebrochen wird ([SWS_NvM_00168], [SWS_NvM_00213]) ErrorDescription S. 56.

Dieser Leitfaden fasst die Kernarchitektur, Modulinteraktionen und Fehlermechanismen des Clusters Memory Services zusammen. Alle Angaben basieren auf den normativen Spezifikationen der AUTOSAR Classic Platform.

AUTOSAR Classic Memory Services

Themenkarte

Detailansicht

Cluster GuideKI-GENERIERT🔍

Systemarchitektur & Rolle des Modulclusters

Zusammenspiel & Interaktionspfade zwischen den Modulen

Synchronisation, Reentranz und Task-Kontexte

Typische Lebenszyklen und Betriebsmodi

Fehlerbehandlung, DET-Tracing und Degradation

Module im Cluster

Bulk NvData Manager (BndM)

EEPROM Abstraction (Ea)

EEPROM Driver (Eep)

Flash EEPROM Emulation (Fee)

Flash Driver (Fls)

Flash Test (FlsTst)

Memory Driver (Mem)

Memory Access (MemAcc)

Memory Abstraction Interface (MemIf)

NVRAM Manager (NvM)

RAM Test (RamTst)

Cluster GuideKI-GENERIERT