La arquitectura AUTOSAR puede ser un desafío, especialmente el módulo EcuM (ECU State Manager), que gestiona el estado operativo de la ECU. En lugar de memorizar estados y secuencias de llamadas, este artículo presenta un enfoque visual y práctico.

Utilizaremos un diagrama de estados y ejemplos de código simplificados para ilustrar el ciclo de vida de EcuM, centrándonos en las fases STARTUP, UP, SLEEP y SHUTDOWN, y su interacción con BswM (Behavioral State Manager).

1. Vista General del Ciclo de Vida de EcuM

El siguiente diagrama de secuencia describe el flujo completo de EcuM:

STARTUP --> UP --> (SLEEP <--> WAKEUP) --> SHUTDOWN --> OFF
       ^_________|
 

Características Clave de los Estados:

Nota: AUTOSAR 4.4 y versiones posteriores utilizan EcuM Flexible, donde BswM gestiona los estados en la fase UP.

2. Fase STARTUP: Inicialización en Dos Pasos

La fase STARTUP se divide en StartPreOs y StartPostOs para optimizar la eficiencia y el orden de inicialización.

2.1 StartPreOs: Preparación antes del Sistema Operativo

Este paso realiza las inicializaciones mínimas necesarias antes de que el sistema operativo comience. Aquí un ejemplo de pseudo-código:

void EcuM_StartPreOs(void) {
   // Configuración de interrupciones esenciales
   EcuM_AL_SetProgrammableInterrupts();
   
   // Inicialización de drivers básicos (sin parámetros)
   EcuM_AL_DriverInitZero();
   
   // Verificación de la configuración
   const EcuM_ConfigType* config = EcuM_DeterminePbConfiguration();
   if (!CheckConfigConsistency(config)) {
       ReportError(CONFIG_CHECK_FAILED);
   }
   
   // Inicialización de drivers (con parámetros)
   EcuM_AL_DriverInitOne(config);
   
   // Procesamiento de la fuente de reinicio
   Mcu_ResetType resetSrc = GetMcuResetReason();
   EcuM_SetWakeupEvent(MapToWakeupSrc(resetSrc));
   
   // Establecer destino de apagado por defecto
   SetDefaultShutdownTarget(SHUTDOWN_TARGET_SLEEP);
   
   // Detección de bucle de arranque
   EcuM_LoopDetection();
   
   // Iniciar el Sistema Operativo
   StartOS();
}
 

Consideraciones importantes:

• Evitar el manejo complejo de interrupciones en esta fase.
• El orden de inicialización es crucial, especialmente para hardware.
• Los fallos en la verificación de configuración deben ser manejados de forma segura.

2.2 StartPostOs: Inicialización Post-SO

Una vez que el sistema operativo ha iniciado, StartPostOs completa la inicialización, con BswM tomando el control:

void StartupTask(void) {
   // Inicialización del Scheduler
   SchM_Init();
   
   // BswM asume el control
   BswM_Init();
   
   // Bucle principal de BswM hasta que esté listo
   while (!BswM_IsReady()) {
       BswM_MainFunction();
       Wait(10ms); // Espera simulada
   }
   
   // Inicio de la orquestación principal
   StartSchedule();
   
   // Transición a la fase UP
   EcuM_StartupTwo_Complete();
}
 

Nota: La condición BswM_IsReady() depende de los requisitos específicos del proyecto.

3. Fase UP: Gestión de Estado por BswM

En la fase UP, EcuM delega gran parte de la gestión de estado a BswM, mientras EcuM se enfoca en los eventos de despertar.

void BswM_MainFunction(void) {
   // Procesar solicitudes de modo RUN
   if (CheckRunRequests()) {
       SwitchToRunMode();
   } 
   // Procesar solicitudes de modo POST-RUN
   else if (CheckPostRunRequests()) {
       SwitchToPostRunMode();
   } 
   // Procesar solicitud de modo SLEEP
   else if (CheckSleepRequest()) {
       EcuM_RequestShutdown(ECUM_SHUTDOWN_SLEEP);
   }
}

// Ejemplo de manejo de evento de despertar
void ISR_WakeupSource(void) {
   EcuM_SetWakeupEvent(WAKEUP_SRC_CAN);
   EcuM_ValidateWakeupEvent(WAKEUP_SRC_CAN, 100ms); // Validación con timeout
}
 

Estados de Validación de Fuente de Despertar:

1. NONE -> PENDING: Evento detectado.

2. PENDING -> VALIDATED: Evento confirmado antes del timeout.

3. PENDING -> EXPIRED: Timeout alcanzado sin confirmación.

4. VALIDATED -> NONE: Evento procesado.

5. Fases SLEEP y SHUTDOWN

4.1 Entrada a SLEEP y Despertar

El modo SLEEP requiere soporte de hardware y configuración adecuada. El flujo típico:

void EnterSleepMode(void) {
   // Configuración pre-sleep para periféricos
   Can_SetSleepMode(CAN_CONTROLLER_0);
   Lin_GoToSleep(LIN_CHANNEL_1);
   
   // Habilitar fuentes de despertar
   EcuM_EnableWakeupSources(WAKEUP_SRC_CAN | WAKEUP_SRC_KL15);
   
   // Entrar en modo de bajo consumo
   if (USE_HALT_MODE) {
       Mcu_Halt(); // Modo HALT
   } else {
       Mcu_Poll(); // Modo de bajo consumo con polling
   }
}

// Manejador de despertar
void WakeupHandler(void) {
   if (EcuM_CheckWakeup(WAKEUP_SRC_CAN)) {
       RestoreNormalOperation();
       EcuM_Resume(); // Reanudar operación normal
   } else {
       ContinueSleep(); // Mantener en modo sleep
   }
}
 

4.2 Variantes del Proceso SHUTDOWN

El proceso de apagado varía según el destino:

Apagado a OFF:

void ShutdownToOff(void) {
   // Fase OffPreOs
   DeinitCriticalModules();
   SetShutdownTarget(ECUM_SHUTDOWN_OFF);
   
   // Desactivar el SO
   ShutdownOS();
   
   // Fase OffPostOs (ejecutada por un hook de shutdown)
   NvM_WriteAll(); // Guardar datos no volátiles
   PowerOffMCU();  // Apagar la MCU
}
 

Apagado a RESET:

void ShutdownToReset(void) {
   // Fase OffPreOs
   SetShutdownTarget(ECUM_SHUTDOWN_RESET);
   
   // Fase OffPostOs
   NvM_WriteAll();
   Mcu_PerformReset(); // Realizar reinicio del sistema
}
 

5. Consejos Prácticos y Errores Comunes

Al implementar EcuM, considere lo siguiente:

Errores de Confgiuración:

• Verificar que EcuMFlexible en EcuMGeneral esté en TRUE.
• Asegurar la correcta asignación de fuentes de despertar en EcuMCommonConfiguration.
• EcuMShutdownTarget debe ser compatible con las capacidades del hardware.

Optimización de Tiempos:

• Minimizar las tareas en StartPreOs.
• Posponer inicializaciones largas a StartPostOs.
• Considerar la paralelización de la inicialización de BswM si es posible.

Sugerencias de Depuración:

• Añadir logs en los puntos de transición de estado.
• Monitorear el valor retornado por EcuM_GetState().
• Utilizar herramientas como TRACE32 para capturar la dinámica en modos de bajo consumo.

Este enfoque combinado de visualización y código debería simplificar significativamente la comprensión de EcuM. Se recomienda implementar un estado mínimo de EcuM en su propio hardware para observar su comportamiento.