/*********************************************************************************************************
** Function name: zyThreadDel
** Descriptions: 删除线程
** input parameters: ulThreadId: 线程ID
** output parameters: none
** Returned value: zy_OK: 成功
** 负数: 错误,绝对值参考zy_if.h
** Created by: Chenmingji
** Created Date: 2009-07-23
**--------------------------------------------------------------------------------------------------------
** Modified by:
** Modified date:
*********************************************************************************************************/
INT32S zyThreadDel (unsigned long ulThreadId)
{
OS_TCB *ptcbTask; /* 任务TCB */
void *pvTmp1;
ptcbTask = (OS_TCB *)ulThreadId;
if (zyThreadGetCurId() == ulThreadId) {
zyIrqDisable();
pvTmp1 = (void *)(ptcbTask->OSTCBStkPtr);
zyHeapFree(pvTmp1);
OSTaskDel(ptcbTask->OSTCBPrio);
zyIrqEnable();
return ZY_OK;
}
OSSchedLock();
pvTmp1 = (void *)(ptcbTask->OSTCBStkPtr);
zyHeapFree(pvTmp1);
OSTaskDel(ptcbTask->OSTCBPrio);
OSSchedUnlock();
return ZY_OK;
}
static void PushKeyTask (void* pdata)
{
INT8U err;
while (1)
{
OSSemPend (os_sem_push, PUSH_TIME, &err);
if (err == OS_TIMEOUT)
{
key_hook (TYPE_KEY_PUSH<<24 | change);
OSQPost (os_q_key_msg, (void*)(TYPE_KEY_PUSH<<24 | change));
#if KEY_CONTINUOUS_PUSH_EN == 1
while (1)
{
key_hook (TYPE_KEY_DOWN<<24 | change);
OSQPost (os_q_key_msg, (void*)(TYPE_KEY_PUSH<<24 | change));
OSTimeDly (PUSH_EXECUTE_INTERVAL);
if (OSSemAccept(os_sem_push))
{
OSSemPost (os_sem_push);
break;
}
}
#else
OSTaskDel (KEY_PUSH_TASK_PRIO);
#endif
}
else
{
OSTaskDel (KEY_PUSH_TASK_PRIO);
}
}
}
/*
*********************************************************************************************************
* test1_1
*********************************************************************************************************
*/
unsigned char test1_3(void){
unsigned char exit_err=0;
STTBX_Print(("\nTEST 1.3 Started...\n"));
STTBX_Print((TEST1_4_STRING));
STTBX_Print(("\n 1.3.1 Creating task T1 Pri=%d...",TASK_T1_PRIORITY));
exit_err = print_debug_task_create(OSTaskCreate(test1_3_T1, (void *)&test1_3_T1Stk, &test1_3_T1Stk[TASK_STK_SIZE - 1], TASK_T1_PRIORITY),OS_NO_ERR);
if(exit_err)
return(exit_err);
STTBX_Print(("\n 1.3.2 Creating task T2 Pri=%d...",TASK_T1_PRIORITY));
exit_err = print_debug_task_create(OSTaskCreate(test1_3_T1, (void *)&test1_3_T1Stk, &test1_3_T1Stk[TASK_STK_SIZE - 1], TASK_T1_PRIORITY),OS_PRIO_EXIST);
if(exit_err)
return(exit_err);
STTBX_Print(("\n 1.3.3 Creating task T2 Pri=%d...",63));
exit_err = print_debug_task_create(OSTaskCreate(test1_3_T1, (void *)&test1_3_T1Stk, &test1_3_T1Stk[TASK_STK_SIZE - 1], 63),OS_PRIO_EXIST/*OS_PRIO_INVALID*/);
if(exit_err)
return(exit_err);
STTBX_Print(("\n 1.3.4 Creating task T2 Pri=%d...",62));
exit_err = print_debug_task_create(OSTaskCreate(test1_3_T1, (void *)&test1_3_T1Stk, &test1_3_T1Stk[TASK_STK_SIZE - 1], 62),OS_NO_ERR);
if(exit_err)
return(exit_err);
STTBX_Print(("\n 1.3.5 Deleting task Pri=%d...",62));
exit_err = print_debug_task_delete(OSTaskDel(62),OS_NO_ERR);
if(exit_err)
return(exit_err);
STTBX_Print(("\n 1.3.6 Deleting task Pri=%d...",20));
exit_err = print_debug_task_delete(OSTaskDel(20),OS_TASK_DEL_ERR);
if(exit_err)
return(exit_err);
STTBX_Print(("\n 1.3.7 Deleting task Pri=%d...",62));
exit_err = print_debug_task_delete(OSTaskDel(62),OS_TASK_DEL_ERR);
if(exit_err)
return(exit_err);
STTBX_Print(("\n 1.3.8 Deleting task T1 Pri=%d...",TASK_T1_PRIORITY));
exit_err = print_debug_task_delete(OSTaskDel(TASK_T1_PRIORITY),OS_NO_ERR);
if(exit_err)
return(exit_err);
return(FALSE);
}
/*
*********************************************************************************************************
* test1_4
*********************************************************************************************************
*/
unsigned char test1_4(void){
unsigned char exit_err=0;
/* The value chould be changed for your system */
TASK_T1_PRIORITY=20;
TASK_T2_PRIORITY=22;
STTBX_Print(("\nTEST 1.4 Started...\n"));
STTBX_Print((TEST1_4_STRING));
STTBX_Print(("\n 1.4.1 Creating task T1 Pri=%d...",TASK_T1_PRIORITY));
exit_err = print_debug_task_create(OSTaskCreate(test1_4_T1, (void *)&test1_4_T1Stk, &test1_4_T1Stk[TASK_STK_SIZE - 1], TASK_T1_PRIORITY),OS_NO_ERR);
if(exit_err)
return(exit_err);
STTBX_Print(("\n 1.4.2 Creating task T2 Pri=%d...",TASK_T2_PRIORITY));
exit_err = print_debug_task_create(OSTaskCreate(test1_4_T2, (void *)&test1_4_T2Stk, &test1_4_T2Stk[TASK_STK_SIZE - 1], TASK_T2_PRIORITY),OS_NO_ERR);
if(exit_err)
return(exit_err);
STTBX_Print(("\n 1.4.3 Change T1 priority from %d to 22...",TASK_T1_PRIORITY));
exit_err = print_debug_task_change_priority(OSTaskChangePrio(TASK_T1_PRIORITY,TASK_T2_PRIORITY),OS_PRIO_EXIST);
if(exit_err)
return(exit_err);
STTBX_Print(("\n 1.4.4 Change T1 priority from %d to 254...",TASK_T1_PRIORITY));
exit_err = print_debug_task_change_priority(OSTaskChangePrio(TASK_T1_PRIORITY,254),OS_NO_ERR);
if(exit_err)
return(exit_err);
STTBX_Print(("\n 1.4.5 Change priority from %d to 12...",11));
exit_err = print_debug_task_change_priority(OSTaskChangePrio(11,12),OS_PRIO_ERR);
if(exit_err)
return(exit_err);
STTBX_Print(("\n 1.4.6 Delete T1..."));
exit_err = print_debug_task_delete(OSTaskDel(254),OS_NO_ERR);
if(exit_err)
return(exit_err);
STTBX_Print(("\n 1.4.7 Delete T2..."));
exit_err = print_debug_task_delete(OSTaskDel(TASK_T2_PRIORITY),OS_NO_ERR);
if(exit_err)
return(exit_err);
return(FALSE);
}
void WSTask(){
int s;
int suspended = 0;
int counter = 0;
long read,total;
INT8U err;
alt_u16 buff[BUFFER_SIZE];
//Setup connection to server
struct sockaddr_in result;
memset(&result, 0, sizeof(struct sockaddr_in));
result.sin_family = AF_INET;
result.sin_port = htons(MY_PORT);
net_aton("198.23.158.70", &(result.sin_addr));
//Test the connection
s = socket(AF_INET, SOCK_STREAM, 0);
if (s < 0) {
sendToLCD("Client: cannot open socket");
die_with_error("");
}
if (connect(s, (struct sockaddr *) &result, sizeof(result))) {
sendToLCD("No connection");
die_with_error("");
}
close(s);
while (1) {
if (counter >= BUFFER_SIZE){
s = socket(AF_INET, SOCK_STREAM, 0);
if (s < 0) {
sendToLCD("Client: cannot open socket");
OSTaskDel(HTTP_PRIO);
}
if (connect(s, (struct sockaddr *) &result, sizeof(result))) {
die_with_error("");
OSTaskDel(HTTP_PRIO);
}
read = write(s,buff, counter);
total += read;
if( read < 0 ){
sendToLCD("Lost connection");
die_with_error("");
}
printf("Sent %d bytes to client. Total: %d\n", read, total);
close(s);
counter = 0;
}
int fill_level;
while((fill_level = altera_avalon_fifo_read_level(INTERNET_FIFO_OUT_BASE)) > 0 && counter < BUFFER_SIZE){
buff[counter] = (alt_u16) altera_avalon_fifo_read_fifo(INTERNET_FIFO_OUT_BASE,INTERNET_FIFO_IN_CSR_BASE);
counter++;
}
}
}
void Task_Init(void* param)
{
/* Initializing SysTick Timer */
BSP_SysTick_Init();
/* Initializing LEDs */
BSP_LED_Init();
/* Create sync objects */
//BSP_Display_Init();//1. feladat - Kijelzõ init
//BSP_TempSensor_Init(); //2. feladat - hõmérés init
//OSSemCreate(); //2. feladat - szemafor init
//BSP_ADC_Init, BSP_Switch_Init 3. feladat
//Limithez szemafor készítés???
//OSFlagCreate(); //4. feladat --> jelzõflag init
//BSP_USART_Init(); //6. feladat USART init
//OSSemCreate USARTnak???
/* Create tasks */
OSTaskCreate(Task_Demo,0,(OS_STK*)&TaskDemoStack[DEFAULT_STACK_SIZE-1],TASK_DEMO_PRIO);
OSTaskDel(OS_PRIO_SELF);
}
void task2(void* pdata)
{
drawtext((volatile char* )pdata, "FPGA_GAME\0" ,36, 10);
OSTaskDel(OS_PRIO_SELF);
}
void write_reg(unsigned char reg, unsigned char val)
{
if(-ENODEV == i2c_write(i2c_addr, &val, reg, 1)) {
// printf("No camera!\n");
OSTaskDel(OS_PRIO_SELF);
}
}
/*************************************************************************
* STARTUP TASK - Prints out checksum and waits for c press. When C is pressed,
* starts LCD and Demo Task, then deletes itself
* Functions included: CalcChkSum, LcdDispStrg, DisplayCheckSum
* Creates: LCDDemoTask and DemoCntrlTask
*************************************************************************/
static void StartTask(void *p_arg)
{
(void)p_arg; /* Avoid compiler warning */
OSTickInit();
DBUG_PORT |= PP7;
KeyInit();
TimeInit();
LcdInit(TRUE,TRUE,FALSE);
SetTheTime();//for reset purposes
(void)OSTaskCreate(UITask, /* Create UITask */
(void *)0,
(void *)&UITaskStk[UITASK_STK_SIZE],
UITASK_PRIO);
(void)OSTaskCreate(TimeDispTask, /* Create TimeDispTask */
(void *)0,
(void *)&TimeDispTaskStk[TIMEDISPTASK_STK_SIZE],
TIMEDISPTASK_PRIO);
(void)OSTaskCreate(TransmitTask, /* Create UITask */
(void *)0,
(void *)&TransmitTaskStk[TRANSMITTASK_STK_SIZE],
TRANSMIT_PRIO);
(void)OSTaskCreate(ReceiveTask, /* Create UITask */
(void *)0,
(void *)&ReceiveTaskStk[RECEIVETASK_STK_SIZE],
RECEIVE_PRIO);
DBUG_PORT &= ~PP7;
(void)OSTaskDel(STARTTASK_PRIO);
FOREVER()
{
}
}
/*************************************************************************
* STARTUP TASK - Prints out checksum and waits for c press. When C is pressed,
* starts LCD and Demo Task, then deletes itself
* Functions included: CalcChkSum, LcdDispStrg, DisplayCheckSum
* Creates: LCDDemoTask and DemoCntrlTask
*************************************************************************/
static void StartTask(void *p_arg)
{
(void)p_arg; /* Avoid compiler warning */
OSTickInit();
TimeInit();
/* Initialize uC/OS-II */
KeyInit();
//LcdInit();
LcdInit(TRUE,TRUE,FALSE);
DBUG_PORT |= PP7;
//LcdClrDisp();
//LcdMoveCursor(1,5);
(void)OSTaskCreate(UITask, /* Create UITask */
(void *)0,
(void *)&UITaskStk[UITASK_STK_SIZE],
UITASK_PRIO);
(void)OSTaskCreate(TimeDispTask, /* Create TimeDispTask */
(void *)0,
(void *)&TimeDispTaskStk[TIMEDISPTASK_STK_SIZE],
TIMEDISPTASK_PRIO);
//LcdDispChar(1,1,CLOCK_LAYER,'2');
DBUG_PORT &= ~PP7;
(void)OSTaskDel(STARTTASK_PRIO);
FOREVER()
{
//do nothing
}
}
/*
* die_with_error()
*
* This routine is just called when a blocking error occurs with the example
* design. It deletes the current task.
*/
void die_with_error(char err_msg[DIE_WITH_ERROR_BUFFER])
{
printf("\n%s\n", err_msg);
OSTaskDel(OS_PRIO_SELF);
while(1);
}
static void test1_1_T2(void *data){
char next_value = 1,temp;
data = data; /* to remove warning that data is never used */
while(counter != END_VALUE){
if(counter == next_value){
next_value++;
STTBX_Print(("\n Task T2 Running, T1: Ready"));
}
}
STTBX_Print(("\n Task T2 Running, T1: Does not exist"));
STTBX_Print(("\n Task T2 deleting its self "));
print_debug_task_delete(OSTaskDel(TASK_T2_PRIORITY),OS_NO_ERR);
}
// this task is the initial task running, started by main(). It begins the system tick timer
// and creates all the other task. Then it deletes itself.
void StartupTask(void* pdata)
{
INT8U err;
DEBUGMSG(1,("StartupTask: begin\n\r"));
DEBUGMSG(1,("StartupTask: tick timer\n\r"));
// Initialize BSP functions
BSP_Init();
// re-init the UART so we can use the serial port
initUART0(38400, UART_8N1, UART_FIFO_OFF, getFcclk());
// initialize the driver sub-system
err = OSDRV_SubsysInit(DriverTable, DRIVER_COUNT);
if (err != OS_DRV_NO_ERR) {
RETAILMSG(1,("StartupTask: Failed to initialize driver subsystem: %d\n\r", err));
//park here
while(TRUE);
}
SemPrint = OSSemCreate(1);
// create the the test tasks
// we have OS_STK_GROWTH set to 1, so the stack grows from high to low
DEBUGMSG(1,("StartupTask: Creating the tasks...\n\r"));
OSTaskCreate(PlayTask, (void*)0, (void*)&TaskPlayStk[APP_TASK_DEFAULT_STK_SIZE-1], APP_TASK_PLAY_PRIO);
#ifdef OS_TASK_STAT_EN
//create a CPU monitor task
OSStatInit ();
//?? OSTaskCreate(MonTask, (void*)0, (void*)&TaskMonStk[APP_TASK_DEFAULT_STK_SIZE-1], APP_TASK_MON_PRIO);
#endif //OS_TASK_STAT_EN
// delete ourselves, letting the work be done in the new tasks.
DEBUGMSG(1,("StartupTask: deleting self\n\r"));
OSTaskDel(OS_PRIO_SELF);
}
/*
*********************************************************************************************************
* App_StartTask()
*
* Description : 系统任务初始化
*
* Argument(s) : pdata.
*
* Return(s) : none.
*********************************************************************************************************
*/
static void App_StartTask(void *pdata)
{
(void)pdata;
//创建事件
App_EventCreate();
//系统滴答设置
SysTick_Configure();
//机器人系统初始化
RobotSystemInit();
//创建任务
App_TaskCreate();
//挂起任务
OSTaskSuspend(4); //超声波避障任务
OSTaskSuspend(5); //机器人防跌落(PD: Prevent Drop)
OSTaskSuspend(6); //机器人动作任务挂起和恢复
// OSTaskSuspend(7); //GLWP: Get the Legs and Waist Position//储存膝关节位置信息，用于指导机器人摆臂
// OSTaskSuspend(8); //串口接收任务
// OSTaskSuspend(9); //动作执行任务(RW: Robot Walk)
// OSTaskSuspend(10); //动作步骤任务(RFS: Robot Forward Step)
// OSTaskSuspend(11); //动作步骤任务(RBS: Robot Backward Step)
// OSTaskSuspend(12); //右臂复位任务(RRA: Reset Right Arm)
// OSTaskSuspend(13); //左臂复位任务(RLA: Reset Left Arm)
// OSTaskSuspend(14); //右摆臂任务(SRA: Swing Right Arm)
// OSTaskSuspend(15); //左摆臂任务(SLA: Swing Left Arm)
// OSTaskSuspend(16); //摆腰任务(SW: Swing Waist)
OSTaskSuspend(17); //左右手腕和头部转动任务（SteerWork：Steer control）
// OSTaskSuspend(18); //眼睛任务(EE: Eye Expression)
// OSTaskSuspend(19); //LED任务(LED:decorative lighting)
// OSTaskSuspend(20); //LED任务(LED:decorative lighting)
//挂起自己
OSTaskDel(OS_PRIO_SELF);
}
void osDeleteTask(OsTask *task)
{
OS_ERR err;
//Delete the specified task
OSTaskDel(task, &err);
}
/*
* This function allows you to delete a task
*/
extern status_t taskDelete
(
uint8_t tid /* task ID of task to delete */
)
{
return OSTaskDel(tid);
}
/**
* @brief tcpserver thread
* @param void *arg :unused.
*/
static void tcpserver_thread(void *arg)
{
tcpserv(arg);
printf("Delete Tcpserver thread.\n");
OSTaskDel(OS_PRIO_SELF);
}
void gd_task_init(void *parg)
{
// INT8S ret = 0;
gd_config_info_t *gd_conf = NULL;
gd_conf = &gd_system.gd_config_info;
drv_all_init();
gd_config_info_init(gd_conf);
gd_config_link_info(gd_conf);
gd_component_init(gd_conf);
// Judge work mode : 0 GD_CONFIG_MODE, 1 GD_TRANS_MODE
gd_judge_work_mode();
if(gd_system.work_mode == GD_TRANS_MODE)
{
gd_uart_init(gd_conf);
}
gd_start_tasks();
OSTaskDel(OS_PRIO_SELF);
}
DWORD WINAPI OSTaskW32( LPVOID lpParameter )
{
OS_TCB *ptcb;
OS_EMU_STK *stack;
ptcb = (OS_TCB*) lpParameter;
stack = (OS_EMU_STK*) ptcb->OSTCBStkPtr;
#ifdef DISABLE_PRIORITY_BOOST
if( SetThreadPriorityBoost( stack->Handle, TRUE ) == 0 ) {
#ifdef OS_CPU_TRACE
OS_Printf("Error: SetThreadPriorityBoost\n");
#endif
}
#endif
OS_INIT_CRITICAL();
stack->Task(stack->pData);
stack->Exit = 1;
OSTaskDel(ptcb->OSTCBPrio);
return 0;
}
static void AppTaskStart (void *p_arg)
{
OS_ERR err;
#if (APP_CFG_TCPIP_MODULE_EN > 0u)
NET_ERR net_err;
#endif
(void)&p_arg;
BSP_Init(); /* Initialize BSP functions */
CPU_Init(); /* Initialize the uC/CPU services */
OS_CPU_TickInit(); /* Init uC/OS periodic time src (SysTick). */
#if (OS_CFG_STAT_TASK_EN > 0u)
OSStatTaskCPUUsageInit(&err); /* Compute CPU capacity with no task running */
#endif
Mem_Init(); /* Initialize mem mgmt module, required for TCP-IP. */
#if (APP_CFG_PROBE_COM_MODULE_EN > 0u)
AppProbe_Init(); /* Initialize uC/Probe modules */
#endif
OSTaskCreate((OS_TCB *)&AppBlinkyTaskTCB, /* Create the start task */
(CPU_CHAR *)"Blinky Task",
(OS_TASK_PTR ) AppBlinkyTask,
(void *) 0,
(OS_PRIO ) BLINKY_TASK_PRIO,
(CPU_STK *)&AppBlinkyTaskStk[0],
(CPU_STK_SIZE) BLINKY_TASK_STK_SIZE / 10u,
(CPU_STK_SIZE) BLINKY_TASK_STK_SIZE,
(OS_MSG_QTY ) 0u,
(OS_TICK ) 0u,
(void *) 0,
(OS_OPT )(OS_OPT_TASK_STK_CHK | OS_OPT_TASK_STK_CLR),
(OS_ERR *)&err);
BSP_GraphLCD_Init();
AppGraphLCD_Hdr();
#if (APP_CFG_TCPIP_MODULE_EN > 0u)
AppTCPIP_Init(&net_err); /* Initialize uC/TCP-IP & associated applications. */
AppCloud_Init(0);
#endif
#ifdef CPU_CFG_INT_DIS_MEAS_EN
CPU_IntDisMeasMaxCurReset();
#endif
AppTCPIP_Cfg = DEF_TRUE;
OSTaskDel(&AppTaskStartTCB, /* Delete task because its work is complete */
&err);
while (DEF_ON) {
; /* Should not get here! */
}
}
void init_task(void *pdata)
{
/* Tells the user that we are up and running. */
WARNING(0, "System boot !");
#if 0
/* Inits the custom math lib. */
NOTICE(0, "Fast math init.");
fast_math_init();
#endif
cvra_beacon_init(&robot.beacon, AVOIDING_BASE, AVOIDING_IRQ, 100, 10., 0.);
cvra_beacon_set_direction_offset(&robot.beacon, 123);
ip_stack_init();
list_netifs();
/* If the logic power supply is off, kindly ask the user to turn it on. */
if ((IORD(PIO_BASE, 0) & 0xff) == 0) {
printf("Hey sac a pain, la commande c'est en option ?\n");
/* We refuse to let the user to a shell before he turns it on. */
while ((IORD(PIO_BASE, 0) & 0xff) == 0);
printf("Merci bien !\n");
}
/* Inits all the trajectory stuff, PID, odometry, etc... */
#if 1
NOTICE(0, "Main control system init.");
cvra_cs_init();
#endif
/* Sets the bounding box for the avoidance module. */
const int robot_size = 150;
polygon_set_boundingbox(robot_size, robot_size, 3000-robot_size, 2000-robot_size);
arm_highlevel_init();
lua_do_settings();
luaconsole_init();
OSTaskCreateExt(heartbeat_task,
NULL,
&heartbeat_task_stk[TASK_STACKSIZE-1],
HEARTBEAT_TASK_PRIORITY,
HEARTBEAT_TASK_PRIORITY,
&heartbeat_task_stk[0],
TASK_STACKSIZE,
NULL, NULL);
/* Tasks must delete themselves before exiting. */
OSTaskDel(OS_PRIO_SELF);
}
/********************************* uCOS�������� *************************************/
void TaskStart(void *pdata)
{
stm32_crc_init();
OSTaskCreateExt(Display_Task,
(void *)0,
&Task_Display_Stk[Task_Display_Stk_Size - 1],
Task_Display_Prio,
Task_Display_Prio,
&Task_Display_Stk[0],
Task_Display_Stk_Size,
(void *)0,
OS_TASK_OPT_STK_CHK | OS_TASK_OPT_STK_CLR);
OSTaskCreateExt(TaskADC,
(void *)0,
&Task_ADC_Stk[Task_ADC_Stk_Size - 1],
Task_ADC_Prio,
Task_ADC_Prio,
Task_ADC_Stk,
Task_ADC_Stk_Size,
(void *)0,
OS_TASK_OPT_STK_CHK | OS_TASK_OPT_STK_CLR);
OSTaskCreateExt(Keyboard_Task,
(void *)0,
&Task_Key_Stk[Task_Key_Stk_Size - 1],
Task_Key_Prio,
Task_Key_Prio,
&Task_Key_Stk[0],
Task_Key_Stk_Size,
(void *)0,
OS_TASK_OPT_STK_CHK | OS_TASK_OPT_STK_CLR);
OSTaskCreateExt(RC_Bus_Task,
(void *)0,
&Task_RCBus_Stk[Task_RCBus_Stk_Size - 1],
Task_RCBus_Prio,
Task_RCBus_Prio,
&Task_RCBus_Stk[0],
Task_RCBus_Stk_Size,
(void *)0,
OS_TASK_OPT_STK_CHK | OS_TASK_OPT_STK_CLR);
OSTaskCreateExt(TaskUSBHID,
(void *)0,
&Task_USBHID_Stk[Task_USBHID_Stk_Size - 1],
Task_USBHID_Prio,
Task_USBHID_Prio,
&Task_USBHID_Stk[0],
Task_USBHID_Stk_Size,
(void *)0,
OS_TASK_OPT_STK_CHK | OS_TASK_OPT_STK_CLR);
OSTaskDel(OS_PRIO_SELF);
}
/*
*********************************************************************************************************
* test3_10
*********************************************************************************************************
*/
unsigned char test3_10(void){
unsigned char exit_err=0;
unsigned char err;
OSMsg msg;
STTBX_Print(("\nTEST 3.10 Started...\n"));
STTBX_Print((TEST3_10_STRING));
STTBX_Print(("\n 3.10.1 Create queue X size=2..."));
exit_err = print_debug_create_queue(MsgQueue = OSQCreate(&MsgQueueTbl[0], 2),TRUE);
if(exit_err)
return(exit_err);
STTBX_Print(("\n 3.10.2 Start Task to post payload msg1 to queue X..."));
exit_err = print_debug_task_create(OSTaskCreate(test3_10_T1, (void *)&test3_10_T1_STK, &test3_10_T1_STK[TASK_STK_SIZE - 1], TASK_1_PRIO),OS_NO_ERR);
if(exit_err)
return(exit_err);
STTBX_Print(("\n 3.10.3 Start Task to receive msg and post Mailbox msg X..."));
exit_err = print_debug_task_create(OSTaskCreate(test3_10_T2, (void *)&test3_10_T2_STK, &test3_10_T2_STK[TASK_STK_SIZE - 1], TASK_2_PRIO),OS_NO_ERR);
if(exit_err)
return(exit_err);
OSTimeDly(400);
STTBX_Print(("\n 3.10.6 Delete T1..."));
exit_err = print_debug_task_delete(OSTaskDel(TASK_1_PRIO),OS_NO_ERR);
if(exit_err)
return(exit_err);
STTBX_Print(("\n 3.10.7 Delete T2..."));
exit_err = print_debug_task_delete(OSTaskDel(TASK_2_PRIO),OS_NO_ERR);
if(exit_err)
return(exit_err);
return(FALSE);
}
/*
*********************************************************************************************************
* test3_1
*********************************************************************************************************
*/
unsigned char test3_1(void){
unsigned char exit_err=0;
unsigned char err;
OSMsg msg;
STTBX_Print(("\nTEST 3.1 Started...\n"));
STTBX_Print((TEST3_1_STRING));
STTBX_Print(("\n 3.1.1 Create queue X size=2..."));
exit_err = print_debug_create_queue(MsgQueueA = OSQCreate(&MsgQueueATbl[0], 2),TRUE);
if(exit_err)
return(exit_err);
STTBX_Print(("\n 3.1.2 Create Task to Post"));
exit_err = print_debug_task_create(OSTaskCreate(test3_1_T1, (void *)&test3_1_T1_STK, &test3_1_T1_STK[TASK_STK_SIZE - 1], TASK_1_PRIO),OS_NO_ERR);
if(exit_err)
return(exit_err);
STTBX_Print(("\n 3.1.3 Create Task to Pend"));
exit_err = print_debug_task_create(OSTaskCreate(test3_1_T2, (void *)&test3_1_T2_STK, &test3_1_T2_STK[TASK_STK_SIZE - 1], TASK_2_PRIO),OS_NO_ERR);
if(exit_err)
return(exit_err);
OSTimeDly(400);
STTBX_Print(("\n 3.1.6 Delete T1..."));
exit_err = print_debug_task_delete(OSTaskDel(TASK_1_PRIO),OS_NO_ERR);
if(exit_err)
return(exit_err);
STTBX_Print(("\n 3.1.7 Delete T2..."));
exit_err = print_debug_task_delete(OSTaskDel(TASK_2_PRIO),OS_NO_ERR);
if(exit_err)
return(exit_err);
return(FALSE);
}
//---------------------------------------------------------------------------------------------------
// Tâches de démarrages, init du hardware et création des tâches de l'applicaiton
//---------------------------------------------------------------------------------------------------
static void AppTaskStart(void *p_arg)
{
OS_ERR aErr;
// Pour le warning du compilateur
(void)p_arg;
// Start BSP and tick initialization
BSP_Init();
// Start Tick Initialization
BSP_Tick_Init();
mLeds_Setup();
#if OS_CFG_STAT_TASK_EN > 0u
// Compute CPU capacity with no task running */
OSStatTaskCPUUsageInit(&aErr);
#endif
OSTaskCreate((OS_TCB *)&Task1_Tcb,
(CPU_CHAR *)"Task1",
(OS_TASK_PTR ) Task1,
(void *) 0,
(OS_PRIO ) kTask1Pr,
(CPU_STK *)&sTask1Stk[0],
(CPU_STK )(kStackSize / 10u),
(CPU_STK_SIZE) kStackSize,
(OS_MSG_QTY ) 0,
(OS_TICK ) 0,
(void *) 0,
(OS_OPT )(OS_OPT_TASK_STK_CHK | OS_OPT_TASK_STK_CLR),
(OS_ERR *)&aErr);
OSTaskCreate((OS_TCB *)&Task2_Tcb,
(CPU_CHAR *)"Task2",
(OS_TASK_PTR ) Task2,
(void *) 0,
(OS_PRIO ) kTask2Pr,
(CPU_STK *)&sTask2Stk[0],
(CPU_STK )(kStackSize / 10u),
(CPU_STK_SIZE) kStackSize,
(OS_MSG_QTY ) 0,
(OS_TICK ) 0,
(void *) 0,
(OS_OPT )(OS_OPT_TASK_STK_CHK | OS_OPT_TASK_STK_CLR),
(OS_ERR *)&aErr);
while (DEF_TRUE)
{
OSTaskDel(&sAppTaskStartTCB,&aErr);
}
}
void Startup_Task(void *parg)
{
Show_Main(0,0,0,0);
Led_Off(0);
Led_Off(1);
OSTaskSuspend(CURSOR_TASK_PRIO);
OSTaskSuspend(TIMER_TASK_PRIO);
OSTaskSuspend(ADC_TASK_PRIO);
OSTaskDel(STARTUP_TASK_PRIO);//刪除自己
}
static void DoubleKeyTask (void* pdata)
{
INT8U err;
while (1)
{
OSSemPend (os_sem_double, DOUBLE_INTERVAL, &err);
if (err == OS_TIMEOUT)
{
OSTaskDel (KEY_DOUBLE_TASK_PRIO);
}
else
{
key_hook (TYPE_KEY_DOUBLE<<24 | change);
OSQPost (os_q_key_msg, (void*)(TYPE_KEY_DOUBLE<<24 | change));
OSTaskDel (KEY_DOUBLE_TASK_PRIO);
}
}
}
static void test3_7_T2(void *data)
{
data = data; /* to remove warning that data is never used */
unsigned char exit_err=0;
unsigned char err = 0xff;
OSMsg *msg = NULL;
int msg_ev=200;
ULONG ret_ev=1;
USHORT msg3;
USHORT size = 0;
ULONG type = 1;
STTBX_Print(("\n 3.7.5 Start to Pend from Task 1..."));
while(1)
{
msg = OSQPend(MsgQueue, 0, &err);
exit_err = print_debug_pend_payload_queue(err,OS_NO_ERR);
//if(exit_err)
// return(exit_err);
if(TEST_EV_VALUE == type)
{
STTBX_Print(("\n 3.7.5.1 Success to get the correct event Event = %d",type));
}
if(!exit_err)
{
STTBX_Print(("\n 3.7.6 Post Mailbox message to Response..."));
exit_err = print_debug_EasyPostSync(OSSyncResponse(msg->msg_pl, msg->msg_len, msg->mailbox,TASK_2_PRIO,TASK_1_PRIO,msg_ev,msg->mb_count),OS_NO_ERR);
OSFreeMsgBuffer (msg);
print_debug_task_delete(OSTaskDel(TASK_1_PRIO),OS_NO_ERR);
print_debug_task_delete(OSTaskDel(TASK_2_PRIO),OS_NO_ERR);
//if(exit_err)
// return(exit_err);
}
}
//return(FALSE);
}
/*..........................................................................*/
static void task_function(void *pdata) { /* uC/OS-II task signature */
((QActive *)pdata)->running = (uint8_t)1; /* enable the thread-loop */
while (((QActive *)pdata)->running) {
QEvent const *e = QActive_get_((QActive *)pdata);
QF_ACTIVE_DISPATCH_(&((QActive *)pdata)->super, e);
QF_gc(e); /* check if the event is garbage, and collect it if so */
}
QF_remove_((QActive *)pdata); /* remove this object from the framework */
OSTaskDel(OS_PRIO_SELF); /* make uC/OS-II forget about this task */
}
/*FUNCTION**********************************************************************
*
* Function Name : OSA_TaskDestroy
* Description : This function destroy a task. Return kStatus_OSA_Success if
* the task is destroied, otherwise return kStatus_OSA_Error.
*
*END**************************************************************************/
osa_status_t OSA_TaskDestroy(task_handler_t handler)
{
if (OS_ERR_NONE == OSTaskDel(handler->OSTCBPrio))
{
return kStatus_OSA_Success;
}
else
{
return kStatus_OSA_Error;
}
}
