void LedFont_Scroller(void *pdata) {
INT8U err;
char *p;
short x, xStart;
(void)pdata; /* avoid compiler warning */
OSFlagPost(LedFont_Flags, LEDFONT_FLAG_READY, OS_FLAG_SET, &err); /* announce that we are ready */
for(;;) { /* forever */
while (LedFont_Text[0] == '\0') { /* no text */
LedFont_Stop();
}
for(xStart=GDisp1_GetWidth()-1;;xStart--) {
GDisp1_Clear();
p = &LedFont_Text[0]; /* get character */
x = xStart;
while(*p != '\0') { /* go through the text */
x += LedFont_PutChar(*p, x);
p++; /* next character */
x++; /* add a space between characters */
}
GDisp1_UpdateFull();
if (x <= 0) { /* reached end of text to scroll: start over again */
LedFont_Stop();
break; /* start again */
}
(void)OSTimeDlyHMSM(0,0,0,60); /* delay specifies the scrolling speed */
if (OSFlagQuery(LedFont_Flags, &err)&LEDFONT_FLAG_QUIT) { /* E8 pressed: quit */
OSFlagPost(LedFont_Flags, LEDFONT_FLAG_QUIT, OS_FLAG_CLR, &err); /* clear flag */
LedFont_Stop();
break; /* start again */
}
} /* for */
}
}
// ------------------------------------------------------------------------------------------------
void TaskCapteurs_CheckBumpers()
{
char uart_buffer[8];
char * buffer_ptr;
INT8U Err = 0; // Var to get error status
CPU_INT16U GP2Data;
//GP2_1 : Front *************************************************
GP2Data = ADC_GetVal (GP2_1);
//putsUART2("GP2_1 : ");
//buffer_ptr = (char*) Str_FmtNbr_32 ((CPU_FP32) GP2Data, (CPU_INT08U) 4, (CPU_INT08U) 1, (CPU_BOOLEAN) DEF_YES, (CPU_BOOLEAN) DEF_YES, uart_buffer);
//putsUART2(buffer_ptr);
//putsUART2(" ");
// Check Value
#ifdef APP_GP2D2_LIMIT_FRONT
if(GP2Data > APP_GP2D2_LIMIT_FRONT)
OSFlagPost(AppFlags, APP_PARAM_APPFLAG_GP2D2_FRONT, OS_FLAG_SET, &Err);
else
OSFlagPost(AppFlags, APP_PARAM_APPFLAG_GP2D2_FRONT, OS_FLAG_CLR, &Err);
#endif
//GP2_2 : Back **************************************************
GP2Data = ADC_GetVal (GP2_2);
// putsUART2("GP2_2 : ");
// buffer_ptr = (char*) Str_FmtNbr_32 ((CPU_FP32) GP2Data, (CPU_INT08U) 4, (CPU_INT08U) 1, (CPU_BOOLEAN) DEF_YES, (CPU_BOOLEAN) DEF_YES, uart_buffer);
// putsUART2(buffer_ptr);
// putsUART2(" ");
// Check Value
#ifdef APP_GP2D2_LIMIT_BACK
if(GP2Data > APP_GP2D2_LIMIT_BACK)
OSFlagPost(AppFlags, APP_PARAM_APPFLAG_GP2D2_BACK, OS_FLAG_SET, &Err);
else
OSFlagPost(AppFlags, APP_PARAM_APPFLAG_GP2D2_BACK, OS_FLAG_CLR, &Err);
#endif
//GP2_3 : Not Used **********************************************
//GP2Data = ADC_GetVal (GP2_3);
//putsUART2("GP2_3 : ");
//buffer_ptr = (char*) Str_FmtNbr_32 ((CPU_FP32) GP2Data, (CPU_INT08U) 4, (CPU_INT08U) 1, (CPU_BOOLEAN) DEF_YES, (CPU_BOOLEAN) DEF_YES, uart_buffer);
//putsUART2(buffer_ptr);
//putsUART2(" ");
//GP2_4 : Not Used **********************************************
//GP2Data = ADC_GetVal (GP2_4);
//putsUART2("GP2_4 : ");
//buffer_ptr = (char*) Str_FmtNbr_32 ((CPU_FP32) GP2Data, (CPU_INT08U) 4, (CPU_INT08U) 1, (CPU_BOOLEAN) DEF_YES, (CPU_BOOLEAN) DEF_YES, uart_buffer);
//putsUART2(buffer_ptr);
//putsUART2(" ");
//GP2_5 : Not Used **********************************************
//GP2Data = ADC_GetVal (GP2_5);
//putsUART2("GP2_5 : ");
//buffer_ptr = (char*) Str_FmtNbr_32 ((CPU_FP32) GP2Data, (CPU_INT08U) 4, (CPU_INT08U) 1, (CPU_BOOLEAN) DEF_YES, (CPU_BOOLEAN) DEF_YES, uart_buffer);
//putsUART2(buffer_ptr);
//putsUART2("\n");
return;
}
void TaskCapteurs_CheckClicClic()
{
INT8U Err = 0; // Var to get error status
// CLIC_1 : Front Left ******************************************
if(CLIC_state(CLIC_1))
OSFlagPost(AppFlags, APP_PARAM_APPFLAG_BUMPER_CLIC1, OS_FLAG_SET, &Err);
else
OSFlagPost(AppFlags, APP_PARAM_APPFLAG_BUMPER_CLIC1, OS_FLAG_CLR, &Err);
// CLIC_2 : Front Right *****************************************
if(CLIC_state(CLIC_2))
OSFlagPost(AppFlags, APP_PARAM_APPFLAG_BUMPER_CLIC2, OS_FLAG_SET, &Err);
else
OSFlagPost(AppFlags, APP_PARAM_APPFLAG_BUMPER_CLIC2, OS_FLAG_CLR, &Err);
// CLIC_3 : Front Center ****************************************
if(CLIC_state(CLIC_3))
OSFlagPost(AppFlags, APP_PARAM_APPFLAG_BUMPER_CLIC3, OS_FLAG_SET, &Err);
else
OSFlagPost(AppFlags, APP_PARAM_APPFLAG_BUMPER_CLIC3, OS_FLAG_CLR, &Err);
// CLIC_4 : Back Center *****************************************
if(CLIC_state(CLIC_4))
OSFlagPost(AppFlags, APP_PARAM_APPFLAG_BUMPER_CLIC4, OS_FLAG_SET, &Err);
else
OSFlagPost(AppFlags, APP_PARAM_APPFLAG_BUMPER_CLIC4, OS_FLAG_CLR, &Err);
}
void osSetEvent(OsEvent *event)
{
OS_ERR err;
//Set the specified event to the signaled state
OSFlagPost(event, 1, OS_OPT_POST_FLAG_SET, &err);
}
void osResetEvent(OsEvent *event)
{
OS_ERR err;
//Force the specified event to the nonsignaled state
OSFlagPost(event, 1, OS_OPT_POST_FLAG_CLR, &err);
}
/*!
*******************************************************************************
This allows the NDS Core to start the audio decoding.
Start audio decoding using the PID previously set using the function
HDISetAudioPID. Take no action and return with an HDI_STATUS of NO_PID
if HDISetAudioPID has not been previously called.
\param None
\return \OK
\NOT_OK
\NO_PID
******************************************************************************/
HDI_STATUS HDIStartAudio(void)
{
#ifdef COMPILE_FOR_CORE
SYS_DEBUG_INFO(DEBL0_NSTR, (CSTR*)" HDIStartAudio ",0,0,0);
SYS_DEBUG_INFO(DEBL0_NSTR, (CSTR*)"6 AudioPID: ",AudioPID,0,0);
if(AudioPID == 0)
return (NO_PID);
if((AudioPID < 0x20)||(AudioPID > 0x1FFE))
return (PARAMETER_ERROR);
GD_AUD_Open(AudioPID);
GD_AUD_Start();
if(audioMute == GFALSE)
GD_AO_UnMute();
OSFlagPost(audiotaskprio, AUDIO_STATUS_STARTED);
return (OK);
#else
return(FEATURE_NOT_SUPPORTED);
#endif
}
BOOL
xMBMasterPortEventPost( eMBMasterEventType eEvent )
{ uint8_t err=OS_ERR_NONE;
//rt_event_send(&xMasterOsEvent, eEvent);
// return TRUE;
OSFlagPost(xMasterOsEvent, eEvent, OS_FLAG_SET, &err);//
return TRUE;
}
static void LedFont_Stop(void) {
INT8U err;
if (LedFont_ScrollOnce) {
OSFlagPost(LedFont_Flags, LEDFONT_FLAG_FINISHED_SCROLLING, OS_FLAG_SET, &err); /* clear all button flags */
}
OSTaskSuspend(OS_PRIO_SELF); /* put task to sleep */
}
void mouseCalibInitStep()
{
OSFlagPost(flagCalibStep,
0xFF,
OS_FLAG_CLR,
&OSLastError);
LOG_TEST_OS_ERROR(OSLastError);
}
void mouseCalibSetStep(int i)
{
OSFlagPost(flagCalibStep,
(0x01 << i),
OS_FLAG_SET,
&OSLastError);
LOG_TEST_OS_ERROR(OSLastError);
}
/*
*********************************************************************************************************
* STARTUP TASK
*
* Description : This is an example of a startup task. As mentioned in the book's text, you MUST
* initialize the ticker only once multitasking has started.
*
* Arguments : p_arg is the argument passed to 'AppTask_2()' by 'OSTaskCreate()'.
*
* Returns : none
*
* Notes : 1) The first line of code is used to prevent a compiler warning because 'p_arg' is not
* used. The compiler should not generate any code for this statement.
*********************************************************************************************************
*/
void CRYPTO_IRQHandler()
{
INT8U err;
if (CRPT->INTSTS & CRPT_INTSTS_PRNGIF_Msk)
{
OSFlagPost(pSecureEventFlagGrp, 0x1, OS_FLAG_SET, &err);
CRPT->INTSTS = CRPT_INTSTS_PRNGIF_Msk;
}
}
bool_t osSetEventFromIsr(OsEvent *event)
{
OS_ERR err;
//Set the specified event to the signaled state
OSFlagPost(event, 1, OS_OPT_POST_FLAG_SET, &err);
//The return value is not relevant
return FALSE;
}
//-----------------------------------------------------------------------------------
// After the transmission begin , this funtion used to give event
//-----------------------------------------------------------------------------------
LOCAL void _SetCardEvent (SDIO_CARD_PAL_HANDLE handle,uint32 EventId)
{
#if defined (UCOS_BSD_EVENT)
INT8U err;
OSFlagPost (handle->sdio_event, EventId, OS_FLAG_SET, &err);
#elif defined (CARD_SDIO_EVENT)
SCI_SetEvent (handle->sdio_event,EventId,SCI_OR);
#else
s_CardEvent |= EventId;
#endif
}
/**
* This is modbus master execute function error process callback function.
* @note There functions will block modbus master poll while execute OS waiting.
* So,for real-time of system.Do not execute too much waiting process.
*
* @param ucDestAddress destination salve address
* @param pucPDUData PDU buffer data
* @param ucPDULength PDU buffer length
*
*/
void vMBMasterErrorCBExecuteFunction(UCHAR ucDestAddress, const UCHAR* pucPDUData,
USHORT ucPDULength) {
/**
* @note This code is use OS's event mechanism for modbus master protocol stack.
* If you don't use OS, you can change it.
*/
uint8_t err=OS_ERR_NONE;
//rt_event_send(&xMasterOsEvent, EV_MASTER_ERROR_EXECUTE_FUNCTION);
OSFlagPost(xMasterOsEvent,EV_MASTER_ERROR_EXECUTE_FUNCTION,OS_FLAG_SET,&err);//
/* You can add your code under here. */
}
int flag_event_post(flag_event_t *event){
/* Make sure that interrupt flag is set */
#if defined(OS_FREERTOS)
xEventGroupSetBits(
*event,
(((uint8_t)1)<< 0));
#elif defined(OS_UCOS)
OS_ERR err;
OSFlagPost(event, 1, OS_OPT_POST_FLAG_SET, &err);
#endif
return 0;
}
void onStatusChanged(void)
{
uint8_t pin;
OS_ERR error;
pin = GPIO_ReadInputDataBit(GPIOE, GPIO_Pin_14);
if( pin == Bit_RESET )
{
OSFlagPost( &SIM90X_Flags,
SIM90X_POWER_FLAG,
OS_OPT_POST_FLAG_CLR,
&error);
}
else
{
OSFlagPost( &SIM90X_Flags,
SIM90X_POWER_FLAG,
OS_OPT_POST_FLAG_SET,
&error);
}
}
/******************************************************
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 AppTaskObj0 (void *p_arg)
{
OS_ERR os_err;
(void)p_arg;
while (DEF_TRUE) {
#if (OS_CFG_SEM_EN > 0u)
OSSemPost(&AppTaskObjSem,
OS_OPT_POST_1,
&os_err);
#endif
#if (OS_CFG_MUTEX_EN > 0u)
OSMutexPend(&AppTaskObjMutex,
0,
OS_OPT_PEND_BLOCKING,
0,
&os_err);
OSTimeDlyHMSM( 0u, 0u, 0u, 100u,
OS_OPT_TIME_HMSM_STRICT,
&os_err);
OSMutexPost(&AppTaskObjMutex,
OS_OPT_POST_NONE,
&os_err);
#endif
#if (OS_CFG_Q_EN > 0u)
OSQPost( &AppTaskObjQ,
(void *) 1u,
1u,
OS_OPT_POST_FIFO,
&os_err);
#endif
#if (OS_CFG_FLAG_EN > 0u)
OSFlagPost(&AppTaskObjFlag,
DEF_BIT_00,
OS_OPT_POST_FLAG_SET,
&os_err);
#endif
OSTimeDlyHMSM( 0u, 0u, 0u, 10u,
OS_OPT_TIME_HMSM_STRICT,
&os_err);
APP_TRACE_INFO(("Object test task 0 running ....\n"));
}
}
//-----------------------------------------------------------------------------------
// Clear all event happened before ,and prepare next transmission
//-----------------------------------------------------------------------------------
LOCAL void _InitCardEvent (SDIO_CARD_PAL_HANDLE handle)
{
s_CardErrCode = 0;
#if defined (UCOS_BSD_EVENT)
{
INT8U err;
OSFlagPost (handle->sdio_event, 0xFFFFFFFF, OS_FLAG_CLR, &err);
}
#elif defined (CARD_SDIO_EVENT)
SCI_SetEvent (handle->sdio_event,0,SCI_AND);
#else
s_CardEvent = 0;
#endif
}
/*!
*******************************************************************************
This function starts playing an audio sound file.
If the sound files feature is not supported, take no action and return with an
HDI_STATUS of FEATURE_NOT_SUPPORTED.
If a sound file is already being played, call the function HDIStopSoundFile
to immediately stop the current sound file.
If the audio type specified by the audio_type parameter is not supported,
take no action and return with an HDI_STATUS of AUDIO_TYPE_NOT_SUPPORTED.
Start playing the sound file pointed to by the c\ audio_sample parameter and
return immediately with an HDI_STATUS of OK.
Post the event HDI_PL_AUDIO_FILE_COMPLETED_XT when the complete sound
file has been played.
The sound file should be played once only; it should not be looped.
\param audio_type Identifies the format of the audio sample data (MPEG-1 layer 1
and layer 2 packetised elementary stream)
\param audio_sample Pointer to the start of the audio sound file
\param number_of_bytes Total number of bytes contained within the audio sound file
\param event_qualifier Event qualifier to identify this play request
\return \OK
\NOT_OK
\FEATURE_NOT_SUPPORTED
\PARAMETER_ERROR
\AUDIO_TYPE_NOT_SUPPORTED
******************************************************************************/
HDI_STATUS HDIPlaySoundFile(AUDIO_TYPE audio_type,
UBYTE *audio_sample,
ULONG number_of_bytes,
ULONG event_qualifier)
{
#ifdef COMPILE_FOR_CORE
//U32* data_address = (U32*)audio_sample;
U32 audio_number_of_bytes = 0;
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);
SYS_DEBUG_INFO(DEBL0_NSTR, (CSTR*)" test ",0,0,0);
OSTimeDly(50);
}
loadcompleted.event_qualifier = event_qualifier;
memDataSize = number_of_bytes;
memDataAddr = audio_sample;
SYS_DEBUG_INFO(DEBL0_NSTR, (CSTR*)" HDIPlaySoundFile ",0,0,0);
if((audio_type != MPEG1_PES)&&(audio_type != MPEG2_PES))
return (PARAMETER_ERROR);
if(audio_sample == NULL)
return (PARAMETER_ERROR);
if(number_of_bytes == NULL)
return (PARAMETER_ERROR);
GD_AUD_OpenMemory();
GD_AO_UnMute();
audio_number_of_bytes = GHA_FeedDataBytes(audio_sample, (U32)number_of_bytes, &dataIndex, &lastDataIndex,&pesLen, GTRUE);
if(audio_number_of_bytes == 0) return (NOT_OK);
if(audio_number_of_bytes < 0x10) return (PARAMETER_ERROR);
GHA_FlushData(audio_number_of_bytes);
soundFileFlag = AUDIO_PLAYED;
OSFlagPost(audiotaskprio, AUDIO_FILE_PLAYED);
return (OK);
#else
return(FEATURE_NOT_SUPPORTED);
#endif
}
/*FUNCTION**********************************************************************
*
* Function Name : OSA_EventClear
* Description : Clear one or more event flags of an event object.
* Return kStatus_OSA_Success if clear successfully, kStatus_OSA_Error if failed.
*
*END**************************************************************************/
osa_status_t OSA_EventClear(event_t *pEvent, event_flags_t flagsToClear)
{
OS_ERR err;
OSFlagPost(&(pEvent->group), flagsToClear, OS_OPT_POST_FLAG_CLR, &err);
if (OS_ERR_NONE == err)
{
return kStatus_OSA_Success;
}
else
{
return kStatus_OSA_Error;
}
}
/****************************************************************************************
rfid处理程序
****************************************************************************************/
void rfid_proc_task(void *pdata)
{
u8 err;
pdata = pdata;
rfid_gpio_init();
for( port_id = 0 ; port_id < MAX_RFID_CNT ; port_id++ )
InitRc522();
while(1)
{
RC522();
OSTimeDly(5);
OSFlagPost(TaskCheckOSFlag,OSFLAG_RFID_PROC_TASK,OS_FLAG_SET,&err);
}
}
/*FUNCTION**********************************************************************
*
* Function Name : OSA_EventClear
* Description : Clear one or more event flags of an event object.
* Return kStatus_OSA_Success if clear successfully, kStatus_OSA_Error if failed.
*
*END**************************************************************************/
osa_status_t OSA_EventClear(event_t *pEvent, event_flags_t flagsToClear)
{
INT8U err;
OSFlagPost(pEvent->pGroup, flagsToClear, OS_FLAG_CLR, &err);
if (OS_ERR_NONE == err)
{
return kStatus_OSA_Success;
}
else
{
return kStatus_OSA_Error;
}
}
static ADI_OSAL_STATUS osal_ModifyFlags( ADI_OSAL_EVENT_HANDLE const hEventGroup,
ADI_OSAL_EVENT_FLAGS nEventFlags,
uint32_t nOption )
{
INT8U nErr;
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 ((NULL == hEventGroup) || (ADI_OSAL_INVALID_EVENT_GROUP == hEventGroup))
{
return(ADI_OSAL_BAD_HANDLE);
}
#endif /* OSAL_DEBUG */
/* Only SET operations are allowed in the adi_osal_EventPost API */
OSFlagPost(hEventNative,
(OS_FLAGS) nEventFlags,
(INT8U) nOption,
&nErr);
switch (nErr)
{
case OS_ERR_NONE:
eRetStatus = ADI_OSAL_SUCCESS;
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_FLAG_INVALID_OPT:
eRetStatus = ADI_OSAL_FAILED;
break;
#endif /* OSAL_DEBUG */
default:
eRetStatus = ADI_OSAL_FAILED;
break;
} /* end of switch */
return( eRetStatus );
}
void LedFont_ScrollText(char *text, bool scrollOnce, bool waitForFinish) {
INT8U err;
UTIL1_strcpy((uint8_t*)LedFont_Text, sizeof(LedFont_Text), (const unsigned char*)text);
LedFont_ScrollOnce = scrollOnce;
while (!(OSFlagQuery(LedFont_Flags, &err)&LEDFONT_FLAG_READY)) {
(void)OSTimeDlyHMSM(0,0,0,100); /* wait task to be ready */
}
OSTaskResume(TASK_PRIO_SCROLLER);
if (scrollOnce && waitForFinish) {
while (!(OSFlagQuery(LedFont_Flags, &err)&LEDFONT_FLAG_FINISHED_SCROLLING)) {
(void)OSTimeDlyHMSM(0,0,0,100); /* wait for scrolling to be finished */
}
OSFlagPost(LedFont_Flags, LEDFONT_FLAG_FINISHED_SCROLLING, OS_FLAG_CLR, &err); /* clear flag */
}
}
/*!
*******************************************************************************
This allows the NDS Core to stop the MPEG audio decoding process.
Stop the audio decoding process and mute the audio output.
\param None
\return \OK
\NOT_OK
******************************************************************************/
HDI_STATUS HDIStopAudio(void)
{
#ifdef COMPILE_FOR_CORE
SYS_DEBUG_INFO(DEBL0_NSTR, (CSTR*)" HDIStopAudio ",0,0,0);
GD_AO_Mute();
//GD_AUD_CloseMemory(GTRUE);
GD_AUD_Stop();
GD_AUD_Close();
OSFlagPost(audiotaskprio, AUDIO_STATUS_STOPPED);
return (OK);
#else
return(FEATURE_NOT_SUPPORTED);
#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;
}
void vMBMasterErrorCBRespondTimeout(UCHAR ucDestAddress, const UCHAR* pucPDUData,
USHORT ucPDULength) {
/**
* @note This code is use OS's event mechanism for modbus master protocol stack.
* If you don't use OS, you can change it.
*/
uint8_t err=OS_ERR_NONE;
//rt_event_send(&xMasterOsEvent, EV_MASTER_ERROR_RESPOND_TIMEOUT);
OSFlagPost(xMasterOsEvent,EV_MASTER_ERROR_RESPOND_TIMEOUT,OS_FLAG_SET,&err);//
/* You can add your code under here. */
switch(ucDestAddress){
case 1:
CommxTimeOut1=1;
break;
case 2:
CommxTimeOut2=1;
break;
}
}
//void vMBMasterCBRequestScuuess( void ) {
void vMBMasterCBRequestScuuess(UCHAR ucDestAddress/*, const UCHAR* pucPDUData,
USHORT ucPDULength*/) {
/**
* @note This code is use OS's event mechanism for modbus master protocol stack.
* If you don't use OS, you can change it.
*/
uint8_t err=OS_ERR_NONE;
//rt_event_send(&xMasterOsEvent, EV_MASTER_PROCESS_SUCESS);
OSFlagPost(xMasterOsEvent,EV_MASTER_PROCESS_SUCESS,OS_FLAG_SET,&err);//
/* You can add your code under here. */
switch(ucDestAddress){
case 1:
CommxTimeOut1=0;
break;
case 2:
CommxTimeOut2=0;
break;
}
}
// ------------------------------------------------------------------------------------------------
// TaskCapteurs_Main()
// ------------------------------------------------------------------------------------------------
void TaskCapteurs_Main(void *p_arg)
{
INT8U Err = 0; // Var to get error status
CPU_INT16U GP2Data;
putsUART2("OUFFF TEAM 2010 : Capteurs online\n");
// We set the current color
OSTimeDlyHMSM(0, 0, 0, 500);
TaskCapteurs_ReadColor();
#ifdef _TARGET_STARTER_KIT
OSTimeDlyHMSM(0, 0, 0, 500); LED_Off(1);
OSTimeDlyHMSM(0, 0, 0, 500); LED_Off(2);
OSTimeDlyHMSM(0, 0, 0, 500); LED_Off(3);
#else
// Comment this part to disable start button detection
// We're waiting for Start button release
while(OS_FALSE == TaskCapteurs_IsStartButtonPressed())
OSTimeDly(1); // Release proc
// We're waiting for start button activation
while(OS_TRUE == TaskCapteurs_IsStartButtonPressed())
OSTimeDly(1); // Release proc
#endif
// StartButton has been pressed
OSFlagPost(AppFlags, APP_PARAM_APPFLAG_START_BUTTON, OS_FLAG_SET, &Err);
while(OS_TRUE) // Main task: we check all other sensors
{
OSTimeDlyHMSM(0, 0, 0, 10);
TaskCapteurs_CheckBumpers(); // Check for bumpers status
TaskCapteurs_CheckClicClic(); // Check for clic clic
}
}
