system/EcuM/EcuM.c

   1 /* -------------------------------- Arctic Core ------------------------------\r
   2  * Arctic Core - the open source AUTOSAR platform http://arccore.com\r
   3  *\r
   4  * Copyright (C) 2009  ArcCore AB <contact@arccore.com>\r
   5  *\r
   6  * This source code is free software; you can redistribute it and/or modify it\r
   7  * under the terms of the GNU General Public License version 2 as published by the\r
   8  * Free Software Foundation; See <http://www.gnu.org/licenses/old-licenses/gpl-2.0.txt>.\r
   9  *\r
  10  * This program is distributed in the hope that it will be useful, but\r
  11  * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY\r
  12  * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License\r
  13  * for more details.\r
  14  * -------------------------------- Arctic Core ------------------------------*/\r
  15 \r
  16 \r
  17 /** @reqSettings DEFAULT_SPECIFICATION_REVISION=3.1.5 */\r
  18 \r
  19 /* ----------------------------[information]----------------------------------*/\r
  20 /*\r
  21  * Author: ?+mahi\r
  22  *\r
  23  * Part of Release:\r
  24  *   3.1.5\r
  25  *\r
  26  * Description:\r
  27  *   Implements the Can Driver module\r
  28  *\r
  29  * Support:\r
  30  *   General                  Have Support\r
  31  *   -------------------------------------------\r
  32  *   ECUM_TTII_ENABLED                          N\r
  33  *   ECUM_DEV_ERROR_DETECT                              Y\r
  34  *   ECUM_VERSION_INFO_API                              Y\r
  35  *   ECUM_INCLUDE_DEM                                   N (controlled by USE_x macro's instead)\r
  36  *   ECUM_INCLUDE_NVRAM_MGR                             N (controlled by USE_x macro's instead)\r
  37  *   ECUM_INLCUDE_DET                                   N (controlled by USE_x macro's instead)\r
  38  *   ECUM_MAIN_FUNCTION_PERDIOD                 Y\r
  39  *   ECUM_TTII_WKSOURCE                                 N\r
  40  *\r
  41  *   Configuration            Have Support\r
  42  *   -------------------------------------------\r
  43  *   ECUM_SLEEP_ACTIVITY_PERIOD                 ?\r
  44  *   ECUM_CONFIGCONSISTENCY_HASH                N\r
  45  *   ECUM_RUN_SELF_REQUEST_PERIOD               ?\r
  46  *   ECUM_NVRAM_WRITEALL_TIMEOUT                Y\r
  47  *   ECUM_DEFAULT_APP_MODE                              ?\r
  48  *\r
  49  *\r
  50  *   DefaultShutdownTarget\r
  51  *   -------------------------------------------\r
  52  *   ECUM_DEFAULT_SHUTDOWN_TARGET               N\r
  53  *\r
  54  *\r
  55  * Things to start with:\r
  56  * - EcuM2181\r
  57  * - EcuM2861 , Watchdog\r
  58  * - ComM_EcuM_RunModeIndication()  not called, See Figure 8 (Seems that the ComM does not do much either)\r
  59  *\r
  60  *\r
  61  *\r
  62  */\r
  63 \r
  64 //lint -emacro(904,VALIDATE,VALIDATE_RV,VALIDATE_NO_RV) //904 PC-Lint exception to MISRA 14.7 (validate macros).\r
  65 \r
  66 \r
  67 /* ----------------------------[includes]------------------------------------*/\r
  68 \r
  69 #include "Std_Types.h"\r
  70 #include "EcuM.h"\r
  71 #include "Modules.h"\r
  72 #include <string.h>\r
  73 #include <Os.h>\r
  74 #include "EcuM_Generated_Types.h"\r
  75 #include "EcuM_Internals.h"\r
  76 #include "EcuM_Cbk.h"\r
  77 #include "SchM_EcuM.h"\r
  78 #include "MemMap.h"\r
  79 #include "Mcu.h"\r
  80 #include "ComStack_Types.h"\r
  81 #if defined(USE_DET)\r
  82 #include "Det.h"\r
  83 #endif\r
  84 #include "isr.h"\r
  85 #if defined(USE_NVM)\r
  86 #include "NvM.h"\r
  87 #endif\r
  88 #if defined(USE_RTE)\r
  89 #include "Rte_Main.h"\r
  90 #endif\r
  91 #if defined(USE_SCHM)\r
  92 #include "SchM.h"\r
  93 #endif\r
  94 \r
  95 \r
  96 /* ----------------------------[private define]------------------------------*/\r
  97 /* ----------------------------[private macro]-------------------------------*/\r
  98 /* ----------------------------[private typedef]-----------------------------*/\r
  99 /* ----------------------------[private function prototypes]-----------------*/\r
 100 /* ----------------------------[private variables]---------------------------*/\r
 101 \r
 102 EcuM_GlobalType internal_data;\r
 103 \r
 104 /* ----------------------------[private functions]---------------------------*/\r
 105 \r
 106 \r
 107 /* ----------------------------[public functions]----------------------------*/\r
 108 \r
 109 #if !defined(USE_DET) && defined(ECUM_DEV_ERROR_DETECT)\r
 110 #error EcuM configuration error. DET is not enabled when ECUM_DEV_ERROR_DETECT is set\r
 111 #endif\r
 112 \r
 113 void EcuM_Init( void )\r
 114 {\r
 115         Std_ReturnType status;\r
 116         set_current_state(ECUM_STATE_STARTUP_ONE);\r
 117 \r
 118         // Initialize drivers that are needed to determine PostBuild configuration\r
 119         EcuM_AL_DriverInitZero();\r
 120 \r
 121         // Initialize the OS\r
 122         InitOS();\r
 123 \r
 124         // Setup interrupts\r
 125         Os_IsrInit();\r
 126 \r
 127         // Determine PostBuild configuration\r
 128         internal_data.config = EcuM_DeterminePbConfiguration();\r
 129 \r
 130 \r
 131         // TODO: Check consistency of PB configuration\r
 132 \r
 133         // Initialize drivers needed before the OS-starts\r
 134         EcuM_AL_DriverInitOne(internal_data.config);\r
 135 \r
 136         // Determine the reset/wakeup reason\r
 137         // TODO Mcu_ResetType type = Mcu_GetResetReason();\r
 138 \r
 139         // Moved this here because EcuM_SelectShutdownTarget needs us to be initilized.\r
 140         internal_data.initiated = TRUE;\r
 141 \r
 142         // Set default shutdown target\r
 143         status = EcuM_SelectShutdownTarget(internal_data.config->EcuMDefaultShutdownTarget,internal_data.config->EcuMDefaultSleepMode);/** @req EcuM2181 */\r
 144         if(status!=E_OK){\r
 145                 //TODO: Report error.\r
 146         }\r
 147 \r
 148 \r
 149         // Set default application mode\r
 150         status =  EcuM_SelectApplicationMode(internal_data.config->EcuMDefaultAppMode);\r
 151         if(status!=E_OK){\r
 152                 //TODO: Report error.\r
 153         }\r
 154 \r
 155 #if defined(USE_COMM) || defined(USE_ECUM_COMM)\r
 156         internal_data.run_comm_requests = 0;\r
 157 #endif\r
 158         internal_data.run_requests = 0;\r
 159         internal_data.postrun_requests = 0;\r
 160 \r
 161         // Start this baby up\r
 162         AppModeType appMode;\r
 163         status = EcuM_GetApplicationMode(&appMode);\r
 164         if(status!=E_OK){\r
 165                 //TODO: Report error.\r
 166         }\r
 167         StartOS(appMode); /** @req EcuM2141 */\r
 168 }\r
 169 \r
 170 /*\r
 171  * The order defined here is found in 3.1.5/EcuM2411\r
 172  */\r
 173 void EcuM_StartupTwo(void)\r
 174 {\r
 175         //TODO:  Validate that we are in state STARTUP_ONE.\r
 176 #if defined(USE_NVM)\r
 177         extern CounterType Os_Arc_OsTickCounter;\r
 178         TickType tickTimerStart, tickTimerElapsed;\r
 179         static NvM_RequestResultType readAllResult;\r
 180         TickType tickTimer;\r
 181         StatusType tickTimerStatus;\r
 182 #endif\r
 183 \r
 184         // Initialize the BSW scheduler\r
 185 #if defined(USE_SCHM)\r
 186         SchM_Init();\r
 187 #endif\r
 188 \r
 189 #if defined(USE_WDGM)\r
 190         WdgM_SetMode(internal_data.config->EcuMWdgMConfig->EcuMWdgMStartupMode);\r
 191 #endif\r
 192 \r
 193         // Initialize drivers that don't need NVRAM data\r
 194         EcuM_AL_DriverInitTwo(internal_data.config);\r
 195 \r
 196 #if defined(USE_NVM)\r
 197         // Start timer to wait for NVM job to complete\r
 198         tickTimerStart = GetOsTick();\r
 199 #endif\r
 200 \r
 201         // Prepare the system to startup RTE\r
 202         // TODO EcuM_OnRTEStartup();\r
 203 #if defined(USE_RTE)\r
 204         Rte_Start();\r
 205 #endif\r
 206 \r
 207         set_current_state(ECUM_STATE_STARTUP_TWO);\r
 208 \r
 209 #if defined(USE_NVM)\r
 210 \r
 211 #if 0\r
 212         /* Wait for the NVM job (NvmReadAll) to terminate. This assumes that:\r
 213          * - A task runs the memory MainFunctions, e.g. Ea_MainFunction(), Eep_MainFunction()\r
 214          *    Prio: HIGH\r
 215          * - A task runs the service functions for EcuM, Nvm.\r
 216          *    Prio: MIDDLE\r
 217          * - This task:\r
 218          *    Prio: LOW  (So that the service functions for the other may run)\r
 219          */\r
 220         do {\r
 221                 /* Read the multiblock status */\r
 222                 NvM_GetErrorStatus(0, &readAllResult);\r
 223                 tickTimerElapsed = OS_TICKS2MS_OsTick(GetOsTick() - tickTimerStart);\r
 224                 /* The timeout EcuMNvramReadAllTimeout is in ms */\r
 225         } while( (readAllResult == NVM_REQ_PENDING) && (tickTimerElapsed < internal_data.config->EcuMNvramReadAllTimeout) );\r
 226 #else\r
 227         // Wait for the NVM job (NvmReadAll) to terminate\r
 228                 do {\r
 229                         NvM_GetErrorStatus(0, &readAllResult);  // Read the multiblock status\r
 230                         tickTimer = tickTimerStart;     // Save this because the GetElapsedCounterValue() will destroy it.\r
 231                         tickTimerStatus =  GetElapsedCounterValue(Os_Arc_OsTickCounter, &tickTimer, &tickTimerElapsed);\r
 232                         if (tickTimerStatus != E_OK) {\r
 233                                 DET_REPORTERROR(MODULE_ID_ECUM, 0, ECUM_ARC_STARTUPTWO_ID, ECUM_E_ARC_TIMERERROR);\r
 234                         }\r
 235                 } while( (readAllResult == NVM_REQ_PENDING) && (tickTimerElapsed < internal_data.config->EcuMNvramReadAllTimeout) );\r
 236 #endif\r
 237 #endif\r
 238 \r
 239         // Initialize drivers that need NVRAM data\r
 240         EcuM_AL_DriverInitThree(internal_data.config);\r
 241 \r
 242         // TODO: Indicate mode change to RTE\r
 243 \r
 244         // If coming from startup sequence, enter Run mode\r
 245 //      if (internal_data.current_state == ECUM_STATE_STARTUP_TWO)\r
 246                 EcuM_enter_run_mode();\r
 247 \r
 248 }\r
 249 \r
 250 // Typically called from OS shutdown hook\r
 251 void EcuM_Shutdown(void)\r
 252 {\r
 253         set_current_state(ECUM_STATE_GO_OFF_TWO);\r
 254 \r
 255         // Let the last drivers do a nice shutdown\r
 256         EcuM_OnGoOffTwo();\r
 257 \r
 258         if (internal_data.shutdown_target == ECUM_STATE_OFF)\r
 259         {\r
 260                 EcuM_AL_SwitchOff();\r
 261         }\r
 262         else\r
 263         {\r
 264 #if (MCU_PERFORM_RESET_API == STD_ON)\r
 265                 Mcu_PerformReset();\r
 266 #else\r
 267                 for(;;)\r
 268                 {\r
 269                   ;\r
 270                 }\r
 271 #endif\r
 272         }\r
 273 }\r
 274 \r
 275 Std_ReturnType EcuM_GetState(EcuM_StateType* state)\r
 276 {\r
 277         VALIDATE_RV(internal_data.initiated, ECUM_GETSTATE_ID, ECUM_E_NOT_INITIATED, E_NOT_OK);\r
 278         VALIDATE_RV(state != NULL, ECUM_GETSTATE_ID, ECUM_E_NULL_POINTER, E_NOT_OK);\r
 279 \r
 280         *state = internal_data.current_state;\r
 281 \r
 282         return E_OK;\r
 283 }\r
 284 \r
 285 Std_ReturnType EcuM_SelectApplicationMode(AppModeType appMode)\r
 286 {\r
 287         VALIDATE_RV(internal_data.initiated, ECUM_SELECTAPPMODE_ID, ECUM_E_NOT_INITIATED, E_NOT_OK);\r
 288 \r
 289         internal_data.app_mode = appMode;\r
 290 \r
 291         return E_OK;\r
 292 }\r
 293 \r
 294 Std_ReturnType EcuM_GetApplicationMode(AppModeType* appMode)\r
 295 {\r
 296         VALIDATE_RV(internal_data.initiated, ECUM_GETAPPMODE_ID, ECUM_E_NOT_INITIATED, E_NOT_OK);\r
 297         VALIDATE_RV(appMode != NULL, ECUM_GETAPPMODE_ID, ECUM_E_NULL_POINTER, E_NOT_OK);\r
 298 \r
 299         *appMode = internal_data.app_mode;\r
 300 \r
 301         return E_OK;\r
 302 }\r
 303 \r
 304 Std_ReturnType EcuM_SelectBootTarget(EcuM_BootTargetType target)\r
 305 {\r
 306         VALIDATE_RV(internal_data.initiated, ECUM_SELECT_BOOTARGET_ID, ECUM_E_NOT_INITIATED, E_NOT_OK);\r
 307 \r
 308         // TODO Do something great here\r
 309         (void) target;\r
 310 \r
 311         return E_NOT_OK;\r
 312 }\r
 313 \r
 314 Std_ReturnType EcuM_GetBootTarget(EcuM_BootTargetType* target)\r
 315 {\r
 316         VALIDATE_RV(internal_data.initiated, ECUM_GET_BOOTARGET_ID, ECUM_E_NOT_INITIATED, E_NOT_OK);\r
 317         VALIDATE_RV(target != NULL, ECUM_GET_BOOTARGET_ID, ECUM_E_NULL_POINTER, E_NOT_OK);\r
 318 \r
 319         // TODO Return selected boot target here\r
 320         (void) target;\r
 321 \r
 322         return E_NOT_OK;\r
 323 }\r
 324 \r
 325 \r
 326 Std_ReturnType EcuM_SelectShutdownTarget(EcuM_StateType shutdownTarget, uint8 sleepMode)\r
 327 {\r
 328         VALIDATE_RV(internal_data.initiated, ECUM_SELECTSHUTDOWNTARGET_ID, ECUM_E_NOT_INITIATED, E_NOT_OK);\r
 329         VALIDATE_RV((shutdownTarget == ECUM_STATE_OFF) || (shutdownTarget == ECUM_STATE_RESET) || (shutdownTarget == ECUM_STATE_SLEEP), ECUM_SELECTSHUTDOWNTARGET_ID, ECUM_E_INVALID_PAR, E_NOT_OK);\r
 330 \r
 331         internal_data.shutdown_target = shutdownTarget;\r
 332         internal_data.sleep_mode = sleepMode;\r
 333 \r
 334         return E_OK;\r
 335 }\r
 336 \r
 337 \r
 338 Std_ReturnType EcuM_GetShutdownTarget(EcuM_StateType* shutdownTarget, uint8* sleepMode) /** @req EcuM2824 */\r
 339 {\r
 340         VALIDATE_RV(internal_data.initiated, ECUM_GETSHUTDOWNTARGET_ID, ECUM_E_NOT_INITIATED, E_NOT_OK);\r
 341         VALIDATE_RV(shutdownTarget != NULL, ECUM_GETSHUTDOWNTARGET_ID, ECUM_E_NULL_POINTER, E_NOT_OK);\r
 342         VALIDATE_RV(sleepMode != NULL, ECUM_GETSHUTDOWNTARGET_ID, ECUM_E_NULL_POINTER, E_NOT_OK);\r
 343 \r
 344         *shutdownTarget = internal_data.shutdown_target;\r
 345         *sleepMode = internal_data.sleep_mode;\r
 346 \r
 347         return E_OK;\r
 348 }\r
 349 \r
 350 \r
 351 Std_ReturnType EcuM_RequestRUN(EcuM_UserType user)\r
 352 {\r
 353         VALIDATE_RV(internal_data.initiated, ECUM_REQUESTRUN_ID, ECUM_E_NOT_INITIATED, E_NOT_OK);\r
 354         VALIDATE_RV(user < ECUM_USER_ENDMARK, ECUM_REQUESTRUN_ID, ECUM_E_INVALID_PAR, E_NOT_OK);\r
 355 \r
 356         internal_data.run_requests |= (uint32)1 << user;\r
 357 \r
 358         return E_OK;\r
 359 }\r
 360 \r
 361 Std_ReturnType EcuM_ReleaseRUN(EcuM_UserType user)\r
 362 {\r
 363         VALIDATE_RV(internal_data.initiated, ECUM_RELEASERUN_ID, ECUM_E_NOT_INITIATED, E_NOT_OK);\r
 364         VALIDATE_RV(user < ECUM_USER_ENDMARK, ECUM_RELEASERUN_ID, ECUM_E_INVALID_PAR, E_NOT_OK);\r
 365 \r
 366         internal_data.run_requests &= ~((uint32)1 << user);\r
 367 \r
 368         return E_OK;\r
 369 }\r
 370 \r
 371 /**\r
 372  *\r
 373  */\r
 374 void EcuM_KillAllRUNRequests( void ) {\r
 375         /* NOT IMPLEMENTED */\r
 376 }\r
 377 \r
 378 \r
 379 /**\r
 380  *\r
 381  * @param sources\r
 382  */\r
 383 void EcuM_SetWakeupEvent(EcuM_WakeupSourceType sources) {\r
 384         /* @req 3.1.5/EcuM2826 The function exists */\r
 385         /* @req 3.1.5/EcuM2171 */\r
 386 \r
 387         /* @req 3.1.5/EcuM2867 */\r
 388 #if  ( ECUM_DEV_ERROR_DETECT == STD_ON )\r
 389         {\r
 390                 EcuM_WakeupSourceType wkSource;\r
 391                 const EcuM_SleepModeType *sleepModePtr;\r
 392 \r
 393                 sleepModePtr = &internal_data.config->EcuMSleepModeConfig[internal_data.sleep_mode];\r
 394                 wkSource =  sleepModePtr->EcuMWakeupSourceMask;\r
 395 \r
 396                 if( !((sources | wkSource) ==  wkSource)) {\r
 397                         Det_ReportError(MODULE_ID_ECUM, 0, ECUM_VALIDATE_WAKEUP_EVENT_ID, ECUM_E_UNKNOWN_WAKEUP_SOURCE );\r
 398                         return;\r
 399                 }\r
 400         }\r
 401 #endif\r
 402 \r
 403 \r
 404         /* @req 3.1.5/EcuM1117 */\r
 405         internal_data.wakeupEvents |= sources;\r
 406 \r
 407         /* @req 3.1.5/EcuM2707 @req 3.1.5/EcuM2709*/\r
 408 //      internal_data.wakeupTimer = ECUM_VALIDATION_TIMEOUT;\r
 409 \r
 410 }\r
 411 \r
 412 #if defined(USE_COMM) || defined(USE_ECUM_COMM)\r
 413 Std_ReturnType EcuM_ComM_RequestRUN(NetworkHandleType channel)\r
 414 {\r
 415         VALIDATE_RV(internal_data.initiated, ECUM_COMM_REQUESTRUN_ID, ECUM_E_NOT_INITIATED, E_NOT_OK);\r
 416         VALIDATE_RV(channel < 32, ECUM_COMM_REQUESTRUN_ID, ECUM_E_INVALID_PAR, E_NOT_OK);\r
 417 \r
 418         internal_data.run_comm_requests |= (uint32)1 << channel;\r
 419 \r
 420         return E_OK;\r
 421 }\r
 422 \r
 423 Std_ReturnType EcuM_ComM_ReleaseRUN(NetworkHandleType channel)\r
 424 {\r
 425         VALIDATE_RV(internal_data.initiated, ECUM_COMM_RELEASERUN_ID, ECUM_E_NOT_INITIATED, E_NOT_OK);\r
 426         VALIDATE_RV(channel < 32, ECUM_COMM_RELEASERUN_ID, ECUM_E_INVALID_PAR, E_NOT_OK);\r
 427 \r
 428         internal_data.run_comm_requests &= ~((uint32)1 << channel);\r
 429 \r
 430         return E_OK;\r
 431 }\r
 432 \r
 433 boolean EcuM_ComM_HasRequestedRUN(NetworkHandleType channel)\r
 434 {\r
 435         VALIDATE_RV(internal_data.initiated, ECUM_COMM_HASREQUESTEDRUN_ID, ECUM_E_NOT_INITIATED, FALSE);\r
 436         VALIDATE_RV(channel < 32, ECUM_COMM_HASREQUESTEDRUN_ID, ECUM_E_INVALID_PAR, FALSE);\r
 437 \r
 438         return (internal_data.run_comm_requests &((uint32)1 << channel)) != 0;\r
 439 }\r
 440 #endif\r
 441 \r
 442 Std_ReturnType EcuM_RequestPOST_RUN(EcuM_UserType user)\r
 443 {\r
 444         VALIDATE_RV(internal_data.initiated, ECUM_REQUESTPOSTRUN_ID, ECUM_E_NOT_INITIATED, E_NOT_OK);\r
 445         VALIDATE_RV(user < ECUM_USER_ENDMARK, ECUM_REQUESTPOSTRUN_ID, ECUM_E_INVALID_PAR, E_NOT_OK);\r
 446 \r
 447         internal_data.postrun_requests |= (uint32)1 << user;\r
 448 \r
 449         return E_OK;\r
 450 }\r
 451 \r
 452 Std_ReturnType EcuM_ReleasePOST_RUN(EcuM_UserType user)\r
 453 {\r
 454         VALIDATE_RV(internal_data.initiated, ECUM_RELEASEPOSTRUN_ID, ECUM_E_NOT_INITIATED, E_NOT_OK);\r
 455         VALIDATE_RV(user < ECUM_USER_ENDMARK, ECUM_RELEASEPOSTRUN_ID, ECUM_E_INVALID_PAR, E_NOT_OK);\r
 456 \r
 457         internal_data.postrun_requests &= ~((uint32)1 << user);\r
 458 \r
 459         return E_OK;\r
 460 }\r
 461 \r
 462 /*\r
 463  * TODO: Don't yet understand the use\r
 464  */\r
 465 void EcuM_ClearWakeupEvent( EcuM_WakeupSourceType source )\r
 466 {\r
 467         switch(source) {\r
 468         case ECUM_WKSTATUS_NONE:\r
 469                 /* Seems quite pointless */\r
 470                 break;\r
 471         case ECUM_WKSTATUS_PENDING:\r
 472                 break;\r
 473         case ECUM_WKSTATUS_VALIDATED:\r
 474                 break;\r
 475         case ECUM_WKSTATUS_EXPIRED:\r
 476                 break;\r
 477         default:\r
 478                 break;\r
 479         }\r
 480 }\r
 481 \r
 482 /**\r
 483  * Get the pending wakeup events.\r
 484  *\r
 485  * @return\r
 486  */\r
 487 EcuM_WakeupSourceType EcuM_GetPendingWakeupEvents( void ) {\r
 488         /* @req 3.1.5/EcuM2827 API\r
 489          * @req 3.1.5/EcuM2172 Callable from interrupt context\r
 490          * */\r
 491 \r
 492         /* @req 3.1.5/EcuM1156 */\r
 493         return internal_data.wakeupEvents;\r
 494 \r
 495 }\r
 496 \r
 497 \r
 498 void EcuM_CheckValidation(EcuM_WakeupSourceType wakeupSource) {\r
 499         /* Used only if CanIf is used ? CanIf_Checkvalidation(wakeupSource) */\r
 500         (void)wakeupSource;\r
 501 }\r
 502 \r
 503 \r
 504 EcuM_WakeupSourceType EcuM_GetValidatedWakeupEvents( void ) {\r
 505         // TODO:\r
 506         return 0;\r
 507 }\r
 508 \r
 509 EcuM_WakeupStatusType EcuM_GetStatusOfWakeupSource( EcuM_WakeupSourceType sources ) {\r
 510         return 0;\r
 511 }\r
 512 \r
 513 \r