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.

Carte des thèmes

Vue détaillée

Sélectionnez une entrée dans le plan.

Aucune donnée d'élément pour cette version

BndM

BndM_Init fonction

Initializes or reinitializes this module.

void BndM_Init(const BndM_ConfigType* ConfigPtr);

BndM_JobEndNotification fonction

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

void BndM_JobEndNotification(void);

BndM_JobErrorNotification fonction

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

void BndM_JobErrorNotification(void);

BndM_MainFunction fonction

Schedule function for the background processing.

void BndM_MainFunction(void);

BndM_WriteCancel fonction

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 fonction

Cancels the ongoing asynchronous operation.

void Ea_Cancel (void);

Ea_EraseImmediateBlock fonction

Erases the block Block Number.

Std_ReturnType Ea_EraseImmediateBlock (uint16 BlockNumber);

Ea_GetJobResult fonction

Service to return the Job Result.

MemIf_JobResultType Ea_GetJobResult (void);

Ea_GetStatus fonction

Service to return the Status.

MemIf_StatusType Ea_GetStatus (void);

Ea_GetVersionInfo fonction

Service to get the version information of this module.

void Ea_GetVersionInfo (Std_VersionInfoType* VersionInfoPtr);

Ea_Init fonction

Initializes the EEPROM abstraction module.

void Ea_Init (const Ea_ConfigType* ConfigPtr);

Ea_InvalidateBlock fonction

Invalidates the block Block Number.

Std_ReturnType Ea_InvalidateBlock (uint16 BlockNumber);

Ea_JobEndNotification fonction

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

void Ea_JobEndNotification (void);

Ea_JobErrorNotification fonction

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

void Ea_JobErrorNotification (void);

Ea_MainFunction fonction

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

void Ea_MainFunction (void);

Ea_Read fonction

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 fonction

Function to switch the mode of the underlying EEPROM Driver

void Ea_SetMode (MemIf_ModeType Mode);

Ea_Write fonction

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

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

NvM_JobEndNotification fonction

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

void NvM_JobEndNotification (void);

NvM_JobErrorNotification fonction

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 fonction

Cancels a running job.

void Eep_Cancel(void);

Eep_Compare fonction

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 fonction

Service for erasing EEPROM sections.

Std_ReturnType Eep_Erase(Eep_AddressType EepromAddress, Eep_LengthType Length);

Eep_GetJobResult fonction

This service returns the result of the last job.

MemIf_JobResultType Eep_GetJobResult(void);

Eep_GetStatus fonction

Returns the EEPROM status.

MemIf_StatusType Eep_GetStatus(void);

Eep_GetVersionInfo fonction

Service to get the version information of this module.

void Eep_GetVersionInfo(Std_VersionInfoType* versioninfo);

Eep_Init fonction

Service for EEPROM initialization.

void Eep_Init(const Eep_ConfigType* ConfigPtr);

Eep_JobEndNotification fonction

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 fonction

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 fonction

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

void Eep_MainFunction(void);

Eep_Read fonction

Reads from EEPROM.

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

Eep_SetMode fonction

Sets the mode.

void Eep_SetMode(MemIf_ModeType Mode);

Eep_Write fonction

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 fonction

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

void Fee_Cancel (void);

Fee_EraseImmediateBlock fonction

Service to erase a logical block.

Std_ReturnType Fee_EraseImmediateBlock (uint16 BlockNumber);

Fee_GetJobResult fonction

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

MemIf_JobResultType Fee_GetJobResult (void);

Fee_GetStatus fonction

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

MemIf_StatusType Fee_GetStatus (void);

Fee_GetVersionInfo fonction

Service to return the version information of the FEE module.

void Fee_GetVersionInfo (Std_VersionInfoType* VersionInfoPtr);

Fee_Init fonction

Service to initialize the FEE module.

void Fee_Init (const Fee_ConfigType* ConfigPtr);

Fee_InvalidateBlock fonction

Service to invalidate a logical block.

Std_ReturnType Fee_InvalidateBlock (uint16 BlockNumber);

Fee_JobEndNotification fonction

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 fonction

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

void Fee_JobErrorNotification (void);

Fee_MainFunction fonction

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

void Fee_MainFunction (void);

Fee_Read fonction

Service to initiate a read job.

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

Fee_SetMode fonction

Function to switch the mode of the underlying Flash Driver

void Fee_SetMode (MemIf_ModeType Mode);

Fee_Write fonction

Service to initiate a write job.

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

NvM_JobEndNotification (Fee) fonction

void NvM_JobEndNotification (void);

NvM_JobErrorNotification (Fee) fonction

void NvM_JobErrorNotification (void);

Fee_ConfigType type

Configuration data structure of the Fee module.

Fls

Fee_JobEndNotification (Fls) fonction

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

void Fee_JobEndNotification(void);

Fee_JobErrorNotification (Fls) fonction

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

void Fee_JobErrorNotification(void);

Fls_BlankCheck fonction

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 fonction

Cancels an ongoing job.

void Fls_Cancel(void);

Fls_Compare fonction

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 fonction

Erases flash sector(s).

Std_ReturnType Fls_Erase(Fls_AddressType TargetAddress, Fls_LengthType Length);

Fls_GetJobResult fonction

Returns the result of the last job.

MemIf_JobResultType Fls_GetJobResult(void);

Fls_GetStatus fonction

Returns the driver state.

MemIf_StatusType Fls_GetStatus(void);

Fls_GetVersionInfo fonction

Returns the version information of this module.

void Fls_GetVersionInfo(Std_VersionInfoType* VersioninfoPtr);

Fls_Init fonction

Initializes the Flash Driver.

void Fls_Init(const Fls_ConfigType* ConfigPtr);

Fls_MainFunction fonction

Performs the processing of jobs.

void Fls_MainFunction(void);

Fls_Read fonction

Reads from flash memory.

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

Fls_SetMode fonction

Sets the flash driver's operation mode.

void Fls_SetMode(MemIf_ModeType Mode);

Fls_Write fonction

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 fonction

Service for aborting the Flash Test.

void FlsTst_Abort(void);

FlsTst_DeInit fonction

Service for Flash Test De - Initialization.

void FlsTst_DeInit(void);

FlsTst_GetVersionInfo fonction

Service returns the version information of this module.

void FlsTst_GetVersionInfo(Std_VersionInfoType* versioninfo);

FlsTst_Init fonction

Service for Flash Test initialization.

void FlsTst_Init(const FlsTst_ConfigType* ConfigPtr);

FlsTst_MainFunction fonction

Service for executing the Flash Test in background mode.

void FlsTst_MainFunction(void);

FlsTst_Resume fonction

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

void FlsTst_Resume(void);

FlsTst_StartFgnd fonction

Service for executing foreground Flash Test.

Std_ReturnType FlsTst_StartFgnd(FlsTst_BlockIdFgndType FgndBlockId);

FlsTst_Suspend fonction

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

void FlsTst_Suspend(void);

FlsTst_TestCompletedNotification fonction

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 fonction

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 fonction

Service returns error detais monitored from the Flash module.

FlsTst_ErrorDetailsType FlsTst_GetErrorDetails(void);

Tst_StateTypeFlsTst_GetCurrentState fonction

Service returns the current Flash Test exection state.

FlsTst_StateType FlsTst_GetCurrentState(void);

Tst_TestResultBgndTypeFlsTst_GetTestResultBgnd fonction

Service returns the Background Flash Test result.

FlsTst_TestResultBgndType FlsTst_GetTestResultBgnd(void);

Tst_TestResultFgndTypeFlsTst_GetTestResultFgnd fonction

Service returns the Foreground Flash Test result.

FlsTst_TestResultFgndType FlsTst_GetTestResultFgnd(void);

Tst_TestSignatureBgndTypeFlsTst_GetTestSignatureBgnd fonction

Service returns the Flash Test result in background mode.

FlsTst_TestSignatureBgndType FlsTst_GetTestSignatureBgnd(void);

Tst_TestSignatureFgndTypeFlsTst_GetTestSignatureFgnd fonction

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 fonction

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 fonction

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 fonction

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 fonction

Service to return results of the most recent job.

Mem_JobResultType Mem_GetJobResult(Mem_InstanceIdType instanceId);

Mem_GetVersionInfo fonction

Service to return the version information of the Mem module.

void Mem_GetVersionInfo(Std_VersionInfoType* versionInfoPtr);

Mem_HwSpecificService fonction

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 fonction

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

void Mem_Init(const Mem_ConfigType* configPtr);

Mem_MainFunction fonction

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

void Mem_MainFunction(void);

Mem_PropagateError fonction

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 fonction

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 fonction

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

void Mem_Resume(Mem_InstanceIdType instanceId);

Mem_Suspend fonction

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

void Mem_Suspend(Mem_InstanceIdType instanceId);

Mem_Write fonction

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> fonction

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

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

<ApplicationLockNotification> fonction

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

void <ApplicationLockNotification>(void);

MemAcc_ActivateMem fonction

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 fonction

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 fonction

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 fonction

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 fonction

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

Std_ReturnType MemAcc_DeactivateMem(MemAcc_HwIdType hwId, MemAcc_AddressType headerAddress);

MemAcc_DeInit fonction

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 fonction

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 fonction

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 fonction

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

MemAcc_JobResultType MemAcc_GetJobResult(MemAcc_AddressAreaIdType addressAreaId);

MemAcc_GetJobStatus fonction

Returns the status of the MemAcc job referenced by addressAreaId.

MemAcc_JobStatusType MemAcc_GetJobStatus(MemAcc_AddressAreaIdType addressAreaId);

MemAcc_GetMemoryInfo fonction

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 fonction

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

MemAcc_LengthType MemAcc_GetProcessedLength(MemAcc_AddressAreaIdType addressAreaId);

MemAcc_GetVersionInfo fonction

Service to return the version information of the MemAcc module.

void MemAcc_GetVersionInfo(Std_VersionInfoType* versionInfoPtr);

MemAcc_HwSpecificService fonction

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 fonction

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

void MemAcc_Init(const MemAcc_ConfigType* configPtr);

MemAcc_MainFunction fonction

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 fonction

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 fonction

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 fonction

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 fonction

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 fonction

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

void MemIf_Cancel (uint8 DeviceIndex);

MemIf_EraseImmediateBlock fonction

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 fonction

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 fonction

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 fonction

Returns version information.

void MemIf_GetVersionInfo (Std_VersionInfoType* VersionInfoPtr);

MemIf_InvalidateBlock fonction

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 fonction

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 fonction

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

void MemIf_SetMode (MemIf_ModeType Mode);

MemIf_Write fonction

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 fonction

Service to cancel all jobs pending for a NV block.

Std_ReturnType NvM_CancelJobs (NvM_BlockIdType BlockId);

NvM_CancelWriteAll fonction

Service to cancel a running Nv M_ Write All request.

void NvM_CancelWriteAll (void);

NvM_EraseNvBlock fonction

Service to erase a NV block.

Std_ReturnType NvM_EraseNvBlock (NvM_BlockIdType BlockId);

NvM_FirstInitAll fonction

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 fonction

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 fonction

Service to read the block dependent error/ status information.

Std_ReturnType NvM_GetErrorStatus (NvM_BlockIdType BlockId, NvM_RequestResultType* RequestResultPtr);

NvM_GetVersionInfo fonction

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

void NvM_GetVersionInfo (Std_VersionInfoType* versioninfo);

NvM_Init fonction

Service for resetting all internal variables.

void NvM_Init (const NvM_ConfigType* ConfigPtr);

NvM_InitBlockCallbackFunction fonction

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 fonction

Service to invalidate a NV block.

Std_ReturnType NvM_InvalidateNvBlock (NvM_BlockIdType BlockId);

NvM_JobEndNotification (NvM) fonction

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

void NvM_JobEndNotification (void);

NvM_JobErrorNotification (NvM) fonction

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

void NvM_JobErrorNotification (void);

NvM_MainFunction fonction

Service for performing the processing of the Nv M jobs.

void NvM_MainFunction (void);

NvM_MultiBlockCallbackFunction fonction

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 fonction

Initiates a multi block read request.

void NvM_ReadAll (void);

NvM_ReadBlock fonction

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 fonction

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

Std_ReturnType NvM_ReadPRAMBlock (NvM_BlockIdType BlockId);

NvM_ReadRamBlockFromNvm fonction

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 fonction

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

Std_ReturnType NvM_RestoreBlockDefaults (NvM_BlockIdType BlockId, void* NvM_DestPtr);

NvM_RestorePRAMBlockDefaults fonction

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

Std_ReturnType NvM_RestorePRAMBlockDefaults (NvM_BlockIdType BlockId);

NvM_SetBlockLockStatus fonction

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 fonction

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 fonction

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

Std_ReturnType NvM_SetDataIndex (NvM_BlockIdType BlockId, uint8 DataIndex);

NvM_SetRamBlockStatus fonction

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 fonction

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 fonction

Initiates a multi block validation request.

void NvM_ValidateAll (void);

NvM_WriteAll fonction

Initiates a multi block write request.

void NvM_WriteAll (void);

NvM_WriteBlock fonction

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 fonction

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

Std_ReturnType NvM_WritePRAMBlock (NvM_BlockIdType BlockId);

NvM_WriteRamBlockToNvm fonction

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 fonction

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

void RamTst_Allow(void);

RamTst_ChangeNumberOfTestedCells fonction

Service changes the current number of tested cells.

void RamTst_ChangeNumberOfTestedCells(RamTst_NumberOfTestedCellsType NewNumberOfTestedCells);

RamTst_DeInit fonction

Service for RAM Test deinitialization.

void RamTst_DeInit(void);

RamTst_ErrorNotification fonction

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 fonction

Service returns the version information of this module.

void RamTst_GetVersionInfo(Std_VersionInfoType* versioninfo);

RamTst_Init fonction

Service for RAM Test initialization.

void RamTst_Init(const RamTst_ConfigType* ConfigPtr);

RamTst_MainFunction fonction

Scheduled function for executing the RAM Test in the background.

void RamTst_MainFunction(void);

RamTst_Resume fonction

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

void RamTst_Resume(void);

RamTst_RunFullTest fonction

Service for executing the full RAM Test in the foreground.

void RamTst_RunFullTest(void);

RamTst_RunPartialTest fonction

Service for testing one RAM block in the foreground.

void RamTst_RunPartialTest(RamTst_NumberOfBlocksType BlockId);

RamTst_SelectAlgParams fonction

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

void RamTst_SelectAlgParams(RamTst_AlgParamsIdType NewAlgParamsId);

RamTst_Stop fonction

Service for stopping the RAM Test.

void RamTst_Stop(void);

RamTst_Suspend fonction

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

void RamTst_Suspend(void);

RamTst_TestCompletedNotification fonction

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 fonction

Service returns the current RAM Test algorithm.

RamTst_AlgorithmType RamTst_GetTestAlgorithm(void);

Tst_AlgParamsIdTypeRamTst_GetAlgParams fonction

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

RamTst_AlgParamsIdType RamTst_GetAlgParams(void);

Tst_ExecutionStatusTypeRamTst_GetExecutionStatus fonction

Service returns the current RAM Test execution status.

RamTst_ExecutionStatusType RamTst_GetExecutionStatus(void);

Tst_NumberOfTestedCellsTypeRamTst_GetNumberOfTestedCells fonction

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

RamTst_NumberOfTestedCellsType RamTst_GetNumberOfTestedCells(void);

Tst_TestResultTypeRamTst_GetTestResult fonction

Service returns the current RAM Test result.

RamTst_TestResultType RamTst_GetTestResult(void);

Tst_TestResultTypeRamTst_GetTestResultPerBlock fonction

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().

Cliquez sur une entrée pour voir ses relations.

Guide du clusterGÉNÉRÉ PAR IA

Sauvegarde et gère les données persistantes indépendamment du matériel via des blocs NVRAM structurés et des pilotes d'abstraction.

GÉNÉRÉ PAR IA non vérifié Modèle : gemini-3.8-flash-medium · Effort : medium · Température : non réglable · Prompt : 34f2477a24b6 Provenance Questions ouvertes (1)

traduit du guide allemandGénéré par l'IAgemini-3.8-flash-low · 2026-10-13 · Original allemand

Sauvegarde et gère les données persistantes indépendamment du matériel via des blocs NVRAM structurés et des pilotes d'abstraction.

Le cluster de modules « Memory Services » assure le stockage indépendant du matériel et la garantie de cohérence des données d'application non volatiles via le gestionnaire NVRAM ainsi que les modules d'abstraction matérielle MemIf, Fee et Ea ([SWS_NvM_00447], [SWS_MemIf_00039]). Les opérations asynchrones de lecture et d'écriture sont traitées via des MainFunctions cycliques et sont exécutées de manière groupée lors du démarrage du calculateur (NvM_ReadAll) ainsi que lors du shutdown (NvM_WriteAll) ModemanagementGuide p. 54. En cas d'erreurs matérielles, des mécanismes à plusieurs niveaux de répétition, de redondance et de restauration ROM interviennent avec notification automatique au DEM ([SWS_NvM_00470]).

Le cluster « Memory Services » assure le stockage persistant et la gestion des données non volatiles dans la pile BSW AUTOSAR Classic. Il comprend le gestionnaire NVRAM ([SWS_NvM_00447]) au niveau des services ainsi que le Memory Abstraction Interface ([SWS_MemIf_00039]) avec les modules Flash EEPROM Emulation ([SWS_Fee_00085]) et EEPROM Abstraction ([SWS_Ea_00083]) au niveau de l'abstraction matérielle AUTOSAR SWS NVRAMManager p. 10.

Diagramme d'architecture : structure en couches et relations entre modules dans le cluster Memory Services. Sources : [SWS_MemIf_00039], AUTOSAR SWS NVRAMManager p. 10

L'échange de données s'effectue via des API de contrôle synchrones et des requêtes d'écriture ou de lecture asynchrones. Les données sont échangées soit implicitement via des blocs RAM permanents, soit explicitement via des miroirs RAM gérés par les modules ([SWS_NvM_00455], [SWS_NvM_00514]) NVDataHandling p. 12. Le traitement cyclique des requêtes mises en file d'attente s'effectue via des fonctions principales BSW exécutées périodiquement (NvM_MainFunction, Fee_MainFunction), tandis que la MemIf délègue les appels sans état aux pilotes sous-jacents ([SWS_MemIf_00040]) AUTOSAR CP SWS FlashEEPROMEmulation p. 42.

Pendant le cycle de fonctionnement, le BswM coordonne les actions multi-blocs : lors du démarrage du système, NvM_ReadAll lit les données persistantes depuis la mémoire NV vers la RAM ([SWS_NvM_00460]), tandis que lors de l'arrêt, NvM_WriteAll sauvegarde les données modifiées ([SWS_NvM_00461]) ModemanagementGuide p. 54. Les accès en lecture ou en écriture défaillants sont interceptés par des tentatives de répétition ainsi que par des copies redondantes ou des valeurs de repli en ROM ; le système signale les erreurs permanentes au DEM ([SWS_NvM_00470], [SWS_NvM_00279]) ErrorDescription p. 62.

Architecture système & rôle du cluster de modules

Le cluster de modules des services de mémoire (Memory Services) de l'AUTOSAR Classic Platform assure la gestion et la persistance normalisées et indépendantes du matériel des données d'application et de logiciel de base dans la mémoire non volatile. Le cluster se divise verticalement en deux couches de l'architecture du logiciel de base AUTOSAR : le gestionnaire NVRAM ([SWS_NvM_00447]) au niveau des services (Services Layer) ainsi que le Memory Abstraction Interface ([SWS_MemIf_00039]) avec les modules d'abstraction sous-jacents Flash EEPROM Emulation ([SWS_Fee_00085]) et EEPROM Abstraction ([SWS_Ea_00083]) au niveau de l'abstraction matérielle (Memory Hardware Abstraction Layer) AUTOSAR SWS NVRAMManager p. 10.

Le gestionnaire NVRAM (NvM) constitue le point d'entrée central pour les composants logiciels (SW-C) ainsi que pour les modules BSW tels que le module Diagnostic Event Manager (Dem) SWS DiagnosticEventManager p. 238. Il gère des blocs de mémoire logiques composés de blocs NV dans la mémoire non volatile, de blocs RAM dans la mémoire volatile ainsi que de blocs ROM optionnels pour les données d'initialisation ([SWS_NvM_00137], [SWS_NvM_00128]). Selon les exigences, les types de gestion de bloc pris en charge sont native (NVM_BLOCK_NATIVE), redundant (NVM_BLOCK_REDUNDANT) ou dataset (NVM_BLOCK_DATASET) AUTOSAR CP RS MemoryServices p. 10.

Les modules Fee et Ea encapsulent les spécificités des supports de stockage physiques respectifs (Flash ou EEPROM) et mappent les numéros de bloc logiques et les décalages d'adresse sur les espaces d'adressage linéaires des pilotes MCAL correspondants (Fls ou Eep) ([SWS_Fee_00087], [SWS_Ea_00086]) AUTOSAR SWS EEPROMAbstraction p. 23. Le module MemIf sert ici de pure couche de routage qui transmet les accès au module cible sur la base du paramètre DeviceIndex, sans conserver ses propres structures de tampon ([SWS_MemIf_00040]).

Diagramme d'architecture : structure en couches et relations entre modules dans le cluster Memory Services. Sources : [SWS_MemIf_00039], AUTOSAR SWS NVRAMManager p. 10

Interaction & voies d'interaction entre les modules

L'interaction entre les modules s'effectue via des chemins synchrones et asynchrones strictement normalisés. Lorsqu'un utilisateur initie une opération d'écriture via NvM_WriteBlock, la requête est d'abord enregistrée dans le bloc administratif du NvM ([SWS_NvM_00455]). En cas d'appel synchrone, la transmission au MemIf s'effectue via MemIf_Write ([SWS_MemIf_00040]), qui transmet l'appel à Fee_Write ou Ea_Write ([SWS_Fee_00088], [SWS_Ea_00087]) AUTOSAR SWS NVRAMManager p. 160.

En ce qui concerne la conservation des données et la synchronisation entre l'application et le gestionnaire NVRAM, deux concepts clés existent : la synchronisation implicite via des blocs RAM permanents (NvMRamBlockDataAddress) et la synchronisation explicite via des tampons basés sur des miroirs (NvMBlockUseSyncMechanism) NVDataHandling p. 12. Lors d'une synchronisation explicite, le NvM copie les données utiles entre la RAM de l'application et le miroir RAM interne via les routines de rappel configurées NvMWriteRamBlockToNvCallback ou NvMReadRamBlockFromNvCallback ([SWS_NvM_00514], [SWS_NvM_00515]) EXP NVDataHandling p. 30.

Lors de l'utilisation de blocs de type dataset (NVM_BLOCK_DATASET), l'appelant sélectionne préalablement l'index d'ensemble de données souhaité via NvM_SetDataIndex ([SWS_NvM_00448]). Les modules d'abstraction calculent ensuite, à partir du numéro de bloc logique et de l'index, le décalage d'adresse exact pour le pilote MCAL ([SWS_NvM_00123]) AUTOSAR SWS Flash EEPROM Emulation p. 21. Les demandes d'annulation sont directement transmises aux sous-modules Fee_Cancel ou Ea_Cancel via MemIf_Cancel ([SWS_MemIf_00041], [SWS_Fee_00089]).

Diagramme de séquence : requête d'écriture asynchrone avec notification par callback et scrutation. Sources : [SWS_NvM_00455], AUTOSAR SWS NVRAMManager p. 160

Synchronisation, réentrance et contextes de tâches

La plupart des API de contrôle et d'état du cluster, dont NvM_GetErrorStatus ([SWS_NvM_00451]), NvM_SetBlockProtection ([SWS_NvM_00450]) et MemIf_GetVersionInfo ([SWS_MemIf_00045]), sont synchrones et peuvent être traitées directement dans le contexte de tâche de l'appelant AUTOSAR SWS NVRAMManager p. 157. En revanche, les fonctions de transfert de données (NvM_ReadBlock, NvM_WriteBlock, Ea_Write) sont asynchrones et non réentrantes ([SWS_MemIf_00040], [SWS_Ea_00087]).

La mise à jour cyclique des tâches en cours incombe aux fonctions principales NvM_MainFunction et Fee_MainFunction appelées périodiquement par le Schedule Manager (SchM) ou par une tâche BSW AUTOSAR CP SWS FlashEEPROMEmulation p. 42. En cas de notifications asynchrones provenant du pilote MCAL, la notification Fee_JobEndNotification ou Fee_JobErrorNotification peut s'effectuer directement au niveau interruption ([SWS_Fee_00095]). Celle-ci positionne l'état sur MEMIF_JOB_OK ou appelle des routines de notification configurées ([SWS_Fee_00142], [SWS_Fee_00194]) SWS FlashEEPROMEmulation p. 37.

Interprétation : afin d'empêcher les conditions de concurrence (race conditions) entre les appelants d'API au niveau tâche et le traitement ultérieur étape par étape dans les MainFunctions, les files d'attente internes et les attributs administratifs devraient être protégés par des zones exclusives, tandis que le MemIf agit comme une couche de relais sans état AUTOSAR SWS NVRAMManager p. 160. Question Q-a50c3362a14b9e6d (ouverte)

Cycles de vie et modes de fonctionnement typiques

Le cycle de vie du cluster est étroitement orchestré par le Basic Software Mode Manager (BswM) et l'ECU State Manager (EcuM). Pendant le démarrage du calculateur (Startup Phase), après les pilotes, ce sont d'abord les modules d'abstraction via Fee_Init ou Ea_Init ([SWS_Fee_00085], [SWS_Ea_00083]), puis le NVRAM Manager via NvM_Init ([SWS_NvM_00447]), qui sont initialisés de manière synchrone AUTOSAR SWS NVRAMManager p. 156.

À l'issue de l'initialisation, le BswM déclenche l'opération de lecture multi-blocs NvM_ReadAll afin de restaurer l'ensemble des blocs de RAM marqués comme persistants à partir de la mémoire non volatile ([SWS_NvM_00460]) ModemanagementGuide p. 54. Le NvM signale la progression et le résultat final au BswM via la fonction de rappel BswM_NvM_CurrentJobMode ([SWS_NvM_00745], [SWS_NvM_00888]). Les états individuels des blocs sont signalés via BswM_NvM_CurrentBlockMode ([SWS_NvM_00746], [SWS_NvM_00890]) ModemanagementGuide p. 28.

Durant la phase d'arrêt (Shutdown), le système commande via NvM_WriteAll la réécriture persistante de tous les blocs de RAM modifiés dans la mémoire NV ([SWS_NvM_00461]). Afin d'optimiser le nombre de cycles d'écriture flash, il est possible de marquer explicitement via NvM_SetRamBlockStatus si un bloc a été modifié ([SWS_NvM_00453]) EXP NVDataHandling p. 18. Une opération d'écriture en cours peut être interrompue via NvM_CancelWriteAll en cas d'événements de réveil prématurés ([SWS_NvM_00238]) AUTOSAR SWS NVRAMManager p. 161.

Gestion des erreurs, traçage DET et dégradation

Le cluster dispose d'un concept de détection des erreurs et de dégradation à plusieurs niveaux. Les erreurs survenant au niveau du pilote et de l'abstraction sont interrogées via le statut de retour MEMIF_JOB_FAILED au moyen de MemIf_GetJobResult ou signalées via NvM_JobErrorNotification ([SWS_Fee_00091], [SWS_Ea_00095]) ErrorDescription p. 49.

En cas d'erreurs de lecture, le NvM fait appel à des mécanismes de restauration configurés : des tentatives de répétition (Read Retries) sont d'abord entreprises ([SWS_NvM_00390]). En cas d'échec de celles-ci, la copie redondante est lue pour les blocs redondants (NVM_BLOCK_REDUNDANT) ([SWS_NvM_00171], [SWS_NvM_00531]). Si une perte de redondance est alors constatée, le NvM définit le résultat de la tâche sur NVM_REQ_REDUNDANCY_FAILED et signale l'erreur de production NVM_E_LOSS_OF_REDUNDANCY au DEM ([SWS_NvM_00470], [SWS_NvM_00546]) ErrorDescription p. 62.

Si la restauration à l'aide des valeurs par défaut en ROM réussit, le NvM signale le résultat NVM_REQ_RESTORED_FROM_ROM ([SWS_NvM_00470]). Si toutes les mesures de restauration échouent, NVM_E_REQ_FAILED est rapporté au DEM ([SWS_NvM_00279], [SWS_NvM_00288]) et le résultat d'interrogation est défini sur NVM_REQ_NOT_OK ([SWS_NvM_00451]). En présence d'erreurs d'écriture, le NvM gère des répétitions d'écriture (NvMMaxNumOfWriteRetries) avant que la requête ne soit abandonnée ([SWS_NvM_00168], [SWS_NvM_00213]) ErrorDescription p. 56.

Ce guide résume l'architecture centrale, les interactions entre modules et les mécanismes d'erreur du cluster Memory Services. Toutes les informations reposent sur les spécifications normatives d'AUTOSAR Classic Platform.

GÉNÉRÉ PAR IA non vérifié Modèle : gemini-3.8-flash-medium · Effort : medium · Température : non réglable · Prompt : e31b8dbca732 Provenance Questions ouvertes (1)

traduit du guide allemandGénéré par l'IAgemini-3.8-flash-medium · 2026-10-14

Gère la persistance et l'abstraction matérielle des données non volatiles pour l'ensemble des modules du calculateur.

Le cluster Memory Services (NvM, MemIf, Fee, Ea) assure la persistance, l'abstraction matérielle et la sécurisation des données non volatiles au sein de la plateforme AUTOSAR Classic (AUTOSAR CP RS MemoryServices p. 10). Il pilote le traitement asynchrone des requêtes de lecture et d'écriture, l'initialisation collective via NvM_ReadAll et la sauvegarde sélective à l'extinction via NvM_WriteAll sous le contrôle du BswM ([SWS_NvM_00460], [SWS_NvM_00461]). Enfin, il intègre des stratégies de reprise sur panne par blocs redondants et valeurs de repli en ROM tout en signalant les anomalies au Dem (ErrorDescription p. 62).

Le cluster Memory Services de la plateforme AUTOSAR Classic fédère la gestion de la persistance des données au travers de quatre modules complémentaires : NvM, MemIf, Fee et Ea (AUTOSAR CP RS MemoryServices p. 10). Le gestionnaire NvM expose des services de haut niveau pour manipuler des blocs de données logiques (natifs, redondants ou organisés en jeux de données), en prenant en charge le contrôle d'intégrité par CRC, la gestion d'en-têtes statiques et les mécanismes de basculement vers des valeurs de secours en ROM ([SWS_NvM_00557], [SWS_NvM_00470], NVDataHandling p. 10).

L'interface intermédiaire MemIf assure l'aiguillage synchrone des requêtes de lecture, d'écriture et d'invalidation vers les modules d'abstraction matérielle Fee (émulation EEPROM sur flash) ou Ea (accès EEPROM) en fonction d'un index de périphérique DeviceIndex ([SWS_MemIf_00039], [SWS_MemIf_00040]). Les données applicatives peuvent être transmises par synchronisation implicite (tampon direct) ou par synchronisation explicite via un tampon miroir géré par le NvM avec les rappels NvM_ReadRamBlockFromNvm et NvM_WriteRamBlockToNvm pour préserver la consistance mémoire (AUTOSAR CP EXP NVDataHandling p. 14, [SWS_NvM_00455]).

Diagramme d'architecture : Vue structurelle du cluster Memory Services et de son intégration dans les couches BSW AUTOSAR. Sources : AUTOSAR CP RS MemoryServices p. 10, [SWS_MemIf_00039].

Le traitement des requêtes s'effectue de manière asynchrone par l'exécution cadencée de NvM_MainFunction et des fonctions périodiques de Fee ou Ea ([SWS_NvM_00467], [SWS_Fee_00097]). Le cycle de vie est coordonné avec le BswM : les opérations collectives NvM_ReadAll au démarrage et NvM_WriteAll lors de l'arrêt permettent de charger puis de sauvegarder sélectivement les blocs RAM modifiés (marquage via NvM_SetRamBlockStatus), tout en signalant les transitions d'état via BswM_NvM_CurrentJobMode (ModemanagementGuide p. 54, [SWS_NvM_00460], [SWS_NvM_00453], [SWS_NvM_00745]).

En cas de défaillance matérielle ou de corruption, le cluster déclenche des mécanismes de reprise graduels (réitérations de lecture/écriture, bascule sur la copie miroir d'un bloc redondant, restauration depuis la ROM) et reporte les erreurs confirmées NVM_E_LOSS_OF_REDUNDANCY ou NVM_E_REQ_FAILED auprès du Dem (ErrorDescription p. 62, [SWS_NvM_00168], [SWS_NvM_00271]).

1. Architecture système et rôle du cluster de modules

Le cluster « Memory Services » de la plateforme AUTOSAR Classic fournit un sous-système unifié pour la persistance, la gestion et la sécurisation des données non volatiles dans les calculateurs électroniques embarqués (AUTOSAR CP RS MemoryServices p. 10). Situé à l'interface entre les composants applicatifs (SW-C), les services de diagnostic comme le DEM et les pilotes matériels sous-jacents, il se compose de quatre modules de base standardisés : le gestionnaire de mémoire non volatile NvM (NVRAM Manager), l'interface d'abstraction mémoire MemIf (Memory Abstraction Interface), ainsi que deux modules d'abstraction matérielle, l'émulation d'EEPROM en mémoire flash Fee (Flash EEPROM Emulation) et l'abstraction d'EEPROM physique Ea (EEPROM Abstraction) ([SWS_MemIf_00039], [SWS_Fee_00087], [SWS_Ea_00086]).

Le module NvM se situe au sommet de cette pile, dans la couche des services de base (Services Layer). Il fournit une vue synchrone et asynchrone logique des données sous forme de blocs NVRAM autonomes, encapsulant la politique d'accès, la cohérence des données, le calcul d'intégrité par CRC, ainsi que les mécanismes de reprise sur erreur (AUTOSAR SWS NVRAMManager p. 10, [SWS_NvM_00557]). Il masque totalement la topologie physique de stockage aux logiciels utilisateurs, qu'il s'agisse de composants applicatifs via la RTE ou de modules BSW tels que le DEM ([SWS_NvM_00451], SWS DiagnosticEventManager p. 238).

Le module intermédiaire MemIf agit comme un routeur d'abstraction statique ou quasi-transparent. Il permet au NvM d'accéder indifféremment à un ou plusieurs périphériques physiques via un paramètre d'index de périphérique DeviceIndex, en déroutant de manière synchrone les requêtes de lecture, d'écriture, d'annulation ou d'invalidation vers le pilote d'abstraction approprié, à savoir Fee ou Ea ([SWS_MemIf_00039], [SWS_MemIf_00040], [SWS_MemIf_00044]). Enfin, Fee et Ea convertissent l'adressage par numéros de blocs logiques et décalages d'octets en opérations linéaires adaptées aux contraintes sectorielles de la flash (avec gestion de l'usure et compactage) ou aux pages physiques d'une EEPROM (AUTOSAR SWS EEPROMAbstraction p. 23, AUTOSAR SWS Flash EEPROM Emulation p. 21).

Diagramme d'architecture : Organisation hiérarchique du cluster Memory Services et flux de commande vers les couches matérielles. Sources : AUTOSAR CP RS MemoryServices p. 10, [SWS_MemIf_00039], [SWS_Fee_00087], [SWS_Ea_00086].

2. Interaction et chemins de communication entre les modules

L'unité conceptuelle fondamentale manipulée au niveau du service est le bloc NVRAM logique. D'après l'architecture structurelle, un bloc NVRAM peut regrouper jusqu'à quatre composants : le bloc non volatile physique stocké en mémoire de masse (NV Block), le bloc miroir en mémoire vive (RAM Block), un bloc de constantes par défaut en lecture seule (ROM Block), et un descripteur d'état interne en RAM (Administrative Block) (AUTOSAR SWS NVRAMManager p. 10, [SWS_NvM_00557], [SWS_NvM_00558]). Trois types de gestion de bloc sont standardisés : natif (NVM_BLOCK_NATIVE), redondant avec deux copies miroirs pour la tolérance aux pannes (NVM_BLOCK_REDUNDANT), et jeu de données (NVM_BLOCK_DATASET) permettant d'indexer plusieurs sous-blocs au moyen de NvM_SetDataIndex (NVDataHandling p. 10, AUTOSAR CP SWS NVRAMManager p. 32, [SWS_NvM_00448]).

Le transfert de données entre les logiciels utilisateurs et le NvM repose sur deux paradigmes d'échange mémoire : la synchronisation implicite et la synchronisation explicite. En synchronisation implicite, l'application utilise un bloc RAM permanent ou temporaire partagé directement référencé lors de l'appel (AUTOSAR CP EXP NVDataHandling p. 12, [SWS_NvM_00454]). En synchronisation explicite, afin d'éliminer les risques d'écrasement ou de corruption de données durant les opérations d'entrée/sortie asynchrones prolongées, le NvM maintient un tampon miroir dédié ; les échanges s'effectuent alors de manière contrôlée via les fonctions de rappel NvM_ReadRamBlockFromNvm et NvM_WriteRamBlockToNvm (AUTOSAR CP EXP NVDataHandling p. 14, NVDataHandling p. 12, [SWS_NvM_00455]).

Lors d'une demande asynchrone de lecture (NvM_ReadBlock) ou d'écriture (NvM_WriteBlock), le NvM enregistre la requête dans sa file d'attente interne, positionne l'état du travail sur NVM_REQ_PENDING et retourne immédiatement le statut synchrone E_OK au demandeur (AUTOSAR SWS NVRAMManager p. 160, [SWS_NvM_00455]). Au cycle suivant, le moteur interne du NvM prépare les métadonnées (en-tête de bloc avec identifiant statique optionnel pour prévenir les erreurs de configuration d'adressage selon AUTOSAR CP SWS NVRAMManager p. 29 et [SWS_NvM_00522]), calcule le CRC le cas échéant, puis relaie la requête vers MemIf_Write ou MemIf_Read ([SWS_MemIf_00039], [SWS_MemIf_00040]). MemIf achemine alors directement le travail vers l'API correspondante Fee_Write/Fee_Read ou Ea_Write/Ea_Read ([SWS_Ea_00087], [SWS_Fee_00088]).

Diagramme de séquence : Déroulement asynchrone d'une requête d'écriture de bloc avec synchronisation miroir et rappels de terminaison. Sources : AUTOSAR SWS NVRAMManager p. 160, AUTOSAR CP EXP NVDataHandling p. 14, [SWS_NvM_00455], [SWS_MemIf_00040].

3. Synchronisation, réentrance et contextes d'exécution

Le traitement des requêtes de mémoire non volatile est intrinsèquement asynchrone et repose sur l'ordonnancement périodique des fonctions principales de base de chaque module (AUTOSAR CP SWS FlashEEPROMEmulation p. 42). NvM_MainFunction cadence la machine d'états centrale du gestionnaire, gère l'évaluation des priorités dans les files d'attente, déclenche la sérialisation des blocs et scrute l'état d'avancement des couches inférieures (AUTOSAR SWS NVRAMManager p. 160, [SWS_NvM_00467]). En parallèle, Fee_MainFunction ou Ea_MainFunction pilote les étapes d'écriture physique, d'effacement de secteurs ou de ramasse-miettes (garbage collection) dans un contexte de tâche BSW cyclique ([SWS_Fee_00097], [SWS_Ea_00089]).

Deux modes de notification de terminaison d'opération sont supportés par le cluster : le scrutation active (polling) et les fonctions de rappel asynchrones (callbacks). En mode polling, NvM interroge périodiquement le résultat du sous-système mémoire via MemIf_GetJobResult, qui consulte Fee_GetJobResult ou le pilote d'abstraction EEPROM (ErrorDescription p. 49, [SWS_Fee_00091], [SWS_MemIf_00065]). En mode événementiel, les pilotes de périphériques signalent la fin de transmission via les rappels Fee_JobEndNotification ou Ea_JobEndNotification, qui peuvent être exécutés sous niveau d'interruption (ISR), mettant immédiatement à jour l'état vers MEMIF_JOB_OK ou MEMIF_JOB_FAILED avant notification du NvM via NvM_JobErrorNotification (SWS FlashEEPROMEmulation p. 37, [SWS_Fee_00095], [SWS_Ea_00095]).

Concernant la réentrance, les interfaces standard de service pour un bloc donné, telles que NvM_ReadBlock, NvM_WriteBlock, MemIf_Read, MemIf_Write, Fee_Cancel ou Ea_Write, sont formellement classées comme non réentrantes ([SWS_MemIf_00039], [SWS_MemIf_00040], [SWS_Fee_00089], [SWS_Ea_00087]). Les modifications concurrentes de descripteurs ou de tables d'administration exigent l'application de sections exclusives fournies par le gestionnaire d'ordonnancement (SchM). En cas de redémarrage d'une partition logicielle (OsApplication), les tâches utilisatrices doivent impérativement invoquer NvM_CancelJobs sur l'ensemble de leurs blocs afin d'annuler les opérations pendantes et d'empêcher toute corruption mémoire par notification tardive (SWS OS p. 328, [SWS_NvM_00535], [SWS_NvM_00536]).

4. Cycles de vie et modes de fonctionnement

Le cycle de vie du cluster est intimement coordonné avec le gestionnaire d'état de l'ECU (EcuM) et le gestionnaire de modes de base (BswM). Durant la phase de démarrage initial du calculateur (Startup Phase II / ECU_STARTUP_ONE), l'orchestration impose d'initialiser les pilotes physiques (Spi, Fls, Eep), puis les couches d'abstraction Ea_Init et Fee_Init, avant d'exécuter NvM_Init (ModemanagementGuide p. 54, AUTOSAR SWS NVRAMManager p. 156, [SWS_NvM_00447], [SWS_Fee_00085], [SWS_Ea_00083]). Fee_Init place initialement le module dans l'état MEMIF_BUSY_INTERNAL pour exécuter les contrôles de structure interne de la flash tout en autorisant l'enregistrement préliminaire des requêtes (AUTOSAR CP SWS FlashEEPROMEmulation p. 42, [SWS_MemIf_00064]).

Une fois les modules initialisés, le BswM déclenche l'opération multi-bloc globale NvM_ReadAll pour restaurer les blocs persistants en mémoire vive avant le lancement des applications de bord (NVDataHandling p. 20, [SWS_NvM_00460]). Le NvM signale le progrès et l'achèvement de ce traitement global au BswM au moyen du rappel BswM_NvM_CurrentJobMode, ainsi que pour chaque bloc individuel via BswM_NvM_CurrentBlockMode, permettant au BswM d'évaluer ses règles de transition et d'autoriser l'exécution de Rte_Start vers l'état ECU_RUN (SWS BSWModeManager p. 75, AUTOSAR SWS NVRAMManager p. 163, [SWS_NvM_00745], [SWS_NvM_00746]).

Lors de la phase d'extinction du calculateur (Shutdown), le BswM ou l'EcuM déclenche le service NvM_WriteAll (NVDataHandling p. 41, [SWS_NvM_00461]). Afin d'optimiser la durée de coupure et d'économiser les cycles d'endurance de la flash ou de l'EEPROM, seuls les blocs RAM marqués comme modifiés (dirty flag) via l'appel préalable à NvM_SetRamBlockStatus(BlockId, TRUE) sont sérialisés et écrits dans la mémoire non volatile (NVDataHandling p. 49, [SWS_NvM_00453]). Si un événement de réveil survient pendant l'extinction, le système peut interrompre de façon non destructive la sauvegarde globale en invoquant NvM_CancelWriteAll (AUTOSAR SWS NVRAMManager p. 161, [SWS_NvM_00238], [SWS_NvM_91003]).

5. Gestion des erreurs, traçage DET et dégradation

La robustesse des données face aux défaillances de stockage physique repose sur un modèle hiérarchisé de détection, notification et restauration. Lors d'un échec de lecture ou d'écriture signalé par MEMIF_JOB_FAILED, le NvM déclenche automatiquement des tentatives de réitération configurables (read retry / write retry via NvMMaxNumOfReadRetries et NvMMaxNumOfWriteRetries) (ErrorDescription p. 56, SWS RTE p. 1503, [SWS_NvM_00168], [SWS_NvM_00213]). En cas de gestion par bloc redondant (NVM_BLOCK_REDUNDANT), une défaillance de la copie primaire provoque une tentative de lecture transparente sur la copie secondaire ; si seule la redondance est compromise, l'erreur NVM_E_LOSS_OF_REDUNDANCY est transmise au gestionnaire de diagnostic Dem et le statut de requête devient NVM_REQ_REDUNDANCY_FAILED (ErrorDescription p. 62, [SWS_NvM_00470], [SWS_NvM_00546]).

Si toutes les copies non volatiles sont déclarées corrompues ou invalides, le NvM active sa stratégie de repli en chargeant automatiquement les valeurs par défaut issues du bloc ROM associé (NvMRomBlockDataAddress) ou par l'intermédiaire d'un callback InitBlockCallbackFunction, attribuant au travail le résultat NVM_REQ_RESTORED_FROM_ROM (ErrorDescription p. 62, NVDataHandling p. 15, [SWS_NvM_00470], [SWS_NvM_00171]). Lorsque l'ensemble des tentatives de récupération échoue, l'erreur irrémédiable de production NVM_E_REQ_FAILED est rapportée au Dem (ErrorDescription p. 46, [SWS_NvM_00271], [SWS_NvM_00269]).

Au niveau du développement et du traçage, l'activation du module Det (Default Error Tracer) permet de capturer les appels invalides, tels que l'invocation d'un service avant initialisation complète (NVM_E_UNINIT, FEE_E_UNINIT) ou la transmission d'un identifiant de bloc hors limites (NVM_E_PARAM_BLOCK_ID) (SWS SoftwareClusterConnection p. 168, SWS FlashEEPROMEmulation p. 29, [SWS_Fee_00124]). Par ailleurs, lors d'évolutions logicielles ou de reprogrammation, le contrôle d'identifiant de configuration (NvMConfigurationIdCheck) garantit que les blocs non résistants aux changements de logiciel (NvMResistantToChangedSw == FALSE) sont automatiquement réinitialisés avec leurs données d'usine pour préserver l'intégrité globale du système (NVDataHandling p. 15, [SWS_NvM_00249], [SWS_NvM_00460]).

Ce guide synthétise les exigences normatives et spécifications d'architecture du cluster Memory Services dans AUTOSAR Classic R20-11.

AUTOSAR Classic Memory Services

Carte des thèmes

Vue détaillée

Guide du clusterGÉNÉRÉ PAR IA🔍

Architecture système & rôle du cluster de modules

Interaction & voies d'interaction entre les modules

Synchronisation, réentrance et contextes de tâches

Cycles de vie et modes de fonctionnement typiques

Gestion des erreurs, traçage DET et dégradation

1. Architecture système et rôle du cluster de modules

2. Interaction et chemins de communication entre les modules

3. Synchronisation, réentrance et contextes d'exécution

4. Cycles de vie et modes de fonctionnement

5. Gestion des erreurs, traçage DET et dégradation

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)

Guide du clusterGÉNÉRÉ PAR IA