boolean EcuM_ComM_HasRequestedRUN(NetworkHandleType channel)
{
VALIDATE_RV(EcuM_World.initiated, ECUM_COMM_HASREQUESTEDRUN_ID, ECUM_E_NOT_INITIATED, FALSE);
VALIDATE_RV(channel < 32, ECUM_COMM_HASREQUESTEDRUN_ID, ECUM_E_INVALID_PAR, FALSE);
return (EcuM_World.run_comm_requests &((uint32)1 << channel)) != 0;
}
Std_ReturnType EcuM_GetState(EcuM_StateType* state) {
VALIDATE_RV(EcuM_World.initiated, ECUM_GETSTATE_ID, ECUM_E_NOT_INITIATED, E_NOT_OK);VALIDATE_RV(state != NULL, ECUM_GETSTATE_ID, ECUM_E_NULL_POINTER, E_NOT_OK);
*state = EcuM_World.current_state;
return E_OK;
}
Std_ReturnType EcuM_ReleasePOST_RUN(EcuM_UserType user) {
VALIDATE_RV(EcuM_World.initiated, ECUM_RELEASEPOSTRUN_ID, ECUM_E_NOT_INITIATED, E_NOT_OK);
VALIDATE_RV(user < ECUM_USER_ENDMARK, ECUM_RELEASEPOSTRUN_ID, ECUM_E_INVALID_PAR, E_NOT_OK);
EcuM_World.postrun_requests &= ~((uint32) 1 << user);
return E_OK;
}
/**
*
* @param user
* @return
*/
Std_ReturnType EcuM_ComM_ReleaseRUN(NetworkHandleType channel)
{
VALIDATE_RV(EcuM_World.initiated, ECUM_COMM_RELEASERUN_ID, ECUM_E_NOT_INITIATED, E_NOT_OK);
VALIDATE_RV(channel < 32, ECUM_COMM_RELEASERUN_ID, ECUM_E_INVALID_PAR, E_NOT_OK);
EcuM_World.run_comm_requests &= ~((uint32)1 << channel);
return E_OK;
}
Std_ReturnType EcuM_RequestPOST_RUN(EcuM_UserType user) {
VALIDATE_RV(EcuM_World.initiated, ECUM_REQUESTPOSTRUN_ID, ECUM_E_NOT_INITIATED, E_NOT_OK);
VALIDATE_RV(user < ECUM_USER_ENDMARK, ECUM_REQUESTPOSTRUN_ID, ECUM_E_INVALID_PAR, E_NOT_OK);
if( !EcuM_World.killAllRequest ) {
EcuM_World.postrun_requests |= (uint32) 1 << user;
}
return E_OK;
}
/** @req SOAD091 */
Std_ReturnType SoAdIf_Transmit(PduIdType SoAdSrcPduId, const PduInfoType* SoAdSrcPduInfoPtr)
{
Std_ReturnType returnCode = E_OK;
uint16 socketNr;
VALIDATE_RV(ModuleStatus != SOAD_UNINITIALIZED, SOAD_IF_TRANSMIT_ID, SOAD_E_NOTINIT, E_NOT_OK); /** @req SOAD213 *//** @req SOAD217 */
VALIDATE_RV(SoAdSrcPduInfoPtr != NULL, SOAD_IF_TRANSMIT_ID, SOAD_E_NULL_PTR, E_NOT_OK); /** @req SOAD235 */
VALIDATE_RV(SoAdSrcPduId < SOAD_PDU_ROUTE_COUNT, SOAD_IF_TRANSMIT_ID, SOAD_E_INVAL, E_NOT_OK); /** @req SOAD214 */
// pi_printf("infor: SoAdIf = ");mini_uart_sendDec(*SoAdSrcPduInfoPtr->SduDataPtr);pi_printf("\r\n");
if (SoAd_Config.PduRoute[SoAdSrcPduId].SourceSduLength == SoAdSrcPduInfoPtr->SduLength) {
// pi_printf("infor: SoAd1\r\n");
if (PduAdminList[SoAdSrcPduId].PduStatus == PDU_IDLE ) {
// pi_printf("infor: SoAd2\r\n");
if (SoAd_Config.PduRoute[SoAdSrcPduId].DestinationSocketRef != NULL ) {
// pi_printf("infor: SoAd3\r\n");
socketNr = SoAd_Config.PduRoute[SoAdSrcPduId].DestinationSocketRef->SocketId;
if ((SocketAdminList[socketNr].SocketState == SOCKET_TCP_LISTENING)
|| (SocketAdminList[socketNr].SocketState == SOCKET_TCP_READY)
|| (SocketAdminList[socketNr].SocketState == SOCKET_UDP_READY)) {
PduAdminList[SoAdSrcPduId].PduStatus = PDU_IF_SENDING;
// pi_printf("infor: SoAdIp = ");mini_uart_sendDec(*SoAdSrcPduInfoPtr->SduDataPtr);pi_printf("\r\n");
SoAd_SendIpMessage(socketNr, SoAdSrcPduInfoPtr->SduLength, SoAdSrcPduInfoPtr->SduDataPtr);
switch (SoAd_Config.PduRoute[SoAdSrcPduId].UserTxConfirmationUL)
{
#if defined(USE_UDPNM)
case SOAD_UL_UDPNM:
UdpNm_SoAdIfTxConfirmation(SoAd_Config.PduRoute[SoAdSrcPduId].SourcePduId);
break;
#endif
default:
PduR_SoAdIfTxConfirmation(SoAd_Config.PduRoute[SoAdSrcPduId].SourcePduId);
break;
}
PduAdminList[SoAdSrcPduId].PduStatus = PDU_IDLE;
} else {
/* Socket not ready */
returnCode = E_NOT_OK;
}
} else {
/* SocketAdminRef is NULL */
returnCode = E_NOT_OK;
}
} else {
/* A PDU is already in progress */
returnCode = E_NOT_OK;
}
} else {
/* Attached length and length from PduRoutingTable does not match */
returnCode = E_NOT_OK;
}
return returnCode;
}
/**
*
* @param user
* @return
*/
Std_ReturnType EcuM_ComM_RequestRUN(NetworkHandleType channel)
{
VALIDATE_RV(EcuM_World.initiated, ECUM_COMM_REQUESTRUN_ID, ECUM_E_NOT_INITIATED, E_NOT_OK);
VALIDATE_RV(channel < 32, ECUM_COMM_REQUESTRUN_ID, ECUM_E_INVALID_PAR, E_NOT_OK);
if( !EcuM_World.killAllRequest ) {
EcuM_World.run_comm_requests |= (uint32)1 << channel;
}
return E_OK;
}
Dio_PortLevelType Dio_ReadPort(Dio_PortType portId)
{
Dio_PortLevelType level = 0;
VALIDATE_RV( DioGlobal.InitRun, DIO_READPORT_ID, DIO_E_UNINIT, (Dio_PortLevelType)0 );
/** @req SWS_Dio_00074 */
VALIDATE_RV( IS_VALID_PORT(portId), DIO_READPORT_ID, DIO_E_PARAM_INVALID_PORT_ID, (Dio_PortLevelType)0 );
level = GPIO_ReadInputData(GPIO_ports[portId]);
return level;
}
/**
*
* @param user
* @return
*/
Std_ReturnType EcuM_ComM_RequestRUN(NetworkHandleType channel)
{
VALIDATE_RV(EcuM_World.initiated, ECUM_COMM_REQUESTRUN_ID, ECUM_E_NOT_INITIATED, E_NOT_OK);
VALIDATE_RV(channel < 32, ECUM_COMM_REQUESTRUN_ID, ECUM_E_INVALID_PAR, E_NOT_OK);
if( !EcuM_World.killAllRequest ) {
EcuM_World.run_comm_requests |= (uint32)1 << channel;
}
/* If we already are in running, call right away */
if( EcuM_World.current_state == ECUM_STATE_APP_RUN ) {
ComM_EcuM_RunModeIndication(channel);
}
return E_OK;
}
Dio_PortLevelType Dio_ReadChannelGroup(
const Dio_ChannelGroupType *channelGroupIdPtr)
{
Dio_PortLevelType level;
VALIDATE_RV( DioGlobal.InitRun, DIO_READCHANNELGROUP_ID, DIO_E_UNINIT, (Dio_PortLevelType)0 );
/** @req SWS_Dio_00114 */
VALIDATE_RV( IS_VALID_CHANNELGROUP(channelGroupIdPtr), DIO_READCHANNELGROUP_ID, DIO_E_PARAM_INVALID_GROUP_ID, (Dio_PortLevelType)0 );
// Get masked values
level = Dio_ReadPort(channelGroupIdPtr->port) & channelGroupIdPtr->mask;
// Shift down
level = level >> channelGroupIdPtr->offset;
return level;
}
/* @req EcuM4046 */
Std_ReturnType EcuM_GoDown(uint16 caller) {
VALIDATE_RV(EcuM_World.initiated, ECUM_GODOWN_ID, ECUM_E_UNINIT, E_NOT_OK);
EcuM_WakeupSourceType wakeupEvents;
Std_ReturnType rv = E_OK;
/* !req EcuM4047 */
#if ECUM_DEFENSIVE_BEHAVIOR == STD_ON
if (!isCallerAllowed(caller)) {
#if defined(USE_DEM)
//TODO: Report ECUM_E_IMPROPER_CALLER to DEM when we have the 4.1 config
#endif
return E_NOT_OK;
}
#endif
#if defined(USE_BSWM)
BswM_Deinit();
#endif
#if defined(USE_SCHM)
SchM_Deinit();
#endif
wakeupEvents = EcuM_GetPendingWakeupEvents();
if (wakeupEvents != 0) {
rv = EcuM_SelectShutdownTarget(ECUM_STATE_RESET, 0);
}
/* @req EcuM2952 */
ShutdownOS(E_OK);
return rv;
}
/* @req EcuM4050 */
Std_ReturnType EcuM_SelectShutdownCause(EcuM_ShutdownCauseType shutdownCause) {
VALIDATE_RV(EcuM_World.initiated, ECUM_SELECTSHUTDOWNCAUSE_ID, ECUM_E_UNINIT, E_NOT_OK);
EcuM_World.shutdown_cause = shutdownCause;
return E_OK ;
}
/* @req EcuM4051 */
Std_ReturnType EcuM_GetShutdownCause(EcuM_ShutdownCauseType *shutdownCause) {
VALIDATE_RV(EcuM_World.initiated, ECUM_GETSHUTDOWNCAUSE_ID, ECUM_E_UNINIT, E_NOT_OK);
*shutdownCause = EcuM_World.shutdown_cause;
return E_OK ;
}
Std_ReturnType EcuM_GetApplicationMode(AppModeType* appMode) {
VALIDATE_RV(EcuM_World.initiated, ECUM_GETAPPMODE_ID, ECUM_E_NOT_INITIATED, E_NOT_OK);VALIDATE_RV(appMode != NULL, ECUM_GETAPPMODE_ID, ECUM_E_NULL_POINTER, E_NOT_OK);
*appMode = EcuM_World.app_mode;
return E_OK;
}
Std_ReturnType EcuM_SelectApplicationMode(AppModeType appMode) {
VALIDATE_RV(EcuM_World.initiated, ECUM_SELECTAPPMODE_ID, ECUM_E_NOT_INITIATED, E_NOT_OK);
EcuM_World.app_mode = appMode;
return E_OK;
}
Std_ReturnType EcuM_SelectBootTarget(EcuM_BootTargetType target) {
VALIDATE_RV(EcuM_World.initiated, ECUM_SELECT_BOOTARGET_ID, ECUM_E_NOT_INITIATED, E_NOT_OK);
// TODO Do something great here
(void) target;
assert(0);
return E_NOT_OK;
}
Dio_LevelType Dio_ReadChannel(Dio_ChannelType channelId)
{
Dio_LevelType level;
VALIDATE_RV( DioGlobal.InitRun, DIO_READCHANNEL_ID, DIO_E_UNINIT, (Dio_LevelType)0 );
/** @req SWS_Dio_00074 */
VALIDATE_RV( IS_VALID_CHANNEL(channelId), DIO_READCHANNEL_ID, DIO_E_PARAM_INVALID_CHANNEL_ID, (Dio_LevelType)0 );
Dio_PortLevelType portVal = Dio_ReadPort(DIO_GET_PORT_FROM_CHANNEL_ID(channelId));
Dio_PortLevelType bit = DIO_GET_BIT_FROM_CHANNEL_ID(channelId);
if ((portVal & bit) != STD_LOW){
level = STD_HIGH;
} else{
level = STD_LOW;
}
return (level);
}
Std_ReturnType EcuM_GetBootTarget(EcuM_BootTargetType* target) {
VALIDATE_RV(EcuM_World.initiated, ECUM_GET_BOOTARGET_ID, ECUM_E_NOT_INITIATED, E_NOT_OK);VALIDATE_RV(target != NULL, ECUM_GET_BOOTARGET_ID, ECUM_E_NULL_POINTER, E_NOT_OK);
// TODO Return selected boot target here
(void) target;
assert(0);
return E_NOT_OK;
}
Std_ReturnType EcuM_ReleaseRUN(EcuM_UserType user) {
VALIDATE_RV(EcuM_World.initiated, ECUM_RELEASERUN_ID, ECUM_E_NOT_INITIATED, E_NOT_OK);VALIDATE_RV(user < ECUM_USER_ENDMARK, ECUM_RELEASERUN_ID, ECUM_E_INVALID_PAR, E_NOT_OK);
#if defined(DEBUG_RELEASE_RUN)
LDEBUG_PRINTF("EcuM_ReleaseRUN(): User %d\n",user);
#endif
EcuM_World.run_requests &= ~((uint32) 1 << user);
return E_OK;
}
Std_ReturnType EcuM_RequestRUN(EcuM_UserType user) {
VALIDATE_RV(EcuM_World.initiated, ECUM_REQUESTRUN_ID, ECUM_E_NOT_INITIATED, E_NOT_OK);VALIDATE_RV(user < ECUM_USER_ENDMARK, ECUM_REQUESTRUN_ID, ECUM_E_INVALID_PAR, E_NOT_OK);
// LDEBUG_PRINTF("EcuM_RequestRUN(): User %d\n",user);
if( !EcuM_World.killAllRequest ) {
EcuM_World.run_requests |= (uint32) 1 << user;
}
return E_OK;
}
Std_ReturnType EcuM_GetShutdownTarget(EcuM_StateType* shutdownTarget,
uint8* sleepMode) /** @req EcuM2824 */
{
VALIDATE_RV(EcuM_World.initiated, ECUM_GETSHUTDOWNTARGET_ID, ECUM_E_NOT_INITIATED, E_NOT_OK);VALIDATE_RV(shutdownTarget != NULL, ECUM_GETSHUTDOWNTARGET_ID, ECUM_E_NULL_POINTER, E_NOT_OK);VALIDATE_RV(sleepMode != NULL, ECUM_GETSHUTDOWNTARGET_ID, ECUM_E_NULL_POINTER, E_NOT_OK);
*shutdownTarget = EcuM_World.shutdown_target;
*sleepMode = EcuM_World.sleep_mode;
return E_OK;
}
/* @req EcuM4049 */
Std_ReturnType EcuM_GoPoll(void) {
VALIDATE_RV(EcuM_World.initiated, ECUM_GOPOLL_ID, ECUM_E_UNINIT, E_NOT_OK);
goSleepSequence();
pollingSequence();
wakeupRestartSequence();
return E_OK ;
}
/* @req EcuM4048 */
Std_ReturnType EcuM_GoHalt(void) {
VALIDATE_RV(EcuM_World.initiated, ECUM_GOHALT_ID, ECUM_E_UNINIT, E_NOT_OK);
goSleepSequence();
haltSequence();
wakeupRestartSequence();
return E_OK ;
}
Std_ReturnType Wdg_SetMode (WdgIf_ModeType Mode)
{
/* @req SWS_Wdg_00160 */
static const Wdg_SettingsType *modeWdgConfig;
Std_ReturnType res = E_NOT_OK;
/* @req SWS_Wdg_00017 */
/* @req SWS_Wdg_00010 */
VALIDATE_RV(runTimeData.configWdgPtr != NULL, WDG_SET_MODE_SERVICE_ID, WDG_E_DRIVER_STATE, E_NOT_OK);
switch (Mode)
{
case WDGIF_OFF_MODE:
modeWdgConfig = &(runTimeData.configWdgPtr->Wdg_ModeConfig->WdgSettingsOff);
break;
case WDGIF_FAST_MODE:
modeWdgConfig = &(runTimeData.configWdgPtr->Wdg_ModeConfig->WdgSettingsFast);
break;
case WDGIF_SLOW_MODE:
modeWdgConfig = &(runTimeData.configWdgPtr->Wdg_ModeConfig->WdgSettingsSlow);
break;
default:
/* @req SWS_Wdg_00091 */
REPORT_DET_ERROR(WDG_SET_MODE_SERVICE_ID, WDG_E_PARAM_MODE);
modeWdgConfig = NULL;
break;
}
if (modeWdgConfig != NULL)
{
/* Enable watchdog if config tell us to.. */
if (modeWdgConfig->ActivationBit != 0u)
{
#if defined(CFG_MPC560X) || defined(CFG_MPC563XM) || defined(CFG_MPC5744P) || defined(CFG_MPC5645S) || defined(CFG_MPC5644A) || defined(CFG_MPC5777M)
StopWatchdog(); // must be stopped in order to change TO
#endif
/* @req SWS_Wdg_00145*/
StartWatchdog(modeWdgConfig->ReloadValue);
}
else
{
StopWatchdog();
}
/* Set internal mode for debugging and test */
runTimeData.mode = Mode;
res = E_OK;
}
/* @req SWS_Wdg_00103 */
return res;
}
Std_ReturnType EcuM_SelectShutdownTarget(EcuM_StateType shutdownTarget,
uint8 sleepMode) {
VALIDATE_RV(EcuM_World.initiated, ECUM_SELECTSHUTDOWNTARGET_ID, ECUM_E_NOT_INITIATED, E_NOT_OK);VALIDATE_RV((shutdownTarget == ECUM_STATE_OFF) || (shutdownTarget == ECUM_STATE_RESET) || (shutdownTarget == ECUM_STATE_SLEEP), ECUM_SELECTSHUTDOWNTARGET_ID, ECUM_E_INVALID_PAR, E_NOT_OK);
#if defined(DEBUG_SELECT_SHUTDOWN_TARGET)
LDEBUG_PRINTF("EcuM_SelectShutdownTarget(): shutdownTarget=%s, sleepMode=%d\n",
GetMainStateAsString(shutdownTarget),
sleepMode);
#endif
EcuM_World.shutdown_target = shutdownTarget;
EcuM_World.sleep_mode = sleepMode;
return E_OK;
}
/** @req SOAD105 */
Std_ReturnType SoAdTp_Transmit(PduIdType SoAdSrcPduId, const PduInfoType* SoAdSrcPduInfoPtr)
{
Std_ReturnType returnCode = E_OK;
PduInfoType txPduInfo;
uint16 socketNr;
VALIDATE_RV(ModuleStatus != SOAD_UNINITIALIZED, SOAD_TP_TRANSMIT_ID, SOAD_E_NOTINIT, E_NOT_OK); /** @req SOAD224 *//** @req SOAD223 */
VALIDATE_RV(SoAdSrcPduInfoPtr != NULL, SOAD_TP_TRANSMIT_ID, SOAD_E_NULL_PTR, E_NOT_OK); /** @req SOAD225 */
VALIDATE_RV(SoAdSrcPduId < SOAD_PDU_ROUTE_COUNT, SOAD_TP_TRANSMIT_ID, SOAD_E_INVAL, E_NOT_OK); /** @req SOAD237 */
if (SoAd_Config.PduRoute[SoAdSrcPduId].DestinationSocketRef != NULL ) {
// pi_printf("infor: destination\r\n");
switch (SoAd_Config.PduRoute[SoAdSrcPduId].DestinationSocketRef->AutosarConnectorType) {
case SOAD_AUTOSAR_CONNECTOR_PDUR:
// pi_printf("infor: soad autosar pdur\r\n");
if (SoAd_Config.PduRoute[SoAdSrcPduId].SourceSduLength == SoAdSrcPduInfoPtr->SduLength) { // TODO: Shall this test be done or all length be allowed?
// pi_printf("infor: length\r\n");
if (PduAdminList[SoAdSrcPduId].PduStatus == PDU_IDLE ) {
// pi_printf("infor: pdu idle\r\n");
socketNr = SoAd_Config.PduRoute[SoAdSrcPduId].DestinationSocketRef->SocketId;
if ((SocketAdminList[socketNr].SocketState == SOCKET_TCP_LISTENING)
|| (SocketAdminList[socketNr].SocketState == SOCKET_TCP_READY)
|| (SocketAdminList[socketNr].SocketState == SOCKET_UDP_READY)) {
PduAdminList[SoAdSrcPduId].PduStatus = PDU_TP_REQ_BUFFER;
// pi_printf("infor: tcp ready\r\n");
txPduInfo.SduLength = SoAdSrcPduInfoPtr->SduLength;
if(SoAd_BufferGet(txPduInfo.SduLength, &txPduInfo.SduDataPtr))
{
PduLengthType availableData;
PduR_SoAdTpCopyTxData(SoAd_Config.PduRoute[SoAdSrcPduId].SourcePduId, &txPduInfo, /* retry */NULL, &availableData );
}else{
// No free buffer. Inform PduR..
PduR_SoAdTpTxConfirmation(SoAd_Config.PduRoute[SoAdSrcPduId].SourcePduId, NTFRSLT_E_NO_BUFFER);
PduAdminList[SoAdSrcPduId].PduStatus = PDU_TP_SENDING;
// pi_printf("infor: soad ip message\r\n");
SoAd_SendIpMessage(socketNr, txPduInfo.SduLength, txPduInfo.SduDataPtr);
PduR_SoAdTpTxConfirmation(SoAd_Config.PduRoute[SoAdSrcPduId].SourcePduId, NTFRSLT_OK);
}
SoAd_BufferFree(txPduInfo.SduDataPtr);
PduAdminList[SoAdSrcPduId].PduStatus = PDU_IDLE;
} else {
/* Socket not ready */
returnCode = E_NOT_OK;
}
} else {
/* A PDU is already in progress */
returnCode = E_NOT_OK;
}
} else {
/* Attached length and length from PduRoutingTable does not match */
returnCode = E_NOT_OK;
}
break;
case SOAD_AUTOSAR_CONNECTOR_DOIP:
returnCode = DoIp_HandleTpTransmit(SoAdSrcPduId, SoAdSrcPduInfoPtr);
break;
default:
// Not supported connector type
returnCode = E_NOT_OK;
break;
} /* End of switch */
} else {
/* SocketAdminRef is NULL */
returnCode = E_NOT_OK;
}
return returnCode;
}
