/* BEGIN_FILE_HDR ******************************************************************************** * NOTICE * This software is the property of HiRain Technologies. Any information * contained in this doc should not be reproduced, or used, or disclosed * without the written authorization from HiRain Technologies. ******************************************************************************** * File Name : CanNm.c ******************************************************************************** * Project/Product : AUTOSAR R21-11 * Title : CAN Network Management module Source File * Author : Hirain ******************************************************************************** * Description : Implementation of CAN Network Management * provided functionality * ******************************************************************************** * Limitations : None * ******************************************************************************** * ******************************************************************************** * Revision History: * * Version Date Initials CR# Descriptions * --------- ---------- -------------- ---------- --------------- * 04.00.00 07/03/2022 Feixiang.Dong N/A Original ******************************************************************************** * END_FILE_HDR*/ /******************************************************************************* * Includes *******************************************************************************/ #include "CanNm.h" #include "CanNm_Cbk.h" #include "CanNm_Callout.h" #include "SchM_CanNm.h" #include "Nm_Cbk.h" #include "Bsw_Common.h" #if(STD_ON == CANNM_DEV_ERROR_DETECT) /*SWS_CanNm_00308*/ #include "Det.h" #endif #if(STD_ON == CANNM_GLOBAL_PN_SUPPORT) #include "CanSM_TxTimeoutException.h" #endif #if(STD_OFF == CANNM_PASSIVE_MODE_ENABLED) /*SWS_CanNm_00312*/ #include "CanIf.h" #endif #if(STD_ON == CANNM_COM_USER_DATA_SUPPORT) /*SWS_CanNm_00326*/ #include "PduR.h" #endif /*SWS_CanNm_00146: The AUTOSAR CanNm algorithm shall be processor independent, which means; it shall not rely on any processor specific hardware support and thus shall be realizable on any processor architecture that is in the scope of AUTOSAR.*/ /******************************************************************************* * Version Check *******************************************************************************/ #if(STD_ON == CANNM_PRIVATE_VERSION_CHECK) /* check Version with cfg file */ #if(CANNM_AR_RELEASE_MAJOR_VERSION != CANNM_AR_RELEASE_MAJOR_VERSION_CFG) #error "AutoSar Major Version Numbers of CanNm kernel and its cfg files are different." #endif #if(CANNM_AR_RELEASE_MINOR_VERSION != CANNM_AR_RELEASE_MINOR_VERSION_CFG) #error "AutoSar Minor Version Numbers of CanNm kernel and its cfg files are different." #endif #if((CANNM_SW_MAJOR_VERSION != CANNM_SW_MAJOR_VERSION_CFG) || \ (CANNM_SW_MINOR_VERSION != CANNM_SW_MINOR_VERSION_CFG)) #error "SW Version Numbers of CanNm kernel and its cfg files are different." #endif #endif /******************************************************************************* * Dependency Check *******************************************************************************/ #if(CANNM_PASSIVE_MODE_ENABLED == STD_ON) #if(CANNM_BUS_LOAD_REDUCTION_ENABLED == STD_ON) #error: "If CanNmPassiveModeEnabled is set to true, then CanNmBusLoadReductionEnabled shoud be false." #endif #if(CANNM_BUS_SYNCHRONIZATION_ENABLED== STD_ON) #error: "If CanNmPassiveModeEnabled is set to true, then CanNmBusSynchronizationEnabled shoud be false." #endif #if(CANNM_COM_USER_DATA_SUPPORT == STD_ON) #error: "If CanNmPassiveModeEnabled is set to true, then CanNmComUserDataSupport shoud be false." #endif #if(CANNM_COORDINATOR_SYNC_SUPPORT == STD_ON) #error: "If CanNmPassiveModeEnabled is set to true, then CanNmCoordinatorSyncSupport shoud be false." #endif #if(CANNM_IMMEDIATE_RESTART_ENABLED == STD_ON) #error: "If CanNmPassiveModeEnabled is set to true, then CanNmImmediateRestartEnabled shoud be false." #endif #if(CANNM_IMMEDIATE_TXCONF_ENABLED == STD_ON) #error: "If CanNmPassiveModeEnabled is set to true, then CanNmImmediateTxconfEnabled shoud be false." #endif #if(CANNM_REMOTE_SLEEP_IND_ENABLED == STD_ON) #error: "If CanNmPassiveModeEnabled is set to true, then CanNmRemoteSleepIndEnabled shoud be false." #endif #endif #if((STD_ON == CANNM_COM_USER_DATA_SUPPORT) && (STD_ON == CANNM_USER_DATA_ENABLED)) #error: "At most one of the configuration parameters CanNmComUserDataSupport and CanNmUserDataEnabled can be true." #endif /******************************************************************************* * Det *******************************************************************************/ #if(STD_ON == CANNM_DEV_ERROR_DETECT) /*SWS_CanNm_00325*/ #define CANNM_DET_REPORT_ERROR(ApiId, errcode) \ Det_ReportError(CANNM_MODULE_ID, CANNM_INSTANCE_ID, (ApiId), (errcode)) /*SWS_CanNm_00324*/ #define CANNM_DET_REPORT_RUNTIME_ERROR(ApiId, errcode) \ DET_REPORT_RUNTIME_ERROR(CANNM_MODULE_ID, CANNM_INSTANCE_ID, (ApiId), (errcode)) #else #define CANNM_DET_REPORT_ERROR(ApiId, errcode) #define CANNM_DET_REPORT_RUNTIME_ERROR(ApiId, errcode) #endif /******************************************************************************* * Macros of config parameters *******************************************************************************/ /*Post build config*/ #if(CANNM_CONFIG_VARIANTS == STD_CONFIG_VARIANTS_POSTBUILD) #define CanNmCfgPtr (CanNm_PBCfg) #else #define CanNmCfgPtr (&CanNm_Config) #endif #define CANNM_CHANNELNUM (CanNmCfgPtr->CanNmNumberOfCahnnels) /*ECUC_CanNm_00031*/ #define CANNM_NODE_ID(nmChannelHandle) (CanNmCfgPtr->CanNmPBChannelConfig[nmChannelHandle].CanNmNodeId) #if(STD_OFF == CANNM_PASSIVE_MODE_ENABLED) /*ECUC_CanNm_00037*/ #define CANNM_TX_PDU_ID(nmChannelHandle) (CanNmCfgPtr->CanNmPBChannelConfig[nmChannelHandle].CanNmTxPduRef) #define CANNM_TX_PDU_LENGTH(nmChannelHandle) (CanNmCfgPtr->CanNmPBChannelConfig[nmChannelHandle].CanNmTxPduLength) #endif #if(STD_ON == CANNM_GLOBAL_PN_SUPPORT) /*ECUC_CanNm_00064*/ #define CANNM_PN_FILTERMASK(Index) (CanNmCfgPtr->CanNmPnFilterMask[Index].CanNmPnFilterMaskByteValue) /*ECUC_CanNm_00066*/ #define CANNM_PN_ENABLED(nmChannelHandle) (CanNmCfgPtr->CanNmPBChannelConfig[nmChannelHandle].CanNmPnEnabled) #endif #if(STD_ON == CANNM_COM_USER_DATA_SUPPORT) /*ECUC_CanNm_00046*/ #define CANNM_TX_USERDATA_PDU_REF(nmChannelHandle) (CanNmCfgPtr->CanNmPBChannelConfig[nmChannelHandle].CanNmTxUserDataPduRef) #endif /*Link time config*/ #if((STD_CONFIG_VARIANTS_PRECOMPILE != CANNM_CONFIG_VARIANTS) && (STD_ON == CANNM_GLOBAL_PN_SUPPORT)) /*ECUC_CanNm_00098*/ #define CANNM_PN_SHUTDOWN_MSG_RETX_DURATION (CanNm_LConfig.CanNmPnShutdownMessageRetransmissionDuration) #endif /*CanNm_ChannelConfig*/ #if(CANNM_PASSIVE_MODE_ENABLED == STD_OFF) /*ECUC_CanNm_00084*/ #define CANNM_ACTIVE_WU_BIT_ENABLED(nmChannelHandle) (CanNm_ChannelConfig[nmChannelHandle].CanNmActiveWakeupBitEnabled) /*ECUC_CanNm_00085 AUTOSAR422*/ #define CANNM_RETRY_FIRST_MSG_REQ(nmChannelHandle) (CanNm_ChannelConfig[nmChannelHandle].CanNmRetryFirstMessageRequest) /*ECUC_CanNm_00057*/ #define CANNM_IMM_NM_CYCLE_TIME(nmChannelHandle) (CanNm_ChannelConfig[nmChannelHandle].CanNmImmediateNmCycleTime) /*ECUC_CanNm_00056*/ #define CANNM_IMM_NM_TRANS(nmChannelHandle) (CanNm_ChannelConfig[nmChannelHandle].CanNmImmediateNmTransmissions) /*ECUC_CanNm_00029*/ #define CANNM_MSG_CYCLE_OFFSET(nmChannelHandle) (CanNm_ChannelConfig[nmChannelHandle].CanNmMsgCycleOffset) /*ECUC_CanNm_00028*/ #define CANNM_MSG_CYCLE_TIME(nmChannelHandle) (CanNm_ChannelConfig[nmChannelHandle].CanNmMsgCycleTime) /*SWS_CanNm_00052*/ #if(CANNM_BUS_LOAD_REDUCTION_ENABLED == STD_ON) /*ECUC_CanNm_00042*/ #define CANNM_BL_REDUCTION_ACTIVE(nmChannelHandle) (CanNm_ChannelConfig[nmChannelHandle].CanNmBusLoadReductionActive) /*ECUC_CanNm_00043*/ #define CANNM_MSG_REDUCED_TIME(nmChannelHandle) (CanNm_ChannelConfig[nmChannelHandle].CanNmMsgReducedTime) #endif #if(CANNM_IMMEDIATE_TXCONF_ENABLED == STD_OFF) /*ECUC_CanNm_00030*/ #define CANNM_MSG_TIMEOUT_TIME(nmChannelHandle) (CanNm_ChannelConfig[nmChannelHandle].CanNmMsgTimeoutTime) #endif #if(CANNM_REMOTE_SLEEP_IND_ENABLED == STD_ON) /*ECUC_CanNm_00023*//*SWS_CanNm_00249*/ #define CANNM_RMT_SLP_IND_TIME(nmChannelHandle) (CanNm_ChannelConfig[nmChannelHandle].CanNmRemoteSleepIndTime) #endif #endif/*#if(CANNM_PASSIVE_MODE_ENABLED == STD_OFF)*/ #if((STD_ON == CANNM_COM_USER_DATA_SUPPORT) || (STD_ON == CANNM_USER_DATA_ENABLED)) /*SWS_CanNm_00501*/ #define CANNM_USER_DATA_OFS(nmChannelHandle) (CanNm_ChannelConfig[nmChannelHandle].CanNmUserDataOffset) #define CANNM_USER_DATA_LEN(nmChannelHandle) (CanNm_ChannelConfig[nmChannelHandle].CanNmUserDataLength) #endif #if(CANNM_CAR_WAKEUP_ENABLED == STD_ON) /*ECUC_CanNm_00075*/ #define CANNM_WU_BIT_POS(nmChannelHandle) (CanNm_ChannelConfig[nmChannelHandle].CanNmCarWakeUpBitPosition) /*ECUC_CanNm_00076*/ #define CANNM_WU_BYTE_POS(nmChannelHandle) (CanNm_ChannelConfig[nmChannelHandle].CanNmCarWakeUpBytePosition) /*ECUC_CanNm_00077*/ #define CANNM_CWU_FILTER_ENABLED(nmChannelHandle) (CanNm_ChannelConfig[nmChannelHandle].CanNmCarWakeUpFilterEnabled) /*ECUC_CanNm_00078*/ #define CANNM_CWU_FILTER_NODE_ID(nmChannelHandle) (CanNm_ChannelConfig[nmChannelHandle].CanNmCarWakeUpFilterNodeId) /*ECUC_CanNm_00074*/ #define CANNM_CWU_RX_ENABLED(nmChannelHandle) (CanNm_ChannelConfig[nmChannelHandle].CanNmCarWakeUpRxEnabled) #endif/*#if(CANNM_CAR_WAKEUP_ENABLED == STD_ON)*/ /*ECUC_CanNm_00090*/ #define CANNM_NID_ENABLED(nmChannelHandle) (CanNm_ChannelConfig[nmChannelHandle].CanNmNodeIdEnabled) /*ECUC_CanNm_00088*/ #define CANNM_NODE_DETECT_ENABLED(nmChannelHandle) (CanNm_ChannelConfig[nmChannelHandle].CanNmNodeDetectionEnabled) /*ECUC_CanNm_00089*/ #define CANNM_REPEAT_MSG_IND_ENABLED(nmChannelHandle) (CanNm_ChannelConfig[nmChannelHandle].CanNmRepeatMsgIndEnabled) /*ECUC_CanNm_00092*/ #define CANNM_STAY_IN_PBS_ENABLED(nmChannelHandle) (CanNm_ChannelConfig[nmChannelHandle].CanNmStayInPbsEnabled) /*ECUC_CanNm_00026*//*SWS_CanNm_00075*/ #define CANNM_PDU_CBV_POS(nmChannelHandle) (CanNm_ChannelConfig[nmChannelHandle].CanNmPduCbvPosition) /*ECUC_CanNm_00025*//*SWS_CanNm_00074*/ #define CANNM_PDU_NID_POS(nmChannelHandle) (CanNm_ChannelConfig[nmChannelHandle].CanNmPduNidPosition) /*ECUC_CanNm_00022*//*SWS_CanNm_00247*/ #define CANNM_RPT_MSG_TIME(nmChannelHandle) (CanNm_ChannelConfig[nmChannelHandle].CanNmRepeatMessageTime) /*ECUC_CanNm_00020*//*SWS_CanNm_00246*/ #define CANNM_TIMEOUT_TIME(nmChannelHandle) (CanNm_ChannelConfig[nmChannelHandle].CanNmTimeoutTime) /*ECUC_CanNm_00021*//*SWS_CanNm_00248*/ #define CANNM_WBS_TIME(nmChannelHandle) (CanNm_ChannelConfig[nmChannelHandle].CanNmWaitBusSleepTime) /*ECUC_CanNm_00018*/ #define CANNM_COMM_NETWORK_HANDLE(nmChannelHandle) (CanNm_ChannelConfig[nmChannelHandle].CanNmComMNetworkHandleRef) /******************************************************************************* * PN Related *******************************************************************************/ #if(STD_ON == CANNM_GLOBAL_PN_SUPPORT) #define CANNM_PNC_BIT_VECTOR_LEN(nmChannelHandle) (CanNm_ChannelConfig[nmChannelHandle].CanNmPncBitVectorLength) /*ECUC_CanNm_00068*/ #define CANNM_ALL_NMMSG_KEEP_AWAKE(nmChannelHandle) (CanNm_ChannelConfig[nmChannelHandle].CanNmAllNmMessagesKeepAwake) /*ECUC_CanNm_00073*/ #define CANNM_PN_MULTIPLE_REQ(nmChannelHandle) (CanNm_ChannelConfig[nmChannelHandle].CanNmPnHandleMultipleNetworkRequests) #if(STD_ON == CANNM_SYNC_PNC_SHUTDOWN_SUPPORT) /*ECUC_CanNm_00097*/ #define CANNM_SYNC_PN_SHUTDOWN_EN(nmChannelHandle) (CanNm_ChannelConfig[nmChannelHandle].CanNmSynchronizedPncShutdownEnabled) #endif #endif/*(STD_ON == CANNM_GLOBAL_PN_SUPPORT)*/ /******************************************************************************* * Static typedef and parameters *******************************************************************************/ typedef void (* CanNm_TimerExpiresType) ( const NetworkHandleType nmChannelHandle ); typedef enum { CANNM_NETWORK_MODE_ENTER = 0, CANNM_RPT_MSG_REQ = 1, CANNM_RPT_MSG_BIT_RX = 2 } CanNm_RptMsgStEnterType; #define CANNM_START_SEC_VAR_INIT_8 #include "CanNm_MemMap.h" STATIC VAR(Std_InitStateType, CANNM_VAR_POWER_ON_INIT) CanNm_InitState = STD_UNINITIALIZED; #define CANNM_STOP_SEC_VAR_INIT_8 #include "CanNm_MemMap.h" #define CANNM_START_SEC_VAR_NOINIT_8 #include "CanNm_MemMap.h" #if(STD_ON == CANNM_SYNC_PNC_SHUTDOWN_SUPPORT) STATIC VAR(boolean, CANNM_VAR_NOINIT) CanNm_SyncPncShutdownPending[CANNM_MAX_NUMBER_OF_CHANNELS]; STATIC VAR(uint8, CANNM_VAR_NOINIT) CanNm_SyncPncShutdownPnInfo[CANNM_MAX_NUMBER_OF_CHANNELS][CANNM_PNC_BIT_VECTOR_MAX_LEN]; #endif #define CANNM_STOP_SEC_VAR_NOINIT_8 #include "CanNm_MemMap.h" #define CANNM_START_SEC_VAR_NOINIT_UNSPECIFIED #include "CanNm_MemMap.h" #if(CANNM_CONFIG_VARIANTS == STD_CONFIG_VARIANTS_POSTBUILD) STATIC P2CONST(CanNm_ConfigType, AUTOMATIC, CANNM_VAR_NOINIT) CanNm_PBCfg; #endif #define CANNM_STOP_SEC_VAR_NOINIT_UNSPECIFIED #include "CanNm_MemMap.h" /******************************************************************************* * Macros of run time parameters *******************************************************************************/ #define CANNM_USER_DATA_DEFAULT_VALUE ((uint8)0x00) /*SWS_CanNm_00045*/ #define CANNM_CBV_RMR_MASK ((uint8)0x01) #define CANNM_CBV_PN_SHUTDOWN_REQ_MASK ((uint8)0x02) #define CANNM_CBV_SLEEP_READY_BIT_MASK ((uint8)0x08) #define CANNM_CBV_ACTIVE_WU_MASK ((uint8)0x10) #define CANNM_CBV_PN_LEARNING_MASK ((uint8)0x20) #define CANNM_CBV_PN_MASK ((uint8)0x40) #define CANNM_START_NMTO_TIMER(nmChannelHandle) \ (*(CanNm_Timer[nmChannelHandle].NmTOTimer.TimerCnt) = CANNM_TIMEOUT_TIME(nmChannelHandle)) #define CANNM_STOP_NMTO_TIMER(nmChannelHandle) \ (*(CanNm_Timer[nmChannelHandle].NmTOTimer.TimerCnt) = (uint16)0) #define CANNM_NMTO_TIMER(nmChannelHandle) \ (&(CanNm_Timer[nmChannelHandle].NmTOTimer)) #define CANNM_START_RPT_MSG_TIMER(nmChannelHandle) \ (*(CanNm_Timer[nmChannelHandle].RptMsgTimer.TimerCnt) = CANNM_RPT_MSG_TIME(nmChannelHandle)) #define CANNM_STOP_RPT_MSG_TIMER(nmChannelHandle) \ (*(CanNm_Timer[nmChannelHandle].RptMsgTimer.TimerCnt) = (uint16)0) #define CANNM_RPT_MSG_TIMER(nmChannelHandle) \ (&(CanNm_Timer[nmChannelHandle].RptMsgTimer)) #define CANNM_START_WBS_TIMER(nmChannelHandle) \ (*(CanNm_Timer[nmChannelHandle].WbsTimer.TimerCnt) = CANNM_WBS_TIME(nmChannelHandle)) #define CANNM_STOP_WBS_TIMER(nmChannelHandle) \ (*(CanNm_Timer[nmChannelHandle].WbsTimer.TimerCnt) = (uint16)0) #define CANNM_WBS_TIMER(nmChannelHandle) \ (&(CanNm_Timer[nmChannelHandle].WbsTimer)) #if(CANNM_PASSIVE_MODE_ENABLED == STD_OFF) #define CANNM_START_MSG_CYCLE_OFFSET(nmChannelHandle) \ (*(CanNm_Timer[nmChannelHandle].MsgCycOffsetTimer.TimerCnt) = CANNM_MSG_CYCLE_OFFSET(nmChannelHandle)) #define CANNM_STOP_MSG_CYCLE_OFFSET(nmChannelHandle) \ (*(CanNm_Timer[nmChannelHandle].MsgCycOffsetTimer.TimerCnt) = (uint16)0) #define CANNM_MSG_CYCLE_OFFSET_TIMER(nmChannelHandle) \ (&(CanNm_Timer[nmChannelHandle].MsgCycOffsetTimer)) /*SWS_CanNm_00073*/ #if(CANNM_IMMEDIATE_TXCONF_ENABLED == STD_OFF) #define CANNM_START_TXTO_TIMER(nmChannelHandle) \ (*(CanNm_Timer[nmChannelHandle].TxTOTimer.TimerCnt) = CANNM_MSG_TIMEOUT_TIME(nmChannelHandle)) #define CANNM_STOP_TXTO_TIMER(nmChannelHandle) \ (*(CanNm_Timer[nmChannelHandle].TxTOTimer.TimerCnt) = (uint16)0) #define CANNM_TXTO_TIMER(nmChannelHandle) \ (&(CanNm_Timer[nmChannelHandle].TxTOTimer)) #endif #define CANNM_SET_MSG_CYC_NORMAL(nmChannelHandle) \ (*(CanNm_Timer[nmChannelHandle].MsgCycTimer.TimerCnt) = CANNM_MSG_CYCLE_TIME(nmChannelHandle)) #define CANNM_SET_MSG_CYC_IMM(nmChannelHandle) \ (*(CanNm_Timer[nmChannelHandle].MsgCycTimer.TimerCnt) = CANNM_IMM_NM_CYCLE_TIME(nmChannelHandle)) /*SWS_CanNm_00052*/ #if(CANNM_BUS_LOAD_REDUCTION_ENABLED == STD_ON) #define CANNM_SET_MSG_CYC_REDUCED(nmChannelHandle) \ (*(CanNm_Timer[nmChannelHandle].MsgCycTimer.TimerCnt) = CANNM_MSG_REDUCED_TIME(nmChannelHandle)) #endif #define CANNM_STOP_MSG_CYC(nmChannelHandle) \ (*(CanNm_Timer[nmChannelHandle].MsgCycTimer.TimerCnt) = (uint16)0) #define CANNM_MSG_CYC_TIMER(nmChannelHandle) \ (&(CanNm_Timer[nmChannelHandle].MsgCycTimer)) #if(CANNM_REMOTE_SLEEP_IND_ENABLED == STD_ON) #define CANNM_START_RMT_SLP_IND_TIMER(nmChannelHandle) \ (*(CanNm_Timer[nmChannelHandle].RmtSlpIndTimer.TimerCnt) = CANNM_RMT_SLP_IND_TIME(nmChannelHandle)) #define CANNM_STOP_RMT_SLP_IND_TIMER(nmChannelHandle) \ (*(CanNm_Timer[nmChannelHandle].RmtSlpIndTimer.TimerCnt) = (uint16)0) #define CANNM_RMT_SLP_IND_TIMER(nmChannelHandle) \ (&(CanNm_Timer[nmChannelHandle].RmtSlpIndTimer)) #endif #endif/*#if(CANNM_PASSIVE_MODE_ENABLED == STD_OFF)*/ #if(CANNM_PASSIVE_MODE_ENABLED == STD_OFF) #define CANNM_TX_PDU_REQ(nmChannelHandle) (CanNm_TxReqFlg[nmChannelHandle] = TRUE) #endif #if(STD_ON == CANNM_GLOBAL_PN_SUPPORT) /*SWS_ComM_00825*/ #define CANNM_GET_PNC_BYTE_INDEX(PncID) (((PncID) >> 3) - CANNM_PNC_BIT_VECTOR_OFFSET) #define CANNM_GET_PNC_BIT_INDEX(PncID) ((PncID) % 8) #endif /******************************************************************************* * Declaration of static functions *******************************************************************************/ #define CANNM_START_SEC_CODE #include "CanNm_MemMap.h" STATIC FUNC(void, CANNM_CODE) CanNm_NetworkReqMainFunction ( const NetworkHandleType nmChannelHandle ); #if(CANNM_PASSIVE_MODE_ENABLED == STD_OFF) STATIC FUNC(void, CANNM_CODE) CanNm_RptMsgReqMainFunction ( const NetworkHandleType nmChannelHandle ); STATIC FUNC(void, CANNM_CODE) CanNm_CheckRptMsgReqBit ( const NetworkHandleType nmChannelHandle ); #endif STATIC FUNC(void, CANNM_CODE) CanNm_TxCfmMainFunction ( const NetworkHandleType nmChannelHandle ); STATIC FUNC(void, CANNM_CODE) CanNm_RxIndMainFunction ( const NetworkHandleType nmChannelHandle ); STATIC FUNC(void, CANNM_CODE) CanNm_NmTOExpires ( const NetworkHandleType nmChannelHandle ); STATIC FUNC(void, CANNM_CODE) CanNm_RptMsgTimerExpires ( const NetworkHandleType nmChannelHandle ); STATIC FUNC(void, CANNM_CODE) CanNm_MsgCycTimerExpires ( const NetworkHandleType nmChannelHandle ); STATIC FUNC(void, CANNM_CODE) CanNm_MsgCycOffsetExpires ( const NetworkHandleType nmChannelHandle ); STATIC FUNC(void, CANNM_CODE) CanNm_WbsTimerExpires ( const NetworkHandleType nmChannelHandle ); #if(CANNM_PASSIVE_MODE_ENABLED == STD_OFF) #if(CANNM_REMOTE_SLEEP_IND_ENABLED == STD_ON) STATIC FUNC(void, CANNM_CODE) CanNm_RmtSlpIndTimerExpires ( const NetworkHandleType nmChannelHandle ); #endif /*SWS_CanNm_00073*/ #if(CANNM_IMMEDIATE_TXCONF_ENABLED == STD_OFF) STATIC FUNC(void, CANNM_CODE) CanNm_TxTOTimerExpires ( const NetworkHandleType nmChannelHandle ); #endif #endif STATIC FUNC(void, CANNM_CODE) CanNm_TimerMainFunction ( const NetworkHandleType nmChannelHandle ); STATIC FUNC(void, CANNM_CODE) CanNm_TimerCheckFunction ( const NetworkHandleType nmChannelHandle, CONSTP2CONST(CanNm_CommTimerType, AUTOMATIC, CANNM_CONST) timer, const CanNm_TimerExpiresType TimerExpires ); STATIC FUNC(void, CANNM_CODE) CanNm_RptMsgStateEnter ( const NetworkHandleType nmChannelHandle, const CanNm_RptMsgStEnterType nmEnterReason ); STATIC FUNC(void, CANNM_CODE) CanNm_NormalOpStateEnter ( const NetworkHandleType nmChannelHandle ); STATIC FUNC(void, CANNM_CODE) CanNm_RdySlpStateEnter ( const NetworkHandleType nmChannelHandle ); STATIC FUNC(void, CANNM_CODE) CanNm_NetworkModeEnter ( const NetworkHandleType nmChannelHandle ); STATIC FUNC(void, CANNM_CODE) CanNm_PreBusSlpModeEnter ( const NetworkHandleType nmChannelHandle ); STATIC FUNC(void, CANNM_CODE) CanNm_BusSlpModeEnter ( const NetworkHandleType nmChannelHandle ); #if(CANNM_PASSIVE_MODE_ENABLED == STD_OFF) STATIC FUNC(void, CANNM_CODE) CanNm_ClrRptMsgBit ( const NetworkHandleType nmChannelHandle ); STATIC FUNC(void, CANNM_CODE) CanNm_SetRptMsgBit ( const NetworkHandleType nmChannelHandle ); STATIC FUNC(void, CANNM_CODE) CanNm_SetNodeId ( const NetworkHandleType nmChannelHandle ); STATIC FUNC(void, CANNM_CODE) CanNm_ClrActiveWakeupBit ( const NetworkHandleType nmChannelHandle ); STATIC FUNC(void, CANNM_CODE) CanNm_SetActiveWakeupBit ( const NetworkHandleType nmChannelHandle ); #if(CANNM_COORDINATOR_SYNC_SUPPORT == STD_ON) STATIC FUNC(void, CANNM_CODE) CanNm_CheckSleepReadyBit ( const NetworkHandleType nmChannelHandle ); #endif /*SWS_CanNm_00072*/ STATIC FUNC(void, CANNM_CODE) CanNm_TxPduMainFunction ( const NetworkHandleType nmChannelHandle ); #if((STD_ON == CANNM_COM_USER_DATA_SUPPORT) || (STD_ON == CANNM_USER_DATA_ENABLED)) STATIC FUNC(void, CANNM_CODE) CanNm_UpdateTxPduUserData ( const NetworkHandleType nmChannelHandle ); #endif #endif/*#if(CANNM_PASSIVE_MODE_ENABLED == STD_OFF)*/ #if(STD_ON == CANNM_GLOBAL_PN_SUPPORT) STATIC FUNC(void, CANNM_CODE) CanNm_ClrTxPduPnBit ( const NetworkHandleType nmChannelHandle ); STATIC FUNC(void, CANNM_CODE) CanNm_SetTxPduPnBit ( const NetworkHandleType nmChannelHandle ); STATIC FUNC(void, CANNM_CODE) CanNm_UpdateTxPduPnData ( const NetworkHandleType nmChannelHandle ); #if(STD_ON == CANNM_SYNC_PNC_SHUTDOWN_SUPPORT) STATIC FUNC(void, CANNM_CODE) CanNm_ClrTxPduPnsrBit ( const NetworkHandleType nmChannelHandle ); STATIC FUNC(void, CANNM_CODE) CanNm_SetTxPduPnsrBit ( const NetworkHandleType nmChannelHandle ); STATIC FUNC(void, CANNM_CODE) CanNm_ClearPendingShutdownPnc ( const NetworkHandleType nmChannelHandle ); #endif #endif #if(STD_ON == CANNM_CAR_WAKEUP_ENABLED) STATIC FUNC(boolean, CANNM_CODE) CanNm_CarWakeupRxCheck ( const NetworkHandleType nmChannelHandle, P2CONST(PduInfoType, AUTOMATIC, CANNM_APPL_DATA) PduInfoPtr ); #endif #if(STD_ON == CANNM_GLOBAL_PN_SUPPORT) STATIC FUNC(boolean, CANNM_CODE) CanNm_PnInfoRxCheck ( const NetworkHandleType nmChannelHandle, P2CONST(PduInfoType, AUTOMATIC, CANNM_APPL_DATA) PduInfoPtr ); #endif /******************************************************************************* * Definition of Global functions *******************************************************************************/ /* BEGIN_FUNCTION_HDR ******************************************************************************** * Function Name: CanNm_Init SWS_CanNm_00208 * * Description: Initialize the CanNm module. * * Inputs: cannmConfigPtr: Pointer to a selected configuration structure. * * Outputs: None. * * Limitations: None. ******************************************************************************** END_FUNCTION_HDR*/ FUNC(void, CANNM_CODE) CanNm_Init ( P2CONST(CanNm_ConfigType, AUTOMATIC, CANNM_APPL_DATA) cannmConfigPtr ) { NetworkHandleType nmChannelHandle; uint8 i; #if(STD_ON == CANNM_GLOBAL_PN_SUPPORT) uint8 j; #endif #if(CANNM_CONFIG_VARIANTS == STD_CONFIG_VARIANTS_POSTBUILD) /*SWS_CanNm_00244*//*ECUC_CanNm_00087*/ if(NULL_PTR == cannmConfigPtr) { /*SWS_CanNm_00507*/ CANNM_DET_REPORT_ERROR(CANNM_INIT_APIID, CANNM_E_PARAM_POINTER); } else { /*SWS_CanNm_00060*/ CanNm_PBCfg = cannmConfigPtr; #else (void)cannmConfigPtr; #endif if(CANNM_CHANNELNUM > CANNM_MAX_NUMBER_OF_CHANNELS) { CANNM_DET_REPORT_ERROR(CANNM_INIT_APIID, CANNM_E_INIT_FAILED); } else { for(nmChannelHandle = (NetworkHandleType)0; nmChannelHandle < CANNM_CHANNELNUM; nmChannelHandle++ ) { /*SWS_CanNm_00166*/ #if(CANNM_STATE_CHANGE_IND_ENABLED == STD_ON) Nm_StateChangeNotification(CANNM_COMM_NETWORK_HANDLE(nmChannelHandle), NM_STATE_UNINIT, NM_STATE_BUS_SLEEP); #endif /*SWS_CanNm_00141*/ CanNm_State[nmChannelHandle] = NM_STATE_BUS_SLEEP; /*SWS_CanNm_00144*/ CanNm_Mode[nmChannelHandle] = NM_MODE_BUS_SLEEP; CanNm_NetworkReqCmd[nmChannelHandle] = CANNM_NULL_CMD; CanNm_RxIndFlg[nmChannelHandle] = FALSE; CANNM_STOP_NMTO_TIMER(nmChannelHandle); CANNM_STOP_RPT_MSG_TIMER(nmChannelHandle); CANNM_STOP_WBS_TIMER(nmChannelHandle); #if(CANNM_PASSIVE_MODE_ENABLED == STD_OFF) CanNm_RptMsgReq[nmChannelHandle] = FALSE; CanNm_RptMsgReqBit[nmChannelHandle] = FALSE; #if(CANNM_COM_CONTROL_ENABLED == STD_ON) CanNm_ComTxEnabled[nmChannelHandle] = TRUE; #endif CanNm_TxCfmFlg[nmChannelHandle] = FALSE; CANNM_STOP_MSG_CYCLE_OFFSET(nmChannelHandle); /*SWS_CanNm_00143*/ CanNm_NetworkState[nmChannelHandle] = CANNM_NETWORK_RELEASED; CanNm_MsgTxEnabled[nmChannelHandle] = FALSE; /*SWS_CanNm_00033*//*SWS_CanNm_00023*/ CANNM_STOP_MSG_CYC(nmChannelHandle); /*SWS_CanNm_00061*/ #if(CANNM_IMMEDIATE_TXCONF_ENABLED == STD_OFF) CANNM_STOP_TXTO_TIMER(nmChannelHandle); #endif #if(CANNM_REMOTE_SLEEP_IND_ENABLED == STD_ON) CanNm_RmtSlpInd[nmChannelHandle] = FALSE; CANNM_STOP_RMT_SLP_IND_TIMER(nmChannelHandle); #endif #if(CANNM_COORDINATOR_SYNC_SUPPORT == STD_ON) CanNm_SleepReadyBit[nmChannelHandle] = FALSE; #endif CanNm_ImmTrans[nmChannelHandle] = (uint8)0; CanNm_TxPdu[nmChannelHandle].SduLength = CANNM_TX_PDU_LENGTH(nmChannelHandle); CanNm_TxPdu[nmChannelHandle].SduDataPtr = CanNm_TxPduBuff[nmChannelHandle]; /*SWS_CanNm_00025*/ for(i = (uint8)0; i < CANNM_MAX_TX_PDU_LENGTH; i++) { CanNm_TxPduBuff[nmChannelHandle][i] = CANNM_USER_DATA_DEFAULT_VALUE; } /*SWS_CanNm_00500*/ /*The Pn data in the sent message is from the Nm module and is obtained from the Nm module before each transmission. Therefore, initialization is not required.*/ if(CANNM_PDU_OFF != CANNM_PDU_CBV_POS(nmChannelHandle)) { /*SWS_CanNm_00085*/ CanNm_TxPduBuff[nmChannelHandle][CANNM_PDU_CBV_POS(nmChannelHandle)] = (uint8)0; } if(TRUE == CANNM_NID_ENABLED(nmChannelHandle)) { /*SWS_CanNm_00013*/ CanNm_SetNodeId(nmChannelHandle); } CanNm_TxReqFlg[nmChannelHandle] = FALSE; CanNm_MsgTxRptCmd[nmChannelHandle] = CANNM_REPEAT_NULL; #endif/*#if(CANNM_PASSIVE_MODE_ENABLED == STD_OFF)*/ CanNm_RxPdu[nmChannelHandle].SduLength = (PduLengthType)0; CanNm_RxPdu[nmChannelHandle].SduDataPtr = CanNm_RxPduBuff[nmChannelHandle]; #if(STD_ON == CANNM_GLOBAL_PN_SUPPORT) CanNm_PnFilterEnable[nmChannelHandle] = FALSE; #if(STD_ON == CANNM_SYNC_PNC_SHUTDOWN_SUPPORT) CanNm_ClearPendingShutdownPnc(nmChannelHandle); #endif #endif } CanNm_InitState = STD_INITIALIZED; } #if(CANNM_CONFIG_VARIANTS == STD_CONFIG_VARIANTS_POSTBUILD) } #endif } /* BEGIN_FUNCTION_HDR ******************************************************************************** * Function Name: CanNm_DeInit SWS_CanNm_91002 * * Description: De-initializes the CanNm module. * * Inputs: None. * * Outputs: None. * * Limitations: None. ******************************************************************************** END_FUNCTION_HDR*/ FUNC(void, CANNM_CODE) CanNm_DeInit ( void ) { NetworkHandleType nmChannelHandle; boolean CanNmCanBeDeInit = TRUE; if(STD_UNINITIALIZED == CanNm_InitState) { /*Must check whether CanNm has been initialized, because CANNM_CHANNELNUM may be a random value befor initialization.*/ CANNM_DET_REPORT_ERROR(CANNM_DEINIT_APIID, CANNM_E_UNINIT); } else { for(nmChannelHandle = (NetworkHandleType)0; nmChannelHandle < CANNM_CHANNELNUM; nmChannelHandle++) { /*SWS_CanNm_00352*/ if(CanNm_Mode[nmChannelHandle] != NM_MODE_BUS_SLEEP) { CanNmCanBeDeInit = FALSE; /*report error CANNM_E_NOT_IN_BUS_SLEEP*/ CANNM_DET_REPORT_ERROR(CANNM_DEINIT_APIID, CANNM_E_NOT_IN_BUS_SLEEP); break; } } if(CanNmCanBeDeInit == TRUE) { CanNm_InitState = STD_UNINITIALIZED; } } } /* BEGIN_FUNCTION_HDR ******************************************************************************** * Function Name: CanNm_PassiveStartUp SWS_CanNm_00211 * * Description: Passive startup of the AUTOSAR CAN NM. It triggers the transition * from Bus-Sleep Mode or Prepare Bus Sleep Mode to the Network Mode * in Repeat Message State. * * Inputs: nmChannelHandle: Identification of the NM-channel. * * Outputs: None * * Limitations: None ******************************************************************************** END_FUNCTION_HDR*/ FUNC(Std_ReturnType, CANNM_CODE) CanNm_PassiveStartUp ( NetworkHandleType nmChannelHandle ) { /*SWS_CanNm_00189*//*SWS_CanNm_00190*/ Std_ReturnType ret = E_NOT_OK; if(STD_UNINITIALIZED == CanNm_InitState) { /*SWS_CanNm_00254*/ CANNM_DET_REPORT_ERROR(CANNM_PASSIVESTARTUP_APIID, CANNM_E_UNINIT); } else if(nmChannelHandle >= CANNM_CHANNELNUM) { /*SWS_CanNm_00192*//*SWS_CanNm_00244*/ CANNM_DET_REPORT_ERROR(CANNM_PASSIVESTARTUP_APIID, CANNM_E_INVALID_CHANNEL); } else { if(NM_MODE_NETWORK == CanNm_Mode[nmChannelHandle]) { /*SWS_CanNm_00147*/ } else { CanNm_NetworkReqCmd[nmChannelHandle] = CANNM_PASSIVE_STARTUP_CMD; ret = E_OK; } } return ret; } /*SWS_CanNm_00257*/ /* BEGIN_FUNCTION_HDR ******************************************************************************** * Function Name: CanNm_NetworkRequest SWS_CanNm_00213 * * Description: Request the network, since ECU needs to communicate on the bus. * * Inputs: nmChannelHandle: Identification of the NM-channel. * * Outputs: None * * Limitations: None ******************************************************************************** END_FUNCTION_HDR*/ FUNC(Std_ReturnType, CANNM_CODE) CanNm_NetworkRequest ( NetworkHandleType nmChannelHandle ) { /*SWS_CanNm_00189*//*SWS_CanNm_00190*/ Std_ReturnType ret = E_NOT_OK; if(STD_UNINITIALIZED == CanNm_InitState) { /*SWS_CanNm_00256*/ CANNM_DET_REPORT_ERROR(CANNM_NETWORKREQUEST_APIID, CANNM_E_UNINIT); } else if(nmChannelHandle >= CANNM_CHANNELNUM) { /*SWS_CanNm_00244*//*SWS_CanNm_00192*/ CANNM_DET_REPORT_ERROR(CANNM_NETWORKREQUEST_APIID, CANNM_E_INVALID_CHANNEL); } else { /*SWS_CanNm_00161*/ #if(CANNM_PASSIVE_MODE_ENABLED == STD_OFF) /*SWS_CanNm_00255*/ CanNm_NetworkReqCmd[nmChannelHandle] = CANNM_NETWORK_REQUEST_CMD; ret = E_OK; #endif } return ret; } /*SWS_CanNm_00260*/ /* BEGIN_FUNCTION_HDR ******************************************************************************** * Function Name: CanNm_NetworkRelease SWS_CanNm_00214 * * Description: Release the network, since ECU doesn't have to communicate on the bus. * * Inputs: nmChannelHandle: Identification of the NM-channel. * * Outputs: None * * Limitations: None ******************************************************************************** END_FUNCTION_HDR*/ FUNC(Std_ReturnType, CANNM_CODE) CanNm_NetworkRelease ( NetworkHandleType nmChannelHandle ) { /*SWS_CanNm_00189*//*SWS_CanNm_00190*/ Std_ReturnType ret= E_NOT_OK; if(STD_UNINITIALIZED == CanNm_InitState) { /*SWS_CanNm_00259*/ CANNM_DET_REPORT_ERROR(CANNM_NETWORKRELEAE_APIID, CANNM_E_UNINIT); } else if(nmChannelHandle >= CANNM_CHANNELNUM) { /*SWS_CanNm_00192*//*SWS_CanNm_00244*/ CANNM_DET_REPORT_ERROR(CANNM_NETWORKRELEAE_APIID, CANNM_E_INVALID_CHANNEL); } else { /*SWS_CanNm_00161*/ #if(CANNM_PASSIVE_MODE_ENABLED == STD_OFF) CanNm_NetworkReqCmd[nmChannelHandle] = CANNM_NETWORK_RELEASE_CMD; ret = E_OK; #endif } return ret; } /* BEGIN_FUNCTION_HDR ******************************************************************************** * Function Name: CanNm_RepeatMessageRequest SWS_CanNm_00221 * * Description: Set Repeat Message Request Bit for NM PDUs transmitted next on the bus. * * Inputs: nmChannelHandle: Identification of the NM-channel. * * Outputs: None * * Limitations: None ******************************************************************************** END_FUNCTION_HDR*/ FUNC(Std_ReturnType, CANNM_CODE) CanNm_RepeatMessageRequest ( NetworkHandleType nmChannelHandle ) { /*SWS_CanNm_00189*//*SWS_CanNm_00190*/ Std_ReturnType ret = E_NOT_OK; if(STD_UNINITIALIZED == CanNm_InitState) { /*SWS_CanNm_00273*/ CANNM_DET_REPORT_ERROR(CANNM_RPTMSGREQ_APIID, CANNM_E_UNINIT); } else if(nmChannelHandle >= CANNM_CHANNELNUM) { /*SWS_CanNm_00244*//*SWS_CanNm_00192*/ CANNM_DET_REPORT_ERROR(CANNM_RPTMSGREQ_APIID, CANNM_E_INVALID_CHANNEL); } else if((NM_STATE_REPEAT_MESSAGE == CanNm_State[nmChannelHandle]) \ || (NM_MODE_BUS_SLEEP == CanNm_Mode[nmChannelHandle]) \ || (NM_MODE_PREPARE_BUS_SLEEP == CanNm_Mode[nmChannelHandle])) { /*SWS_CanNm_00137 return E_NOT_OK*/ } else { /*SWS_CanNm_00161*/ #if(CANNM_PASSIVE_MODE_ENABLED == STD_OFF) /*SWS_CanNm_00112*//*SWS_CanNm_00113*/ if(TRUE == CANNM_NODE_DETECT_ENABLED(nmChannelHandle)) { /*SWS_CanNm_00120*//*SWS_CanNm_00121*/ CanNm_RptMsgReq[nmChannelHandle] = TRUE; ret = E_OK; } #endif } return ret; } /*SWS_CanNm_00327*//*SWS_CanNm_00266*//*SWS_CanNm_00158*/ #if((STD_OFF == CANNM_COM_USER_DATA_SUPPORT) && (STD_ON == CANNM_USER_DATA_ENABLED)) /* BEGIN_FUNCTION_HDR ******************************************************************************** * Function Name: CanNm_SetUserData SWS_CanNm_00217 * * Description: Set user data for NM PDUs transmitted next on the bus. * * Inputs: nmChannelHandle: Identification of the NM-channel. * nmUserDataPtr: Pointer where the user data for the next transmitted * NM PDU shall be copied from * * Outputs: None * * Limitations: None ******************************************************************************** END_FUNCTION_HDR*/ FUNC(Std_ReturnType, CANNM_CODE) CanNm_SetUserData ( NetworkHandleType nmChannelHandle, P2CONST(uint8, AUTOMATIC, CANNM_APPL_DATA) nmUserDataPtr ) { uint8 *DestDataPtr; /*SWS_CanNm_00189*//*SWS_CanNm_00190*/ Std_ReturnType ret = E_NOT_OK; if(STD_UNINITIALIZED == CanNm_InitState) { /*SWS_CanNm_00265*/ CANNM_DET_REPORT_ERROR(CANNM_SETUSERDATA_APIID, CANNM_E_UNINIT); } else if(nmChannelHandle >= CANNM_CHANNELNUM) { /*SWS_CanNm_00244*//*SWS_CanNm_00192*/ CANNM_DET_REPORT_ERROR(CANNM_SETUSERDATA_APIID, CANNM_E_INVALID_CHANNEL); } else if(NULL_PTR == nmUserDataPtr) { /*SWS_CanNm_00507*/ CANNM_DET_REPORT_ERROR(CANNM_SETUSERDATA_APIID, CANNM_E_PARAM_POINTER); } else { /*SWS_CanNm_00161*/ #if(CANNM_PASSIVE_MODE_ENABLED == STD_OFF) /*SWS_CanNm_00159*/ DestDataPtr = &(CanNm_TxPdu[nmChannelHandle].SduDataPtr[CANNM_USER_DATA_OFS(nmChannelHandle)]); SchM_Enter_CanNm_CANNM_EXCLUSIVE_AREA_1(); Bsw_MemCpy(DestDataPtr, nmUserDataPtr, CANNM_USER_DATA_LEN(nmChannelHandle)); SchM_Exit_CanNm_CANNM_EXCLUSIVE_AREA_1(); ret = E_OK; #endif } return ret; } #endif/*#if(CANNM_USER_DATA_ENABLED == STD_ON)*/ /*SWS_CanNm_00280*//*SWS_CanNm_00185*/ #if(CANNM_BUS_SYNCHRONIZATION_ENABLED == STD_ON) /* BEGIN_FUNCTION_HDR ******************************************************************************** * Function Name: CanNm_RequestBusSynchronization SWS_CanNm_00226 * * Description: Request bus synchronization. * * Inputs: nmChannelHandle: Identification of the NM-channel. * * Outputs: None * * Limitations: None ******************************************************************************** END_FUNCTION_HDR*/ FUNC(Std_ReturnType, CANNM_CODE) CanNm_RequestBusSynchronization ( NetworkHandleType nmChannelHandle ) { /*SWS_CanNm_00189*//*SWS_CanNm_00190*/ Std_ReturnType ret = E_NOT_OK; if(STD_UNINITIALIZED == CanNm_InitState) { /*SWS_CanNm_00279*/ CANNM_DET_REPORT_ERROR(CANNM_REQBUSSYNCH_APIID, CANNM_E_UNINIT); } else if(nmChannelHandle >= CANNM_CHANNELNUM) { /*SWS_CanNm_00244*//*SWS_CanNm_00192*/ CANNM_DET_REPORT_ERROR(CANNM_REQBUSSYNCH_APIID, CANNM_E_INVALID_CHANNEL); } #if(CANNM_COM_CONTROL_ENABLED == STD_ON) else if(FALSE == CanNm_ComTxEnabled[nmChannelHandle]) { /*SWS_CanNm_00181 return E_NOT_OK*/ } #endif else if((NM_MODE_BUS_SLEEP == CanNm_Mode[nmChannelHandle]) \ || (NM_MODE_PREPARE_BUS_SLEEP == CanNm_Mode[nmChannelHandle])) { /*SWS_CanNm_00187 return E_NOT_OK*/ } else { /*SWS_CanNm_00161*/ #if(CANNM_PASSIVE_MODE_ENABLED == STD_OFF) SchM_Enter_CanNm_CANNM_EXCLUSIVE_AREA_1(); /*SWS_CanNm_00130*//*SWS_CanNm_00325*/ ret = CanIf_Transmit(CANNM_TX_PDU_ID(nmChannelHandle), &CanNm_TxPdu[nmChannelHandle]); SchM_Exit_CanNm_CANNM_EXCLUSIVE_AREA_1(); if(ret == E_OK) { /*SWS_CanNm_00071*/ #if(CANNM_IMMEDIATE_TXCONF_ENABLED == STD_ON) CanNm_TxCfmFlg[nmChannelHandle] = TRUE; /*SWS_CanNm_00073*/ #else /*SWS_CanNm_00064*/ CANNM_START_TXTO_TIMER(nmChannelHandle); #endif } #endif } return ret; } #endif/*#if(CANNM_BUS_SYNCHRONIZATION_ENABLED == STD_ON)*/ /*SWS_CanNm_00282*/ #if(CANNM_REMOTE_SLEEP_IND_ENABLED == STD_ON) /* BEGIN_FUNCTION_HDR ******************************************************************************** * Function Name: CanNm_CheckRemoteSleepIndication SWS_CanNm_00227 * * Description: Check if remote sleep indication takes place or not. * * Inputs: nmChannelHandle: Identification of the NM-channel. * * Outputs: nmRemoteSleepIndPtr: Pointer where check result of remote sleep * indication shall be copied to * * Limitations: None ******************************************************************************** END_FUNCTION_HDR*/ FUNC(Std_ReturnType, CANNM_CODE) CanNm_CheckRemoteSleepIndication ( NetworkHandleType nmChannelHandle, P2VAR(boolean, AUTOMATIC, CANNM_APPL_DATA) nmRemoteSleepIndPtr ) { /*SWS_CanNm_00189*//*SWS_CanNm_00190*/ Std_ReturnType ret = E_NOT_OK; if(STD_UNINITIALIZED == CanNm_InitState) { /*SWS_CanNm_00281*/ CANNM_DET_REPORT_ERROR(CANNM_CHECKRMTSLEEPIND_APIID, CANNM_E_UNINIT); } else if(nmChannelHandle >= CANNM_CHANNELNUM) { /*SWS_CanNm_00244*//*SWS_CanNm_00192*/ CANNM_DET_REPORT_ERROR(CANNM_CHECKRMTSLEEPIND_APIID, CANNM_E_INVALID_CHANNEL); } else if(NULL_PTR == nmRemoteSleepIndPtr) { /*SWS_CanNm_00507*/ CANNM_DET_REPORT_ERROR(CANNM_CHECKRMTSLEEPIND_APIID, CANNM_E_PARAM_POINTER); } else { /*SWS_CanNm_00161*/ #if(CANNM_PASSIVE_MODE_ENABLED == STD_OFF) if((NM_MODE_BUS_SLEEP == CanNm_Mode[nmChannelHandle]) \ || (NM_MODE_PREPARE_BUS_SLEEP == CanNm_Mode[nmChannelHandle]) \ || (NM_STATE_REPEAT_MESSAGE == CanNm_State[nmChannelHandle])) { /*SWS_CanNm_00154 return E_NOT_OK*/ } else { /*SWS_CanNm_00153*/ *nmRemoteSleepIndPtr = CanNm_RmtSlpInd[nmChannelHandle]; ret = E_OK; } #endif } return ret; } #endif/*#if(CANNM_REMOTE_SLEEP_IND_ENABLED == STD_ON)*/ /* BEGIN_FUNCTION_HDR ******************************************************************************** * Function Name: CanNm_MainFunction SWS_CanNm_00234 * * Description: Main function of the CanNm which processes the algorithm describes * in that document. * * Inputs: None * * Outputs: None * * Limitations: None ******************************************************************************** END_FUNCTION_HDR*/ FUNC(void, CANNM_CODE) CanNm_MainFunction ( void ) { NetworkHandleType nmChannelHandle; if(STD_UNINITIALIZED != CanNm_InitState) { /*SWS_CanNm_00089*/ for(nmChannelHandle = (NetworkHandleType)0; nmChannelHandle < CANNM_CHANNELNUM; nmChannelHandle++) { CanNm_TimerMainFunction(nmChannelHandle); CanNm_NetworkReqMainFunction(nmChannelHandle); #if(CANNM_PASSIVE_MODE_ENABLED == STD_OFF) CanNm_RptMsgReqMainFunction(nmChannelHandle); #endif CanNm_RxIndMainFunction(nmChannelHandle); #if(CANNM_PASSIVE_MODE_ENABLED == STD_OFF) CanNm_TxCfmMainFunction(nmChannelHandle); /*SWS_CanNm_00072*/ CanNm_TxPduMainFunction(nmChannelHandle); #endif } } } /*SWS_CanNm_00284*/ #if(CANNM_PASSIVE_MODE_ENABLED == STD_OFF) #if(CANNM_IMMEDIATE_TXCONF_ENABLED == STD_OFF) /* BEGIN_FUNCTION_HDR ******************************************************************************** * Function Name: CanNm_TxConfirmation SWS_CanNm_00228 * * Description: The lower layer communication interface module confirms the * transmission of a PDU, or the failure to transmit a PDU. * * Inputs: TxPduId: ID of the PDU that has been transmitted. * result: E_OK: The PDU was transmitted. E_NOT_OK: Transmission of the PDU failed. * * Outputs: None * * Limitations: None ******************************************************************************** END_FUNCTION_HDR*/ FUNC(void, CANNM_CODE) CanNm_TxConfirmation ( PduIdType TxPudId, Std_ReturnType result ) { NetworkHandleType nmChannelHandle = TxPudId; if(STD_UNINITIALIZED == CanNm_InitState) { /*SWS_CanNm_00283*/ CANNM_DET_REPORT_ERROR(CANNM_TXCFM_APIID, CANNM_E_UNINIT); } else if(nmChannelHandle >= CANNM_CHANNELNUM) { /*SWS_CanNm_00244*//*SWS_CanNm_00195*/ CANNM_DET_REPORT_ERROR(CANNM_TXCFM_APIID, CANNM_E_INVALID_PDUID); } else { if(E_OK == result) { CanNm_TxCfmFlg[nmChannelHandle] = TRUE; } else { /*SWS_CanNm_00066*/ } #if(STD_ON == CANNM_COM_USER_DATA_SUPPORT) /*SWS_CanNm_00329*/ PduR_LoIfTxConfirmation(CANNM_TX_USERDATA_PDU_REF(nmChannelHandle), result); #endif } } #endif #endif /* BEGIN_FUNCTION_HDR ******************************************************************************** * Function Name: CanNm_RxIndication SWS_CanNm_00231 * * Description: Indication of a received PDU from a lower layer communication * interface module. * * Inputs: RxPduId: ID of the received PDU. * PduInfoPtr: Contains the length (SduLength) of the received PDU, a * pointer to a buffer (SduDataPtr) containing the PDU, and * the MetaData related to this PDU. * * Outputs: * * Limitations: ******************************************************************************** END_FUNCTION_HDR*/ FUNC(void, CANNM_CODE) CanNm_RxIndication ( PduIdType RxPudId, P2CONST(PduInfoType, AUTOMATIC, CANNM_APPL_DATA) PduInfoPtr ) { NetworkHandleType nmChannelHandle; #if((STD_ON == CANNM_CAR_WAKEUP_ENABLED) || (STD_ON == CANNM_GLOBAL_PN_SUPPORT)) boolean DropRxPduFlag = TRUE; #endif nmChannelHandle = (NetworkHandleType)RxPudId; if(STD_UNINITIALIZED == CanNm_InitState) { /*SWS_CanNm_00285*/ CANNM_DET_REPORT_ERROR(CANNM_RXIND_APIID, CANNM_E_UNINIT); } else if(nmChannelHandle >= CANNM_CHANNELNUM) { /*SWS_CanNm_00244*//*SWS_CanNm_00195*/ CANNM_DET_REPORT_ERROR(CANNM_RXIND_APIID, CANNM_E_INVALID_CHANNEL); } else if((NULL_PTR == PduInfoPtr) || (NULL_PTR == (PduInfoPtr->SduDataPtr))) { /*SWS_CanNm_00507*/ CANNM_DET_REPORT_ERROR(CANNM_RXIND_APIID, CANNM_E_PARAM_POINTER); } else if(CANNM_MAX_RX_PDU_LENGTH < (PduInfoPtr->SduLength)) { /*do nothing*/ } #if(STD_ON == CANNM_GLOBAL_PN_SUPPORT) else if((CANNM_PNC_BIT_VECTOR_OFFSET + CANNM_PNC_BIT_VECTOR_LEN(nmChannelHandle)) > (PduInfoPtr->SduLength)) { /*do nothing*/ } #endif else { #if(STD_ON == CANNM_CAR_WAKEUP_ENABLED) DropRxPduFlag &= CanNm_CarWakeupRxCheck(nmChannelHandle, PduInfoPtr); #endif #if(STD_ON == CANNM_GLOBAL_PN_SUPPORT) DropRxPduFlag &= CanNm_PnInfoRxCheck(nmChannelHandle, PduInfoPtr); #endif #if((STD_ON == CANNM_CAR_WAKEUP_ENABLED) || (STD_ON == CANNM_GLOBAL_PN_SUPPORT)) if(DropRxPduFlag == FALSE) #endif { /*SWS_CanNm_00285*/ CanNm_RxIndFlg[nmChannelHandle] = TRUE; /*SWS_CanNm_00035*/ SchM_Enter_CanNm_CANNM_EXCLUSIVE_AREA_2(); CanNm_RxPdu[nmChannelHandle].SduLength = PduInfoPtr->SduLength; Bsw_MemCpy(CanNm_RxPdu[nmChannelHandle].SduDataPtr, PduInfoPtr->SduDataPtr, PduInfoPtr->SduLength); SchM_Exit_CanNm_CANNM_EXCLUSIVE_AREA_2(); /*SWS_CanNm_00127*/ if(NM_MODE_BUS_SLEEP == CanNm_Mode[nmChannelHandle]) { /*SWS_CanNm_00324*/ Nm_NetworkStartIndication(CANNM_COMM_NETWORK_HANDLE(nmChannelHandle)); /*Violates SWS_CanNm_00336*/ /*CANNM_DET_REPORT_RUNTIME_ERROR(CANNM_RXIND_APIID, CANNM_E_NET_START_IND);*/ } /*SWS_CanNm_00037*//*SWS_CanNm_00325*/ #if(CANNM_PDU_RX_INDICATION_ENABLED == STD_ON) Nm_PduRxIndication(CANNM_COMM_NETWORK_HANDLE(nmChannelHandle)); #endif #if(STD_ON == CANNM_CAR_WAKEUP_ENABLED) if(TRUE == CANNM_CWU_RX_ENABLED(nmChannelHandle)) { /*SWS_CanNm_00406*//*SWS_CanNm_00408*/ Nm_CarWakeUpIndication(CANNM_COMM_NETWORK_HANDLE(nmChannelHandle)); } #endif #if(CANNM_PASSIVE_MODE_ENABLED == STD_OFF) if(CANNM_PDU_OFF != (CANNM_PDU_CBV_POS(nmChannelHandle))) { CanNm_CheckRptMsgReqBit(nmChannelHandle); #if(CANNM_COORDINATOR_SYNC_SUPPORT == STD_ON) CanNm_CheckSleepReadyBit(nmChannelHandle); #endif } #endif/*#if(CANNM_PASSIVE_MODE_ENABLED == STD_OFF)*/ } } } /* BEGIN_FUNCTION_HDR ******************************************************************************** * Function Name: CanNm_GetState SWS_CanNm_00223 * * Description: Returns the state and the mode of the network management. * * Inputs: nmChannelHandle: Identification of the NM-channel. * * Outputs: nmStatePtr: Pointer where state of the network management shall be copied to. * nmModePtr: Pointer where the mode of the network management shall be copied to. * * Limitations: None ******************************************************************************** END_FUNCTION_HDR*/ FUNC(Std_ReturnType, CANNM_CODE) CanNm_GetState ( NetworkHandleType nmChannelHandle, P2VAR(Nm_StateType, AUTOMATIC, CANNM_APPL_DATA) nmStatePtr, P2VAR(Nm_ModeType, AUTOMATIC, CANNM_APPL_DATA) nmModePtr ) { /*SWS_CanNm_00189*//*SWS_CanNm_00190*/ Std_ReturnType ret = E_NOT_OK; if(STD_UNINITIALIZED == CanNm_InitState) { /*SWS_CanNm_00277*/ CANNM_DET_REPORT_ERROR(CANNM_GETSTATE_APIID, CANNM_E_UNINIT); } else if(nmChannelHandle >= CANNM_CHANNELNUM) { /*SWS_CanNm_00192*//*SWS_CanNm_00244*/ CANNM_DET_REPORT_ERROR(CANNM_GETSTATE_APIID, CANNM_E_INVALID_CHANNEL); } else if((NULL_PTR == nmStatePtr) || (NULL_PTR == nmModePtr)) { /*SWS_CanNm_00507*/ CANNM_DET_REPORT_ERROR(CANNM_GETSTATE_APIID, CANNM_E_PARAM_POINTER); } else { /*SWS_CanNm_00091*/ SchM_Enter_CanNm_CANNM_EXCLUSIVE_AREA_3(); *nmStatePtr = CanNm_State[nmChannelHandle]; *nmModePtr = CanNm_Mode[nmChannelHandle]; SchM_Exit_CanNm_CANNM_EXCLUSIVE_AREA_3(); ret = E_OK; } return ret; } #if(CANNM_VERSION_INFO_API == STD_ON) /* BEGIN_FUNCTION_HDR ******************************************************************************** * Function Name: CanNm_GetVersionInfo SWS_CanNm_00224 * * Description: This service returns the version information of this module. * * Inputs: None * * Outputs: versioninfo: Pointer to where to store the version information of this module. * * Limitations: None ******************************************************************************** END_FUNCTION_HDR*/ FUNC(void, CANNM_CODE) CanNm_GetVersionInfo ( P2VAR(Std_VersionInfoType, AUTOMATIC, CANNM_APPL_DATA) versioninfo ) { if(NULL_PTR == versioninfo) { /*SWS_CanNm_00244*//*SWS_CanNm_00507*/ CANNM_DET_REPORT_ERROR(CANNM_GETVERSIONINFO_APIID, CANNM_E_PARAM_POINTER); } else { versioninfo->vendorID = CANNM_VENDOR_ID; versioninfo->moduleID = CANNM_MODULE_ID; versioninfo->sw_major_version = CANNM_SW_MAJOR_VERSION; versioninfo->sw_minor_version = CANNM_SW_MINOR_VERSION; versioninfo->sw_patch_version = CANNM_SW_PATCH_VERSION; } } #endif /*SWS_CanNm_00340*/ #if(CANNM_COORDINATOR_SYNC_SUPPORT == STD_ON) /* BEGIN_FUNCTION_HDR ******************************************************************************** * Function Name: CanNm_SetSleepReadyBit SWS_CanNm_00338 * * Description: Set the NM Coordinator Sleep Ready bit in the Control Bit Vector. * * Inputs: nmChannelHandle: Identification of the NM-channel. * nmSleepReadyBit: Value written to ReadySleep Bit in CBV. * * Outputs: None * * Limitations: None ******************************************************************************** END_FUNCTION_HDR*/ FUNC(Std_ReturnType, CANNM_CODE) CanNm_SetSleepReadyBit ( NetworkHandleType nmChannelHandle, boolean nmSleepReadyBit ) { /*SWS_CanNm_00189*//*SWS_CanNm_00190*/ Std_ReturnType ret = E_NOT_OK; if(STD_UNINITIALIZED == CanNm_InitState) { /*SWS_CanNm_00339*/ CANNM_DET_REPORT_ERROR(CANNM_SETSLEEPREADYBIT_APIID, CANNM_E_UNINIT); } else if(nmChannelHandle >= CANNM_CHANNELNUM) { /*SWS_CanNm_00192*//*SWS_CanNm_00244*/ CANNM_DET_REPORT_ERROR(CANNM_SETSLEEPREADYBIT_APIID, CANNM_E_INVALID_CHANNEL); } else if(CANNM_PDU_OFF == CANNM_PDU_CBV_POS(nmChannelHandle)) { /*ret = E_NOT_OK;*/ } else { if(nmSleepReadyBit == TRUE) { CanNm_TxPduBuff[nmChannelHandle][CANNM_PDU_CBV_POS(nmChannelHandle)] |= CANNM_CBV_SLEEP_READY_BIT_MASK; } else { CanNm_TxPduBuff[nmChannelHandle][CANNM_PDU_CBV_POS(nmChannelHandle)] &= (~CANNM_CBV_SLEEP_READY_BIT_MASK); } /*SWS_CanNm_00342*//*Trigger a single Network Management PDU*/ if((NM_STATE_NORMAL_OPERATION == CanNm_State[nmChannelHandle]) \ || (NM_STATE_REPEAT_MESSAGE == CanNm_State[nmChannelHandle])) { SchM_Enter_CanNm_CANNM_EXCLUSIVE_AREA_1(); /*SWS_CanNm_00325*/ ret = CanIf_Transmit(CANNM_TX_PDU_ID(nmChannelHandle), &CanNm_TxPdu[nmChannelHandle]); SchM_Exit_CanNm_CANNM_EXCLUSIVE_AREA_1(); if(ret == E_OK) { #if(CANNM_IMMEDIATE_TXCONF_ENABLED == STD_ON) CanNm_TxCfmFlg[nmChannelHandle] = TRUE; /*SWS_CanNm_00073*/ #else /*SWS_CanNm_00064*/ CANNM_START_TXTO_TIMER(nmChannelHandle); #endif } } } return ret; } #endif #if(CANNM_GLOBAL_PN_SUPPORT == STD_ON) /*SWS_CanNm_00385*/ #if(CANNM_DYN_PNC_MAPPING_SUPPORT == STD_ON) /* BEGIN_FUNCTION_HDR ******************************************************************************** * Function Name: CanNm_PnLearningRequest SWS_CanNm_91004 * * Description: Set Repeat Message Request Bit and Partial Network Learning Bit * for NM messages transmitted next on the bus. This will force all * nodes to enter the PNC Learning Phase. This is needed for the * optional Dynamic PNC-to-channel-mapping feature. * * Inputs: nmChannelHandle: Identification of the NM-channel. * * Outputs: None * * Limitations: None ******************************************************************************** END_FUNCTION_HDR*/ FUNC(Std_ReturnType, CANNM_CODE) CanNm_PnLearningRequest ( NetworkHandleType nmChannelHandle ) { (void)nmChannelHandle; } #endif /* BEGIN_FUNCTION_HDR ******************************************************************************** * Function Name: CanNm_RequestSynchronizedPncShutdown SWS_CanNm_91003 * * Description: Requests transmission of a NM-PDU with PNSR bit set to 1. * * Inputs: nmChannelHandle: Identification of the NM-channel. * pncId: Identifier of the PNC which is requested for a synchronized * shutdown across the PN topology * * Outputs: None * * Limitations: None ******************************************************************************** END_FUNCTION_HDR*/ FUNC(Std_ReturnType, CANNM_CODE) CanNm_RequestSynchronizedPncShutdown ( NetworkHandleType nmChannelHandle, PNCHandleType pncId ) { #if(STD_ON == CANNM_SYNC_PNC_SHUTDOWN_SUPPORT) uint8 PncByteIndex; uint8 PncBitIndex; #endif Std_ReturnType ret = E_NOT_OK; if(STD_UNINITIALIZED == CanNm_InitState) { CANNM_DET_REPORT_ERROR(CANNM_REQSYNCPNCSHUTDOWN_APIID, CANNM_E_UNINIT); } else if(nmChannelHandle >= CANNM_CHANNELNUM) { CANNM_DET_REPORT_ERROR(CANNM_REQSYNCPNCSHUTDOWN_APIID, CANNM_E_INVALID_CHANNEL); } else { #if(STD_ON == CANNM_SYNC_PNC_SHUTDOWN_SUPPORT) PncByteIndex = CANNM_GET_PNC_BYTE_INDEX(pncId); if(PncByteIndex < CANNM_PNC_BIT_VECTOR_LEN(nmChannelHandle)) { /*SWS_CanNm_00467*/ if(TRUE == CANNM_SYNC_PN_SHUTDOWN_EN(nmChannelHandle)) { PncBitIndex = CANNM_GET_PNC_BIT_INDEX(pncId); /*SWS_CanNm_00462*/ /*The transmission as PN shutdown message (set the PNSR bit in the CBV to 1) is done asynchronously in the context of CanNm_Mainfunction.*/ CanNm_SyncPncShutdownPending[nmChannelHandle] = TRUE; CanNm_SyncPncShutdownPnInfo[nmChannelHandle][PncByteIndex] |= ((uint8)1 << PncBitIndex); ret = E_OK; } } #endif } return ret; } #endif/*#if(CANNM_GLOBAL_PN_SUPPORT == STD_ON)*/ /*SWS_CanNm_00268*//*SWS_CanNm_00158*/ #if(CANNM_USER_DATA_ENABLED == STD_ON) /* BEGIN_FUNCTION_HDR ******************************************************************************** * Function Name: CanNm_GetUserData SWS_CanNm_00218 * * Description: Get user data out of the most recently received NM PDU. * * Inputs: nmChannelHandle: Identification of the NM-channel. * * Outputs: nmUserDataPtr: Pointer where user data out of the most recently * received NM PDU shall be copied to * * Limitations: None ******************************************************************************** END_FUNCTION_HDR*/ FUNC(Std_ReturnType, CANNM_CODE) CanNm_GetUserData ( NetworkHandleType nmChannelHandle, CONSTP2VAR(uint8, AUTOMATIC, CANNM_APPL_DATA) nmUserDataPtr ) { uint8 *SrcDataPtr; /*SWS_CanNm_00189*//*SWS_CanNm_00190*/ Std_ReturnType ret = E_NOT_OK; if(STD_UNINITIALIZED == CanNm_InitState) { /*SWS_CanNm_00267*/ CANNM_DET_REPORT_ERROR(CANNM_GETUSERDATA_APIID, CANNM_E_UNINIT); } else if(nmChannelHandle >= CANNM_CHANNELNUM) { /*SWS_CanNm_00244*//*SWS_CanNm_00192*/ CANNM_DET_REPORT_ERROR(CANNM_GETUSERDATA_APIID, CANNM_E_INVALID_CHANNEL); } else if(NULL_PTR == nmUserDataPtr) { /*SWS_CanNm_00507*/ CANNM_DET_REPORT_ERROR(CANNM_GETUSERDATA_APIID, CANNM_E_PARAM_POINTER); } else { SrcDataPtr = &(CanNm_RxPdu[nmChannelHandle].SduDataPtr[CANNM_USER_DATA_OFS(nmChannelHandle)]); /*SWS_CanNm_00160*/ SchM_Enter_CanNm_CANNM_EXCLUSIVE_AREA_2(); Bsw_MemCpy(nmUserDataPtr, SrcDataPtr, CANNM_USER_DATA_LEN(nmChannelHandle)); SchM_Exit_CanNm_CANNM_EXCLUSIVE_AREA_2(); ret = E_OK; } return ret; } #endif /*SWS_CanNm_00262*//*SWS_CanNm_00264*/ #if(CANNM_COM_CONTROL_ENABLED == STD_ON) /* BEGIN_FUNCTION_HDR ******************************************************************************** * Function Name: CanNm_DisableCommunication SWS_CanNm_00215 * * Description: Disable the NM PDU transmission ability due to a ISO14229 * Communication Control (28hex) service * * Inputs: nmChannelHandle: Identification of the NM-channel. * * Outputs: None * * Limitations: None ******************************************************************************** END_FUNCTION_HDR*/ FUNC(Std_ReturnType, CANNM_CODE) CanNm_DisableCommunication ( NetworkHandleType nmChannelHandle ) { /*SWS_CanNm_00189*//*SWS_CanNm_00190*/ Std_ReturnType ret = E_NOT_OK; /*SWS_CanNm_00298*/ #if(CANNM_PASSIVE_MODE_ENABLED == STD_OFF) if(STD_UNINITIALIZED == CanNm_InitState) { /*SWS_CanNm_00261*/ CANNM_DET_REPORT_ERROR(CANNM_DISABLECOMM_APIID, CANNM_E_UNINIT); } else if(nmChannelHandle >= CANNM_CHANNELNUM) { /*SWS_CanNm_00244*//*SWS_CanNm_00192*/ CANNM_DET_REPORT_ERROR(CANNM_DISABLECOMM_APIID, CANNM_E_INVALID_CHANNEL); } else if(NM_MODE_NETWORK != CanNm_Mode[nmChannelHandle]) { /*SWS_CanNm_00172*/ } else { /*SWS_CanNm_00170*/ CanNm_ComTxEnabled[nmChannelHandle] = FALSE; ret = E_OK; } #endif return ret; } /* BEGIN_FUNCTION_HDR ******************************************************************************** * Function Name: CanNm_EnableCommunication SWS_CanNm_00216 * * Description: Enable the NM PDU transmission ability due to a ISO14229 * Communication Control (28hex) service * * Inputs: nmChannelHandle: Identification of the NM-channel. * * Outputs: None * * Limitations: None ******************************************************************************** END_FUNCTION_HDR*/ FUNC(Std_ReturnType, CANNM_CODE) CanNm_EnableCommunication ( NetworkHandleType nmChannelHandle ) { /*SWS_CanNm_00189*//*SWS_CanNm_00190*/ Std_ReturnType ret = E_NOT_OK; /*SWS_CanNm_00297*/ #if(CANNM_PASSIVE_MODE_ENABLED == STD_OFF) if(STD_UNINITIALIZED == CanNm_InitState) { /*SWS_CanNm_00263*/ CANNM_DET_REPORT_ERROR(CANNM_ENABLECOMM_APIID, CANNM_E_UNINIT); } else if(nmChannelHandle >= CANNM_CHANNELNUM) { /*SWS_CanNm_00244*//*SWS_CanNm_00192*/ CANNM_DET_REPORT_ERROR(CANNM_ENABLECOMM_APIID, CANNM_E_INVALID_CHANNEL); } else if((NM_MODE_NETWORK != CanNm_Mode[nmChannelHandle]) \ || (TRUE == CanNm_ComTxEnabled[nmChannelHandle])) { /*SWS_CanNm_00295*//*SWS_CanNm_00177*/ } else { /*SWS_CanNm_00176*/ CanNm_ComTxEnabled[nmChannelHandle] = TRUE; /*SWS_CanNm_00178*/ CANNM_TX_PDU_REQ(nmChannelHandle); CANNM_SET_MSG_CYC_NORMAL(nmChannelHandle); /*SWS_CanNm_00179*/ CANNM_START_NMTO_TIMER(nmChannelHandle); /*SWS_CanNm_00180*/ #if(CANNM_REMOTE_SLEEP_IND_ENABLED == STD_ON) CANNM_START_RMT_SLP_IND_TIMER(nmChannelHandle); #endif ret = E_OK; } #endif return ret; } #endif/*#if(CANNM_COM_CONTROL_ENABLED == STD_ON)*/ /* BEGIN_FUNCTION_HDR ******************************************************************************** * Function Name: CanNm_GetPduData SWS_CanNm_00222 * * Description: Get the whole PDU data out of the most recently received NM PDU. * * Inputs: nmChannelHandle: Identification of the NM-channel. * * Outputs: nmPduDataPtr: Pointer where NM PDU shall be copied to * * Limitations: None ******************************************************************************** END_FUNCTION_HDR*/ FUNC(Std_ReturnType, CANNM_CODE) CanNm_GetPduData ( NetworkHandleType nmChannelHandle, CONSTP2VAR(uint8, AUTOMATIC, CANNM_APPL_DATA) nmPduDataPtr ) { /*SWS_CanNm_00189*//*SWS_CanNm_00190*/ Std_ReturnType ret = E_NOT_OK; if(STD_UNINITIALIZED == CanNm_InitState) { /*SWS_CanNm_00275*/ CANNM_DET_REPORT_ERROR(CANNM_GETPDUDATA_APIID, CANNM_E_UNINIT); } else if(nmChannelHandle >= CANNM_CHANNELNUM) { /*SWS_CanNm_00244*//*SWS_CanNm_00192*/ CANNM_DET_REPORT_ERROR(CANNM_GETPDUDATA_APIID, CANNM_E_INVALID_CHANNEL); } else if(NULL_PTR == nmPduDataPtr) { /*SWS_CanNm_00507*/ CANNM_DET_REPORT_ERROR(CANNM_GETPDUDATA_APIID, CANNM_E_PARAM_POINTER); } else { /*SWS_CanNm_00407*/ if((TRUE == CANNM_NID_ENABLED(nmChannelHandle)) || (TRUE == CANNM_NODE_DETECT_ENABLED(nmChannelHandle)) \ || (CANNM_USER_DATA_ENABLED == STD_ON)) { /*SWS_CanNm_00138*/ SchM_Enter_CanNm_CANNM_EXCLUSIVE_AREA_2(); Bsw_MemCpy(nmPduDataPtr, (CanNm_RxPdu[nmChannelHandle].SduDataPtr), (CanNm_RxPdu[nmChannelHandle].SduLength)); SchM_Exit_CanNm_CANNM_EXCLUSIVE_AREA_2(); ret = E_OK; } } return ret; } /* BEGIN_FUNCTION_HDR ******************************************************************************** * Function Name: CanNm_GetNodeIdentifier SWS_CanNm_00219 * * Description: Get node identifier out of the most recently received NM PDU. * * Inputs: nmChannelHandle: Identification of the NM-channel. * * Outputs: nmNodeIdPtr: Pointer where node identifier out of the most recently * received NM PDU shall be copied to * * Limitations: None ******************************************************************************** END_FUNCTION_HDR*/ FUNC(Std_ReturnType, CANNM_CODE) CanNm_GetNodeIdentifier ( NetworkHandleType nmChannelHandle, P2VAR(uint8, AUTOMATIC, CANNM_APPL_DATA) nmNodeIdPtr ) { /*SWS_CanNm_00189*//*SWS_CanNm_00190*/ Std_ReturnType ret= E_NOT_OK; if(STD_UNINITIALIZED == CanNm_InitState) { /*SWS_CanNm_00269*/ CANNM_DET_REPORT_ERROR(CANNM_GETNODEID_APIID, CANNM_E_UNINIT); } else if(nmChannelHandle >= CANNM_CHANNELNUM) { /*SWS_CanNm_00244*//*SWS_CanNm_00192*/ CANNM_DET_REPORT_ERROR(CANNM_GETNODEID_APIID, CANNM_E_INVALID_CHANNEL); } else if(NULL_PTR == nmNodeIdPtr) { /*SWS_CanNm_00507*/ CANNM_DET_REPORT_ERROR(CANNM_GETNODEID_APIID, CANNM_E_PARAM_POINTER); } else if(CANNM_PDU_OFF == CANNM_PDU_NID_POS(nmChannelHandle)) { /*return E_NOT_OK*/ } else { if(TRUE == CANNM_NID_ENABLED(nmChannelHandle)) { /*SWS_CanNm_00132*/ *nmNodeIdPtr = CanNm_RxPduBuff[nmChannelHandle][CANNM_PDU_NID_POS(nmChannelHandle)]; ret = E_OK; } } return ret; } /* BEGIN_FUNCTION_HDR ******************************************************************************** * Function Name: CanNm_GetLocalNodeIdentifier SWS_CanNm_00220 * * Description: Get node identifier configured for the local node. * * Inputs: nmChannelHandle: Identification of the NM-channel. * * Outputs: nmNodeIdPtr: Pointer where node identifier of the local node shall * be copied to * * Limitations: None ******************************************************************************** END_FUNCTION_HDR*/ FUNC(Std_ReturnType, CANNM_CODE) CanNm_GetLocalNodeIdentifier ( NetworkHandleType nmChannelHandle, P2VAR(uint8, AUTOMATIC, CANNM_APPL_DATA) nmNodeIdPtr ) { /*SWS_CanNm_00189*//*SWS_CanNm_00190*/ Std_ReturnType ret = E_NOT_OK; if(STD_UNINITIALIZED == CanNm_InitState) { /*SWS_CanNm_00271*/ CANNM_DET_REPORT_ERROR(CANNM_GETLOCALNODEID_APIID, CANNM_E_UNINIT); } else if(nmChannelHandle >= CANNM_CHANNELNUM) { /*SWS_CanNm_00244*//*SWS_CanNm_00192*/ CANNM_DET_REPORT_ERROR(CANNM_GETLOCALNODEID_APIID, CANNM_E_INVALID_CHANNEL); } else if(NULL_PTR == nmNodeIdPtr) { /*SWS_CanNm_00507*/ CANNM_DET_REPORT_ERROR(CANNM_GETLOCALNODEID_APIID, CANNM_E_PARAM_POINTER); } else { if(TRUE == CANNM_NID_ENABLED(nmChannelHandle)) { /*SWS_CanNm_00133*/ *nmNodeIdPtr = CANNM_NODE_ID(nmChannelHandle); ret = E_OK; } } return ret; } /*SWS_CanNm_00346*/ #if(STD_ON == CANNM_GLOBAL_PN_SUPPORT) /* BEGIN_FUNCTION_HDR ******************************************************************************** * Function Name: CanNm_ConfirmPnAvailability SWS_CanNm_00344 * * Description: Enables the PN filter functionality on the indicated NM channel. * * Inputs: nmChannelHandle: Identification of the NM-channel * * Outputs: None * * Limitations: The API is only available if CanNmGlobalPnSupport is TRUE. ******************************************************************************** END_FUNCTION_HDR*/ FUNC(void, CANNM_CODE) CanNm_ConfirmPnAvailability ( NetworkHandleType nmChannelHandle ) { if(STD_UNINITIALIZED == CanNm_InitState) { /*SWS_CanNm_00345*/ CANNM_DET_REPORT_ERROR(CANNM_CFMPNAVAIL_APIID, CANNM_E_UNINIT); } else if(nmChannelHandle >= CANNM_CHANNELNUM) { /*SWS_CanNm_00192*/ CANNM_DET_REPORT_ERROR(CANNM_CFMPNAVAIL_APIID, CANNM_E_INVALID_CHANNEL); } else { if(TRUE == CANNM_PN_ENABLED(nmChannelHandle)) { CanNm_PnFilterEnable[nmChannelHandle] = TRUE; } } } #endif /* BEGIN_FUNCTION_HDR ******************************************************************************** * Function Name: CanNm_TriggerTransmit SWS_CanNm_91001 * * Description: Within this API, the upper layer module (called module) shall check * whether the available data fits into the buffer size reported by * PduInfoPtr->SduLength. If it fits, it shall copy its data into the * buffer provided by PduInfoPtr->SduDataPtr and update the length of * the actual copied data in PduInfoPtr->SduLength. * * Inputs: TxPduId: ID of the SDU that is requested to be transmitted. * PduInfoPtr: Contains a pointer to a buffer (SduDataPtr) to where the SDU * data shall be copied, and the available buffer size in SduLengh. * * Outputs: PduInfoPtr: On return, the service will indicate the length of the copied * SDU data in SduLength. * * Limitations: None ******************************************************************************** END_FUNCTION_HDR*/ FUNC(Std_ReturnType, CANNM_CODE) CanNm_TriggerTransmit ( PduIdType TxPduId, CONSTP2VAR(PduInfoType, AUTOMATIC, CANNM_APPL_DATA) PduInfoPtr ) { /*SWS_CanNm_00189*//*SWS_CanNm_00190*/ Std_ReturnType ret = E_NOT_OK; NetworkHandleType nmChannelHandle = TxPduId; if(STD_UNINITIALIZED == CanNm_InitState) { CANNM_DET_REPORT_ERROR(CANNM_TRIGGER_TRANS_APIID, CANNM_E_UNINIT); } else if(nmChannelHandle >= CANNM_CHANNELNUM) { /*SWS_CanNm_00195*/ CANNM_DET_REPORT_ERROR(CANNM_CFMPNAVAIL_APIID, CANNM_E_INVALID_PDUID); } #if(STD_OFF == CANNM_PASSIVE_MODE_ENABLED) else if((PduInfoPtr->SduLength < CANNM_TX_PDU_LENGTH(nmChannelHandle)) || (PduInfoPtr->SduDataPtr == NULL_PTR) ) { /*SWS_CanNm_00507*/ CANNM_DET_REPORT_ERROR(CANNM_CFMPNAVAIL_APIID, CANNM_E_PARAM_POINTER); } #endif else { #if(STD_OFF == CANNM_PASSIVE_MODE_ENABLED) SchM_Enter_CanNm_CANNM_EXCLUSIVE_AREA_1(); /*SWS_CanNm_00508*//*SWS_CanNm_00509*//*SWS_CanNm_00510*//*SWS_CanNm_00351*/ PduInfoPtr->SduLength = CANNM_TX_PDU_LENGTH(nmChannelHandle); Bsw_MemCpy((PduInfoPtr->SduDataPtr), (CanNm_TxPdu[nmChannelHandle].SduDataPtr), (PduInfoPtr->SduLength)); ret = E_OK; SchM_Exit_CanNm_CANNM_EXCLUSIVE_AREA_1(); #endif } return ret; } /*SWS_CanNm_00330*/ #if(STD_ON == CANNM_COM_USER_DATA_SUPPORT) /* BEGIN_FUNCTION_HDR ******************************************************************************** * Function Name: CanNm_Transmit SWS_CanNm_00331 * * Description: Requests transmission of a PDU. * * Inputs: TxPduId: Identifier of the PDU to be transmitted * PduInfoPtr: Length of and pointer to the PDU data and pointer to MetaData. * * Outputs: None * * Limitations: Synchronous ******************************************************************************** END_FUNCTION_HDR*/ FUNC(Std_ReturnType, CANNM_CODE) CanNm_Transmit ( PduIdType TxPduId, P2CONST(PduInfoType, AUTOMATIC, CANNM_APPL_DATA) PduInfoPtr ) { uint8 *DestDataPtr; uint8 DataLen; /*SWS_CanNm_00189*//*SWS_CanNm_00190*/ Std_ReturnType ret = E_NOT_OK; NetworkHandleType nmChannelHandle = TxPduId; if(STD_UNINITIALIZED == CanNm_InitState) { CANNM_DET_REPORT_ERROR(CANNM_TRANSMIT_APIID, CANNM_E_UNINIT); } else if(nmChannelHandle >= CANNM_CHANNELNUM) { /*SWS_CanNm_00244*//*SWS_CanNm_00195*/ CANNM_DET_REPORT_ERROR(CANNM_TRANSMIT_APIID, CANNM_E_INVALID_PDUID); } else if((PduInfoPtr == NULL_PTR) || ((PduInfoPtr->SduDataPtr) == NULL_PTR)) { /*SWS_CanNm_00507*/ CANNM_DET_REPORT_ERROR(CANNM_TRANSMIT_APIID, CANNM_E_PARAM_POINTER); } else if((PduInfoPtr->SduLength) != CANNM_USER_DATA_LEN(nmChannelHandle)) { /*do nothing*/ } else { if((NM_STATE_NORMAL_OPERATION == CanNm_State[nmChannelHandle]) \ || (NM_STATE_REPEAT_MESSAGE == CanNm_State[nmChannelHandle])) { /*SWS_CanNm_00333*/ #if(CANNM_COM_CONTROL_ENABLED == STD_ON) if(TRUE == CanNm_ComTxEnabled[nmChannelHandle]) #endif { DestDataPtr = &(CanNm_TxPdu[nmChannelHandle].SduDataPtr[CANNM_USER_DATA_OFS(nmChannelHandle)]); DataLen = CANNM_USER_DATA_LEN(nmChannelHandle); SchM_Enter_CanNm_CANNM_EXCLUSIVE_AREA_1(); Bsw_MemCpy(DestDataPtr, (PduInfoPtr->SduDataPtr), DataLen); /*SWS_CanNm_00325*/ ret = CanIf_Transmit(CANNM_TX_PDU_ID(nmChannelHandle), &CanNm_TxPdu[nmChannelHandle]); SchM_Exit_CanNm_CANNM_EXCLUSIVE_AREA_1(); if(ret == E_OK) { /*SWS_CanNm_00071*/ #if(CANNM_IMMEDIATE_TXCONF_ENABLED == STD_ON) CanNm_TxCfmFlg[nmChannelHandle] = TRUE; /*SWS_CanNm_00073*/ #else /*SWS_CanNm_00064*/ CANNM_START_TXTO_TIMER(nmChannelHandle); #endif } } } } return ret; } #endif /* BEGIN_FUNCTION_HDR ******************************************************************************** * Function Name: CanNm_NetworkReqMainFunction * * Description: Main function to process network request or release from upper layer. * * Inputs: nmChannelHandle * * Outputs: None * * Limitations: None ******************************************************************************** END_FUNCTION_HDR*/ STATIC FUNC(void, CANNM_CODE) CanNm_NetworkReqMainFunction ( const NetworkHandleType nmChannelHandle ) { CanNm_NetworkReqType cmd; SchM_Enter_CanNm_CANNM_EXCLUSIVE_AREA_0(); cmd = CanNm_NetworkReqCmd[nmChannelHandle]; CanNm_NetworkReqCmd[nmChannelHandle] = CANNM_NULL_CMD; SchM_Exit_CanNm_CANNM_EXCLUSIVE_AREA_0(); #if(CANNM_PASSIVE_MODE_ENABLED == STD_OFF) if(CANNM_NETWORK_RELEASE_CMD == cmd) { /*SWS_CanNm_00105*/ CanNm_NetworkState[nmChannelHandle] = CANNM_NETWORK_RELEASED; if(NM_STATE_NORMAL_OPERATION == CanNm_State[nmChannelHandle]) { /*SWS_CanNm_00118*/ CanNm_RdySlpStateEnter(nmChannelHandle); } } else if(CANNM_NETWORK_REQUEST_CMD == cmd) { /*SWS_CanNm_00255*//*SWS_CanNm_00104*/ CanNm_NetworkState[nmChannelHandle] = CANNM_NETWORK_REQUESTED; if((NM_MODE_BUS_SLEEP == CanNm_Mode[nmChannelHandle]) \ || (NM_MODE_PREPARE_BUS_SLEEP == CanNm_Mode[nmChannelHandle])) { /*SWS_CanNm_00401*/ if(TRUE == CANNM_ACTIVE_WU_BIT_ENABLED(nmChannelHandle)) { CanNm_SetActiveWakeupBit(nmChannelHandle); } if(NM_MODE_PREPARE_BUS_SLEEP == CanNm_Mode[nmChannelHandle]) { /*SWS_CanNm_00122*/ #if(CANNM_IMMEDIATE_RESTART_ENABLED == STD_ON) CANNM_TX_PDU_REQ(nmChannelHandle); #endif CANNM_STOP_WBS_TIMER(nmChannelHandle); } /*SWS_CanNm_00123*//*SWS_CanNm_00129*/ CanNm_NetworkModeEnter(nmChannelHandle); } #if(STD_ON == CANNM_GLOBAL_PN_SUPPORT) else if((NM_MODE_NETWORK == CanNm_Mode[nmChannelHandle]) \ && (TRUE == CANNM_PN_MULTIPLE_REQ(nmChannelHandle))) { /*SWS_CanNm_00454*//*SWS_CanNm_00444*/ CanNm_RptMsgStateEnter(nmChannelHandle, CANNM_NETWORK_MODE_ENTER); } #endif else if(NM_STATE_READY_SLEEP == CanNm_State[nmChannelHandle]) { /*SWS_CanNm_00006*/ CANNM_TX_PDU_REQ(nmChannelHandle); CANNM_SET_MSG_CYC_NORMAL(nmChannelHandle); /*SWS_CanNm_00110*/ CanNm_NormalOpStateEnter(nmChannelHandle); } else { /*do nothing*/ } } else #endif if(CANNM_PASSIVE_STARTUP_CMD == cmd) { /*SWS_CanNm_00128*/ if((NM_MODE_BUS_SLEEP == CanNm_Mode[nmChannelHandle]) \ || (NM_MODE_PREPARE_BUS_SLEEP == CanNm_Mode[nmChannelHandle])) { CanNm_NetworkModeEnter(nmChannelHandle); } } else { /*do nothing*/ } } #if(CANNM_PASSIVE_MODE_ENABLED == STD_OFF) /* BEGIN_FUNCTION_HDR ******************************************************************************** * Function Name: CanNm_RptMsgReqMainFunction * * Description: Main function to process repeat message request command from upper layer. * * Inputs: nmChannelHandle * * Outputs: None * * Limitations: None ******************************************************************************** END_FUNCTION_HDR*/ STATIC FUNC(void, CANNM_CODE) CanNm_RptMsgReqMainFunction ( const NetworkHandleType nmChannelHandle ) { if((TRUE == CANNM_NODE_DETECT_ENABLED(nmChannelHandle)) && (TRUE == CanNm_RptMsgReq[nmChannelHandle])) { CanNm_RptMsgReq[nmChannelHandle] = FALSE; if((NM_STATE_NORMAL_OPERATION == CanNm_State[nmChannelHandle]) \ || (NM_STATE_READY_SLEEP == CanNm_State[nmChannelHandle])) { /*SWS_CanNm_00120*//*SWS_CanNm_00112*/ CanNm_RptMsgStateEnter(nmChannelHandle, CANNM_RPT_MSG_REQ); /*SWS_CanNm_00149*/ #if(CANNM_REMOTE_SLEEP_IND_ENABLED == STD_ON) /*SWS_CanNm_00152*/ if(TRUE == CanNm_RmtSlpInd[nmChannelHandle]) { /*SWS_CanNm_00325*/ Nm_RemoteSleepCancellation(CANNM_COMM_NETWORK_HANDLE(nmChannelHandle)); CanNm_RmtSlpInd[nmChannelHandle] = FALSE; CANNM_STOP_RMT_SLP_IND_TIMER(nmChannelHandle); } #endif /*SWS_CanNm_00121*//*SWS_CanNm_00113*/ CanNm_SetRptMsgBit(nmChannelHandle); } } } /* BEGIN_FUNCTION_HDR ******************************************************************************** * Function Name: CanNm_CheckRptMsgReqBit * * Description: Called to check if received Repeat Message Request bit with 1 in * CanNm_RxIndication(). * * Inputs: nmChannelHandle * * Outputs: None * * Limitations: None ******************************************************************************** END_FUNCTION_HDR*/ STATIC FUNC(void, CANNM_CODE) CanNm_CheckRptMsgReqBit ( const NetworkHandleType nmChannelHandle ) { if((TRUE == CANNM_NODE_DETECT_ENABLED(nmChannelHandle)) && (TRUE == CANNM_REPEAT_MSG_IND_ENABLED(nmChannelHandle))) { if((uint8)0 != ((CanNm_RxPduBuff[nmChannelHandle][CANNM_PDU_CBV_POS(nmChannelHandle)]) & CANNM_CBV_RMR_MASK)) { CanNm_RptMsgReqBit[nmChannelHandle] = TRUE; /*SWS_CanNm_00014*//*SWS_CanNm_00325*/ Nm_RepeatMessageIndication(CANNM_COMM_NETWORK_HANDLE(nmChannelHandle), FALSE); } } } /* BEGIN_FUNCTION_HDR ******************************************************************************** * Function Name: CanNm_TxCfmMainFunction * * Description: Main function to process the tx confirmation of an NM PDU. * * Inputs: nmChannelHandle * * Outputs: None * * Limitations: None ******************************************************************************** END_FUNCTION_HDR*/ STATIC FUNC(void, CANNM_CODE) CanNm_TxCfmMainFunction ( const NetworkHandleType nmChannelHandle ) { if(TRUE == CanNm_TxCfmFlg[nmChannelHandle]) { CanNm_TxCfmFlg[nmChannelHandle] = FALSE; /*SWS_CanNm_00099*/ CANNM_START_NMTO_TIMER(nmChannelHandle); /*SWS_CanNm_00065*/ #if(CANNM_IMMEDIATE_TXCONF_ENABLED == STD_OFF) CANNM_STOP_TXTO_TIMER(nmChannelHandle); #endif /*SWS_CanNm_00052*/ #if(CANNM_BUS_LOAD_REDUCTION_ENABLED == STD_ON) /*SWS_CanNm_00156*//*SWS_CanNm_00157*//*SWS_CanNm_00238*/ if((NM_STATE_NORMAL_OPERATION == CanNm_State[nmChannelHandle]) \ && (TRUE == CANNM_BL_REDUCTION_ACTIVE(nmChannelHandle))) { CANNM_SET_MSG_CYC_NORMAL(nmChannelHandle); } #endif } } #endif /* BEGIN_FUNCTION_HDR ******************************************************************************** * Function Name: CanNm_RxIndMainFunction * * Description: Main function to process the received NM PDU. * * Inputs: nmChannelHandle * * Outputs: None * * Limitations: None ******************************************************************************** END_FUNCTION_HDR*/ STATIC FUNC(void, CANNM_CODE) CanNm_RxIndMainFunction ( const NetworkHandleType nmChannelHandle ) { if(TRUE == CanNm_RxIndFlg[nmChannelHandle]) { CanNm_RxIndFlg[nmChannelHandle] = FALSE; /*SWS_CanNm_00098*/ CANNM_START_NMTO_TIMER(nmChannelHandle); /*SWS_CanNm_00124*/ if(NM_MODE_PREPARE_BUS_SLEEP == CanNm_Mode[nmChannelHandle]) { CanNm_NetworkModeEnter(nmChannelHandle); CANNM_STOP_WBS_TIMER(nmChannelHandle); } /*SWS_CanNm_00052*//*SWS_CanNm_00069*/ #if(CANNM_PASSIVE_MODE_ENABLED == STD_OFF) #if(CANNM_BUS_LOAD_REDUCTION_ENABLED == STD_ON) /*SWS_CanNm_00157*/ if((NM_STATE_NORMAL_OPERATION == CanNm_State[nmChannelHandle]) \ && (TRUE == CANNM_BL_REDUCTION_ACTIVE(nmChannelHandle))) { CANNM_SET_MSG_CYC_REDUCED(nmChannelHandle); } #endif /*SWS_CanNm_00149*/ #if(CANNM_REMOTE_SLEEP_IND_ENABLED == STD_ON) /*SWS_CanNm_00150*/ if(NM_STATE_NORMAL_OPERATION == CanNm_State[nmChannelHandle]) { CANNM_START_RMT_SLP_IND_TIMER(nmChannelHandle); } /*SWS_CanNm_00151*/ if((TRUE == CanNm_RmtSlpInd[nmChannelHandle]) \ && ((NM_STATE_NORMAL_OPERATION == CanNm_State[nmChannelHandle]) \ || (NM_STATE_READY_SLEEP == CanNm_State[nmChannelHandle]))) { /*SWS_CanNm_00325*/ Nm_RemoteSleepCancellation(CANNM_COMM_NETWORK_HANDLE(nmChannelHandle)); CanNm_RmtSlpInd[nmChannelHandle] = FALSE; } #endif /*SWS_CanNm_00119*//*SWS_CanNm_00111*/ if((TRUE == CANNM_NODE_DETECT_ENABLED(nmChannelHandle)) && (TRUE == CanNm_RptMsgReqBit[nmChannelHandle])) { CanNm_RptMsgReqBit[nmChannelHandle] = FALSE; if((NM_STATE_NORMAL_OPERATION == CanNm_State[nmChannelHandle]) \ || (NM_STATE_READY_SLEEP == CanNm_State[nmChannelHandle])) { CanNm_RptMsgStateEnter(nmChannelHandle, CANNM_RPT_MSG_BIT_RX); } } #endif/*#if(CANNM_PASSIVE_MODE_ENABLED == STD_OFF)*/ } } /* BEGIN_FUNCTION_HDR ******************************************************************************** * Function Name: CanNm_NmTOExpires * * Description: Called when NM-Timeout Timer expires * * Inputs: nmChannelHandle: Identification of the NM-channel. * * Outputs: None * * Limitations: None ******************************************************************************** END_FUNCTION_HDR*/ STATIC FUNC(void, CANNM_CODE) CanNm_NmTOExpires ( const NetworkHandleType nmChannelHandle ) { if((NM_STATE_REPEAT_MESSAGE == CanNm_State[nmChannelHandle]) \ || (NM_STATE_NORMAL_OPERATION == CanNm_State[nmChannelHandle])) { /*SWS_CanNm_00101*//*SWS_CanNm_00117*/ CANNM_START_NMTO_TIMER(nmChannelHandle); /*SWS_CanNm_00193*//*SWS_CanNm_00194*/ CANNM_DET_REPORT_RUNTIME_ERROR(CANNM_MAINFUNC_APIID, CANNM_E_NETWORK_TIMEOUT); } else if(NM_STATE_READY_SLEEP == CanNm_State[nmChannelHandle]) { #if(CANNM_PASSIVE_MODE_ENABLED == STD_OFF) /*SWS_CanNm_00402*/ if(TRUE == CANNM_ACTIVE_WU_BIT_ENABLED(nmChannelHandle)) { CanNm_ClrActiveWakeupBit(nmChannelHandle); } #endif /*SWS_CanNm_00109*/ CanNm_PreBusSlpModeEnter(nmChannelHandle); } else { /*Intentionally Empty*/ } } /* BEGIN_FUNCTION_HDR ******************************************************************************** * Function Name: CanNm_RptMsgTimerExpires * * Description: Called when repeat message timer expires, CanNm shall leave the * Repeat Message State and enter Normal Operation State or Ready * Sleep State. * * Inputs: nmChannelHandle * * Outputs: None * * Limitations: None ******************************************************************************** END_FUNCTION_HDR*/ STATIC FUNC(void, CANNM_CODE) CanNm_RptMsgTimerExpires ( const NetworkHandleType nmChannelHandle ) { /*SWS_CanNm_00102*/ if(CANNM_NETWORK_REQUESTED == CanNm_NetworkState[nmChannelHandle]) { /*SWS_CanNm_00103*/ CanNm_NormalOpStateEnter(nmChannelHandle); } else if(CANNM_NETWORK_RELEASED == CanNm_NetworkState[nmChannelHandle]) { /*SWS_CanNm_00106*/ CanNm_RdySlpStateEnter(nmChannelHandle); } else { /* Intentionally Empty */ } #if(CANNM_PASSIVE_MODE_ENABLED == STD_OFF) /*SWS_CanNm_00107*/ if(TRUE == CANNM_NODE_DETECT_ENABLED(nmChannelHandle)) { CanNm_ClrRptMsgBit(nmChannelHandle); } #endif } #if(CANNM_PASSIVE_MODE_ENABLED == STD_OFF) /* BEGIN_FUNCTION_HDR ******************************************************************************** * Function Name: CanNm_MsgCycTimerExpires * * Description: Called when message cycle timer expires, CanNm should send an NM * message and restart message cycle timer. * * Inputs: nmChannelHandle * * Outputs: None * * Limitations: None ******************************************************************************** END_FUNCTION_HDR*/ STATIC FUNC(void, CANNM_CODE) CanNm_MsgCycTimerExpires ( const NetworkHandleType nmChannelHandle ) { /*SWS_CanNm_00032*//*SWS_CanNm_00087*//*SWS_CanNm_00237*/ CANNM_TX_PDU_REQ(nmChannelHandle); if((CanNm_ImmTrans[nmChannelHandle] > (uint8)0) \ && (NM_STATE_REPEAT_MESSAGE == CanNm_State[nmChannelHandle])) { CanNm_ImmTrans[nmChannelHandle]--; if(CanNm_ImmTrans[nmChannelHandle] > (uint8)0) { CANNM_SET_MSG_CYC_IMM(nmChannelHandle); } else { /*SWS_CanNm_00040*/ CANNM_SET_MSG_CYC_NORMAL(nmChannelHandle); } } else { /*SWS_CanNm_00040*/ CANNM_SET_MSG_CYC_NORMAL(nmChannelHandle); } } /* BEGIN_FUNCTION_HDR ******************************************************************************** * Function Name: CanNm_MsgCycOffsetExpires * * Description: Called when message offset timer expires, CanNm should send an NM * message and start the normal cycle timer. * * Inputs: nmChannelHandle * * Outputs: None * * Limitations: None ******************************************************************************** END_FUNCTION_HDR*/ STATIC FUNC(void, CANNM_CODE) CanNm_MsgCycOffsetExpires ( const NetworkHandleType nmChannelHandle ) { CANNM_TX_PDU_REQ(nmChannelHandle); CANNM_SET_MSG_CYC_NORMAL(nmChannelHandle); } #endif /* BEGIN_FUNCTION_HDR ******************************************************************************** * Function Name: CanNm_WbsTimerExpires * * Description: Called when Wait Bus Sleep Timer expires, CanNm should enter * Bus-Sleep Mode. * * Inputs: nmChannelHandle * * Outputs: None * * Limitations: None ******************************************************************************** END_FUNCTION_HDR*/ STATIC FUNC(void, CANNM_CODE) CanNm_WbsTimerExpires ( const NetworkHandleType nmChannelHandle ) { /*SWS_CanNm_00115*//*SWS_CanNm_00088*/ if(FALSE == CANNM_STAY_IN_PBS_ENABLED(nmChannelHandle)) { CanNm_BusSlpModeEnter(nmChannelHandle); } } #if(CANNM_PASSIVE_MODE_ENABLED == STD_OFF) /*SWS_CanNm_00149*/ #if(CANNM_REMOTE_SLEEP_IND_ENABLED == STD_ON) /* BEGIN_FUNCTION_HDR ******************************************************************************** * Function Name: CanNm_RmtSlpIndTimerExpires * * Description: Called when remote sleep indication timer expires, CanNm shall * call the callback function Nm_RemoteSleepIndication. * * Inputs: nmChannelHandle * * Outputs: None * * Limitations: None ******************************************************************************** END_FUNCTION_HDR*/ STATIC FUNC(void, CANNM_CODE) CanNm_RmtSlpIndTimerExpires ( const NetworkHandleType nmChannelHandle ) { /*SWS_CanNm_00150*//*SWS_CanNm_00175*/ if((NM_STATE_NORMAL_OPERATION == CanNm_State[nmChannelHandle]) #if(CANNM_COM_CONTROL_ENABLED == STD_ON) && (TRUE == CanNm_ComTxEnabled[nmChannelHandle]) #endif ) { CanNm_RmtSlpInd[nmChannelHandle] = TRUE; /*SWS_CanNm_00325*/ Nm_RemoteSleepIndication(CANNM_COMM_NETWORK_HANDLE(nmChannelHandle)); } } #endif /*SWS_CanNm_00073*/ #if(CANNM_IMMEDIATE_TXCONF_ENABLED == STD_OFF) /* BEGIN_FUNCTION_HDR ******************************************************************************** * Function Name: CanNm_TxTOTimerExpires * * Description: Called when Tx timeout timer expires, CanNm shall call the function * Nm_TxTimeoutException. * * Inputs: nmChannelHandle * * Outputs: None * * Limitations: None ******************************************************************************** END_FUNCTION_HDR*/ STATIC FUNC(void, CANNM_CODE) CanNm_TxTOTimerExpires ( const NetworkHandleType nmChannelHandle ) { /*SWS_CanNm_00066*//*SWS_CanNm_00325*/ Nm_TxTimeoutException(CANNM_COMM_NETWORK_HANDLE(nmChannelHandle)); /*SWS_CanNm_00446*//*SWS_CanNm_00325*/ #if(STD_ON == CANNM_GLOBAL_PN_SUPPORT) CanSM_TxTimeoutException(CANNM_COMM_NETWORK_HANDLE(nmChannelHandle)); #endif } #endif #endif/*#if(CANNM_PASSIVE_MODE_ENABLED == STD_OFF)*/ /* BEGIN_FUNCTION_HDR ******************************************************************************** * Function Name: CanNm_TimerMainFunction * * Description: It is the main function of all timers, responsible for managing * these timers and executing actions after the timers expire. * * Inputs: nmChannelHandle * * Outputs: None * * Limitations: None ******************************************************************************** END_FUNCTION_HDR*/ STATIC FUNC(void, CANNM_CODE) CanNm_TimerMainFunction ( const NetworkHandleType nmChannelHandle ) { CanNm_TimerCheckFunction(nmChannelHandle, CANNM_NMTO_TIMER(nmChannelHandle), &CanNm_NmTOExpires); CanNm_TimerCheckFunction(nmChannelHandle, CANNM_WBS_TIMER(nmChannelHandle), &CanNm_WbsTimerExpires); #if(CANNM_PASSIVE_MODE_ENABLED == STD_OFF) CanNm_TimerCheckFunction(nmChannelHandle, CANNM_MSG_CYCLE_OFFSET_TIMER(nmChannelHandle), &CanNm_MsgCycOffsetExpires); CanNm_TimerCheckFunction(nmChannelHandle, CANNM_MSG_CYC_TIMER(nmChannelHandle), &CanNm_MsgCycTimerExpires); #if(CANNM_IMMEDIATE_TXCONF_ENABLED == STD_OFF) CanNm_TimerCheckFunction(nmChannelHandle, CANNM_TXTO_TIMER(nmChannelHandle), &CanNm_TxTOTimerExpires); #endif #if(CANNM_REMOTE_SLEEP_IND_ENABLED == STD_ON) CanNm_TimerCheckFunction(nmChannelHandle, CANNM_RMT_SLP_IND_TIMER(nmChannelHandle), &CanNm_RmtSlpIndTimerExpires); #endif #endif CanNm_TimerCheckFunction(nmChannelHandle, CANNM_RPT_MSG_TIMER(nmChannelHandle), &CanNm_RptMsgTimerExpires); } /* BEGIN_FUNCTION_HDR ******************************************************************************** * Function Name: CanNm_TimerCheckFunction * * Description: Check whether a timer expires or not and call the timeout processing * function when timer expires. * * Inputs: nmChannelHandle, timer, TimerExpires * * Outputs: None * * Limitations: None ******************************************************************************** END_FUNCTION_HDR*/ STATIC FUNC(void, CANNM_CODE) CanNm_TimerCheckFunction ( const NetworkHandleType nmChannelHandle, CONSTP2CONST(CanNm_CommTimerType, AUTOMATIC, CANNM_CONST) timer, const CanNm_TimerExpiresType TimerExpires ) { CONSTP2VAR(uint16, AUTOMATIC, CANNM_CONST) timerCnt = timer->TimerCnt; if(NULL_PTR != timerCnt) { if(*timerCnt > (uint16)0) { *timerCnt = (*timerCnt) - (uint16)1; if((uint16)0 == *timerCnt) { if(TimerExpires != NULL_PTR) { TimerExpires(nmChannelHandle); } } } } } /* BEGIN_FUNCTION_HDR ******************************************************************************** * Function Name: CanNm_RptMsgStateEnter * * Description: Called when CanNm enter Repeat Message State. * * Inputs: nmChannelHandle, nmEnterReason * * Outputs: None * * Limitations: None ******************************************************************************** END_FUNCTION_HDR*/ STATIC FUNC(void, CANNM_CODE) CanNm_RptMsgStateEnter ( const NetworkHandleType nmChannelHandle, const CanNm_RptMsgStEnterType nmEnterReason ) { /*SWS_CanNm_00094*//*SWS_CanNm_00166*/ #if(CANNM_STATE_CHANGE_IND_ENABLED == STD_ON) Nm_StateChangeNotification(CANNM_COMM_NETWORK_HANDLE(nmChannelHandle), CanNm_State[nmChannelHandle], NM_STATE_REPEAT_MESSAGE); #endif #if(CANNM_PASSIVE_MODE_ENABLED == STD_OFF) /*SWS_CanNm_00007 AUTOSAR422 if the first transmit request after transition from Bus Sleep to Repeat Message State is not accepted by CanIf, the message request shall be repeated in the next main function until one transmit request is accepted by CanIf.*/ /*Changed: Bus Sleep -> Pre Bus Sleep*/ if(TRUE == CANNM_RETRY_FIRST_MSG_REQ(nmChannelHandle)) { if((CanNm_State[nmChannelHandle] == NM_STATE_BUS_SLEEP) \ || (CanNm_State[nmChannelHandle] == NM_STATE_PREPARE_BUS_SLEEP)) { CanNm_MsgTxRptCmd[nmChannelHandle] = CANNM_REPEAT_PENDING; } } #endif CanNm_State[nmChannelHandle] = NM_STATE_REPEAT_MESSAGE; /*SWS_CanNm_00102*/ CANNM_START_RPT_MSG_TIMER(nmChannelHandle); /*SWS_CanNm_00100*/ #if(CANNM_PASSIVE_MODE_ENABLED == STD_OFF) CanNm_MsgTxEnabled[nmChannelHandle] = TRUE; /*SWS_CanNm_00156*//*SWS_CanNm_00334*/ if((CANNM_NETWORK_REQUESTED == CanNm_NetworkState[nmChannelHandle]) \ && (CANNM_IMM_NM_TRANS(nmChannelHandle) > (uint8)0) \ && (CANNM_NETWORK_MODE_ENTER == nmEnterReason)) { CANNM_TX_PDU_REQ(nmChannelHandle); CanNm_ImmTrans[nmChannelHandle] = CANNM_IMM_NM_TRANS(nmChannelHandle); CanNm_ImmTrans[nmChannelHandle]--; if(CanNm_ImmTrans[nmChannelHandle] > (uint8)0) { CANNM_SET_MSG_CYC_IMM(nmChannelHandle); } else { CANNM_SET_MSG_CYC_NORMAL(nmChannelHandle); } } else if((CANNM_IMM_NM_TRANS(nmChannelHandle) > (uint8)0) \ && (CANNM_RPT_MSG_REQ == nmEnterReason)) { /*Geely Requirment 20170114*/ CANNM_TX_PDU_REQ(nmChannelHandle); CanNm_ImmTrans[nmChannelHandle] = CANNM_IMM_NM_TRANS(nmChannelHandle); CanNm_ImmTrans[nmChannelHandle]--; if(CanNm_ImmTrans[nmChannelHandle] > (uint8)0) { CANNM_SET_MSG_CYC_IMM(nmChannelHandle); } else { CANNM_SET_MSG_CYC_NORMAL(nmChannelHandle); } } else { /*SWS_CanNm_00005*/ if((uint16)0 != CANNM_MSG_CYCLE_OFFSET(nmChannelHandle)) { CANNM_START_MSG_CYCLE_OFFSET(nmChannelHandle); } else { CanNm_MsgCycOffsetExpires(nmChannelHandle); } } #endif } /* BEGIN_FUNCTION_HDR ******************************************************************************** * Function Name: CanNm_NormalOpStateEnter * * Description: Called when CanNm enter Normal Operation State. * * Inputs: nmChannelHandle * * Outputs: None * * Limitations: None ******************************************************************************** END_FUNCTION_HDR*/ STATIC FUNC(void, CANNM_CODE) CanNm_NormalOpStateEnter ( const NetworkHandleType nmChannelHandle ) { /*SWS_CanNm_00094*//*SWS_CanNm_00166*/ #if(CANNM_STATE_CHANGE_IND_ENABLED == STD_ON) Nm_StateChangeNotification(CANNM_COMM_NETWORK_HANDLE(nmChannelHandle), CanNm_State[nmChannelHandle], NM_STATE_NORMAL_OPERATION); #endif CanNm_State[nmChannelHandle] = NM_STATE_NORMAL_OPERATION; #if(CANNM_PASSIVE_MODE_ENABLED == STD_OFF) /*SWS_CanNm_00116*/ CanNm_MsgTxEnabled[nmChannelHandle] = TRUE; #if(CANNM_REMOTE_SLEEP_IND_ENABLED == STD_ON) CANNM_START_RMT_SLP_IND_TIMER(nmChannelHandle); #endif #endif } /* BEGIN_FUNCTION_HDR ******************************************************************************** * Function Name: CanNm_RdySlpStateEnter * * Description: Called when CanNm enter Ready Sleep State. * * Inputs: nmChannelHandle * * Outputs: None * * Limitations: None ******************************************************************************** END_FUNCTION_HDR*/ STATIC FUNC(void, CANNM_CODE) CanNm_RdySlpStateEnter ( const NetworkHandleType nmChannelHandle ) { /*SWS_CanNm_00094*//*SWS_CanNm_00166*/ #if(CANNM_STATE_CHANGE_IND_ENABLED == STD_ON) Nm_StateChangeNotification(CANNM_COMM_NETWORK_HANDLE(nmChannelHandle), CanNm_State[nmChannelHandle], NM_STATE_READY_SLEEP); #endif CanNm_State[nmChannelHandle] = NM_STATE_READY_SLEEP; #if(CANNM_PASSIVE_MODE_ENABLED == STD_OFF) /*SWS_CanNm_00108*/ CanNm_TxReqFlg[nmChannelHandle] = FALSE; CanNm_MsgTxEnabled[nmChannelHandle] = FALSE; /*SWS_CanNm_00051*/ CANNM_STOP_MSG_CYC(nmChannelHandle); #if(CANNM_REMOTE_SLEEP_IND_ENABLED == STD_ON) CANNM_STOP_RMT_SLP_IND_TIMER(nmChannelHandle); #endif #endif } /* BEGIN_FUNCTION_HDR ******************************************************************************** * Function Name: CanNm_NetworkMode * * Description: Called when CanNm enter Network Mode from Bus Sleep Mode or Pre * Bus Sleep Mode. * * Inputs: nmChannelHandle * * Outputs: None * * Limitations: None ******************************************************************************** END_FUNCTION_HDR*/ STATIC FUNC(void, CANNM_CODE) CanNm_NetworkModeEnter ( const NetworkHandleType nmChannelHandle ) { CanNm_Mode[nmChannelHandle] = NM_MODE_NETWORK; /*SWS_CanNm_00314*//*SWS_CanNm_00315*/ CanNm_RptMsgStateEnter(nmChannelHandle, CANNM_NETWORK_MODE_ENTER); /*SWS_CanNm_00096*//*SWS_CanNm_00206*/ CANNM_START_NMTO_TIMER(nmChannelHandle); /*SWS_CanNm_00097*//*SWS_CanNm_00092*//*SWS_CanNm_00093*//*SWS_CanNm_00324*/ Nm_NetworkMode(CANNM_COMM_NETWORK_HANDLE(nmChannelHandle)); } /* BEGIN_FUNCTION_HDR ******************************************************************************** * Function Name: CanNm_PreBusSlpModeEnter * * Description: Called when the NM-Timeout Timer expires in the Ready Sleep State, * the CanNm module shall enter the Prepare Bus-Sleep Mode. * * Inputs: nmChannelHandle * * Outputs: None * * Limitations: None ******************************************************************************** END_FUNCTION_HDR*/ STATIC FUNC(void, CANNM_CODE) CanNm_PreBusSlpModeEnter ( const NetworkHandleType nmChannelHandle ) { /*SWS_CanNm_00166*/ #if(CANNM_STATE_CHANGE_IND_ENABLED == STD_ON) Nm_StateChangeNotification(CANNM_COMM_NETWORK_HANDLE(nmChannelHandle), CanNm_State[nmChannelHandle], \ NM_STATE_PREPARE_BUS_SLEEP); #endif CanNm_State[nmChannelHandle] = NM_STATE_PREPARE_BUS_SLEEP; CanNm_Mode[nmChannelHandle] = NM_MODE_PREPARE_BUS_SLEEP; #if(CANNM_PASSIVE_MODE_ENABLED == STD_OFF) /*SWS_CanNm_00007 AUTOSAR422 if the first transmit request after transition from Bus Sleep to Repeat Message State is not accepted by CanIf, the message request shall be repeated in the next main function until one transmit request is accepted by CanIf.*/ /*Changed: Bus Sleep -> Pre Bus Sleep*/ if(TRUE == CANNM_RETRY_FIRST_MSG_REQ(nmChannelHandle)) { CanNm_MsgTxRptCmd[nmChannelHandle] = CANNM_REPEAT_NULL; } #if(CANNM_REMOTE_SLEEP_IND_ENABLED == STD_ON) CanNm_RmtSlpInd[nmChannelHandle] = FALSE; #endif #endif /*SWS_CanNm_00114*//*SWS_CanNm_00092*//*SWS_CanNm_00093*//*SWS_CanNm_00324*/ Nm_PrepareBusSleepMode(CANNM_COMM_NETWORK_HANDLE(nmChannelHandle)); /*SWS_CanNm_00115*/ CANNM_START_WBS_TIMER(nmChannelHandle); } /* BEGIN_FUNCTION_HDR ******************************************************************************** * Function Name: CanNm_BusSlpModeEnter * * Description: Called when CanNm enter bus sleep mode. * * Inputs: nmChannelHandle * * Outputs: None * * Limitations: None ******************************************************************************** END_FUNCTION_HDR*/ STATIC FUNC(void, CANNM_CODE) CanNm_BusSlpModeEnter ( const NetworkHandleType nmChannelHandle ) { /*SWS_CanNm_00166*/ #if(CANNM_STATE_CHANGE_IND_ENABLED == STD_ON) Nm_StateChangeNotification(CANNM_COMM_NETWORK_HANDLE(nmChannelHandle), CanNm_State[nmChannelHandle], NM_STATE_BUS_SLEEP); #endif #if(CANNM_COORDINATOR_SYNC_SUPPORT == STD_ON) CanNm_SleepReadyBit[nmChannelHandle] = FALSE; #endif CanNm_State[nmChannelHandle] = NM_STATE_BUS_SLEEP; CanNm_Mode[nmChannelHandle] = NM_MODE_BUS_SLEEP; /*SWS_CanNm_00126*//*SWS_CanNm_00092*//*SWS_CanNm_00093*//*SWS_CanNm_00324*/ Nm_BusSleepMode(CANNM_COMM_NETWORK_HANDLE(nmChannelHandle)); } #if(CANNM_PASSIVE_MODE_ENABLED == STD_OFF) /* BEGIN_FUNCTION_HDR ******************************************************************************** * Function Name: CanNm_ClrRptMsgBit * * Description: Used to clear the Repeat Message Request Bit. * * Inputs: nmChannelHandle * * Outputs: None * * Limitations: None ******************************************************************************** END_FUNCTION_HDR*/ STATIC FUNC(void, CANNM_CODE) CanNm_ClrRptMsgBit ( const NetworkHandleType nmChannelHandle ) { if(CANNM_PDU_OFF != CANNM_PDU_CBV_POS(nmChannelHandle)) { (CanNm_TxPduBuff[nmChannelHandle][CANNM_PDU_CBV_POS(nmChannelHandle)]) &= (uint8)(~CANNM_CBV_RMR_MASK); } } /* BEGIN_FUNCTION_HDR ******************************************************************************** * Function Name: CanNm_SetRptMsgBit * * Description: Used to set Repeat Message Request Bit. * * Inputs: nmChannelHandle * * Outputs: None * * Limitations: None ******************************************************************************** END_FUNCTION_HDR*/ STATIC FUNC(void, CANNM_CODE) CanNm_SetRptMsgBit ( const NetworkHandleType nmChannelHandle ) { if(CANNM_PDU_OFF != CANNM_PDU_CBV_POS(nmChannelHandle)) { CanNm_TxPduBuff[nmChannelHandle][CANNM_PDU_CBV_POS(nmChannelHandle)] |= CANNM_CBV_RMR_MASK; } } /* BEGIN_FUNCTION_HDR ******************************************************************************** * Function Name: CanNm_SetNodeId * * Description: Set the source node identifier with the configuration parameter * CanNmNodeId unless CanNmPduNidPosition is set to off. * * Inputs: nmChannelHandle * * Outputs: None * * Limitations: None ******************************************************************************** END_FUNCTION_HDR*/ STATIC FUNC(void, CANNM_CODE) CanNm_SetNodeId ( const NetworkHandleType nmChannelHandle ) { /*SWS_CanNm_00013*/ if(CANNM_PDU_OFF != CANNM_PDU_NID_POS(nmChannelHandle)) { CanNm_TxPduBuff[nmChannelHandle][CANNM_PDU_NID_POS(nmChannelHandle)] = CANNM_NODE_ID(nmChannelHandle); } } /* BEGIN_FUNCTION_HDR ******************************************************************************** * Function Name: CanNm_ClrActiveWakeupBit * * Description: Clear the active wakeup bit. * * Inputs: nmChannelHandle * * Outputs: None * * Limitations: None ******************************************************************************** END_FUNCTION_HDR*/ STATIC FUNC(void, CANNM_CODE) CanNm_ClrActiveWakeupBit ( const NetworkHandleType nmChannelHandle ) { if(CANNM_PDU_OFF != CANNM_PDU_CBV_POS(nmChannelHandle)) { (CanNm_TxPduBuff[nmChannelHandle][CANNM_PDU_CBV_POS(nmChannelHandle)]) &= (uint8)(~CANNM_CBV_ACTIVE_WU_MASK); } } /* BEGIN_FUNCTION_HDR ******************************************************************************** * Function Name: CanNm_SetActiveWakeupBit * * Description: Set the active wakeup bit. * * Inputs: nmChannelHandle * * Outputs: None * * Limitations: None ******************************************************************************** END_FUNCTION_HDR*/ STATIC FUNC(void, CANNM_CODE) CanNm_SetActiveWakeupBit ( const NetworkHandleType nmChannelHandle ) { if(CANNM_PDU_OFF != CANNM_PDU_CBV_POS(nmChannelHandle)) { CanNm_TxPduBuff[nmChannelHandle][CANNM_PDU_CBV_POS(nmChannelHandle)] |= CANNM_CBV_ACTIVE_WU_MASK; } } #if(CANNM_COORDINATOR_SYNC_SUPPORT == STD_ON) /* BEGIN_FUNCTION_HDR ******************************************************************************** * Function Name: CanNm_CheckSleepReadyBit * * Description: Called in CanNm_RxIndication() to check if received Sleep Ready * Bit with 1. * * Inputs: nmChannelHandle * * Outputs: None * * Limitations: None ******************************************************************************** END_FUNCTION_HDR*/ STATIC FUNC(void, CANNM_CODE) CanNm_CheckSleepReadyBit ( const NetworkHandleType nmChannelHandle ) { if((uint8)0 != ((CanNm_RxPduBuff[nmChannelHandle][CANNM_PDU_CBV_POS(nmChannelHandle)]) & CANNM_CBV_SLEEP_READY_BIT_MASK)) { if((NM_MODE_NETWORK == CanNm_Mode[nmChannelHandle]) && (FALSE == CanNm_SleepReadyBit[nmChannelHandle])) { CanNm_SleepReadyBit[nmChannelHandle] = TRUE; /*SWS_CanNm_00341*//*SWS_CanNm_00325*/ Nm_CoordReadyToSleepIndication(CANNM_COMM_NETWORK_HANDLE(nmChannelHandle)); } } else { if((NM_MODE_NETWORK == CanNm_Mode[nmChannelHandle]) && (TRUE == CanNm_SleepReadyBit[nmChannelHandle])) { CanNm_SleepReadyBit[nmChannelHandle] = FALSE; /*SWS_CanNm_00348*//*SWS_CanNm_00325*/ Nm_CoordReadyToSleepCancellation(CANNM_COMM_NETWORK_HANDLE(nmChannelHandle)); } } } #endif /* BEGIN_FUNCTION_HDR ******************************************************************************** * Function Name: CanNm_TxPduMainFunction * * Description: Main function to transmit the NM PDU. * * Inputs: nmChannelHandle * * Outputs: None * * Limitations: None ******************************************************************************** END_FUNCTION_HDR*/ STATIC FUNC(void, CANNM_CODE) CanNm_TxPduMainFunction ( const NetworkHandleType nmChannelHandle ) { Std_ReturnType ret; if((TRUE == CanNm_TxReqFlg[nmChannelHandle]) || (CANNM_REPEAT_CFM == CanNm_MsgTxRptCmd[nmChannelHandle]) #if(STD_ON == CANNM_SYNC_PNC_SHUTDOWN_SUPPORT) || (TRUE == CanNm_SyncPncShutdownPending[nmChannelHandle]) #endif ) { #if(CANNM_COM_CONTROL_ENABLED == STD_ON) if(TRUE == CanNm_ComTxEnabled[nmChannelHandle]) #endif { #if(STD_ON == CANNM_GLOBAL_PN_SUPPORT) CanNm_UpdateTxPduPnData(nmChannelHandle); #endif/*(STD_ON == CANNM_GLOBAL_PN_SUPPORT)*/ #if((STD_ON == CANNM_COM_USER_DATA_SUPPORT) || (STD_ON == CANNM_USER_DATA_ENABLED)) CanNm_UpdateTxPduUserData(nmChannelHandle); #endif SchM_Enter_CanNm_CANNM_EXCLUSIVE_AREA_1(); /*SWS_CanNm_00325*/ ret = CanIf_Transmit(CANNM_TX_PDU_ID(nmChannelHandle), &CanNm_TxPdu[nmChannelHandle]); SchM_Exit_CanNm_CANNM_EXCLUSIVE_AREA_1(); if(E_OK == ret) { /*SWS_CanNm_00071*/ #if(CANNM_IMMEDIATE_TXCONF_ENABLED == STD_ON) CanNm_TxCfmFlg[nmChannelHandle] = TRUE; /*SWS_CanNm_00073*/ #else /*SWS_CanNm_00064*/ CANNM_START_TXTO_TIMER(nmChannelHandle); #endif } else { /*SWS_CanNm_00335*/ if(CanNm_ImmTrans[nmChannelHandle] > (uint8)0) { CANNM_TX_PDU_REQ(nmChannelHandle); } } /*SWS_CanNm_00007 AUTOSAR422 if the first transmit request after transition from Bus Sleep to Repeat Message State is not accepted by CanIf, the message request shall be repeated in the next main function until one transmit request is accepted by CanIf.*/ /*Changed: Bus Sleep -> Pre Bus Sleep*/ if(TRUE == CANNM_RETRY_FIRST_MSG_REQ(nmChannelHandle)) { if((CANNM_REPEAT_PENDING == CanNm_MsgTxRptCmd[nmChannelHandle]) \ || (CANNM_REPEAT_CFM == CanNm_MsgTxRptCmd[nmChannelHandle])) { if(E_NOT_OK == ret) { CanNm_MsgTxRptCmd[nmChannelHandle] = CANNM_REPEAT_CFM; } else { CanNm_MsgTxRptCmd[nmChannelHandle] = CANNM_REPEAT_SUCCESS; } } } } /*SWS_CanNm_00460*/ #if(STD_ON == CANNM_SYNC_PNC_SHUTDOWN_SUPPORT) if(TRUE == CanNm_SyncPncShutdownPending[nmChannelHandle]) { CanNm_ClearPendingShutdownPnc(nmChannelHandle); } else #endif { CanNm_TxReqFlg[nmChannelHandle] = FALSE; } } } #if((STD_ON == CANNM_COM_USER_DATA_SUPPORT) || (STD_ON == CANNM_USER_DATA_ENABLED)) /* BEGIN_FUNCTION_HDR ******************************************************************************** * Function Name: CanNm_UpdateTxPduUserData * * Description: Called before sending an NM PDU to update user data. * * Inputs: nmChannelHandle * * Outputs: None * * Limitations: None ******************************************************************************** END_FUNCTION_HDR*/ STATIC FUNC(void, CANNM_CODE) CanNm_UpdateTxPduUserData ( const NetworkHandleType nmChannelHandle ) { Std_ReturnType ret; #if(STD_ON == CANNM_COM_USER_DATA_SUPPORT) PduInfoType TriggerTxInfo; #endif uint8 TriggerData[CANNM_MAX_TX_PDU_LENGTH]; uint8* DestDataPtr; uint8 DataLen; /*At most one of the configuration parameters CanNmComUserDataSupport and CanNmUserDataEnabled can be true.*/ #if(STD_ON == CANNM_COM_USER_DATA_SUPPORT) /*SWS_CanNm_00328*/ TriggerTxInfo.SduDataPtr = TriggerData; TriggerTxInfo.SduLength = CANNM_MAX_TX_PDU_LENGTH; ret = PduR_LoIfTriggerTransmit(CANNM_TX_USERDATA_PDU_REF(nmChannelHandle), &TriggerTxInfo); #endif #if(STD_ON == CANNM_USER_DATA_ENABLED) ret = CanNm_UserData_TriggerTransmit_Callout(nmChannelHandle, TriggerData); #endif if(ret == E_OK) { DestDataPtr = &(CanNm_TxPdu[nmChannelHandle].SduDataPtr[CANNM_USER_DATA_OFS(nmChannelHandle)]); DataLen = CANNM_USER_DATA_LEN(nmChannelHandle); SchM_Enter_CanNm_CANNM_EXCLUSIVE_AREA_1(); Bsw_MemCpy(DestDataPtr, TriggerData, DataLen); SchM_Exit_CanNm_CANNM_EXCLUSIVE_AREA_1(); } else { /*SWS_CanNm_00450 CanNm shall use the last transmitted value for NmUserData.*/ } } #endif #endif/*#if(CANNM_PASSIVE_MODE_ENABLED == STD_OFF)*/ #if(STD_ON == CANNM_GLOBAL_PN_SUPPORT) /* BEGIN_FUNCTION_HDR ******************************************************************************** * Function Name: CanNm_ClrTxPduPnBit * * Description: Called before sending an NM PDU to clear the PN bit in CBV byte. * * Inputs: nmChannelHandle * * Outputs: None * * Limitations: None ******************************************************************************** END_FUNCTION_HDR*/ STATIC FUNC(void, CANNM_CODE) CanNm_ClrTxPduPnBit ( const NetworkHandleType nmChannelHandle ) { if(CANNM_PDU_OFF != CANNM_PDU_CBV_POS(nmChannelHandle)) { (CanNm_TxPduBuff[nmChannelHandle][CANNM_PDU_CBV_POS(nmChannelHandle)]) &= (uint8)(~CANNM_CBV_PN_MASK); } } /* BEGIN_FUNCTION_HDR ******************************************************************************** * Function Name: CanNm_SetTxPduPnBit * * Description: Called before sending an NM PDU to set the PN bit in CBV byte. * * Inputs: nmChannelHandle * * Outputs: None * * Limitations: None ******************************************************************************** END_FUNCTION_HDR*/ STATIC FUNC(void, CANNM_CODE) CanNm_SetTxPduPnBit ( const NetworkHandleType nmChannelHandle ) { if(CANNM_PDU_OFF != CANNM_PDU_CBV_POS(nmChannelHandle)) { CanNm_TxPduBuff[nmChannelHandle][CANNM_PDU_CBV_POS(nmChannelHandle)] |= CANNM_CBV_PN_MASK; } } /* BEGIN_FUNCTION_HDR ******************************************************************************** * Function Name: CanNm_UpdateTxPduPnData * * Description: Called before sending an NM PDU to update the pn related bit and data. * * Inputs: nmChannelHandle * * Outputs: None * * Limitations: None ******************************************************************************** END_FUNCTION_HDR*/ STATIC FUNC(void, CANNM_CODE) CanNm_UpdateTxPduPnData ( const NetworkHandleType nmChannelHandle ) { uint8 DataLen; uint8* DestDataPtr = NULL_PTR; /*SWS_CanNm_00506*/ if(TRUE == CANNM_PN_ENABLED(nmChannelHandle)) { /*SWS_CanNm_00413*/ CanNm_SetTxPduPnBit(nmChannelHandle); DestDataPtr = &(CanNm_TxPdu[nmChannelHandle].SduDataPtr[CANNM_PNC_BIT_VECTOR_OFFSET]); #if(STD_ON == CANNM_SYNC_PNC_SHUTDOWN_SUPPORT) if(TRUE == CanNm_SyncPncShutdownPending[nmChannelHandle]) { CanNm_SetTxPduPnsrBit(nmChannelHandle); DataLen = CANNM_PNC_BIT_VECTOR_LEN(nmChannelHandle); SchM_Enter_CanNm_CANNM_EXCLUSIVE_AREA_1(); Bsw_MemCpy(DestDataPtr, (CanNm_SyncPncShutdownPnInfo[nmChannelHandle]), DataLen); SchM_Exit_CanNm_CANNM_EXCLUSIVE_AREA_1(); } else { CanNm_ClrTxPduPnsrBit(nmChannelHandle); #endif /*SWS_CanNm_00505*/ Nm_PncBitVectorTxIndication(CANNM_COMM_NETWORK_HANDLE(nmChannelHandle), DestDataPtr); #if(STD_ON == CANNM_SYNC_PNC_SHUTDOWN_SUPPORT) } #endif } else { /*SWS_CanNm_00414*/ CanNm_ClrTxPduPnBit(nmChannelHandle); } } #if(STD_ON == CANNM_SYNC_PNC_SHUTDOWN_SUPPORT) /* BEGIN_FUNCTION_HDR ******************************************************************************** * Function Name: CanNm_ClrTxPduPnsrBit * * Description: Called before sending an NM PDU to clear the PNSR bit in CBV byte. * * Inputs: nmChannelHandle * * Outputs: None * * Limitations: None ******************************************************************************** END_FUNCTION_HDR*/ STATIC FUNC(void, CANNM_CODE) CanNm_ClrTxPduPnsrBit ( const NetworkHandleType nmChannelHandle ) { if(CANNM_PDU_OFF != CANNM_PDU_CBV_POS(nmChannelHandle)) { CanNm_TxPduBuff[nmChannelHandle][CANNM_PDU_CBV_POS(nmChannelHandle)] &= (uint8)(~CANNM_CBV_PN_SHUTDOWN_REQ_MASK); } } /* BEGIN_FUNCTION_HDR ******************************************************************************** * Function Name: CanNm_SetTxPduPnsrBit * * Description: Called before sending an NM PDU to set the PNSR bit in CBV byte. * * Inputs: nmChannelHandle * * Outputs: None * * Limitations: None ******************************************************************************** END_FUNCTION_HDR*/ STATIC FUNC(void, CANNM_CODE) CanNm_SetTxPduPnsrBit ( const NetworkHandleType nmChannelHandle ) { if(CANNM_PDU_OFF != CANNM_PDU_CBV_POS(nmChannelHandle)) { CanNm_TxPduBuff[nmChannelHandle][CANNM_PDU_CBV_POS(nmChannelHandle)] |= CANNM_CBV_PN_SHUTDOWN_REQ_MASK; } } /* BEGIN_FUNCTION_HDR ******************************************************************************** * Function Name: CanNm_ClearPendingShutdownPnc * * Description: Used to clear PNCs record that request synchronous shutdown from * CanNm_RequestSynchronizedPncShutdown function. * * Inputs: nmChannelHandle * * Outputs: None * * Limitations: None ******************************************************************************** END_FUNCTION_HDR*/ STATIC FUNC(void, CANNM_CODE) CanNm_ClearPendingShutdownPnc ( const NetworkHandleType nmChannelHandle ) { uint8 i; CanNm_SyncPncShutdownPending[nmChannelHandle] = FALSE; for(i = (uint8)0; i < CANNM_PNC_BIT_VECTOR_MAX_LEN; i++) { CanNm_SyncPncShutdownPnInfo[nmChannelHandle][i] = (uint8)0; } } #endif/*#if(STD_ON == CANNM_SYNC_PNC_SHUTDOWN_SUPPORT)*/ #endif/*(STD_ON == CANNM_GLOBAL_PN_SUPPORT)*/ #if(STD_ON == CANNM_CAR_WAKEUP_ENABLED) /* BEGIN_FUNCTION_HDR ******************************************************************************** * Function Name: CanNm_CarWakeupRxCheck * * Description: This function is called in the CanNm_RxIndication function to check * the CarWakeup flag bit and node ID in the received message. * * Inputs: nmChannelHandle, PduInfoPtr * * Outputs: None * * Limitations: None ******************************************************************************** END_FUNCTION_HDR*/ STATIC FUNC(boolean, CANNM_CODE) CanNm_CarWakeupRxCheck ( const NetworkHandleType nmChannelHandle, P2CONST(PduInfoType, AUTOMATIC, CANNM_APPL_DATA) PduInfoPtr ) { uint8 CarWakeupByteValue; uint8 CarWakeupNodeId; boolean DropRxPduFlag = TRUE; if(TRUE == CANNM_CWU_RX_ENABLED(nmChannelHandle)) { CarWakeupByteValue = (PduInfoPtr->SduDataPtr[CANNM_WU_BYTE_POS(nmChannelHandle)]); if((uint8)0 != (CarWakeupByteValue & ((uint8)1 << CANNM_WU_BIT_POS(nmChannelHandle)))) { CarWakeupNodeId = (PduInfoPtr->SduDataPtr[CANNM_PDU_NID_POS(nmChannelHandle)]); if((FALSE == CANNM_CWU_FILTER_ENABLED(nmChannelHandle)) || (CarWakeupNodeId == CANNM_CWU_FILTER_NODE_ID(nmChannelHandle))) { /*SWS_CanNm_00406*//*SWS_CanNm_00408*/ DropRxPduFlag = FALSE; } } } else { DropRxPduFlag = FALSE; } return DropRxPduFlag; } #endif #if(STD_ON == CANNM_GLOBAL_PN_SUPPORT) /* BEGIN_FUNCTION_HDR ******************************************************************************** * Function Name: CanNm_PnInfoRxCheck * * Description: This function is called in the CanNm_RxIndication function to check * the PNI bit and PNSR bit and call the corresponding Nm module function. * * Inputs: nmChannelHandle, PduInfoPtr * * Outputs: None * * Limitations: None ******************************************************************************** END_FUNCTION_HDR*/ STATIC FUNC(boolean, CANNM_CODE) CanNm_PnInfoRxCheck ( const NetworkHandleType nmChannelHandle, P2CONST(PduInfoType, AUTOMATIC, CANNM_APPL_DATA) PduInfoPtr ) { uint8 Rx_CBV; boolean DropRxPduFlag = TRUE; boolean RelevantPncRequestDetected = FALSE; if(TRUE == CANNM_PN_ENABLED(nmChannelHandle)) { Rx_CBV = (PduInfoPtr->SduDataPtr[CANNM_PDU_CBV_POS(nmChannelHandle)]); /*SWS_CanNm_00411*/ if((Rx_CBV & CANNM_CBV_PN_MASK) == CANNM_CBV_PN_MASK) { if((Rx_CBV & CANNM_CBV_PN_SHUTDOWN_REQ_MASK) == (uint8)0) { /*SWS_CanNm_00502*/ Nm_PncBitVectorRxIndication(CANNM_COMM_NETWORK_HANDLE(nmChannelHandle), \ &(PduInfoPtr->SduDataPtr[CANNM_PNC_BIT_VECTOR_OFFSET]), &RelevantPncRequestDetected); /*SWS_CanNm_00503*/ if(FALSE == CanNm_PnFilterEnable[nmChannelHandle]) { RelevantPncRequestDetected = TRUE; } } #if(STD_ON == CANNM_SYNC_PNC_SHUTDOWN_SUPPORT) else { if(TRUE == CANNM_SYNC_PN_SHUTDOWN_EN(nmChannelHandle)) { /*SWS_CanNm_00504*/ Nm_ForwardSynchronizedPncShutdown(CANNM_COMM_NETWORK_HANDLE(nmChannelHandle), \ &(PduInfoPtr->SduDataPtr[CANNM_PNC_BIT_VECTOR_OFFSET])); DropRxPduFlag = FALSE; } } #endif } if((TRUE == CANNM_ALL_NMMSG_KEEP_AWAKE(nmChannelHandle)) || (TRUE == RelevantPncRequestDetected)) { /*SWS_CanNm_00410*//*SWS_CanNm_00503*/ DropRxPduFlag = FALSE; } } else { /*SWS_CanNm_00409*/ DropRxPduFlag = FALSE; } return DropRxPduFlag; } #endif #define CANNM_STOP_SEC_CODE #include "CanNm_MemMap.h"