Started working on timeouts

diff --git a/communication/ComM/ComM.c b/communication/ComM/ComM.c
index 836a6e0e7762f9ce90060b8cdd5641b5fd30c4a8..37b01b3e21779f8ed0978bb28029a57c0796327d 100644 (file)
--- a/communication/ComM/ComM.c
+++ b/communication/ComM/ComM.c
@@ -115,7 +115,7 @@ static Std_ReturnType ComM_Internal_RequestComMode(
        ComM_Internal_UserType* UserInternal = &ComM_Internal.Users[User];
 
        UserInternal->RequestedMode = ComMode;
-       uint32 userMask = 1 << User;
+       uint32 userMask = (1 << User);
 
        Std_ReturnType requestStatus = E_OK;
 
@@ -168,7 +168,6 @@ Std_ReturnType ComM_PreventWakeUp( NetworkHandleType Channel, boolean Status ){
        COMM_VALIDATE_INIT(COMM_SERVICEID_PREVENTWAKEUP, COMM_E_UNINIT);
        COMM_VALIDATE_CHANNEL(Channel, COMM_SERVICEID_PREVENTWAKEUP, E_NOT_OK);
 #if (COMM_MODE_LIMITATION_ENABLED == STD_ON)
-       ComM_ChannelType* ChannelConf = &ComM_Config->Channels[Channel];
        ComM_Internal_ChannelType* ChannelInternal = &ComM_Internal.Channels[Channel];
        if (Status) {
                ChannelInternal->InhibitionStatus |=  (COMM_INHIBITION_STATUS_WAKE_UP);
@@ -185,7 +184,7 @@ Std_ReturnType ComM_LimitChannelToNoComMode( NetworkHandleType Channel, boolean
        COMM_VALIDATE_INIT(COMM_SERVICEID_LIMITCHANNELTONOCOMMODE, COMM_E_UNINIT);
        COMM_VALIDATE_CHANNEL(Channel, COMM_SERVICEID_LIMITCHANNELTONOCOMMODE, E_NOT_OK);
 #if (COMM_MODE_LIMITATION_ENABLED == STD_ON)
-       ComM_ChannelType* ChannelConf = &ComM_Config->Channels[Channel];
+       const ComM_ChannelType* ChannelConf = &ComM_Config->Channels[Channel];
        ComM_Internal_ChannelType* ChannelInternal = &ComM_Internal.Channels[Channel];
        if (Status) {
                ChannelInternal->InhibitionStatus |=  (COMM_INHIBITION_STATUS_NO_COMMUNICATION);
@@ -204,7 +203,7 @@ Std_ReturnType ComM_LimitECUToNoComMode( boolean Status ){
        ComM_Internal.NoCommunication = Status;
        int Channel;
        for (Channel = 0; Channel < COMM_CHANNEL_COUNT; Channel++) {
-               ComM_ChannelType* ChannelConf = &ComM_Config->Channels[Channel];
+               const ComM_ChannelType* ChannelConf = &ComM_Config->Channels[Channel];
                ComM_Internal_UpdateChannelState(ChannelConf, FALSE);
        }
        return E_OK;
@@ -305,6 +304,23 @@ void ComM_BusSM_ModeIndication( NetworkHandleType Channel, ComM_ModeType ComMode
 }
 
 
+// Scheduled main function
+// -----------------------
+
+void ComM_MainFunction(NetworkHandleType Channel) {
+       const ComM_ChannelType* ChannelConf = &ComM_Config->Channels[Channel];
+       ComM_Internal_ChannelType* ChannelInternal = &ComM_Internal.Channels[Channel];
+
+       if (ChannelInternal->Mode == COMM_FULL_COMMUNICATION) {
+               if (ChannelConf->MainFunctionPeriod >= ChannelInternal->FullComMinDurationTimeLeft) {
+                       ChannelInternal->FullComMinDurationTimeLeft = 0;
+                       ComM_Internal_UpdateChannelState(ChannelConf, FALSE);
+               } else {
+                       ChannelInternal->FullComMinDurationTimeLeft -= ChannelConf->MainFunctionPeriod;
+               }
+       }
+}
+
 // ----------------------------------------------------------------------------
 // Internal functions
 // ----------------------------------------------------------------------------
@@ -358,68 +374,83 @@ static Std_ReturnType ComM_Internal_PropagateComMode( const ComM_ChannelType* Ch
 }
 
 /* Processes all requests etc. and makes state machine transitions accordingly */
-static Std_ReturnType ComM_Internal_UpdateChannelState( const ComM_ChannelType* Channel, boolean isRequest ) {
-       ComM_Internal_ChannelType* ChannelInternal = &ComM_Internal.Channels[Channel->Number];
+static Std_ReturnType ComM_Internal_UpdateChannelState( const ComM_ChannelType* ChannelConf, boolean isRequest ) {
+       ComM_Internal_ChannelType* ChannelInternal = &ComM_Internal.Channels[ChannelConf->Number];
 
        switch (ChannelInternal->Mode) {
                case COMM_NO_COMMUNICATION:
-                       if ((ChannelInternal->InhibitionStatus & COMM_INHIBITION_STATUS_NO_COMMUNICATION) ||
-                               (ChannelInternal->InhibitionStatus & COMM_INHIBITION_STATUS_WAKE_UP) ||
-                               (ComM_Internal.NoCommunication == TRUE)) {
-                               // Stay in NO
-                               if (isRequest) {
-                                       ComM_Internal.InhibitCounter++;
-                               }
-                       } else {
-                               if (ChannelInternal->UserRequestMask != 0) {
-                                       // NO -> FULL
-                                       ChannelInternal->Mode = COMM_FULL_COMMUNICATION;
-                                       ChannelInternal->SubMode = COMM_SUBMODE_NETWORK_REQUESTED;
-                                       return ComM_Internal_PropagateComMode(Channel);
-                               } else {
-                                       // Stay in NO
-                               }
-                       }
-                       break;
+                       return ComM_Internal_UpdateFromNoCom(ChannelConf, ChannelInternal, isRequest);
                case COMM_SILENT_COMMUNICATION:
-                       if ((ChannelInternal->InhibitionStatus & COMM_INHIBITION_STATUS_NO_COMMUNICATION) ||
-                               (ComM_Internal.NoCommunication == TRUE)) {
-                               // Stay in SILENT
-                               if (isRequest) {
-                                       ComM_Internal.InhibitCounter++;
-                               }
-                       } else {
-                               if (ChannelInternal->UserRequestMask != 0) {
-                                       // SILENT -> FULL/NETWORK_REQUESTED
-                                       ChannelInternal->Mode = COMM_FULL_COMMUNICATION;
-                                       ChannelInternal->SubMode = COMM_SUBMODE_NETWORK_REQUESTED;
-                                       return ComM_Internal_PropagateComMode(Channel);
-                               } else {
-                                       // Stay in SILENT
-                               }
-                       }
-                       break;
+                       return ComM_Internal_UpdateFromSilentCom(ChannelConf, ChannelInternal, isRequest);
                case COMM_FULL_COMMUNICATION:
-                       if ((ChannelInternal->InhibitionStatus & COMM_INHIBITION_STATUS_NO_COMMUNICATION) ||
-                               (ComM_Internal.NoCommunication == TRUE)) {
+                       return ComM_Internal_UpdateFromFullCom(ChannelConf, ChannelInternal, isRequest);
+               default:
+                       return E_NOT_OK;
+       }
+}
+
+inline Std_ReturnType ComM_Internal_UpdateFromNoCom(const ComM_ChannelType* ChannelConf,
+                                       ComM_Internal_ChannelType* ChannelInternal, boolean isRequest) {
+       if ((ChannelInternal->InhibitionStatus & COMM_INHIBITION_STATUS_NO_COMMUNICATION) ||
+               (ChannelInternal->InhibitionStatus & COMM_INHIBITION_STATUS_WAKE_UP) ||
+               (ComM_Internal.NoCommunication == TRUE)) {
+               // Stay in NO
+               if (isRequest) ComM_Internal.InhibitCounter++;
+       } else {
+               if (ChannelInternal->UserRequestMask != 0) {
+                       // NO -> FULL
+                       ChannelInternal->FullComMinDurationTimeLeft = COMM_T_MIN_FULL_COM_MODE_DURATION;
+                       ChannelInternal->Mode = COMM_FULL_COMMUNICATION;
+                       ChannelInternal->SubMode = COMM_SUBMODE_NETWORK_REQUESTED;
+                       return ComM_Internal_PropagateComMode(ChannelConf);
+               } else {
+                       // Stay in NO
+               }
+       }
+       return E_OK;
+}
+
+inline Std_ReturnType ComM_Internal_UpdateFromSilentCom(const ComM_ChannelType* ChannelConf,
+                                       ComM_Internal_ChannelType* ChannelInternal,     boolean isRequest) {
+       if ((ChannelInternal->InhibitionStatus & COMM_INHIBITION_STATUS_NO_COMMUNICATION) ||
+               (ComM_Internal.NoCommunication == TRUE)) {
+               // Stay in SILENT
+               if (isRequest) ComM_Internal.InhibitCounter++;
+       } else {
+               if (ChannelInternal->UserRequestMask != 0) {
+                       // SILENT -> FULL/NETWORK_REQUESTED
+                       ChannelInternal->FullComMinDurationTimeLeft = COMM_T_MIN_FULL_COM_MODE_DURATION;
+                       ChannelInternal->Mode = COMM_FULL_COMMUNICATION;
+                       ChannelInternal->SubMode = COMM_SUBMODE_NETWORK_REQUESTED;
+                       return ComM_Internal_PropagateComMode(ChannelConf);
+               } else {
+                       // Stay in SILENT
+               }
+       }
+       return E_OK;
+}
+
+inline Std_ReturnType ComM_Internal_UpdateFromFullCom(const ComM_ChannelType* ChannelConf,
+                                       ComM_Internal_ChannelType* ChannelInternal, boolean isRequest) {
+       if ((ChannelInternal->InhibitionStatus & COMM_INHIBITION_STATUS_NO_COMMUNICATION) ||
+               (ComM_Internal.NoCommunication == TRUE)) {
+               if (ChannelInternal->FullComMinDurationTimeLeft == 0) {
+                       // FULL/* -> FULL/READY_SLEEP
+                       ChannelInternal->SubMode = COMM_SUBMODE_READY_SLEEP;
+               }
+               if (isRequest) ComM_Internal.InhibitCounter++;
+       } else {
+               if (ChannelInternal->UserRequestMask == 0) {
+                       if (ChannelInternal->FullComMinDurationTimeLeft == 0) {
                                // FULL/* -> FULL/READY_SLEEP
+                               ChannelInternal->LightTimeoutTimeLeft = ChannelConf->LightTimeout;
                                ChannelInternal->SubMode = COMM_SUBMODE_READY_SLEEP;
-                               if (isRequest) {
-                                       ComM_Internal.InhibitCounter++;
-                               }
-                       } else {
-                               if (ChannelInternal->UserRequestMask == 0) {
-                                       // FULL/* -> FULL/READY_SLEEP
-                                       ChannelInternal->SubMode = COMM_SUBMODE_READY_SLEEP;
-                               } else {
-                                       // FULL/* -> FULL/NETWORK_REQUESTED
-                                       ChannelInternal->SubMode = COMM_SUBMODE_NETWORK_REQUESTED;
-                               }
                        }
-                       break;
-               default:
-                       break;
+               } else {
+                       // FULL/* -> FULL/NETWORK_REQUESTED
+                       ChannelInternal->FullComMinDurationTimeLeft = COMM_T_MIN_FULL_COM_MODE_DURATION;
+                       ChannelInternal->SubMode = COMM_SUBMODE_NETWORK_REQUESTED;
+               }
        }
-
        return E_OK;
 }

diff --git a/communication/ComM/ComM_Internal.h b/communication/ComM/ComM_Internal.h
index 78db9973f7c4c20e1199819e73f750eeab5f33d3..0bb4d078e51f8fec855aa48d340725838874babc 100644 (file)
--- a/communication/ComM/ComM_Internal.h
+++ b/communication/ComM/ComM_Internal.h
@@ -58,6 +58,8 @@ typedef struct {
        ComM_Internal_SubModeType       SubMode;\r
        uint32                                          UserRequestMask;\r
        ComM_InhibitionStatusType       InhibitionStatus;\r
+       uint32                                          FullComMinDurationTimeLeft;\r
+       uint32                                          LightTimeoutTimeLeft;\r
 } ComM_Internal_ChannelType;\r
 \r
 typedef struct {\r

diff --git a/include/ComM.h b/include/ComM.h
index 1a3a8fc84039393fd9373520c4bc205e58bad8cf..d317cf1cdbc4debfc2e6d9817ac95ddcf6e72f14 100644 (file)
--- a/include/ComM.h
+++ b/include/ComM.h
@@ -74,6 +74,15 @@
 #define COMM_SERVICEID_MAINFUNCTION                                            0x60\r
 
 
+#define COMM_MAIN_FUNCTION_PROTOTYPE(channel) \
+void ComM_MainFunction_##channel (void)
+
+#define COMM_MAIN_FUNCTION(channel)    \
+void ComM_MainFunction_##channel (void) { \
+       ComM_MainFunction(COMM_NETWORK_HANDLE_##channel); \
+}
+
+
 /** Initializes the AUTOSAR Communication Manager and restarts the internal state machines.*/\r
 void ComM_Init( ComM_ConfigType *);
 

diff --git a/include/ComM_ConfigTypes.h b/include/ComM_ConfigTypes.h
index 4c962067a959461e941df829767dd9b2d121346f..a78153ca1093e25c146fa4173d6639e831a53a23 100644 (file)
--- a/include/ComM_ConfigTypes.h
+++ b/include/ComM_ConfigTypes.h
@@ -27,6 +27,8 @@ typedef enum {
 typedef struct {\r
        const ComM_BusTypeType                  BusType;\r
        const NetworkHandleType                 BusSMNetworkHandle;\r
+       const uint32                                    MainFunctionPeriod;\r
+       const uint32                                    LightTimeout;\r
        const uint8                                             Number;\r
 } ComM_ChannelType;\r
 \r