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);
}
}
PUBLIC SDIO_CARD_PAL_HANDLE SDIO_Card_Pal_Open (SDIO_CARD_PAL_SLOT_E slotNo)
{
SDIO_CARD_PAL_IRQ_DECLARE;
SDIO_CARD_PAL_ASSERT (SDIO_CARD_PAL_SUPPORT_NUM > slotNo); /*assert verified*/
// 检查是否有有效的handle存在
SDIO_CARD_PAL_DISABLE_IRQ;
if (TRUE == s_sdioCardPalHd[slotNo].flag)
{
SDIO_CARD_PAL_ENABLE_IRQ;
SDIO_CARD_PAL_ASSERT (0); /*assert verified*/
}
s_sdioCardPalHd[slotNo].flag = TRUE;
SDIO_CARD_PAL_ENABLE_IRQ;
s_sdioCardPalHd[slotNo].MagicNum = SDIO_CARD_PAL_MAGICNUM;
#if defined (UCOS_BSD_EVENT)
{
INT8U err;
s_sdioCardPalHd[slotNo].sdio_event = PNULL;
s_sdioCardPalHd[slotNo].sdio_event = OSFlagCreate (0, &err);
if (PNULL == s_sdioCardPalHd[slotNo].sdio_event)
{
SDIO_CARD_PAL_ASSERT (0); /*assert verified*/
}
}
#elif defined (CARD_SDIO_EVENT)
s_sdioCardPalHd[slotNo].sdio_event = PNULL;
s_sdioCardPalHd[slotNo].sdio_event = SCI_CreateEvent ("SDIO_EVENT");
if (PNULL == s_sdioCardPalHd[slotNo].sdio_event)
{
SDIO_CARD_PAL_ASSERT (0); /*assert verified*/
}
#else
s_CardEvent = 0;
#endif
s_sdioCardPalHd[slotNo].sdio_port = (SDHOST_HANDLE) SDHOST_Register ( (SDHOST_SLOT_NO) slotNo,_irqCardProc);
if (0 == s_sdioCardPalHd[slotNo].sdio_port)
{
SDIO_CARD_PAL_ASSERT (0); /*assert verified*/
}
#ifdef DUAL_TCARD_SUPPORT
s_sdioCardPalHd[slotNo].sdio_No = slotNo;
s_activeslot = slotNo;
_SlotSelect(slotNo);
#endif
return &s_sdioCardPalHd[slotNo];
}
/* ----------------------- Start implementation -----------------------------*/
BOOL
xMBMasterPortEventInit( void )
{ uint8_t err=OS_ERR_NONE;
//rt_event_init(&xMasterOsEvent,"master event",RT_IPC_FLAG_PRIO);
// return TRUE;
xMasterOsEvent=OSFlagCreate(0,&err);
return TRUE;
}
int flag_event_init(flag_event_t* event){
#if defined(OS_FREERTOS)
*event = xEventGroupCreate();
return (*event) ? 0 : -1;
#elif defined(OS_UCOS)
OS_ERR err;
OSFlagCreate(event, "", 0, &err);
return (err == OS_ERR_NONE) ? 0 : -1;
#endif
}
bool_t osCreateEvent(OsEvent *event)
{
OS_ERR err;
//Create an event flag group
OSFlagCreate(event, "EVENT", 0, &err);
//Check whether the event flag group was successfully created
if(err == OS_ERR_NONE)
return TRUE;
else
return FALSE;
}
/*FUNCTION**********************************************************************
*
* Function Name : OSA_EventCreate
* Description : This function is used to create a event object. Return
* kStatus_OSA_Success if create successfully, otherwise return kStatus_OSA_Error.
*
*END**************************************************************************/
osa_status_t OSA_EventCreate(event_t *pEvent, osa_event_clear_mode_t clearMode)
{
INT8U err;
pEvent->pGroup = OSFlagCreate(0u, &err);
if (OS_ERR_NONE == err)
{
pEvent->clearMode = clearMode;
return kStatus_OSA_Success;
}
else
{
return kStatus_OSA_Error;
}
}
/*FUNCTION**********************************************************************
*
* Function Name : OSA_EventCreate
* Description : This function is used to create a event object. Return
* kStatus_OSA_Success if create successfully, otherwise return kStatus_OSA_Error.
*
*END**************************************************************************/
osa_status_t OSA_EventCreate(event_t *pEvent, osa_event_clear_mode_t clearMode)
{
OS_ERR err;
OSFlagCreate(&(pEvent->group), "event", (OS_FLAGS)0, &err);
if (OS_ERR_NONE == err)
{
pEvent->clearMode = clearMode;
return kStatus_OSA_Success;
}
else
{
return kStatus_OSA_Error;
}
}
/*!
****************************************************************************
@brief Creates a event group.
@param[out] phEventGroup - Pointer to a location to write the returned
event group ID
@return ADI_OSAL_SUCCESS - If event is created successfully
@return ADI_OSAL_FAILED - If failed to create event
@return ADI_OSAL_CALLER_ERROR - If the call is made from an invalid location
(i.e an ISR)
Note:
phEventGroup set to "ADI_OSAL_INVALID_EVENT_GROUP" if event creation is failed.
*****************************************************************************/
ADI_OSAL_STATUS adi_osal_EventGroupCreate(ADI_OSAL_EVENT_HANDLE *phEventGroup)
{
OS_FLAG_GRP* pEventNative;
INT8U nErr;
ADI_OSAL_STATUS eRetStatus;
#ifdef OSAL_DEBUG
if (NULL == phEventGroup)
{
return(ADI_OSAL_FAILED);
}
if (CALLED_FROM_AN_ISR)
{
*phEventGroup = ADI_OSAL_INVALID_EVENT_GROUP;
return (ADI_OSAL_CALLER_ERROR);
}
#endif /* OSAL_DEBUG */
/* Flags are initially all created as unset (0x0) */
pEventNative = OSFlagCreate(0x0u, &nErr);
switch (nErr)
{
case OS_ERR_NONE:
#pragma diag(push)
#pragma diag(suppress:misra_rule_11_4 : "typecasting is necessary to convert the handle type into a pointer to a useful structure")
*phEventGroup = (ADI_OSAL_EVENT_HANDLE) pEventNative;
#pragma diag(pop)
eRetStatus = ADI_OSAL_SUCCESS;
break;
#ifdef OSAL_DEBUG
case OS_ERR_CREATE_ISR:
*phEventGroup = ADI_OSAL_INVALID_EVENT_GROUP;
eRetStatus = ADI_OSAL_CALLER_ERROR;
break;
case OS_ERR_FLAG_GRP_DEPLETED:
*phEventGroup = ADI_OSAL_INVALID_EVENT_GROUP;
eRetStatus = ADI_OSAL_MEM_ALLOC_FAILED;
break;
#endif
default:
*phEventGroup = ADI_OSAL_INVALID_EVENT_GROUP;
eRetStatus = ADI_OSAL_FAILED;
break;
} /* end of switch */
return (eRetStatus);
}
/*
* Create our MicroC/OS-II resources. All of the resources beginning with
* "SSS" are declared in this file, and created in this function.
*/
void SSSCreateOSDataStructs(void)
{
INT8U error_code;
/*
* Create the resource for our MicroC/OS-II Queue for sending commands
* received on the TCP/IP socket from the SSSSimpleSocketServerTask()
* to the LEDManagementTask().
*/
SSSLEDCommandQ = OSQCreate(&SSSLEDCommandQTbl[0], SSS_LED_COMMAND_Q_SIZE);
if (!SSSLEDCommandQ)
{
alt_uCOSIIErrorHandler(EXPANDED_DIAGNOSIS_CODE,
"Failed to create SSSLEDCommandQ.\n");
}
/* Create our MicroC/OS-II LED Lightshow Semaphore. The semaphore is checked
* by the SSSLEDLightshowTask each time it updates 7 segment LED displays,
* U8 and U9. The LEDTask grabs the semaphore away from the lightshow task to
* toggle the lightshow off, and gives up the semaphore to turn the lightshow
* back on. The LEDTask does this in response to the CMD_LEDS_LIGHTSHOW
* command sent from the SSSSimpleSocketServerTask when the user sends the
* toggle lightshow command over the TCPIP socket.
*/
SSSLEDLightshowSem = OSSemCreate(1);
if (!SSSLEDLightshowSem)
{
alt_uCOSIIErrorHandler(EXPANDED_DIAGNOSIS_CODE,
"Failed to create SSSLEDLightshowSem.\n");
}
/*
* Create our MicroC/OS-II LED Event Flag. Each flag corresponds to one of
* the LEDs on the Nios Development board, D0 - D7.
*/
SSSLEDEventFlag = OSFlagCreate(0, &error_code);
if (!SSSLEDEventFlag)
{
alt_uCOSIIErrorHandler(error_code, 0);
}
}
void main()
{
INT8U err;
OSInit();
InitDisplay();
// create tasks with 512 byte stacks.
OSTaskCreate(MasterTask, NULL, 512, 6);
OSTaskCreate(UserTask, NULL, 512, 7);
// create mutex used by tasks. Priority inversion
// priority is set to 5 (1 less that highest priority
// task).
GuessMutex = OSMutexCreate(5, &err);
if(err != OS_NO_ERR)
exit(err);
// create event flags used by tasks, initially set to 0.
ColorFlags = OSFlagCreate(0x00, &err);
if(err != OS_NO_ERR)
exit(err);
OSStart();
}
status_t DSPI_RTOS_Init(dspi_rtos_handle_t *handle,
SPI_Type *base,
const dspi_master_config_t *masterConfig,
uint32_t srcClock_Hz)
{
OS_ERR err;
if (handle == NULL)
{
return kStatus_InvalidArgument;
}
if (base == NULL)
{
return kStatus_InvalidArgument;
}
memset(handle, 0, sizeof(dspi_rtos_handle_t));
OSSemCreate(&handle->mutex, "DSPI", (OS_SEM_CTR)1, &err);
if (OS_ERR_NONE != err)
{
return kStatus_Fail;
}
OSFlagCreate(&handle->event, "DSPI", (OS_FLAGS)0, &err);
if (OS_ERR_NONE != err)
{
OSSemDel(&handle->mutex, OS_OPT_DEL_ALWAYS, &err);
return kStatus_Fail;
}
handle->base = base;
DSPI_MasterInit(handle->base, masterConfig, srcClock_Hz);
DSPI_MasterTransferCreateHandle(handle->base, &handle->drv_handle, DSPI_RTOS_Callback, (void *)handle);
return kStatus_Success;
}
/******************************************************
Enable and initalize bar code reader
*******************************************************/
void BCR_Init(void)
{
enable = 1;
INT8U err;
erD_sndstr("Starting BCR update task\n\r");
bcFlag = OSFlagCreate(0x00, &err);
//ComDriverInit(BCREADER_CONFIG);
OSTaskCreateExt(BCRUpdateTask,
NULL,
(OS_STK *)&BCRUpdateTaskStk[TASK_BCR_SIZE-1],
TASK_BCR_PRIO,
TASK_BCR_PRIO,
(OS_STK *)&BCRUpdateTaskStk[0],
TASK_BCR_SIZE,
NULL,
OS_TASK_OPT_STK_CHK | OS_TASK_OPT_STK_CLR
);
erD_sndstr("Init done...BCR\n\r");
}
/*
*********************************************************************************************************
* AppObjCreate()
*
* Description : Create Application Kernel Objects.
*
* Argument(s) : none
*
* Return(s) : none
*
* Caller(s) : AppTaskStart()
*
* Note(s) : none.
*********************************************************************************************************
*/
static void AppObjCreate (void)
{
OS_ERR os_err;
#if (OS_CFG_SEM_EN > 0u)
OSSemCreate(&AppTaskObjSem,
"Sem Test",
0u,
&os_err);
OSSemCreate(&AppTraceSem,
"Trace Lock",
1u,
&os_err);
#endif
#if (OS_CFG_MUTEX_EN > 0u)
OSMutexCreate(&AppTaskObjMutex,
"Mutex Test",
&os_err);
#endif
#if (OS_CFG_Q_EN > 0u)
OSQCreate(&AppTaskObjQ,
"Queue Test",
1,
&os_err);
#endif
#if (OS_CFG_FLAG_EN > 0u)
OSFlagCreate(&AppTaskObjFlag,
"Flag Test",
DEF_BIT_NONE,
&os_err);
#endif
}
/*******************************************************
Creates GPS and Map related tasks
*******************************************************/
void Tasks()
{
INT8U err;
InitFlag = OSFlagCreate(0x0, &err);
// Create GPSUpdateTask
OSTaskCreateExt(GPSUpdateTask,
NULL,
(OS_STK *)&GPSUpdateTaskStk[TASK_GPS_SIZE-1],
TASK_GPS_PRIO,
TASK_GPS_PRIO,
(OS_STK *)&GPSUpdateTaskStk[0],
TASK_GPS_SIZE,
NULL,
OS_TASK_OPT_STK_CHK | OS_TASK_OPT_STK_CLR);
// Create GPSSendDataTask
OSTaskCreateExt(GPSSendDataTask,
NULL,
(OS_STK *)&GPSSendDataTaskTsk[TASK_GPS_SIZE-1],
TASK_GPS_SEND_PRIO,
TASK_GPS_SEND_PRIO,
(OS_STK *)&GPSSendDataTaskTsk[0],
TASK_GPS_SIZE,
NULL,
OS_TASK_OPT_STK_CHK | OS_TASK_OPT_STK_CLR);
// Create MapUpdateTask
OSTaskCreateExt(MapUpdateTask,
NULL,
(OS_STK *)&MapUpdateTaskStk[TASK_MAP_SIZE-1],
TASK_MAP_PRIO,
TASK_MAP_PRIO,
(OS_STK *)&MapUpdateTaskStk[0],
TASK_MAP_SIZE,
NULL,
OS_TASK_OPT_STK_CHK | OS_TASK_OPT_STK_CLR
);
}
//开始任务函数
void start_task(void *p_arg)
{
OS_ERR err;
CPU_SR_ALLOC();
p_arg = p_arg;
CPU_Init();
#if OS_CFG_STAT_TASK_EN > 0u
OSStatTaskCPUUsageInit(&err); //统计任务
#endif
#ifdef CPU_CFG_INT_DIS_MEAS_EN //如果使能了测量中断关闭时间
CPU_IntDisMeasMaxCurReset();
#endif
#if OS_CFG_SCHED_ROUND_ROBIN_EN //当使用时间片轮转的时候
//使能时间片轮转调度功能,时间片长度为1个系统时钟节拍，既1*5=5ms
OSSchedRoundRobinCfg(DEF_ENABLED,1,&err);
#endif
OS_CRITICAL_ENTER(); //进入临界区
OSFlagCreate((OS_FLAG_GRP *)&event_flag,
(CPU_CHAR *)"event flag",
(OS_FLAGS)0x00,
(OS_ERR *)&err
);
OSTaskCreate((OS_TCB * )&Led0TaskTCB,
(CPU_CHAR * )"led0 task",
(OS_TASK_PTR )led0_task,
(void * )0,
(OS_PRIO )LED0_TASK_PRIO,
(CPU_STK * )&LED0_TASK_STK[0],
(CPU_STK_SIZE)LED0_STK_SIZE/10,
(CPU_STK_SIZE)LED0_STK_SIZE,
(OS_MSG_QTY )0,
(OS_TICK )0,
(void * )0,
(OS_OPT )OS_OPT_TASK_STK_CHK|OS_OPT_TASK_STK_CLR,
(OS_ERR * )&err);
//创建浮点测试任务
OSTaskCreate((OS_TCB * )&FloatTaskTCB,
(CPU_CHAR * )"float test task",
(OS_TASK_PTR )float_task,
(void * )0,
(OS_PRIO )FLOAT_TASK_PRIO,
(CPU_STK * )&FLOAT_TASK_STK[0],
(CPU_STK_SIZE)FLOAT_STK_SIZE/10,
(CPU_STK_SIZE)FLOAT_STK_SIZE,
(OS_MSG_QTY )5,
(OS_TICK )0,
(void * )0,
(OS_OPT )OS_OPT_TASK_STK_CHK|OS_OPT_TASK_STK_CLR,
(OS_ERR * )&err);
//创建协议处理任务
OSTaskCreate((OS_TCB * )&ProtocolTaskTCB,
(CPU_CHAR * )"protocol task",
(OS_TASK_PTR )protocol_task,
(void * )0,
(OS_PRIO )Protocol_TASK_PRIO,
(CPU_STK * )&Protocol_TASK_STK[0],
(CPU_STK_SIZE)Protocol_STK_SIZE/10,
(CPU_STK_SIZE)Protocol_STK_SIZE,
(OS_MSG_QTY )0,
(OS_TICK )0,
(void * )0,
(OS_OPT )OS_OPT_TASK_STK_CHK|OS_OPT_TASK_STK_CLR,
(OS_ERR * )&err);
OS_CRITICAL_EXIT(); //进入临界区
OSTaskDel(NULL,&err);
}
/*
*********************************************************************************************************
* AppCreateIPCS
*
* Description : This function creates all IPCS objects
* Arguments : None
*********************************************************************************************************
*/
void AppCreateIPCS()
{
INT8U perr;
// Mutex
App_MutexCmdToTaskMvt = OSMutexCreate(APP_MUTEX_MVT_PRIO, &perr);
App_MutexCmdToTaskAsser = OSMutexCreate(APP_MUTEX_ASSER_PRIO, &perr);
if((NULL == App_MutexCmdToTaskMvt) || (NULL == App_MutexCmdToTaskAsser))
{
AppDebugMsg("DEBUG (App.c) : Error -> Unable to create Semaphore or Mutex\n");
AppDebugMsg("DEBUG (App.c) : Entering in sleeping mode...\n");
while(OS_TRUE) // Infinite Loop
OSTimeDlyHMSM(1, 0, 0, 0);
}
#if APP_USE_DEBUG > 0
App_MutexUART1 = OSMutexCreate(APP_MUTEX_UART1_PRIO, &perr);
App_MutexUART2 = OSMutexCreate(APP_MUTEX_UART2_PRIO, &perr);
#else
App_MutexCmdToTaskMvt = NULL;
App_MutexCmdToTaskAsser = NULL;
#endif
#if APP_QUEUE_SENSORS_SIZE > 0
// Create an empty queue for asser process
AppQueueSensors = OSQCreate(AppQSensorsStk, APP_QUEUE_SENSORS_SIZE);
if(NULL == AppQueueSensors) // Check if Queue is well created
{
AppDebugMsg("DEBUG (App.c) : Error -> Unable to create AsserQueue\n");
AppDebugMsg("DEBUG (App.c) : Entering in sleeping mode...\n");
while(OS_TRUE) // Infinite Loop
OSTimeDlyHMSM(1, 0, 0, 0);
}
#endif
// Flags
AppFlags = OSFlagCreate(APP_PARAM_APPFLAG_INITAL_VALUE, &perr);
if(NULL == AppFlags)
{
AppDebugMsg("DEBUG (App.c) : Error -> Unable to create Appliction Flag\n");
AppDebugMsg("DEBUG (App.c) : Entering in sleeping mode...\n");
while(OS_TRUE) // Infinite Loop
OSTimeDlyHMSM(1, 0, 0, 0);
}
// Strategy Flags
AppStrategyFlags = OSFlagCreate(APP_PARAM_STRATEGYFLAG_INITAL_VALUE, &perr);
if(NULL == AppStrategyFlags)
{
AppDebugMsg("DEBUG (App.c) : Error -> Unable to create Strategy Flag\n");
AppDebugMsg("DEBUG (App.c) : Entering in sleeping mode...\n");
while(OS_TRUE) // Infinite Loop
OSTimeDlyHMSM(1, 0, 0, 0);
}
return;
}
void mouse_Init()
{
int i;
uint8 code;
REGISTER_LOG_CLIENT("MOUSE SENSOR");
flagCalibStep = OSFlagCreate(0x00, &OSLastError);
LOG_TEST_OS_ERROR(OSLastError);
ex_PushITHandler(MOUSE1_FAILURE, mouseFailureHandler);
ex_PushITHandler(MOUSE2_FAILURE, mouseFailureHandler);
mice[0].uart = CHANNEL_UART_MOUSE_1;
mice[0].RatioKU = 1.00f;
mice[0].RatioKV = 1.00f;
mice[0].theta = -0.785997f;
mice[0].Delta0 = 1500.0f;
mice[0].DeltaA = 0.0f;
mice[0].RX0 = -7668.8f;
mice[0].RXA = 0.0f;
mice[0].RY0 = 10150;//10565.61;
mice[0].RYA = 0;//-3044.32*valueVTops/valueSample;
mice[1].uart = CHANNEL_UART_MOUSE_2;
mice[1].RatioKU = 1.00f;
mice[1].RatioKV = 1.00f;
mice[1].theta = -0.780678f;
mice[1].Delta0 = 1499.5f;
mice[1].DeltaA = 0.0f;
mice[1].RX0 = -7741.7f;
mice[1].RXA = 0.0f;
mice[1].RY0 = -10214;//-10819.70;
mice[1].RYA = 0;//3127.76*valueVTops/valueSample;
corrLR = -6308*valueVTops/valueSample;
corrRR = -6301*valueVTops/valueSample;
for(i=0; i<MOUSE_NUMBER; i++)
{
//init mouse uart
uart_Init(mice[i].uart, MOUSE_UART_BAUDRATE);
//reset mice values
mice[i].error = 0;
mice[i].calibU = 0;
mice[i].calibV = 0;
mice[i].nbGoodMessage = 0;
mice[i].nbCksmError = 0;
mice[i].nbUnkError = 0;
mice[i].calibAlpha1 = 0.0f;
mice[i].calibAlpha2 = 0.0f;
mice[i].calibDelta = 0.0f;
mice[i].cosTheta = cosf(mice[i].theta);
mice[i].sinTheta = sinf(mice[i].theta);
sendCalibParameters(i);
}
}
