/** @req COMM429 */
void ComM_MainFunction(NetworkHandleType Channel) {
const ComM_ChannelType* ChannelConf = &ComM_Config->Channels[Channel];
ComM_Internal_ChannelType* ChannelInternal = &ComM_Internal.Channels[Channel];
if ((ChannelConf->NmVariant == COMM_NM_VARIANT_NONE) ||
(ChannelConf->NmVariant == COMM_NM_VARIANT_LIGHT)) {
Std_ReturnType status = ComM_Internal_TickFullComMinTime(ChannelConf, ChannelInternal);
if (status != E_OK) {
// IMPROVEMENT: Report DET error?
}
}
if (ChannelConf->NmVariant == COMM_NM_VARIANT_LIGHT) {
Std_ReturnType status = ComM_Internal_TickLightTime(ChannelConf, ChannelInternal);
if (status != E_OK) {
// IMPROVEMENT: Report DET error?
}
}
if (ChannelInternal->Mode == COMM_NO_COMMUNICATION &&
ChannelInternal->SubMode == COMM_NO_COM_REQUEST_PENDING )
{
Std_ReturnType status = ComM_Internal_UpdateChannelState(ChannelConf, FALSE);
if (status != E_OK) {
// IMPROVEMENT: Report DET error?
}
}
}
void ComM_DCM_InactiveDiagnostic(NetworkHandleType Channel){
COMM_VALIDATE_INIT_NORV(COMM_SERVICEID_DCM_INACTIVEDIAGNOSTIC);
COMM_VALIDATE_CHANNEL_NORV(Channel, COMM_SERVICEID_DCM_INACTIVEDIAGNOSTIC);
const ComM_ChannelType* ChannelConf = &ComM_Config->Channels[Channel];
ComM_Internal.Channels[Channel].DCM_Requested = FALSE;
/* IMPROVEMENT: Report DET error if returning error */
(void)ComM_Internal_UpdateChannelState(ChannelConf, FALSE);
}
static inline Std_ReturnType ComM_Internal_TickFullComMinTime(const ComM_ChannelType* ChannelConf, ComM_Internal_ChannelType* ChannelInternal) {
Std_ReturnType status = E_OK;
if (ChannelInternal->Mode == COMM_FULL_COMMUNICATION) {
if (ChannelConf->MainFunctionPeriod >= ChannelInternal->FullComMinDurationTimeLeft) {
ChannelInternal->FullComMinDurationTimeLeft = 0;
status = ComM_Internal_UpdateChannelState(ChannelConf, FALSE);
} else {
ChannelInternal->FullComMinDurationTimeLeft -= ChannelConf->MainFunctionPeriod;
}
}
return status;
}
/** @req COMM392 */
void ComM_Nm_BusSleepMode( NetworkHandleType Channel ){
COMM_VALIDATE_INIT_NORV(COMM_SERVICEID_NM_BUSSLEEPMODE); /** @req COMM810 */
COMM_VALIDATE_CHANNEL_NORV(Channel, COMM_SERVICEID_NM_BUSSLEEPMODE);
const ComM_ChannelType* ChannelConf = &ComM_Config->Channels[Channel];
ComM_Internal_ChannelType* ChannelInternal = &ComM_Internal.Channels[Channel];
ChannelInternal->NmIndicationMask |= COMM_NM_INDICATION_BUS_SLEEP;
Std_ReturnType status = ComM_Internal_UpdateChannelState(ChannelConf, FALSE);
if (status != E_OK) {
// IMPROVEMENT: Report DET error?
}
}
static inline Std_ReturnType ComM_Internal_TickLightTime(const ComM_ChannelType* ChannelConf, ComM_Internal_ChannelType* ChannelInternal) {
Std_ReturnType status = E_OK;
if ((ChannelInternal->Mode == COMM_FULL_COMMUNICATION) &&
(ChannelInternal->SubMode == COMM_SUBMODE_READY_SLEEP)) {
if (ChannelConf->MainFunctionPeriod >= ChannelInternal->LightTimeoutTimeLeft) {
ChannelInternal->LightTimeoutTimeLeft = 0;
status = ComM_Internal_UpdateChannelState(ChannelConf, FALSE);
} else {
ChannelInternal->LightTimeoutTimeLeft -= ChannelConf->MainFunctionPeriod;
}
}
return status;
}
/** @req COMM792 */
void ComM_Nm_RestartIndication( NetworkHandleType Channel ){
COMM_VALIDATE_INIT_NORV(COMM_SERVICEID_NM_RESTARTINDICATION); /** @req COMM812 */
COMM_VALIDATE_CHANNEL_NORV(Channel, COMM_SERVICEID_NM_RESTARTINDICATION);
const ComM_ChannelType* ChannelConf = &ComM_Config->Channels[Channel];
ComM_Internal_ChannelType* ChannelInternal = &ComM_Internal.Channels[Channel];
ChannelInternal->NmIndicationMask |= COMM_NM_INDICATION_RESTART;
Std_ReturnType status = ComM_Internal_UpdateChannelState(ChannelConf, TRUE);
if (status != E_OK) {
// IMPROVEMENT: Report DET error?
}
}
/** @req COMM383 */
void ComM_Nm_NetworkStartIndication( NetworkHandleType Channel ){
COMM_VALIDATE_INIT_NORV(COMM_SERVICEID_NM_NETWORKSTARTINDICATION); /** @req COMM805 */
COMM_VALIDATE_CHANNEL_NORV(Channel, COMM_SERVICEID_NM_NETWORKSTARTINDICATION);
const ComM_ChannelType* ChannelConf = &ComM_Config->Channels[Channel];
ComM_Internal_ChannelType* ChannelInternal = &ComM_Internal.Channels[Channel];
// Used to simulate Wake-up
ChannelInternal->NmIndicationMask |= COMM_NM_INDICATION_RESTART;
Std_ReturnType status = ComM_Internal_UpdateChannelState(ChannelConf, FALSE);
if (status != E_OK) {
// IMPROVMENT: Add DET error
}
}
/** @req COMM800.partially */
Std_ReturnType ComM_LimitChannelToNoComMode( NetworkHandleType Channel, boolean Status ){
COMM_VALIDATE_INIT(COMM_SERVICEID_LIMITCHANNELTONOCOMMODE);
COMM_VALIDATE_CHANNEL(Channel, COMM_SERVICEID_LIMITCHANNELTONOCOMMODE);
#if (COMM_MODE_LIMITATION_ENABLED == STD_ON)
const ComM_ChannelType* ChannelConf = &ComM_Config->Channels[Channel];
ComM_Internal_ChannelType* ChannelInternal = &ComM_Internal.Channels[Channel];
if (Status) {
ChannelInternal->InhibitionStatus |= (COMM_INHIBITION_STATUS_NO_COMMUNICATION);
} else {
ChannelInternal->InhibitionStatus &= ~(COMM_INHIBITION_STATUS_NO_COMMUNICATION);
}
return ComM_Internal_UpdateChannelState(ChannelConf, FALSE);
#else
(void)Status; /* Avoid compiler warning */
return E_NOT_OK;
#endif
}
/** @req COMM429 */
void ComM_MainFunction(NetworkHandleType Channel) {
const ComM_ChannelType* ChannelConf = &ComM_Config->Channels[Channel];
ComM_Internal_ChannelType* ChannelInternal = &ComM_Internal.Channels[Channel];
Std_ReturnType status = ComM_Internal_UpdateChannelState(ChannelConf, TRUE);
if ((ChannelConf->NmVariant == COMM_NM_VARIANT_NONE) ||
(ChannelConf->NmVariant == COMM_NM_VARIANT_LIGHT)) {
status = ComM_Internal_TickFullComMinTime(ChannelConf, ChannelInternal);
}
if (ChannelConf->NmVariant == COMM_NM_VARIANT_LIGHT) {
status = ComM_Internal_TickLightTime(ChannelConf, ChannelInternal);
}
if (status != E_OK) {
// Report error?
}
}
/** @req COMM801.partially */
Std_ReturnType ComM_LimitECUToNoComMode( boolean Status ){
COMM_VALIDATE_INIT(COMM_SERVICEID_LIMITECUTONOCOMMODE);
#if (COMM_MODE_LIMITATION_ENABLED == STD_ON)
ComM_Internal.NoCommunication = Status;
uint8 Channel;
Std_ReturnType totalStatus = E_OK;
for (Channel = 0; Channel < COMM_CHANNEL_COUNT; Channel++) {
const ComM_ChannelType* ChannelConf = &ComM_Config->Channels[Channel];
Std_ReturnType status = ComM_Internal_UpdateChannelState(ChannelConf, FALSE);
if (status > totalStatus) {
totalStatus = status;
}
}
return totalStatus;
#else
(void)Status; /* Avoid compiler warning */
return E_NOT_OK;
#endif
}
static Std_ReturnType ComM_Internal_RequestComMode(
ComM_UserHandleType User, ComM_ModeType ComMode ){
const ComM_UserType* UserConfig = &ComM_Config->Users[User]; /** @req COMM795 */
ComM_Internal_UserType* UserInternal = &ComM_Internal.Users[User];
UserInternal->RequestedMode = ComMode; /**< @req COMM500 @req COMM92 */
uint32 userMask = (1LU << User);
Std_ReturnType requestStatus = E_OK;
/* Go through users channels. Relay to SMs. Collect overall success status */
for (uint8 i = 0; i < UserConfig->ChannelCount; ++i) {
const ComM_ChannelType* Channel = UserConfig->ChannelList[i];
ComM_Internal_ChannelType* ChannelInternal = &ComM_Internal.Channels[Channel->Number];
/** @req COMM625 */
// Put user request into mask
if (ComMode == COMM_NO_COMMUNICATION) {
ChannelInternal->UserRequestMask &= ~(userMask);
} else if (ComMode == COMM_FULL_COMMUNICATION) {
ChannelInternal->UserRequestMask |= userMask; /** @req COMM839 */
} else {
//Nothing to be done.
}
// take request -> new state
Std_ReturnType status = ComM_Internal_UpdateChannelState(Channel, TRUE);
if (status > requestStatus){
requestStatus = status;
}
}
return requestStatus;
}
