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.
Themakaart
BndM
9Ea
16Eep
16Fee
16Fls
17FlsTst
25Mem
20MemAcc
54MemIf
12NvM
36RamTst
27Geen elementgegevens voor deze release
BndM
Initializes or reinitializes this module.
void BndM_Init(const BndM_ConfigType* ConfigPtr);This callback function is called when a FLS job has been finished with positive result.
void BndM_JobEndNotification(void);This callback function is called when a FLS job has been canceled or finished with negative result.
void BndM_JobErrorNotification(void);Schedule function for the background processing.
void BndM_MainFunction(void);Cancels the writing
void BndM_WriteCancel(void);Unique identification of an bulk nv block. The BndM_BlockId is assigned by the BndM.
The elements of this structure data type is the C-structured representation of the configured ImplementationDataPrototype.
This type of the external data structure shall contain the post build initialization data for the BndM.
Result of the asynchronous job finish notifications
Ea
Cancels the ongoing asynchronous operation.
void Ea_Cancel (void);Erases the block Block Number.
Std_ReturnType Ea_EraseImmediateBlock (uint16 BlockNumber);Service to return the Job Result.
MemIf_JobResultType Ea_GetJobResult (void);Service to return the Status.
MemIf_StatusType Ea_GetStatus (void);Service to get the version information of this module.
void Ea_GetVersionInfo (Std_VersionInfoType* VersionInfoPtr);Initializes the EEPROM abstraction module.
void Ea_Init (const Ea_ConfigType* ConfigPtr);Invalidates the block Block Number.
Std_ReturnType Ea_InvalidateBlock (uint16 BlockNumber);Service to report to this module the successful end of an asynchronous operation.
void Ea_JobEndNotification (void);Service to report to this module the failure of an asynchronous operation.
void Ea_JobErrorNotification (void);Service to handle the requested jobs and the internal management operations.
void Ea_MainFunction (void);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);Function to switch the mode of the underlying EEPROM Driver
void Ea_SetMode (MemIf_ModeType Mode);Writes the contents of the Data Buffer Ptr to the block Block Number.
Std_ReturnType Ea_Write (uint16 BlockNumber, const uint8* DataBufferPtr);Function to be used by the underlying memory abstraction to signal end of job without error.
void NvM_JobEndNotification (void);Function to be used by the underlying memory abstraction to signal end of job with error.
void NvM_JobErrorNotification (void);Configuration data structure of the Ea module.
Eep
Cancels a running job.
void Eep_Cancel(void);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);Service for erasing EEPROM sections.
Std_ReturnType Eep_Erase(Eep_AddressType EepromAddress, Eep_LengthType Length);This service returns the result of the last job.
MemIf_JobResultType Eep_GetJobResult(void);Returns the EEPROM status.
MemIf_StatusType Eep_GetStatus(void);Service to get the version information of this module.
void Eep_GetVersionInfo(Std_VersionInfoType* versioninfo);Service for EEPROM initialization.
void Eep_Init(const Eep_ConfigType* ConfigPtr);This callback function provided by the module user is called when a job has been completed with a positive result.
void Eep_JobEndNotification(void);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);Service to perform the processing of the EEPROM jobs (read/write/erase/compare) .
void Eep_MainFunction(void);Reads from EEPROM.
Std_ReturnType Eep_Read(Eep_AddressType EepromAddress, uint8* DataBufferPtr, Eep_LengthType Length);Sets the mode.
void Eep_SetMode(MemIf_ModeType Mode);Writes to EEPROM.
Std_ReturnType Eep_Write(Eep_AddressType EepromAddress, const uint8* DataBufferPtr, Eep_LengthType Length);Used as address offset from the configured EEPROM base address to access a certain EEPROM memory area.
This is the type of the external data structure containing the initialization data for the EEPROM driver.
Specifies the number of bytes to read/write/erase/compare.
Fee
Service to call the cancel function of the underlying flash driver.
void Fee_Cancel (void);Service to erase a logical block.
Std_ReturnType Fee_EraseImmediateBlock (uint16 BlockNumber);Service to query the result of the last accepted job issued by the upper layer software.
MemIf_JobResultType Fee_GetJobResult (void);Service to return the status. AUTOSAR CP R20 - of Document ID : AUTOSAR_SWS_FlashEEPROMEmulation
MemIf_StatusType Fee_GetStatus (void);Service to return the version information of the FEE module.
void Fee_GetVersionInfo (Std_VersionInfoType* VersionInfoPtr);Service to initialize the FEE module.
void Fee_Init (const Fee_ConfigType* ConfigPtr);Service to invalidate a logical block.
Std_ReturnType Fee_InvalidateBlock (uint16 BlockNumber);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);Service to report to this module the failure of an asynchronous operation.
void Fee_JobErrorNotification (void);Service to handle the requested read / write / erase jobs and the internal management operations.
void Fee_MainFunction (void);Service to initiate a read job.
Std_ReturnType Fee_Read (uint16 BlockNumber, uint16 BlockOffset, uint8* DataBufferPtr, uint16 Length);Function to switch the mode of the underlying Flash Driver
void Fee_SetMode (MemIf_ModeType Mode);Service to initiate a write job.
Std_ReturnType Fee_Write (uint16 BlockNumber, const uint8* DataBufferPtr);-
void NvM_JobEndNotification (void);-
void NvM_JobErrorNotification (void);Configuration data structure of the Fee module.
Fls
This callback function is called when a job has been completed with a positive result.
void Fee_JobEndNotification(void);This callback function is called when a job has been canceled or finished with negative result.
void Fee_JobErrorNotification(void);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);Cancels an ongoing job.
void Fls_Cancel(void);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);Erases flash sector(s).
Std_ReturnType Fls_Erase(Fls_AddressType TargetAddress, Fls_LengthType Length);Returns the result of the last job.
MemIf_JobResultType Fls_GetJobResult(void);Returns the driver state.
MemIf_StatusType Fls_GetStatus(void);Returns the version information of this module.
void Fls_GetVersionInfo(Std_VersionInfoType* VersioninfoPtr);Initializes the Flash Driver.
void Fls_Init(const Fls_ConfigType* ConfigPtr);Performs the processing of jobs.
void Fls_MainFunction(void);Reads from flash memory.
Std_ReturnType Fls_Read(Fls_AddressType SourceAddress, uint8* TargetAddressPtr, Fls_LengthType Length);Sets the flash driver's operation mode.
void Fls_SetMode(MemIf_ModeType Mode);Writes one or more complete flash pages.
Std_ReturnType Fls_Write(Fls_AddressType TargetAddress, const uint8* SourceAddressPtr, Fls_LengthType Length);Used as address offset from the configured flash base address to access a certain flash memory area.
A pointer to such a structure is provided to the flash driver initialization routine for configuration of the driver and flash memory hardware.
Specifies the number of bytes to read/write/erase/compare.
FlsTst
Service for aborting the Flash Test.
void FlsTst_Abort(void);Service for Flash Test De - Initialization.
void FlsTst_DeInit(void);Service returns the version information of this module.
void FlsTst_GetVersionInfo(Std_VersionInfoType* versioninfo);Service for Flash Test initialization.
void FlsTst_Init(const FlsTst_ConfigType* ConfigPtr);Service for executing the Flash Test in background mode.
void FlsTst_MainFunction(void);Service for continuing the Flash Test at the point it was suspended.
void FlsTst_Resume(void);Service for executing foreground Flash Test.
Std_ReturnType FlsTst_StartFgnd(FlsTst_BlockIdFgndType FgndBlockId);Service for suspending current operation of the Flash Test, until Fls Tst_ Resume is called.
void FlsTst_Suspend(void);The function Fls Tst_ Test Completed shall be called every time when a complete test cycle had been tested.
void FlsTst_TestCompletedNotification(void);Service executes a test of ECC hardware. This is only applicable in case the hardware provices such functionality.
Std_ReturnType FlsTst_TestEcc(void);Service returns error detais monitored from the Flash module.
FlsTst_ErrorDetailsType FlsTst_GetErrorDetails(void);Service returns the current Flash Test exection state.
FlsTst_StateType FlsTst_GetCurrentState(void);Service returns the Background Flash Test result.
FlsTst_TestResultBgndType FlsTst_GetTestResultBgnd(void);Service returns the Foreground Flash Test result.
FlsTst_TestResultFgndType FlsTst_GetTestResultFgnd(void);Service returns the Flash Test result in background mode.
FlsTst_TestSignatureBgndType FlsTst_GetTestSignatureBgnd(void);Service returns the Flash Test result in foreground mode.
FlsTst_TestSignatureFgndType FlsTst_GetTestSignatureFgnd(void);This type specifies the identification (ID) for a Flash block to be tested in foreground mode, which is configured in the configuration structure.
This type of external data structure shall contain the initialization data for the Flash Test.
This type shall specify implementation specific error information monitored in the Flash test module.
This is a state value returned by the API service Fls Tst_ Get Current State().
Return type of API service Fls Tst_ Get Test Result Bgnd().
Return type of API service Fls Tst_ Get Result Fgnd().
-
Type for test signature in background mode.
Type for test signature in foreground mode
Mem
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);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);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);Service to return results of the most recent job.
Mem_JobResultType Mem_GetJobResult(Mem_InstanceIdType instanceId);Service to return the version information of the Mem module.
void Mem_GetVersionInfo(Std_VersionInfoType* versionInfoPtr);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);Initialization function - initializes all variables and sets the module state to initialized.
void Mem_Init(const Mem_ConfigType* configPtr);Service to handle the requested jobs and the internal management operations.
void Mem_MainFunction(void);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);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);Resume suspended memory operation using hardware mechanism. Tags: atp.Status=draft
void Mem_Resume(Mem_InstanceIdType instanceId);Suspend active memory operation using hardware mechanism. Tags: atp.Status=draft
void Mem_Suspend(Mem_InstanceIdType instanceId);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);Physical memory device address type
Postbuild configuration structure type
Read data user buffer type
Hardware specific service request identifier type
Job end notification function called by Mem in case the job processing is configured for job end notification.
Asynchronous job result type
Physical memory device length type
MemAcc
MemAcc application job end notification callback. The function name is configurable. Tags: atp.Status=draft
void <AddressAreaJobEndNotification>(MemAcc_AddressAreaIdType addressAreaId, MemAcc_JobResultType jobResult);Address area lock application callback. The function name is configurable. Tags: atp.Status=draft
void <ApplicationLockNotification>(void);Dynamic activation and initialization of a Mem driver referenced by hwId and headerAddress.
Std_ReturnType MemAcc_ActivateMem(MemAcc_AddressType headerAddress, MemAcc_HwIdType hwId);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);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);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);Dynamic deactivation of a Mem driver referenced by hwId and headerAddress.
Std_ReturnType MemAcc_DeactivateMem(MemAcc_HwIdType hwId, MemAcc_AddressType headerAddress);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);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);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);Returns the consolidated job result of the address area referenced by addressAreaId.
MemAcc_JobResultType MemAcc_GetJobResult(MemAcc_AddressAreaIdType addressAreaId);Returns the status of the MemAcc job referenced by addressAreaId.
MemAcc_JobStatusType MemAcc_GetJobStatus(MemAcc_AddressAreaIdType addressAreaId);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);Returns the accumulated number of bytes that have already been processed in the current job.
MemAcc_LengthType MemAcc_GetProcessedLength(MemAcc_AddressAreaIdType addressAreaId);Service to return the version information of the MemAcc module.
void MemAcc_GetVersionInfo(Std_VersionInfoType* versionInfoPtr);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);Initialization function - initializes all variables and sets the module state to initialized.
void MemAcc_Init(const MemAcc_ConfigType* configPtr);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);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);Release access lock of provided address area. Tags: atp.Status=draft
Std_ReturnType MemAcc_ReleaseLock(MemAcc_AddressAreaIdType addressAreaId, MemAcc_AddressType address, MemAcc_LengthType length);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);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);Unique address area ID type.
Logical memory address type.
Type of the function pointer to register an application callback to be notified once the address area lock was successfully acquired.
Postbuild configuration structure type.
General data type.
Type for the unique numeric identifiers of all Mem hardware instances used for hardware specific requests.
This structure contains information the current processing state of the MemAcc module.
Asynchronous job result type.
Asynchronous job status type.
Type for asynchronous jobs.
Job length type.
Physical memory device address type
This structure contains elements for accessing the Mem driver service functions and consistency information. Tags: atp.Status=draft
Function pointer for the Mem_BlankCheck service for the invocation of the Mem driver API via function pointer interface. Tags: atp.Status=draft
Memory driver configuration structure type
General data type
Function pointer for the Mem_DeInit service for the invocation of the Mem driver API via function pointer interface.
Function pointer for the Mem_Erase service for the invocation of the Mem driver API via function pointer interface. Tags: atp.Status=draft
Function pointer for the Mem_JobResultType service for the invocation of the Mem driver API via function pointer interface.
Index type for Mem driver hardware specific service table.
Function pointer for the Mem_HwSpecificService function for the invocation of the Mem driver API via function pointer interface. Tags: atp.Status=draft
Function pointer for the Mem_Init service for the invocation of the Mem driver API via function pointer interface.
Memory driver instance ID type
Asynchronous job result type
Physical memory device length type
Function pointer for the Mem_MainFunction service for the invocation of the Mem driver API via function pointer interface.
This structure contains information of Mem device characteristics. It can be accessed via the MemAcc_GetMemoryInfo() service. Tags: atp.Status=draft
Function pointer for the Mem_PropagateError service for the invocation of the Mem driver API via function pointer interface.
Function pointer for the Mem_Read service for the invocation of the Mem driver API via function pointer interface. Tags: atp.Status=draft
Function pointer for the Mem_Resume service for the invocation of the Mem driver API via function pointer interface. Tags: atp.Status=draft
Function pointer for the Mem_Suspend service for the invocation of the Mem driver API via function pointer interface. Tags: atp.Status=draft
Function pointer for the Mem_Write service for the invocation of the Mem driver API via function pointer interface. Tags: atp.Status=draft
MemIf
Invokes the "Cancel" function of the underlying memory abstraction module selected by the parameter Device Index.
void MemIf_Cancel (uint8 DeviceIndex);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);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);Invokes the "Get Status" function of the underlying memory abstraction module selected by the parameter Device Index.
MemIf_StatusType MemIf_GetStatus (uint8 DeviceIndex);Returns version information.
void MemIf_GetVersionInfo (Std_VersionInfoType* VersionInfoPtr);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);Invokes the "Set Mode" functions of all underlying memory abstraction modules.
void MemIf_SetMode (MemIf_ModeType Mode);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);Denotes the result of the last job.
Denotes the operation mode of the underlying abstraction mod ules and device drivers.
Denotes the current status of the underlying abstraction module and device drive. AUTOSAR CP R20 - of Document ID : AUTOSAR_SWS_MemoryAbstractionInterface
NvM
Service to cancel all jobs pending for a NV block.
Std_ReturnType NvM_CancelJobs (NvM_BlockIdType BlockId);Service to cancel a running Nv M_ Write All request.
void NvM_CancelWriteAll (void);Service to erase a NV block.
Std_ReturnType NvM_EraseNvBlock (NvM_BlockIdType BlockId);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);Service for getting the currently set Data Index of a datase t NVRAM block
Std_ReturnType NvM_GetDataIndex (NvM_BlockIdType BlockId, uint8* DataIndexPtr);Service to read the block dependent error/ status information.
Std_ReturnType NvM_GetErrorStatus (NvM_BlockIdType BlockId, NvM_RequestResultType* RequestResultPtr);Service to get the version information of the Nv M module.
void NvM_GetVersionInfo (Std_VersionInfoType* versioninfo);Service for resetting all internal variables.
void NvM_Init (const NvM_ConfigType* ConfigPtr);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);Service to invalidate a NV block.
Std_ReturnType NvM_InvalidateNvBlock (NvM_BlockIdType BlockId);Function to be used by the underlying memory abstraction to signal end of job without error.
void NvM_JobEndNotification (void);Function to be used by the underlying memory abstraction to signal end of job with error.
void NvM_JobErrorNotification (void);Service for performing the processing of the Nv M jobs.
void NvM_MainFunction (void);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);Initiates a multi block read request.
void NvM_ReadAll (void);Service to copy the data of the NV block to its corresponding RAM block.
Std_ReturnType NvM_ReadBlock (NvM_BlockIdType BlockId, void* NvM_DstPtr);Service to copy the data of the NV block to its corresponding permanent RAM block.
Std_ReturnType NvM_ReadPRAMBlock (NvM_BlockIdType BlockId);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);Service to restore the default data to its corr esponding RAM block.
Std_ReturnType NvM_RestoreBlockDefaults (NvM_BlockIdType BlockId, void* NvM_DestPtr);Service to restore the default data to its corresponding permanent RAM block.
Std_ReturnType NvM_RestorePRAMBlockDefaults (NvM_BlockIdType BlockId);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);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);Service for setting the Data Inde x of a dataset NVRAM block.
Std_ReturnType NvM_SetDataIndex (NvM_BlockIdType BlockId, uint8 DataIndex);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);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);Initiates a multi block validation request.
void NvM_ValidateAll (void);Initiates a multi block write request.
void NvM_WriteAll (void);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);Service to copy the data of the permanent RAM block to its corresponding NV block.
Std_ReturnType NvM_WritePRAMBlock (NvM_BlockIdType BlockId);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);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
Identifies the type of reques t performed on a block when signaled via the callback function
Configuration data structure of the Nv M module.
Identifies the type of request performed on a block when signaled via the callback function
Identifies the type of request performed on multi block when signaled via the callback function or when reporting to Bsw M
Type NvM_RequestResultType.
RamTst
Service for continuing the RAM Test after calling 'Ram Tst_ Stop.
void RamTst_Allow(void);Service changes the current number of tested cells.
void RamTst_ChangeNumberOfTestedCells(RamTst_NumberOfTestedCellsType NewNumberOfTestedCells);Service for RAM Test deinitialization.
void RamTst_DeInit(void);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);Service returns the version information of this module.
void RamTst_GetVersionInfo(Std_VersionInfoType* versioninfo);Service for RAM Test initialization.
void RamTst_Init(const RamTst_ConfigType* ConfigPtr);Scheduled function for executing the RAM Test in the background.
void RamTst_MainFunction(void);Service for allowing to continue the background RAM Test at the point is was suspended.
void RamTst_Resume(void);Service for executing the full RAM Test in the foreground.
void RamTst_RunFullTest(void);Service for testing one RAM block in the foreground.
void RamTst_RunPartialTest(RamTst_NumberOfBlocksType BlockId);Service used to set the test algorithm and its parameter set.
void RamTst_SelectAlgParams(RamTst_AlgParamsIdType NewAlgParamsId);Service for stopping the RAM Test.
void RamTst_Stop(void);Service for suspending current operation of background RAM Test, until RESUME is called.
void RamTst_Suspend(void);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);Service returns the current RAM Test algorithm.
RamTst_AlgorithmType RamTst_GetTestAlgorithm(void);Service returns the ID of the current RAM Test algorithm parameter set.
RamTst_AlgParamsIdType RamTst_GetAlgParams(void);Service returns the current RAM Test execution status.
RamTst_ExecutionStatusType RamTst_GetExecutionStatus(void);Service returns the current number of tested cells per main - function cycle.
RamTst_NumberOfTestedCellsType RamTst_GetNumberOfTestedCells(void);Service returns the current RAM Test result.
RamTst_TestResultType RamTst_GetTestResult(void);Service returns the current RAM Test result for the specified block.
RamTst_TestResultType RamTst_GetTestResultPerBlock(RamTst_NumberOfBlocksType BlockID);This is a value returned by the API service Ram Tst_ Get Test Algorithm().
Data type used to identify a set of configuration parameters for a test algorithm.
Configuration data structure of the Ram Tst module.
This is a status value returned by the API service Ram Tst_ Get Execution Status().
Data type used to identify or count RAM blocks given in the test configuration parameters.
Data type of number of tested RAM cells
This is a status value returned by the API service Ram Tst_ Get Test Result().
ClustergidsAI-GEGENEREERD
Borgt en beheert persistente gegevens hardware-onafhankelijk via gestructureerde NVRAM-blokken en abstractiestuurprogramma's.
Borgt en beheert persistente gegevens hardware-onafhankelijk via gestructureerde NVRAM-blokken en abstractiestuurprogramma's.
De modulecluster 'Memory Services' realiseert de hardware-onafhankelijke opslag en consistentieborging van niet-vluchtige applicatiegegevens via de NVRAM Manager en de hardware-abstraherende modules MemIf, Fee en Ea ([SWS_NvM_00447], [SWS_MemIf_00039]). Asynchrone lees- en schrijfbewerkingen worden afgehandeld via cyclische MainFunctions en gebundeld uitgevoerd tijdens de opstart van de ECU (NvM_ReadAll) en bij de shutdown (NvM_WriteAll) ModemanagementGuide p. 54. Bij hardwarefouten treden meertraps herhalings-, redundantie- en ROM-herstelmechanismen in werking met automatische rapportering aan DEM ([SWS_NvM_00470]).
De cluster 'Memory Services' verzorgt de persistente opslag en het beheer van niet-vluchtige gegevens in de AUTOSAR Classic BSW-stack. Deze omvat de NVRAM Manager ([SWS_NvM_00447]) op de servicelaag en het Memory Abstraction Interface ([SWS_MemIf_00039]) met de modules Flash EEPROM Emulation ([SWS_Fee_00085]) en EEPROM Abstraction ([SWS_Ea_00083]) op de hardware-abstractielaag AUTOSAR SWS NVRAMManager p. 10.
Architectuurdiagram: Lagenstructuur en modulerelaties in de Memory Services-cluster. Bronnen: [SWS_MemIf_00039], AUTOSAR SWS NVRAMManager p. 10
De gegevensuitwisseling verloopt via synchrone besturings-API's en asynchrone schrijf- respectievelijk leesopdrachten. Gegevens worden ofwel impliciet via permanente RAM-blokken ofwel expliciet via modulebeherende RAM-spiegels uitgewisseld ([SWS_NvM_00455], [SWS_NvM_00514]) NVDataHandling p. 12. De cyclische verwerking van in de wachtrij geplaatste opdrachten vindt plaats via periodiek uitgevoerde BSW-hoofdfuncties (NvM_MainFunction, Fee_MainFunction), terwijl MemIf aanroepen toestandloos delegeert naar de onderliggende stuurprogramma's ([SWS_MemIf_00040]) AUTOSAR CP SWS FlashEEPROMEmulation p. 42.
Tijdens de bedrijfscyclus coördineert BswM de multi-block-acties: Bij de systeemstart leest NvM_ReadAll de persistente gegevens uit het NV-geheugen naar het RAM ([SWS_NvM_00460]), terwijl bij het afsluiten NvM_WriteAll gewijzigde gegevens veiligstelt ([SWS_NvM_00461]) ModemanagementGuide p. 54. Foutieve lees- of schrijfacties worden opgevangen door herhaalde pogingen, redundante kopieën of ROM-terugvalwaarden; permanente fouten meldt het systeem aan DEM ([SWS_NvM_00470], [SWS_NvM_00279]) ErrorDescription p. 62.
Systeemarchitectuur & rol van het modulecluster
De modulecluster van de geheugendiensten (Memory Services) van het AUTOSAR Classic Platform waarborgt het gestandaardiseerde, hardware-onafhankelijke beheer en de persistentie van applicatie- en basissoftwaregegevens in het niet-vluchtige geheugen. Het cluster is verticaal opgedeeld in twee lagen van de AUTOSAR-basissoftwarearchitectuur: de NVRAM Manager ([SWS_NvM_00447]) op de servicelaag (Services Layer) en het Memory Abstraction Interface ([SWS_MemIf_00039]) met de daaronder liggende abstractiemodules Flash EEPROM Emulation ([SWS_Fee_00085]) en EEPROM Abstraction ([SWS_Ea_00083]) op de hardware-abstractielaag (Memory Hardware Abstraction Layer) AUTOSAR SWS NVRAMManager p. 10.
De NVRAM Manager (NvM) vormt het centrale toegangspunt voor softwarecomponenten (SW-C) en BSW-modules zoals de Diagnostic Event Manager-module (Dem) SWS DiagnosticEventManager p. 238. Hij beheert logische geheugenblokken die zijn samengesteld uit NV-blokken in het niet-vluchtige geheugen, RAM-blokken in het vluchtige geheugen en optionele ROM-blokken voor initialisatiegegevens ([SWS_NvM_00137], [SWS_NvM_00128]). Afhankelijk van de vereisten worden de blokbeheertypen native (NVM_BLOCK_NATIVE), redundant (NVM_BLOCK_REDUNDANT) of dataset (NVM_BLOCK_DATASET) ondersteund AUTOSAR CP RS MemoryServices p. 10.
De modules Fee en Ea kapselen de bijzonderheden van de respectieve fysieke opslagmedia (Flash resp. EEPROM) in en mappen logische bloknummers en adres-offsets op de lineaire adresruimten van de desbetreffende MCAL-stuurprogramma's (Fls resp. Eep) ([SWS_Fee_00087], [SWS_Ea_00086]) AUTOSAR SWS EEPROMAbstraction p. 23. De module MemIf fungeert hierbij als een zuivere routeringslaag, die aan de hand van parameter DeviceIndex toegangen doorstuurt naar de doelmodule zonder eigen bufferstructuren aan te houden ([SWS_MemIf_00040]).
Architectuurdiagram: Lagenstructuur en modulerelaties in de Memory Services-cluster. Bronnen: [SWS_MemIf_00039], AUTOSAR SWS NVRAMManager p. 10
Samenspel & interactiepaden tussen de modules
De interactie tussen de modules verloopt via strikt gestandaardiseerde synchrone en asynchrone paden. Wanneer een gebruiker een schrijfbewerking initieert via NvM_WriteBlock, wordt het verzoek eerst geregistreerd in het administratieve blok van de NvM ([SWS_NvM_00455]). Bij een synchrone aanroep vindt doorsturing plaats naar MemIf via MemIf_Write ([SWS_MemIf_00040]), die de aanroep overdraagt aan Fee_Write of Ea_Write ([SWS_Fee_00088], [SWS_Ea_00087]) AUTOSAR SWS NVRAMManager p. 160.
Wat betreft gegevensbeheer en synchronisatie tussen de applicatie en de NVRAM Manager bestaan er twee kernconcepten: impliciete synchronisatie via permanente RAM-blokken (NvMRamBlockDataAddress) en expliciete synchronisatie via spiegelgebaseerde buffers (NvMBlockUseSyncMechanism) NVDataHandling p. 12. Bij expliciete synchronisatie kopieert de NvM de gebruikersgegevens via de geconfigureerde callback-routines NvMWriteRamBlockToNvCallback respectievelijk NvMReadRamBlockFromNvCallback tussen het applicatie-RAM en de interne RAM-spiegel ([SWS_NvM_00514], [SWS_NvM_00515]) EXP NVDataHandling p. 30.
Bij het gebruik van dataset-blokken (NVM_BLOCK_DATASET) selecteert de aanroeper vooraf via NvM_SetDataIndex de gewenste datasetindex ([SWS_NvM_00448]). De abstractiemodules berekenen vervolgens op basis van het logische bloknummer en de index de exacte adres-offset voor het MCAL-stuurprogramma ([SWS_NvM_00123]) AUTOSAR SWS Flash EEPROM Emulation p. 21. Annuleringsverzoeken worden via MemIf_Cancel direct doorgestuurd naar de submodules Fee_Cancel respectievelijk Ea_Cancel ([SWS_MemIf_00041], [SWS_Fee_00089]).
Sequentiediagram: Asynchrone schrijfopdracht met callback-notificatie en polling. Bronnen: [SWS_NvM_00455], AUTOSAR SWS NVRAMManager p. 160
Synchronisatie, re-entrantie en taakcontexten
De meeste controle- en status-API's van het cluster, waaronder NvM_GetErrorStatus ([SWS_NvM_00451]), NvM_SetBlockProtection ([SWS_NvM_00450]) en MemIf_GetVersionInfo ([SWS_MemIf_00045]), zijn synchroon uitgevoerd en kunnen direct in de taskcontext van de aanroeper worden afgehandeld AUTOSAR SWS NVRAMManager p. 157. De gegevensoverdragende functies (NvM_ReadBlock, NvM_WriteBlock, Ea_Write) zijn daarentegen asynchroon en niet-re-entrant ontworpen ([SWS_MemIf_00040], [SWS_Ea_00087]).
De cyclische voortgang van lopende opdrachten is de taak van de periodiek door de Schedule Manager (SchM) dan wel een BSW-task aangeroepen hoofdfuncties NvM_MainFunction en Fee_MainFunction AUTOSAR CP SWS FlashEEPROMEmulation p. 42. Bij asynchrone meldingen vanuit het MCAL-stuurprogramma kan de notificatie Fee_JobEndNotification respectievelijk Fee_JobErrorNotification direct op interruptniveau plaatsvinden ([SWS_Fee_00095]). Deze stelt de status in op MEMIF_JOB_OK of roept geconfigureerde notificatieroutines aan ([SWS_Fee_00142], [SWS_Fee_00194]) SWS FlashEEPROMEmulation p. 37.
Interpretatie: Om race conditions tussen API-aanroepers op taskniveau en de stapsgewijze verdere verwerking in de MainFunctions te voorkomen, worden de interne wachtrijen en administratieve attributen vermoedelijk beschermd door exclusieve gebieden, terwijl MemIf ageert als een toestandloze doorstuurlaag AUTOSAR SWS NVRAMManager p. 160. Vraag Q-a50c3362a14b9e6d (open)
Typische levenscycli en bedrijfsmodi
De levenscyclus van het cluster wordt nauw georkestreerd door de Basic Software Mode Manager (BswM) en de ECU State Manager (EcuM). Tijdens het opstarten van de ECU (Startup Phase) worden na de stuurprogramma's eerst de abstractiemodules via Fee_Init respectievelijk Ea_Init ([SWS_Fee_00085], [SWS_Ea_00083]) en aansluitend de NVRAM Manager via NvM_Init ([SWS_NvM_00447]) synchroon geïnitialiseerd AUTOSAR SWS NVRAMManager p. 156.
Aansluitend op de initialisatie initieert de BswM de multi-block-leesbewerking NvM_ReadAll om alle als persistent gemarkeerde RAM-blokken vanuit het niet-vluchtige geheugen te herstellen ([SWS_NvM_00460]) ModemanagementGuide p. 54. De voortgang en het eindresultaat meldt de NvM via de callback-functie BswM_NvM_CurrentJobMode terug aan de BswM ([SWS_NvM_00745], [SWS_NvM_00888]). Toestanden van individuele blokken worden gesignaleerd via BswM_NvM_CurrentBlockMode ([SWS_NvM_00746], [SWS_NvM_00890]) ModemanagementGuide p. 28.
In de shutdown-fase initieert het systeem via NvM_WriteAll het persistente wegschrijven van alle gewijzigde RAM-blokken naar het NV-geheugen ([SWS_NvM_00461]). Om het aantal Flash-schrijfcycli te optimaliseren, kan via NvM_SetRamBlockStatus gericht worden gemarkeerd of een blok is gewijzigd ([SWS_NvM_00453]) EXP NVDataHandling p. 18. Een lopende schrijfactie kan bij voortijdige wake-up-events worden afgebroken via NvM_CancelWriteAll ([SWS_NvM_00238]) AUTOSAR SWS NVRAMManager p. 161.
Foutafhandeling, DET-tracing en degradatie
Het cluster beschikt over een meertraps foutdetectie- en degradatieconcept. Fouten die optreden op stuurprogramma- en abstractieniveau worden via de retourstatus MEMIF_JOB_FAILED met behulp van MemIf_GetJobResult opgevraagd of via NvM_JobErrorNotification gemeld ([SWS_Fee_00091], [SWS_Ea_00095]) ErrorDescription p. 49.
Bij het optreden van leesfouten valt de NvM terug op geconfigureerde herstelmechanismen: Eerst worden herhaalde pogingen (Read Retries) ondernomen ([SWS_NvM_00390]). Als deze mislukken, wordt bij redundante blokken (NVM_BLOCK_REDUNDANT) de redundante kopie gelezen ([SWS_NvM_00171], [SWS_NvM_00531]). Wordt hierbij een redundantieverlies vastgesteld, dan stelt de NvM het taakresultaat in op NVM_REQ_REDUNDANCY_FAILED en meldt de productiefout NVM_E_LOSS_OF_REDUNDANCY aan DEM ([SWS_NvM_00470], [SWS_NvM_00546]) ErrorDescription p. 62.
Slaagt het herstel via ROM-standaardwaarden, dan meldt de NvM het resultaat NVM_REQ_RESTORED_FROM_ROM ([SWS_NvM_00470]). Mislukken alle herstelmaatregelen, dan wordt NVM_E_REQ_FAILED gerapporteerd aan DEM ([SWS_NvM_00279], [SWS_NvM_00288]) en wordt het opvraagresultaat ingesteld op NVM_REQ_NOT_OK ([SWS_NvM_00451]). Bij schrijffouten regelt de NvM herhaalde schrijfpogingen (NvMMaxNumOfWriteRetries) voordat het verzoek wordt afgebroken ([SWS_NvM_00168], [SWS_NvM_00213]) ErrorDescription p. 56.
Deze handleiding vat de kernarchitectuur, module-interacties en foutmechanismen van het cluster Memory Services samen. Alle gegevens zijn gebaseerd op de normatieve specificaties van het AUTOSAR Classic Platform.
Module im Cluster
Bulk NvData Manager (BndM)
AUTOSAR Classic Memory Services-Modul Bulk NvData Manager (BndM, Spezifikation: AUTOSAR_CP_SWS_BulkNvDataManager.pdf, AUTOSAR_SWS_BulkNvDataManager.pdf).
EEPROM Abstraction (Ea)
Provides uniform access to external and internal EEPROM devices.
EEPROM Driver (Eep)
AUTOSAR Classic Memory Drivers-Modul EEPROM Driver (Eep, Spezifikation: AUTOSAR_CP_SWS_EEPROMDriver.pdf, AUTOSAR_SWS_EEPROMDriver.pdf, AUTOSAR_SWS_EEPROM_Driver.pdf).
Flash EEPROM Emulation (Fee)
Provides emulation of EEPROM-like data blocks on Flash memory devices.
Flash Driver (Fls)
AUTOSAR Classic Memory Drivers-Modul Flash Driver (Fls, Spezifikation: AUTOSAR_CP_SWS_FlashDriver.pdf, AUTOSAR_SWS_FlashDriver.pdf).
Flash Test (FlsTst)
AUTOSAR Classic Memory Drivers-Modul Flash Test (FlsTst, Spezifikation: AUTOSAR_CP_SWS_FlashTest.pdf, AUTOSAR_SWS_FlashTest.pdf).
Memory Driver (Mem)
AUTOSAR Classic Memory Drivers-Modul Memory Driver (Mem, Spezifikation: AUTOSAR_CP_SWS_MemoryDriver.pdf, AUTOSAR_SWS_MemoryDriver.pdf).
Memory Access (MemAcc)
AUTOSAR Classic Memory HW Abstraction-Modul Memory Access (MemAcc, Spezifikation: AUTOSAR_CP_SWS_MemoryAccess.pdf, AUTOSAR_SWS_MemoryAccess.pdf).
Memory Abstraction Interface (MemIf)
Abstracts underlying Flash and EEPROM memory drivers.
NVRAM Manager (NvM)
Provides synchronous and asynchronous block-based data management for non-volatile storage (EEPROM, Flash).
RAM Test (RamTst)
AUTOSAR Classic Memory Drivers-Modul RAM Test (RamTst, Spezifikation: AUTOSAR_CP_SWS_RAMTest.pdf, AUTOSAR_SWS_RAMTest.pdf, AUTOSAR_SWS_RAM_Test.pdf).
gemini-3.8-flash-low· 2026-10-13 · Duits origineel