bool_t osWaitForEvent(OsEvent *event, systime_t timeout)
{
OS_ERR err;
//Wait until the specified event is in the signaled
//state or the timeout interval elapses
if(timeout == 0)
{
//Non-blocking call
OSFlagPend(event, 1, 0, OS_OPT_PEND_FLAG_SET_ANY |
OS_OPT_PEND_FLAG_CONSUME | OS_OPT_PEND_NON_BLOCKING, NULL, &err);
}
else if(timeout == INFINITE_DELAY)
{
//Infinite timeout period
OSFlagPend(event, 1, 0, OS_OPT_PEND_FLAG_SET_ANY |
OS_OPT_PEND_FLAG_CONSUME | OS_OPT_PEND_BLOCKING, NULL, &err);
}
else
{
//Wait until the specified event becomes set
OSFlagPend(event, 1, OS_MS_TO_SYSTICKS(timeout), OS_OPT_PEND_FLAG_SET_ANY |
OS_OPT_PEND_FLAG_CONSUME | OS_OPT_PEND_BLOCKING, NULL, &err);
}
//Check whether the specified event is set
if(err == OS_ERR_NONE)
return TRUE;
else
return FALSE;
}
/******************************************************
Read serial for bcr data
*******************************************************/
void BCRUpdateTask()
{
INT8U err;
erD_sndstr("In the BCRUpdateTask()\n\r");
COM_BUFF_INFO RxBuff = GetTaskRxComBuff();
int i;
INT16U timeout;
while(1)
{
timeout = 0;
i = 0;
memset(BCRValue, 0x00, MAX_BARCODE_LENGTH);
while (err != OS_TIMEOUT) {
OSFlagPend(comFlag,
RX_SERIAL_DATA_AVAILABLE,
OS_FLAG_WAIT_SET_ALL + OS_FLAG_CONSUME,
timeout,
&err);
if(err == OS_NO_ERR)
{
timeout = 3000;
while ((*RxBuff.ptrCurrent != *RxBuff.ptrEnd) && (i<MAX_BARCODE_LENGTH))
{
printf("%d", i);
*(RxBuff.ptrCurrent) = (*(RxBuff.ptrCurrent)+1) % (int)SERIAL_BUFF_SIZE;
BCRValue[i] = RxBuff.Buffer[*(RxBuff.ptrCurrent)];
i++;
}
BCRValue[i] = '\0';
}
}
OSFlagPost(bcFlag,
BAR_CODE_AVAILABLE,
OS_FLAG_SET,
&err);
OSFlagPend(bcFlag,
BAR_CODE_CONSUMED,
OS_FLAG_WAIT_SET_ALL + OS_FLAG_CONSUME,
0,
&err);
#if DEBUG
printf("BCR Update Task\n\r");
#endif
}
}
static void AppTask_2 (void *p_arg)
{
INT8U err;
(void)p_arg;
APP_TRACE_INFO(("AppTask_2\n\r"));
pSecureEventFlagGrp = OSFlagCreate(0x0, &err);
/* Enable Crypto clock */
CLK->AHBCLK |= CLK_AHBCLK_CRPTCKEN_Msk;
BSP_IntVectSet(BSP_INT_ID_CRYPTO, CRYPTO_IRQHandler);
BSP_IntEn(BSP_INT_ID_CRYPTO);
PRNG_ENABLE_INT();
while (1)
{
PRNG_Open(PRNG_KEY_SIZE_256, 0, 0);
bsp_printf("Start PRNG...\n");
PRNG_Start();
OSFlagPend(pSecureEventFlagGrp, 0x1, OS_FLAG_WAIT_SET_ANY, 0, &err);
dump_PRNG();
OSTimeDlyHMSM(0, 0, 0, 100);
}
}
void mouseCalibWaitNextStep(int i)
{
OSFlagPend(flagCalibStep,
(0x01 << i),
OS_FLAG_WAIT_SET_ALL,
0,
&OSLastError);
LOG_TEST_OS_ERROR(OSLastError);
}
static void AppTaskObj1 (void *p_arg)
{
OS_ERR os_err;
OS_MSG_SIZE msg_size;
(void)p_arg;
while (DEF_TRUE) {
#if (OS_CFG_SEM_EN > 0u)
OSSemPend(&AppTaskObjSem,
0,
OS_OPT_PEND_BLOCKING,
0,
&os_err);
#endif
#if (OS_CFG_MUTEX_EN > 0u)
OSMutexPend(&AppTaskObjMutex,
0,
OS_OPT_PEND_BLOCKING,
0,
&os_err);
OSMutexPost(&AppTaskObjMutex,
OS_OPT_POST_NONE,
&os_err);
#endif
#if (OS_CFG_Q_EN > 0u)
OSQPend(&AppTaskObjQ,
0,
OS_OPT_PEND_BLOCKING,
&msg_size,
0,
&os_err);
#endif
#if (OS_CFG_FLAG_EN > 0u)
OSFlagPend(&AppTaskObjFlag,
DEF_BIT_00,
0,
OS_OPT_PEND_FLAG_SET_ALL + OS_OPT_PEND_FLAG_CONSUME + OS_OPT_PEND_BLOCKING,
0,
&os_err);
#endif
OSTimeDlyHMSM( 0u, 0u, 0u, 10u,
OS_OPT_TIME_HMSM_STRICT,
&os_err);
APP_TRACE_INFO(("Object test task 1 running ....\n"));
}
}
/*FUNCTION**********************************************************************
*
* Function Name : OSA_EventWait
* Description : This function checks the event's status, if it meets the wait
* condition, return kStatus_OSA_Success, otherwise, timeout will be used for
* wait. The parameter timeout indicates how long should wait in milliseconds.
* Pass OSA_WAIT_FOREVER to wait indefinitely, pass 0 will return the value
* kStatus_OSA_Timeout immediately if wait condition is not met. The event flags
* will be cleared if the event is auto clear mode. Flags that wakeup waiting
* task could be obtained from the parameter setFlags.
* This function returns kStatus_OSA_Success if wait condition is met, returns
* kStatus_OSA_Timeout if wait condition is not met within the specified
* 'timeout', returns kStatus_OSA_Error if any errors occur during waiting.
*
*END**************************************************************************/
osa_status_t OSA_EventWait(event_t *pEvent,
event_flags_t flagsToWait,
bool waitAll,
uint32_t timeout,
event_flags_t *setFlags)
{
OS_ERR err;
OS_OPT opt;
/* Prepare wait options base on wait type and clear type. */
if (waitAll)
{
opt = OS_OPT_PEND_FLAG_SET_ALL;
}
else
{
opt = OS_OPT_PEND_FLAG_SET_ANY;
}
if (kEventAutoClear == pEvent->clearMode)
{
opt |= OS_OPT_PEND_FLAG_CONSUME;
}
if (0U == timeout)
{
opt |= OS_OPT_PEND_NON_BLOCKING;
}
else
{
timeout = wait_timeout_msec_to_tick(timeout);
opt |= OS_OPT_PEND_BLOCKING;
}
*setFlags = OSFlagPend(&(pEvent->group), flagsToWait, timeout,
opt, (CPU_TS*)0, &err);
if (OS_ERR_NONE == err)
{
return kStatus_OSA_Success;
}
else if ((OS_ERR_TIMEOUT == err) ||
(OS_ERR_PEND_WOULD_BLOCK == err))
{
return kStatus_OSA_Timeout;
}
else
{
return kStatus_OSA_Error;
}
}
/*FUNCTION**********************************************************************
*
* Function Name : OSA_EventWait
* Description : This function checks the event's status, if it meets the wait
* condition, return kStatus_OSA_Success, otherwise, timeout will be used for
* wait. The parameter timeout indicates how long should wait in milliseconds.
* Pass OSA_WAIT_FOREVER to wait indefinitely, pass 0 will return the value
* kStatus_OSA_Timeout immediately if wait condition is not met. The event flags
* will be cleared if the event is auto clear mode. Flags that wakeup waiting
* task could be obtained from the parameter setFlags.
* This function returns kStatus_OSA_Success if wait condition is met, returns
* kStatus_OSA_Timeout if wait condition is not met within the specified
* 'timeout', returns kStatus_OSA_Error if any errors occur during waiting.
*
*END**************************************************************************/
osa_status_t OSA_EventWait(event_t *pEvent,
event_flags_t flagsToWait,
bool waitAll,
uint32_t timeout,
event_flags_t *setFlags)
{
INT8U err, opt;
/* Prepare wait options base on wait type and clear type. */
if (waitAll)
{
opt = OS_FLAG_WAIT_SET_ALL;
}
else
{
opt = OS_FLAG_WAIT_SET_ANY;
}
if (kEventAutoClear == pEvent->clearMode)
{
opt |= OS_FLAG_CONSUME;
}
/* If timeout is 0, try to wait. */
if (0U == timeout)
{
*setFlags = OSFlagAccept (pEvent->pGroup, flagsToWait, opt, &err);
}
else
{
/* If timeout is not 0, convert it to tickes. */
timeout = wait_timeout_msec_to_tick(timeout);
*setFlags = OSFlagPend(pEvent->pGroup, flagsToWait, opt, timeout, &err);
}
if (OS_ERR_NONE == err)
{
return kStatus_OSA_Success;
}
else if ((OS_ERR_TIMEOUT == err) ||
(OS_ERR_FLAG_NOT_RDY == err))
{
return kStatus_OSA_Timeout;
}
else
{
return kStatus_OSA_Error;
}
}
static bool SIM90x_WaitPowerDown(uint32_t timeout)
{
OS_ERR error;
OS_FLAGS flags;
timeout = SYS_MsToTick(timeout);
flags = OSFlagPend( &SIM90X_Flags,
SIM90X_POWER_FLAG,
timeout,
OS_OPT_PEND_FLAG_CLR_AND,
(void*)0,
&error );
return (flags == SIM90X_POWER_FLAG);
}
/**
* This function is wait for modbus master request finish and return result.
* Waiting result include request process success, request respond timeout,
* receive data error and execute function error.You can use the above callback function.
* @note If you are use OS, you can use OS's event mechanism. Otherwise you have to run
* much user custom delay for waiting.
*
* @return request error code
*/
eMBMasterReqErrCode eMBMasterWaitRequestFinish( void ) {
eMBMasterReqErrCode eErrStatus = MB_MRE_NO_ERR;
//rt_uint32_t recvedEvent;
/* waiting for OS event */
//rt_event_recv(&xMasterOsEvent,
// EV_MASTER_PROCESS_SUCESS | EV_MASTER_ERROR_RESPOND_TIMEOUT
// | EV_MASTER_ERROR_RECEIVE_DATA
// | EV_MASTER_ERROR_EXECUTE_FUNCTION,
// RT_EVENT_FLAG_OR | RT_EVENT_FLAG_CLEAR, RT_WAITING_FOREVER,
// &recvedEvent);
OS_FLAGS recvedEvent;
uint8_t err=OS_ERR_NONE;
recvedEvent=OSFlagPend(xMasterOsEvent,
EV_MASTER_PROCESS_SUCESS |
EV_MASTER_ERROR_RESPOND_TIMEOUT |
EV_MASTER_ERROR_RECEIVE_DATA |
EV_MASTER_ERROR_EXECUTE_FUNCTION,
OS_FLAG_WAIT_SET_ANY|OS_FLAG_CONSUME,
0, //Waiting for forever
&err );
switch (recvedEvent)
{
case EV_MASTER_PROCESS_SUCESS:
break;
case EV_MASTER_ERROR_RESPOND_TIMEOUT:
{
eErrStatus = MB_MRE_TIMEDOUT;
break;
}
case EV_MASTER_ERROR_RECEIVE_DATA:
{
eErrStatus = MB_MRE_REV_DATA;
break;
}
case EV_MASTER_ERROR_EXECUTE_FUNCTION:
{
eErrStatus = MB_MRE_EXE_FUN;
break;
}
}
return eErrStatus;
}
BOOL
xMBMasterPortEventGet( eMBMasterEventType * eEvent )
{
// rt_uint32_t recvedEvent;
/* waiting forever OS event */
//rt_event_recv(&xMasterOsEvent,
// EV_MASTER_READY | EV_MASTER_FRAME_RECEIVED | EV_MASTER_EXECUTE |
// EV_MASTER_FRAME_SENT | EV_MASTER_ERROR_PROCESS,
// RT_EVENT_FLAG_OR | RT_EVENT_FLAG_CLEAR, RT_WAITING_FOREVER,
// &recvedEvent);
/* the enum type couldn't convert to int type */
OS_FLAGS recvedEvent;
uint8_t err=OS_ERR_NONE;
recvedEvent=OSFlagPend(xMasterOsEvent,
EV_MASTER_READY |
EV_MASTER_FRAME_RECEIVED |
EV_MASTER_EXECUTE |
EV_MASTER_FRAME_SENT|
EV_MASTER_ERROR_PROCESS,
OS_FLAG_WAIT_SET_ANY|OS_FLAG_CONSUME,
0, //Waiting for forever
&err );
switch (recvedEvent)
{
case EV_MASTER_READY:
*eEvent = EV_MASTER_READY;
break;
case EV_MASTER_FRAME_RECEIVED:
*eEvent = EV_MASTER_FRAME_RECEIVED;
break;
case EV_MASTER_EXECUTE:
*eEvent = EV_MASTER_EXECUTE;
break;
case EV_MASTER_FRAME_SENT:
*eEvent = EV_MASTER_FRAME_SENT;
break;
case EV_MASTER_ERROR_PROCESS:
*eEvent = EV_MASTER_ERROR_PROCESS;
break;
}
return TRUE;
}
int flag_event_wait(flag_event_t *event){
#if defined(OS_FREERTOS)
EventBits_t uxBits;
uxBits = xEventGroupWaitBits(*event,
((uint32_t)1) << 0,
pdTRUE,
pdFALSE,
portMAX_DELAY);
if(uxBits & (((uint32_t)1) << 0))
return 1;
return 0;
#elif defined(OS_UCOS)
OS_ERR err;
OS_FLAGS flags;
flags = OSFlagPend(event, 1, 0, OS_OPT_PEND_FLAG_SET_ANY, 0, &err);
if((err == OS_ERR_NONE) && (flags & ((OS_FLAGS)1) == 1)) return 1;
return 0;
#endif
}
status_t DSPI_RTOS_Transfer(dspi_rtos_handle_t *handle, dspi_transfer_t *transfer)
{
status_t status;
OS_FLAGS ev;
OS_ERR err;
/* Lock resource mutex */
OSSemPend(&handle->mutex, 0, OS_OPT_PEND_BLOCKING, NULL, &err);
if (OS_ERR_NONE != err)
{
return kStatus_Fail;
}
ev = OSFlagPost(&handle->event, RTOS_DSPI_COMPLETE, OS_OPT_POST_FLAG_CLR, &err);
assert((ev & RTOS_DSPI_COMPLETE) == 0);
status = DSPI_MasterTransferNonBlocking(handle->base, &handle->drv_handle, transfer);
if (status != kStatus_Success)
{
OSSemPost(&handle->mutex, OS_OPT_POST_1, &err);
return status;
}
/* Wait for transfer to finish */
ev = OSFlagPend(&handle->event, RTOS_DSPI_COMPLETE, 0, OS_OPT_PEND_FLAG_SET_ALL, NULL, &err);
if (!(ev & RTOS_DSPI_COMPLETE))
{
OSSemPost(&handle->mutex, OS_OPT_POST_1, &err);
return kStatus_Fail;
}
/* Unlock resource mutex */
OSSemPost(&handle->mutex, OS_OPT_POST_1, &err);
if (OS_ERR_NONE != err)
{
/* We could not post back the semaphore, exit with error */
return kStatus_Fail;
}
/* Return status captured by callback function */
return handle->async_status;
}
//-----------------------------------------------------------------------------------
// After the transmission begin , wait event during the transmission
//-----------------------------------------------------------------------------------
LOCAL uint32 _WaitCardEvent (SDIO_CARD_PAL_HANDLE handle,uint32 EventId)
{
#if defined (UCOS_BSD_EVENT)
INT8U err;
OSFlagPend (handle->sdio_event, EventId, OS_FLAG_WAIT_SET_ALL|OS_FLAG_CONSUME, 1000, &err);
if (OS_TIMEOUT == err)
{
s_CardErrCode |= BIT_31;
}
#elif defined (CARD_SDIO_EVENT)
{
uint32 actualFlag;
uint32 eRet;
eRet = SCI_GetEvent (handle->sdio_event,EventId,SCI_AND_CLEAR,&actualFlag,3000);
if (SCI_SUCCESS != eRet)
{
s_CardErrCode |= BIT_31;
SDIO_CARD_PRINT(("SCM Wait event error!!! eRet = 0x%x",eRet));
}
}
#else
// CARD_PRINT(("SD20 Wait event before %x",EventId));
if(EventId == (s_CardEvent&EventId))
{
return 0;
}
else
{
return 1;
}
// CARD_PRINT(("SD20 Wait event end %x",s_CardEvent));
#endif
}
int flag_event_timedwait(flag_event_t *event, const struct timespec *abs_timeout){
#if defined(OS_FREERTOS)
EventBits_t uxBits;
TickType_t timeout = abs_timeout->tv_sec * 1000 * portTICK_PERIOD_MS;
timeout += abs_timeout->tv_nsec / 1000000 * portTICK_PERIOD_MS;
uxBits = xEventGroupWaitBits(*event,
((uint32_t)1) << 0,
pdTRUE,
pdFALSE,
timeout);
if(uxBits & (((uint32_t)1) << 0))
return 1;
return 0;
#elif defined(OS_UCOS)
OS_ERR err;
OS_FLAGS flags;
OS_TICK timeout = abs_timeout->tv_sec * TICK_RATE_HZ;
timeout += abs_timeout->tv_nsec / 1000000 * TICK_RATE_HZ / 1000;
flags = OSFlagPend(event, 1, timeout, OS_OPT_PEND_FLAG_SET_ANY|OS_OPT_PEND_FLAG_CONSUME, 0, &err);
if((err == OS_ERR_NONE) && (flags & ((OS_FLAGS)1) == 1)) return 1;
return 0;
#endif
}
//audio task
void AudioTask()
{
OS_STATUS os_status;
UBYTE os_err;
AUDIO_STATUS audio;
USHORT actualflagmask;
GBOOL audioStatus = GFALSE;
U8 tsInput;
U32 rx,wx;
U32 offset;
OSSemPend(driver_sync_sem, 0, &os_err);
/* Do initialisation that requires the OS to be running or interrupts enabled*/
/* None of the Core/Verifier or Application tasks are running */
OSSemPost(driver_sync_sem);
tsInput = GH_BM_getm_ReadEnable_HW_BUF_SEL();
if(tsInput == GD_TSD_2)
offset = GH_BM2_get_BufferSize(GD_TSD_AUDIO_PES);
else
offset = GH_BM1_get_BufferSize(GD_TSD_AUDIO_PES);
while(1)
{
os_status = OSFlagPend(eventflagmask, eventflagtype, 0, &actualflagmask);
//SYS_DEBUG_INFO(DEBL0_NSTR, (CSTR*)"8 actualflagmask ",actualflagmask,0,0);
if((actualflagmask&AUDIO_FILE_PLAYED) == AUDIO_FILE_PLAYED)
{
OSFlagClear(eventflagmask, &actualflagmask);
SYS_DEBUG_INFO(DEBL0_NSTR, (CSTR*)"8 actualflagmask1 ",actualflagmask,0,0);
while(dataIndex < memDataSize)
{
OSTimeDly(50);
GD_TSD_GetBufferPointer(GD_TSD_AUDIO_PES, tsInput, &rx, &wx);
GHA_ResumeFeedData(memDataAddr, memDataSize, &dataIndex, &lastDataIndex, &pesLen, wx, rx-1);
if(rx == 0)
wx =offset;
else
wx =rx-1;
if(tsInput == GD_TSD_2 )
GH_BM2_set_BufferWritePointer(GD_TSD_AUDIO_PES, wx);
else
GH_BM1_set_BufferWritePointer(GD_TSD_AUDIO_PES, wx);
}
if(soundFileFlag == AUDIO_PLAYED)
{
//OSQPostToCore(HDI_PL_AUDIO_FILE_COMPLETED_XT, (void*)&loadcompleted, sizeof(HDI_PL_AUDIO_FILE_COMPLETED_XT));
SYS_DEBUG_INFO(DEBL0_NSTR, (CSTR*)"8 loadcompleted.event_qualifier: ",loadcompleted.event_qualifier,0,0);
}
soundFileFlag = AUDIO_COMPLETED;
GD_AUD_Stop();
GD_AUD_Close();
if(audioStatus == GTRUE)
{
HDIStartAudio();
SYS_DEBUG_INFO(DEBL0_NSTR, (CSTR*)" start audio",0,0,0);
}
}
else if((actualflagmask&AUDIO_FILE_STOPPED) == AUDIO_FILE_STOPPED)
{
OSFlagClear(eventflagmask, &actualflagmask);
SYS_DEBUG_INFO(DEBL0_NSTR, (CSTR*)"8 actualflagmask2 ",actualflagmask,0,0);
SYS_DEBUG_INFO(DEBL0_NSTR, (CSTR*)"8 loadcompleted.event_qualifier: ",loadcompleted.event_qualifier,0,0);
}
else if((actualflagmask&AUDIO_STATUS_STARTED) == AUDIO_STATUS_STARTED)
{
OSFlagClear(eventflagmask, &actualflagmask);
SYS_DEBUG_INFO(DEBL0_NSTR, (CSTR*)"8 actualflagmask3 ",actualflagmask,0,0);
if(audioStatus == GFALSE)
{
audioStatus = GTRUE;
aoparameter.change_mask |= 0x01;
aoparameter.audio_state.state = AUDIO_RUNNING;
audio.standard_id = MPEG;
audio.parameters.mpeg_status.layer = aoparameter.audio_state.parameters.mpeg_status.layer;
audio.parameters.mpeg_status.bitrate_index = aoparameter.audio_state.parameters.mpeg_status.bitrate_index;
audio.parameters.mpeg_status.sampling_frequency = aoparameter.audio_state.parameters.mpeg_status.sampling_frequency;
audio.parameters.mpeg_status.mode = aoparameter.audio_state.parameters.mpeg_status.mode;
audio.parameters.mpeg_status.emphasis = aoparameter.audio_state.parameters.mpeg_status.emphasis;
OSTimeDly(30);
HDIGetAudioStatus(&audio);
SYS_DEBUG_INFO(DEBL0_NSTR, (CSTR*)"8 aoparameter.change_mask ",aoparameter.change_mask,0,0);
if((aoparameter.audio_state.parameters.mpeg_status.layer!=audio.parameters.mpeg_status.layer)||
(aoparameter.audio_state.parameters.mpeg_status.bitrate_index!=audio.parameters.mpeg_status.bitrate_index)||
(aoparameter.audio_state.parameters.mpeg_status.sampling_frequency!=audio.parameters.mpeg_status.sampling_frequency)||
(aoparameter.audio_state.parameters.mpeg_status.mode!=audio.parameters.mpeg_status.mode)||
(aoparameter.audio_state.parameters.mpeg_status.emphasis!=audio.parameters.mpeg_status.emphasis))
{
aoparameter.change_mask |= 0x04;
aoparameter.audio_state.parameters.mpeg_status.layer = audio.parameters.mpeg_status.layer;
aoparameter.audio_state.parameters.mpeg_status.bitrate_index = audio.parameters.mpeg_status.bitrate_index;
aoparameter.audio_state.parameters.mpeg_status.sampling_frequency = audio.parameters.mpeg_status.sampling_frequency;
aoparameter.audio_state.parameters.mpeg_status.mode = audio.parameters.mpeg_status.mode;
aoparameter.audio_state.parameters.mpeg_status.emphasis = audio.parameters.mpeg_status.emphasis;
}
//OSQPostToCore(HDI_EV_AUDIO_STATUS_CHANGED, (void*)&aoparameter, sizeof(HDI_PL_AUDIO_STATUS_CHANGED_XT));
}
aoparameter.change_mask = 0;
}
else if((actualflagmask&AUDIO_STATUS_STOPPED) == AUDIO_STATUS_STOPPED)
{
OSFlagClear(eventflagmask, &actualflagmask);
SYS_DEBUG_INFO(DEBL0_NSTR, (CSTR*)"8 actualflagmask4 ",actualflagmask,0,0);
if(audioStatus == GTRUE)
{
audioStatus = GFALSE;
aoparameter.change_mask |= 0x01;
aoparameter.audio_state.state = AUDIO_STOPPED;
//OSQPostToCore(HDI_EV_AUDIO_STATUS_CHANGED, (void*)&aoparameter, sizeof(HDI_PL_AUDIO_STATUS_CHANGED_XT));
}
aoparameter.change_mask = 0;
}
else if((actualflagmask&AUDIO_TUNER_RECONNECTED) == AUDIO_TUNER_RECONNECTED)
{
OSFlagClear(eventflagmask, &actualflagmask);
SYS_DEBUG_INFO(DEBL0_NSTR, (CSTR*)"8 actualflagmask5 ",actualflagmask,0,0);
if(audioStatus == GTRUE)
{
audioStatus = GFALSE;
aoparameter.change_mask |= 0x01;
aoparameter.audio_state.state = AUDIO_STOPPED;
//OSQPostToCore(HDI_EV_AUDIO_STATUS_CHANGED, (void*)&aoparameter, sizeof(HDI_PL_AUDIO_STATUS_CHANGED_XT));
}
}
else if((actualflagmask&AUDIO_TUNER_REMOVED) == AUDIO_TUNER_REMOVED)
{
OSFlagClear(eventflagmask, &actualflagmask);
SYS_DEBUG_INFO(DEBL0_NSTR, (CSTR*)"8 actualflagmask6 ",actualflagmask,0,0);
if(audioStatus == GFALSE)
{
audioStatus = GTRUE;
aoparameter.change_mask |= 0x01;
aoparameter.audio_state.state = AUDIO_RUNNING;
//OSQPostToCore(HDI_EV_AUDIO_STATUS_CHANGED, (void*)&aoparameter, sizeof(HDI_PL_AUDIO_STATUS_CHANGED_XT));
}
}
}
}
/*!
*
* @brief Alarm Task
*/
void alarm_task(void *arg)
{
wave_t const *waveform = (wave_t *)NULL;
uint8_t speaker_task_alive = 0;
uint8_t create_speaker_task;
OS_FLAGS flags;
OS_ERR err;
(void)arg;
speaker_config();
for (;;)
{
flags = OSFlagPend(&alarm_flags, 0xF, 0,
OS_OPT_PEND_FLAG_SET_ANY | OS_OPT_PEND_FLAG_CONSUME |
OS_OPT_PEND_BLOCKING, NULL, &err);
assert(OS_ERR_NONE == err);
create_speaker_task = 0;
if ((flags & ALARM_HIGH) && (waveform != &alarm_high))
{
kill_speaker_if_alive(&speaker_task_alive);
waveform = &alarm_high;
create_speaker_task = 1;
}
else if ((flags & ALARM_MEDIUM) && (waveform != &alarm_medium))
{
kill_speaker_if_alive(&speaker_task_alive);
waveform = &alarm_medium;
create_speaker_task = 1;
}
else if ((flags & ALARM_LOW) && (waveform != &alarm_low))
{
kill_speaker_if_alive(&speaker_task_alive);
waveform = &alarm_low;
create_speaker_task = 1;
}
else if (flags & ALARM_NONE)
{
kill_speaker_if_alive(&speaker_task_alive);
waveform = NULL;
create_speaker_task = 0;
}
if (create_speaker_task)
{
OSTaskCreate(&speaker_tcb, "Speaker Task", speaker_task,
(void *)waveform, SPEAKER_PRIO, &speaker_stack[0],
TASK_STACK_SIZE / 10u, TASK_STACK_SIZE, 0u, 0u, 0, 0, &err);
assert(OS_ERR_NONE == err);
speaker_task_alive = 1;
}
}
}
/*******************************************************************************
* 名 称： comm_para_flow
* 功 能： 参数流。根据IC卡的类型进行操作
* 入口参数：
* 出口参数： 无
* 作 者： redmorningcn.
* 创建日期： 2017-05-26
* 修 改：
* 修改日期：
* 备 注： 任务创建函数需要在app.h文件中声明
*******************************************************************************/
void comm_para_flow(StrDevOtr * sDtu,uint8 addrnum)
{
OS_ERR err;
uint8 retrytimes = 0;
uint8 Infolen = 0;
uint8 *p = (uint8 *)&m_sModelCard;
/***********************************************
* 描述： 根据IC卡类型进行相应操作。卡类型在插入卡后，赋值
* 如果未插卡，则认为是普通数据卡。
*/
sDtu->Wr.Code = Ctrl.sRunPara.CardType;
switch (Ctrl.sRunPara.CardType)
{
//设置密度
case DENSITY_CARD:
sDtu->Wr.Info.Density = Ctrl.SOilPara.Density;
Infolen = sizeof(Ctrl.SOilPara.Density);
break;
case HIGHT_CARD:
sDtu->Wr.Info.Hig = Ctrl.SOilPara.Hig;
Infolen = sizeof(Ctrl.SOilPara.Hig);
break;
//模型选择卡
case MODEL_SELECT_CARD:
sDtu->Wr.Info.ModelNum = Ctrl.SOilPara.ModelNum;
Infolen = sizeof(Ctrl.SOilPara.ModelNum);
break;
//车型车号
case FIX_CARD:
sDtu->Wr.Info.sLocoId.Num = Ctrl.sProductInfo.sLocoId.Num;
sDtu->Wr.Info.sLocoId.Type = Ctrl.sProductInfo.sLocoId.Type;
Infolen = sizeof( Ctrl.sProductInfo.sLocoId.Num) +
sizeof( Ctrl.sProductInfo.sLocoId.Type );
break;
//读数据指示
case DATA_CARD_DIS:
sDtu->Wr.Info.CardRecNum = Ctrl.sRec.StoreCnt;
Infolen = sizeof(Ctrl.sRec.StoreCnt);
sDtu->ConnCtrl[0].SendFramNum++;
break;
case DATA_CARD_ERR:
sDtu->Wr.Info.Buf[0] = Ctrl.sRunPara.CardErrData;
Infolen = sizeof(Ctrl.sRunPara.CardErrData);
sDtu->ConnCtrl[0].SendFramNum++;
break;
//读数据指示结束
case DATA_CARD_FIN:
Infolen = 0;
break;
/***********************************************
* 描述： 设置油箱模型。
* IC 卡模块插入IC卡后，IC卡主动应答模型。
* 后续每200ms发送数据，序号从0开始累加。
数据发送完成后，序号为0xffffffff。
*/
case MODEL_CARD: {
modelsendnum = 0;
p = (uint8 *)&m_sModelCard;
int sendmodellen = 0; //已发送数据长度
uint16 sendtimes = 0;
OSFlagPendAbort(( OS_FLAG_GRP *)&Ctrl.Os.CommEvtFlagGrp,
( OS_OPT ) OS_OPT_PEND_ABORT_ALL,
( OS_ERR *)&err );
while(sizeof(stcModelCard ) > 128 * modelsendnum ) {
if((sizeof(stcModelCard ) - 128 * modelsendnum) > 128 ) {
if(modelsendnum == 0)
p = (uint8 *)&m_sModelCard;
//数据序号
memcpy((uint8 *)&sDtu->Wr.Info.Buf[0],(uint8 *)&modelsendnum,sizeof(modelsendnum));
//数据内容
memcpy((uint8 *)&sDtu->Wr.Info.Buf[4],&p[sendmodellen],128);
Infolen = sizeof(modelsendnum)+128;
} else {
//发送结束信号
modelsendnum = 0xffffffff;
//数据序号
memcpy((uint8 *)&sDtu->Wr.Info.Buf[0],(uint8 *)&modelsendnum,sizeof(modelsendnum));
//数据内容
memcpy((uint8 *)&sDtu->Wr.Info.Buf[4],&p[sendmodellen],(sizeof(stcModelCard ) - sendmodellen));
Infolen = sizeof(modelsendnum) + (sizeof(stcModelCard ) - sendmodellen);
sendmodellen = sizeof(stcModelCard ) ;
//更改卡类型。退出模型卡
//modelsendnum = 0;
Ctrl.sRunPara.CardType = DATA_CARD;
}
CSNC_SendData(sDtu->pch, //通讯控制块
SLAVE_ADDR_OTR, //源地址
MASTE_ADDR_HOST, //目标地址
sDtu->ConnCtrl[0].SendFramNum, //发送帧号
0, //帧类型，默认为0，在数据区内明确
(uint8 *)&sDtu->Wr, //发送缓冲区
Infolen+sizeof(sDtu->Wr.Code) //发送数据区长度
);
//数据完成
if(modelsendnum == 0xffffffff)
return;
OS_FLAGS flags =
OSFlagPend( ( OS_FLAG_GRP *)&Ctrl.Os.CommEvtFlagGrp,
( OS_FLAGS ) COMM_EVT_FLAG_OTR_RX,
( OS_TICK ) 250,
( OS_OPT ) OS_OPT_PEND_FLAG_SET_ANY,
( CPU_TS *) NULL,
( OS_ERR *)&err);
/***********************************************
* 描述： 如果串口有应答，则继续发送下一帧
*/
if ( err == OS_ERR_NONE ) {
/***********************************************
* 描述： 清除标志位
*/
OSFlagPost( ( OS_FLAG_GRP *)&Ctrl.Os.CommEvtFlagGrp,
( OS_FLAGS )COMM_EVT_FLAG_OTR_RX,
( OS_OPT )OS_OPT_POST_FLAG_CLR,
( OS_ERR *)&err);
if( Ctrl.Otr.RxCtrl.FramNum == sDtu->ConnCtrl[0].SendFramNum &&
Ctrl.Otr.Rd.modelcontrl.code == MODEL_CARD ) {
retrytimes = 0;
modelsendnum++;
sendmodellen += 128;
} else {
retrytimes++;
if(retrytimes > 2) {
retrytimes = 0;
modelsendnum++;
sendmodellen += 128;
}
}
/***********************************************
* 描述： 如果串口没有应答，则超时后发送下一帧
*/
} else {
retrytimes++;
if(retrytimes > 2) {
retrytimes = 0;
modelsendnum++;
sendmodellen += 128;
}
}
}
return;
} break;
/***********************************************
* 描述： 数据卡(默认状态)。
* 对
* 后续每200ms发送数据，序号从0开始累加。
数据发送完成后，序号为0xffffffff。
*/
//数据卡
case DATA_CARD:
return;
break;
//其他类型数据，直接退出
default:
return;
}
CSNC_SendData( sDtu->pch, //通讯控制块
SLAVE_ADDR_OTR, //源地址
MASTE_ADDR_HOST, //目标地址
sDtu->ConnCtrl[0].SendFramNum, //发送帧号
0, //帧类型，默认为0，在数据区内明确
(uint8 *)&sDtu->Wr, //发送缓冲区
Infolen+sizeof(sDtu->Wr.Code) //发送数据区长度
);
}
/*******************************************************************************
* Function Name : MSD_ReadBlock
* Description : Reads a block of data from the MSD.
* Input : - pBuffer : pointer to the buffer that receives the data read
* from the MSD.
* - ReadAddr : MSD's internal address to read from.
* - NumByteToRead : number of bytes to read from the MSD.
* Output : None
* Return : The MSD Response: - MSD_RESPONSE_FAILURE: Sequence failed
* - MSD_RESPONSE_NO_ERROR: Sequence succeed
*******************************************************************************/
u8 MSD_ReadBlock_DMA(u8 *pBuffer, u32 ReadAddr, u16 NumByteToRead)
{
u8 rvalue = MSD_RESPONSE_FAILURE;
DMA_InitTypeDef DMA_InitStructure;
char DuumyClock[512];
// INT8U err;
memset(DuumyClock, 0xff, 512);
// debug("MSD_ReadBlock_DMA!\r\n");
if(CardInfo.CardType != CARDTYPE_SDV2HC)
{
ReadAddr = ReadAddr << 9;
}
/* MSD chip select low */
MSD_CS_LOW();
DMA_DeInit(DMA1_Channel4);
DMA_DeInit(DMA1_Channel5);
DMA_InitStructure.DMA_PeripheralBaseAddr = (u32)&SPI2->DR;
DMA_InitStructure.DMA_MemoryBaseAddr = (u32)pBuffer;
DMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralSRC;
DMA_InitStructure.DMA_BufferSize = 512;
DMA_InitStructure.DMA_PeripheralInc = DMA_PeripheralInc_Disable;
DMA_InitStructure.DMA_MemoryInc = DMA_MemoryInc_Enable;
DMA_InitStructure.DMA_PeripheralDataSize = DMA_PeripheralDataSize_Byte;
DMA_InitStructure.DMA_MemoryDataSize = DMA_MemoryDataSize_Byte;
DMA_InitStructure.DMA_Mode = DMA_Mode_Normal;
DMA_InitStructure.DMA_Priority = DMA_Priority_VeryHigh;
DMA_InitStructure.DMA_M2M = DMA_M2M_Disable;
DMA_Init(DMA1_Channel4, &DMA_InitStructure);
DMA_InitStructure.DMA_MemoryBaseAddr = (u32)DuumyClock; //512字节的dummy
DMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralDST;
//DMA_InitStructure.DMA_Mode = DMA_Mode_Circular;
DMA_InitStructure.DMA_Priority = DMA_Priority_Low;
DMA_Init(DMA1_Channel5, &DMA_InitStructure);
/* Enable DMA1 Channel4 Transfer Complete interrupt */
DMA_ITConfig(DMA1_Channel4, DMA_IT_TC, ENABLE);
/* Enable DMA1 Channel5 Transfer Complete interrupt */
DMA_ITConfig(DMA1_Channel5, DMA_IT_TC, ENABLE);
SPI_I2S_DMACmd(SPI2, SPI_I2S_DMAReq_Tx, ENABLE);
SPI_I2S_DMACmd(SPI2, SPI_I2S_DMAReq_Rx, ENABLE);
/* Send CMD17 (MSD_READ_SINGLE_BLOCK) to read one block */
MSD_SendCmd(CMD17, ReadAddr, 0xFF);
/* Check if the MSD acknowledged the read block command: R1 response (0x00: no errors) */
if (!MSD_GetResponse(MSD_RESPONSE_NO_ERROR))
{
/* Now look for the data token to signify the start of the data */
if (!MSD_GetResponse(MSD_START_DATA_SINGLE_BLOCK_READ))
{
DMA_Cmd(DMA1_Channel5, ENABLE);
DMA_Cmd(DMA1_Channel4, ENABLE);
#ifdef DMA1_IRQ
OSFlagPend(Sem_SD_DMA, (OS_FLAGS)3, OS_FLAG_WAIT_SET_ALL, 0, &err); //请求信号量集的第0和第1位且都置1。
//debug("MSD_ReadBlock_DMA OSFlagPend err=%d \r\n",err);
DMA_ClearFlag(DMA1_FLAG_TC4);
#else
while(!DMA_GetFlagStatus(DMA1_FLAG_TC5));
while(!DMA_GetFlagStatus(DMA1_FLAG_TC4));
DMA_ClearFlag(DMA1_FLAG_TC4);
#endif
/* Get CRC bytes (not really needed by us, but required by MSD) */
MSD_ReadByte();
MSD_ReadByte();
/* Set response value to success */
rvalue = MSD_RESPONSE_NO_ERROR;
}
else
{
//debug("\r\n erro:MSD_START_DATA_SINGLE_BLOCK_READ\r\n");
}
}
else
{
//debug("\r\n error:MSD_RESPONSE_NO_ERROR\r\n");
}
DMA_Cmd(DMA1_Channel4, DISABLE);
DMA_Cmd(DMA1_Channel5, DISABLE);
/* MSD chip select high */
MSD_CS_HIGH();
/* Send dummy byte: 8 Clock pulses of delay */
MSD_WriteByte(DUMMY_BYTE);
/* Send stop data transmit command - CMD12 */
_send_command(CMD12, 0, 0);
/* Returns the reponse */
return rvalue;
}
/************************************************************************************
* Function Name : MSD_WriteMultipleBlock_DMA(uint32_t sector, uc8 *buffer，u16 NumByteToWrite)
* Description : None
* Input : - sector:
* - buffer:
* Output : None
* Return : None
* Attention : None
************************************************************************************/
int MSD_WriteMultipleBlock_DMA(uint32_t sector, uc8 *buffer, u8 NbrOfSector, u16 NumByteToWrite)
{
uint8 r1;
// uint16_t i=0;
uint32_t retry;
u8 value = 0;
// INT8U err;
u8 rvalue = MSD_RESPONSE_FAILURE;
DMA_InitTypeDef DMA_InitStructure; //定义DMA初始化结构体
/*begin:yangfei added 2012.11.29*/
// debug("MSD_WriteMultipleBlock_DMA\r\n");
_card_enable();
DMA_DeInit(DMA1_Channel5);
DMA_InitStructure.DMA_PeripheralBaseAddr = (u32)&SPI2->DR;
DMA_InitStructure.DMA_MemoryBaseAddr = (u32)buffer;
DMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralDST;
DMA_InitStructure.DMA_BufferSize = NumByteToWrite;
DMA_InitStructure.DMA_PeripheralInc = DMA_PeripheralInc_Disable;
DMA_InitStructure.DMA_MemoryInc = DMA_MemoryInc_Enable;
DMA_InitStructure.DMA_PeripheralDataSize = DMA_PeripheralDataSize_Byte;
DMA_InitStructure.DMA_MemoryDataSize = DMA_MemoryDataSize_Byte;
DMA_InitStructure.DMA_Mode = DMA_Mode_Normal;
DMA_InitStructure.DMA_Priority = DMA_Priority_Medium;
DMA_InitStructure.DMA_M2M = DMA_M2M_Disable;
DMA_Init(DMA1_Channel5, &DMA_InitStructure);
/* Enable DMA1 Channel5 Transfer Complete interrupt */
DMA_ITConfig(DMA1_Channel5, DMA_IT_TC, ENABLE);
SPI_I2S_DMACmd(SPI2, SPI_I2S_DMAReq_Tx, ENABLE);
/*end:yangfei added 2012.11.29*/
//SPI_DMA_Send_Init(buffer,MSD_BLOCKSIZE);
/* if ver = SD2.0 HC, sector need <<9 */
if(CardInfo.CardType != CARDTYPE_SDV2HC)
{
sector = sector << 9;
}
if(CardInfo.CardType != CARDTYPE_MMC)
{
_send_command(ACMD23, NbrOfSector, 0);
}
/* Send CMD25 : Write multiple block command */
MSD_SendCmd(CMD25, sector, 0xff);
//_spi_read_write(DUMMY_BYTE);
//_spi_read_write(DUMMY_BYTE);
if (!MSD_GetResponse(MSD_RESPONSE_NO_ERROR))
{
_spi_read_write(DUMMY_BYTE);
/* Start data write token: 0xFE */
_spi_read_write(0xFC);
/*begin:yangfei added 2012.11.28*/
DMA_Cmd(DMA1_Channel5, ENABLE);
#ifdef DMA1_IRQ
OSFlagPend(Sem_SD_DMA, (OS_FLAGS)1, OS_FLAG_WAIT_SET_ALL, 0, &err); //请求信号量集的第0位置1
DMA_ClearFlag(DMA1_FLAG_TC5);
#else
while(!DMA_GetFlagStatus(DMA1_FLAG_TC5)) ;
DMA_ClearFlag(DMA1_FLAG_TC5);
#endif
/* 2Bytes dummy CRC */
_spi_read_write(DUMMY_BYTE);
_spi_read_write(DUMMY_BYTE);
value = MSD_GetDataResponse();
if (value == MSD_DATA_OK)
{
rvalue = MSD_RESPONSE_NO_ERROR;
}
// debug("value=%x\r\n",value);
}
/* Send end of transmit token: 0xFD */
r1 = _spi_read_write(0xFD);
if(r1 == 0x00)
{
return 4;
}
/*begin:yangfei added 2012.12.07 for wait programm finished else write error*/
/* Wait all the data programm finished */
retry = 0;
while(_spi_read_write(DUMMY_BYTE) == 0x00)
{
/* Timeout return */
if(retry++ == 0x40000)
{
_card_disable();
return 3;
}
}
/* chip disable and dummy byte */
_card_disable();
_spi_read_write(DUMMY_BYTE);
/*yangfei added*/
DMA_Cmd(DMA1_Channel5, DISABLE);
return rvalue;
}
void UserTask(void* pdata)
{
auto char key;
auto int CurrentX;
auto int CurrentY;
auto int CurrentChoice;
auto BOOLEAN done;
auto int position;
auto INT8U err;
auto INT16U returnedflags;
auto char num[2];
while(1)
{
done = FALSE;
CurrentX = 11;
CurrentY = 27;
CurrentChoice = 0;
position = 0;
returnedflags = 0;
memset(PatternGuess, 0, sizeof(PatternGuess));
DispStr(CurrentX, CurrentY, Colors[CurrentChoice], " ");
DispStr(CurrentX + 4, CurrentY, BGBLACK, " ");
DispStr(CurrentX + 8, CurrentY, BGBLACK, " ");
DispStr(CurrentX + 12, CurrentY, BGBLACK, " ");
DispStr(CurrentX, CurrentY + 2, DEF_TEXT_COLOR, "+");
// get a pattern from the user
while(!done)
{
if(kbhit())
{
key = getchar();
switch(key)
{
case 0x38: // up
CurrentChoice++;
CurrentChoice %= COLEND;
DispStr(CurrentX, CurrentY, Colors[CurrentChoice], " ");
PatternGuess[position] = CurrentChoice;
break;
case 0x32: // down
CurrentChoice--;
if(CurrentChoice < 0) CurrentChoice = COLEND - 1;
CurrentChoice %= COLEND;
DispStr(CurrentX, CurrentY, Colors[CurrentChoice], " ");
PatternGuess[position] = CurrentChoice;
break;
case 0x34: // left
if(position > 0)
{
DispStr(CurrentX, CurrentY + 2, DEF_TEXT_COLOR, " ");
position--;
CurrentChoice = PatternGuess[position];
CurrentX -= 4;
DispStr(CurrentX, CurrentY, Colors[CurrentChoice], " ");
DispStr(CurrentX, CurrentY + 2, DEF_TEXT_COLOR, "+");
}
break;
case 0x36: // right
if(position < 3)
{
DispStr(CurrentX, CurrentY + 2, DEF_TEXT_COLOR, " ");
position++;
CurrentChoice = PatternGuess[position];
CurrentX += 4;
DispStr(CurrentX, CurrentY, Colors[CurrentChoice], " ");
DispStr(CurrentX, CurrentY + 2, DEF_TEXT_COLOR, "+");
}
break;
case 0x0d:
done = TRUE;
DispStr(CurrentX, CurrentY + 2, DEF_TEXT_COLOR, " ");
break;
}
}
}
// let the master task know which colors in what order were selected
OSMutexPend(GuessMutex, 0, &err);
if(err != OS_NO_ERR)
exit(err);
GuessDone = TRUE;
OSMutexPost(GuessMutex);
// pend on flags from master task to let us know how many colors
// were selected in the correct location
OSFlagPend(ColorFlags, FLAG_GUESS_DONE | FLAG_COLORS_DONE | FLAG_POSITIONS_DONE |
FLAG_PATTERN_DONE | FLAG_COLOR_MARKERS_DONE | FLAG_POSITION_MARKERS_DONE,
OS_FLAG_WAIT_SET_ALL + OS_FLAG_CONSUME, 0, &err);
// Once all flags have been set by master task, CorrectLocations and
// CorrectColors are valid. If CorrectColors and CorrectLocations are both
// 4, then correct pattern has been guessed.
if(CorrectColors != 4 && CorrectLocations != 4)
{
sprintf(num, "%d", CorrectColors);
DispStr(29, 30, FGWHITE BGBLACK, num);
sprintf(num, "%d", CorrectLocations);
DispStr(29, 31, FGWHITE BGBLACK, num);
}
}
}
ADI_OSAL_STATUS adi_osal_EventPend (ADI_OSAL_EVENT_HANDLE const hEventGroup,
ADI_OSAL_EVENT_FLAGS nRequestedEvents,
ADI_OSAL_EVENT_FLAG_OPTION eGetOption,
ADI_OSAL_TICKS nTimeoutInTicks,
ADI_OSAL_EVENT_FLAGS *pnReceivedEvents)
{
INT8U nErr;
INT8U nWaitOption = OS_FLAG_WAIT_SET_ALL;
OS_FLAGS nRetValue;
ADI_OSAL_STATUS eRetStatus;
#pragma diag(push)
#pragma diag(suppress:misra_rule_11_4 : "typecasting is necessary to convert the handle type into a native uCOS pointer")
OS_FLAG_GRP *hEventNative = (OS_FLAG_GRP*) hEventGroup;
#pragma diag(pop)
#ifdef OSAL_DEBUG
if ( (nTimeoutInTicks > ADI_OSAL_MAX_TIMEOUT) &&
(nTimeoutInTicks != ADI_OSAL_TIMEOUT_FOREVER) )
{
return (ADI_OSAL_BAD_TIME);
}
if ((CALLED_FROM_AN_ISR) || (CALLED_IN_SCHED_LOCK_REGION))
{
return (ADI_OSAL_CALLER_ERROR);
}
if ( (eGetOption != ADI_OSAL_EVENT_FLAG_ANY) &&
(eGetOption != ADI_OSAL_EVENT_FLAG_ALL) )
{
return (ADI_OSAL_BAD_OPTION);
}
if ((NULL == hEventGroup) || (ADI_OSAL_INVALID_EVENT_GROUP == hEventGroup))
{
return(ADI_OSAL_BAD_HANDLE);
}
#endif /* OSAL_DEBUG */
if(eGetOption == ADI_OSAL_EVENT_FLAG_ANY)
{
nWaitOption = OS_FLAG_WAIT_SET_ANY;
}
switch (nTimeoutInTicks)
{
case ADI_OSAL_TIMEOUT_NONE:
nRetValue = OSFlagAccept(hEventNative, (OS_FLAGS) nRequestedEvents, nWaitOption, &nErr);
break;
case ADI_OSAL_TIMEOUT_FOREVER:
nRetValue = OSFlagPend(hEventNative, (OS_FLAGS) nRequestedEvents, nWaitOption, 0u, &nErr);
break;
default:
#pragma diag(push)
#pragma diag(suppress:misra_rule_10_1_c : "we have checked that the timeout is 16-bit or less in debug so we can cast it without losing information")
nRetValue = OSFlagPend(hEventNative, (OS_FLAGS) nRequestedEvents, nWaitOption, (INT16U) nTimeoutInTicks, &nErr);
break;
#pragma diag(pop)
}
switch (nErr)
{
case OS_ERR_NONE:
eRetStatus = ADI_OSAL_SUCCESS;
break;
case OS_ERR_TIMEOUT:
eRetStatus = ADI_OSAL_TIMEOUT;
break;
#ifdef OSAL_DEBUG
case OS_ERR_EVENT_TYPE: /* FALLTHROUGH */
case OS_ERR_FLAG_INVALID_PGRP:
eRetStatus = ADI_OSAL_BAD_HANDLE;
break;
case OS_ERR_PEND_ISR:
eRetStatus = ADI_OSAL_CALLER_ERROR;
break;
case OS_ERR_FLAG_WAIT_TYPE:
eRetStatus = ADI_OSAL_BAD_OPTION;
break;
#endif /* OSAL_DEBUG */
default:
eRetStatus = ADI_OSAL_FAILED;
break;
}
/* uC/OS also sets its return value (nRetValue) to be 0 in case of error */
*pnReceivedEvents = (uint32_t) nRetValue;
return( eRetStatus );
}
