INT8U resume_network_tasks() { INT8U err = OS_NO_ERR; err = ( OSTaskResume( TK_NETMAIN_TPRIO )| OSTaskResume( TK_NETTICK_TPRIO )| OSTaskResume( SSS_NIOS_II_SIMPLE_SOCKET_SERVER_TASK_PRIORITY ) ); return( err ); }
/* * This function is called to resume a previously suspended task */ extern status_t taskResume ( uint8_t tid /* task ID of task to resume */ ) { return OSTaskResume(tid); }
//浮点测试任务 void float_task(void *p_arg) { OS_ERR err; CPU_SR_ALLOC(); static float float_num = 0.01; //uint32_t temp = &float_num; while(1) { float_num+=0.01f; OS_CRITICAL_ENTER(); //进入临界区 //printf("float_num的值为: %.4f\r\n",float_num); OS_CRITICAL_EXIT(); //退出临界区 if(float_num > 0.901f && float_num < 0.919f) { OSTaskSuspend((OS_TCB*)&Led0TaskTCB,&err); printf("挂起LED任务\n\r"); } if(float_num > 1.991f && float_num < 2.001f) { OSTaskResume((OS_TCB*)&Led0TaskTCB,&err); printf("恢复LED任务\n\r"); float_num = 0.0f; } OSTimeDlyHMSM(0,0,0,300,OS_OPT_TIME_HMSM_STRICT,&err); //延时300ms } }
static void task1(void *pdata) { int timeout; int i; INT8U err; char *p; while(1) { dprintf("task1,%s\r\n",pdata); //dprintf("sys_jiffies:%d\r\n",sys_jiffies()); //dprintf("sys_now:%dms\r\n",sys_now()); //p = OSQPend(mbox, 1, &err); timeout = sys_arch_mbox_fetch(&sys_mbox, (void **)&p, 0); sys_mutex_lock(&sys_mutex); if(timeout != -1) dprintf("task1 received mbox: %s\r\n",p); sys_mutex_unlock(&sys_mutex); //else //OSTaskResume(9); #if 0 if(err != OS_NO_ERR) { dprintf("task1 OSQPend err:%d\r\n",err); OSTaskResume(9); } else dprintf("task1 received mbox: %s\r\n",p); #endif } }
/* Handle the commands for each gesture */ static void handleGestureCommands(int gesture_code) { INT8U err; static int state = PAUSE; static int volume = 70; char *message = (char *) calloc(LARGE_BUF_SIZE, sizeof(char)); // Pause if ((state == PLAY) && (gesture_code == GCODE_DOWN_LEFT)) { OSTaskSuspend(AUDIO_TASK_PRIORITY); state = PAUSE; snprintf(message, LARGE_BUF_SIZE, "RECOGNIZED DOWN-LEFT: PAUSE"); // Play } else if ((state == PAUSE) && (gesture_code == GCODE_UP_LEFT)) { OSTaskResume(AUDIO_TASK_PRIORITY); state = PLAY; snprintf(message, LARGE_BUF_SIZE, "RECOGNIZED UP-LEFT: PLAY"); // Volume down } else if ((state == PLAY) && (gesture_code == GCODE_DOWN_RIGHT)) { volume = decreaseVolume(volume); audio_set_headphone_volume(av_dev, volume); snprintf(message, LARGE_BUF_SIZE, "RECOGNIZED DOWN-RIGHT: VOL-DOWN"); // Volume up } else if ((state == PLAY) && (gesture_code == GCODE_UP_RIGHT)) { volume = increaseVolume(volume); audio_set_headphone_volume(av_dev, volume); snprintf(message, LARGE_BUF_SIZE, "RECOGNIZED UP-RIGHT: VOL-UP"); } printf("%s\n", message); if ((err = OSQPost(lcd_queue, message)) != OS_NO_ERR) { printf("Error %d: message not put on LCD queue.\n", err); } }
/********************************************************************************************************* ** Function name: zyThreadResume ** 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 zyThreadResume (unsigned long ulThreadId) { OS_TCB *ptcbTask; /* 任务TCB */ ptcbTask = (OS_TCB *)ulThreadId; OSTaskResume(ptcbTask->OSTCBPrio); return ZY_OK; }
static void task3(void *pdata) { unsigned char *p; while(1) { dprintf("task3,%s\r\n",pdata); OSTaskResume(10); } }
/* prio:10 */ static void task2(void *pdata) { while(1) { dprintf("task2,%s\r\n",pdata); OSTaskSuspend(OS_PRIO_SELF); OSTaskResume(9); } }
void board_control_task(void *pdata) { INT8U error_code = OS_NO_ERR; board_control_mbox = OSMboxCreate((void *)NULL); struct http_form_data* board_control_mbox_contents; while(1) { board_control_mbox_contents = (void*)OSMboxPend(board_control_mbox, 0, &error_code); if (board_control_mbox_contents->LED_ON) { OSTaskResume(LED_PRIO); } else { /* Suspend the task and clear the LED. */ OSTaskSuspend(LED_PRIO); IOWR_ALTERA_AVALON_PIO_DATA( LEDG_BASE, 0 ); } if (board_control_mbox_contents->SSD_ON) { OSTaskResume(SSD_PRIO); } else { /* Suspend the task and set SSD to all zeros. */ OSTaskSuspend(SSD_PRIO); #ifdef SEG7_NAME //sevenseg_set_hex(0); #endif } /* Always dump text to the LCD... */ #ifdef LCD_NAME lcd_output_text( board_control_mbox_contents->LCD_TEXT ); usleep(500*1000); #endif } }
/* * timerCheck - If there are any expired timers, wake up the timer task. * This is designed to be called from within the Jiffy timer interrupt so * it has to have minimal overhead. */ void timerCheck(void) { #ifdef OS_DEPENDENT if ((long)(timerHead.timerNext->expiryTime - OSTimeGet()) <= 0) (void) OSTaskResume(PRI_TIMER); #endif #if ONETASK_SUPPORT > 0 // Support for non multitasking environment // Call timerTask if a timer has expired if ((long)(timerHead.timerNext->expiryTime - OSTimeGet()) <= 0) timerTask(NULL); #endif }
//任务3 //按键检测 void TaskKey(void *pdata) { u8 key=0; while(1){ key=KEY_Scan(); if(key==1) { OSTaskSuspend(LED_TASK_Prio); OSTaskSuspend(LCD_TASK_Prio); } else if(key==2) { OSTaskResume(LED_TASK_Prio); OSTaskResume(LCD_TASK_Prio); } else if(key==3) { OSTaskDelReq(LED_TASK_Prio); OSTaskDelReq(LCD_TASK_Prio); } OSTimeDlyHMSM(0,0,0,20); } }
void StartAllTasks ( void ) { int i; for (i = 0x00; i < N_TASKS; i ++) { if (!sRunning[i]) { OSTaskResume(i + 1); sRunning[i] = 0x01; } } }
void TK_OSTaskResume(u_char * Id) { INT8U err; err = OSTaskResume(*Id); if ((err != OS_NO_ERR) && (err != OS_TASK_NOT_SUSPENDED)) { dprintf("ChronOS API call failure, to Resume Suspended Task!\n"); dtrap(); panic("TK_OSTaskResume"); } return; }
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 */ } }
void turn_master_id(u8 id)//改变当前整个系统中主机的ID号 { u8 i,flag=0; { flag=cont; if(id==(flag)){ for(i=1;i<33;i++) { order_trans_rs485(mybox.myid,i,0,0,0); delay_us(10000); }//及时告知其他slave机器,已有主机 mybox.master=1; OSTaskResume(MASTER_TASK_PRIO); cont=1; } // LED1=!LED1; } }
/****************************************************** Enable bar code reader *******************************************************/ void BCR_Enable() { COM_BUFF_INFO RxBuff = GetTaskRxComBuff(); if(enable == 0) { GPS_Disable(); BCR_Init(); } else { GPS_Disable(); //SetCTS(); OSTaskResume(TASK_BCR_PRIO); } *(RxBuff.ptrCurrent) = *(RxBuff.ptrEnd); }
int HandleCommand ( WORD index ) { char sMsg[80]; if (index > 0x100 && index < 0x200) { switch(index) { case 0x101: DisplayMessage("Start all tasks just now ..."); StartAllTasks(); break; case 0x102: DisplayMessage("Stop all tasks just now ..."); StopAllTasks(); break; } } else if (index > 0x00 && index <= 0x0a) { if (sRunning[index - 1]) { sprintf(sMsg, "Suspend task%d just now ...", index); DisplayMessage(sMsg); OSTaskSuspend(index); sRunning[index - 1] = 0x00; } else { sprintf(sMsg, "Resume task%d just now ...", index); DisplayMessage(sMsg); OSTaskResume(index); sRunning[index - 1] = 0x01; } } else if (index > 0x200) { if (index == 0x201) DoHelp(); else if (index == 0x202) DoAbout(); } return 0x00; }
//闹铃处理(尺寸:44*20) //x,y:坐标 //返回值,处理结果 u8 calendar_alarm_msg(u16 x,u16 y) { u8 rval=0; u16 *lcdbuf=0; //LCD显存 lcdbuf=(u16*)gui_memin_malloc(44*20*2); //申请内存 if(lcdbuf) //申请成功 { app_read_bkcolor(x,y,44,20,lcdbuf); //读取背景色 gui_fill_rectangle(x,y,44,20,LIGHTBLUE); gui_draw_rectangle(x,y,44,20,BROWN); gui_show_num(x+2,y+2,2,RED,16,alarm.hour,0X81); gui_show_ptchar(x+2+16,y+2,x+2+16+8,y+2+16,0,RED,16,':',1); gui_show_num(x+2+24,y+2,2,RED,16,alarm.min,0X81); OSTaskSuspend(6); //挂起主任务 while(rval==0) { tp_dev.scan(0); if(tp_dev.sta&TP_PRES_DOWN)//触摸屏被按下 { if(app_tp_is_in_area(&tp_dev,x,y,44,20))//判断某个时刻,触摸屏的值是不是在某个区域内 { rval=0XFF;//取消 break; } } delay_ms(5); if(system_task_return)break; //需要返回 } app_recover_bkcolor(x,y,44,20,lcdbuf); //读取背景色 }else rval=1; system_task_return=0; alarm.ringsta&=~(1<<7); //取消闹铃 calendar_alarm_init((_alarm_obj*)&alarm,&calendar); //重新初始化闹钟 gui_memin_free(lcdbuf); OSTaskResume(6); //恢复主任务 system_task_return=0; return rval; }
INT8U CTask::Resume() { return OSTaskResume(m_nPrio); }
/* ********************************************************************************************************* * App_SuspendResumeTask() * * Description : 机器人动作挂起和恢复任务 * * Argument(s) : pdata. * * Return(s) : none. ********************************************************************************************************* */ static void App_SuspendResumeTask(void *pdata) { static uint8_t SuspendResume = 0; //临界区 // OS_CPU_SR cpu_sr; while(1) { // OS_ENTER_CRITICAL(); //进入临界区 if((SuspendResume==0) && ((PDropL==1) || (PDropR==1) || (UltrTask==1))) { //suspend the tasks 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) //stop all motors HeadMove(70); LeftWristMove(70); RightWristMove(70); WaistMove(50); LeftArmMove(50); RightArmMove(50); LeftKneeMove(50); RightKneeMove(50); LeftFootMove(50); RightFootMove(50); if((PDropL==1) && (PDropR==0)) { //左转矫正 LeftFootMove(90); RightFootMove(5); } else if((PDropR==1) && (PDropL==0)) { //右转矫正 LeftFootMove(5); RightFootMove(90); } SuspendResume = 1; } else if((SuspendResume==1) && (PDropL==0) && (PDropR==0) && (UltrTask==0)) { //resume the tasks OSTaskResume(9); //动作执行任务(RW: Robot Walk) OSTaskResume(10); //动作步骤任务(RFS: Robot Forward Step) OSTaskResume(11); //动作步骤任务(RBS: Robot Backward Step) OSTaskResume(12); //右臂复位任务(RRA: Reset Right Arm) OSTaskResume(13); //左臂复位任务(RLA: Reset Left Arm) OSTaskResume(14); //右摆臂任务(SRA: Swing Right Arm) OSTaskResume(15); //左摆臂任务(SLA: Swing Left Arm) if(robotMode == SlideForward) { LeftFootMove(5); RightFootMove(5); } SuspendResume = 0; } // OS_EXIT_CRITICAL(); //退出临界区 OSTimeDlyHMSM(0,0,0,10); } }
void Input_Task(void *parg) { u8 err; u8 OK=0; u8 buffer[4]={0}; u8 LEN=0; u8 flag=0; u16 e=0; OS_CPU_SR cpu_sr; (void)parg; for(;;) { OSSemPend(PENIRQ,0,&err); Exti_Set(0); OS_ENTER_CRITICAL(); touch.FLAG=Read_XY_2(&touch.AD_X,&touch.AD_Y); OS_EXIT_CRITICAL(); if(touch.FLAG) { Led_On(1); touch.FLAG=0; touch.LCD_X=CalcXY(touch.AD_X,0); touch.LCD_Y=CalcXY(touch.AD_Y,1); touch.KEY=Get_Key(touch.PID,touch.LCD_X,touch.LCD_Y); if(touch.KEY<=10) { OS_ENTER_CRITICAL(); Set_Color(WHITE,BLACK); if(touch.KEY==10) Show_Char('.',cursor.x,cursor.y); else { Show_Dec(touch.KEY,1,cursor.x,cursor.y); if(LEN<4) { buffer[LEN]=touch.KEY; LEN++; } } if(cursor.x<224) { cursor.x+=8; if(cursor.x>=224) cursor.x=224; } OS_EXIT_CRITICAL(); } else if(touch.KEY==11) { OK++; if(OK==1) { VALUE1=CalcDec(buffer,LEN); Set_Color(BLACK,GREEN); Show_String(">>VALUE1:",2,22); Show_Dec(VALUE1,LEN,82,22); OS_ENTER_CRITICAL(); LCD_Clear(4,121,232,38,WHITE); cursor.x=8; cursor.y=132; OS_EXIT_CRITICAL(); buffer[0]=0; buffer[1]=0; buffer[2]=0; buffer[3]=0; LEN=0; } else if(OK==2) { VALUE2=CalcDec(buffer,LEN); Set_Color(BLACK,GREEN); Show_String(">>VALUE2:",2,38); Show_Dec(VALUE2,LEN,82,38); OS_ENTER_CRITICAL(); LCD_Clear(4,121,232,38,WHITE); cursor.x=8; cursor.y=132; OS_EXIT_CRITICAL(); buffer[0]=0; buffer[1]=0; buffer[2]=0; buffer[3]=0; LEN=0; } else if(OK==3) { VALUE3=CalcDec(buffer,LEN); Set_Color(BLACK,GREEN); Show_String(">>VALUE3:",2,54); Show_Dec(VALUE3,LEN,82,54); OS_ENTER_CRITICAL(); LCD_Clear(4,121,232,38,WHITE); cursor.x=8; cursor.y=132; OS_EXIT_CRITICAL(); buffer[0]=0; buffer[1]=0; buffer[2]=0; buffer[3]=0; LEN=0; } else if(OK==4) { if(VALUE2>0&&VALUE2<=5000) { if(VALUE1<VALUE2&&VALUE1>0) { if(VALUE3>0&&VALUE3<10000) { e=0; Set_Color(BLACK,GREEN); Show_String(">>OK!",2,70); } else { e=1; } } else { e=1; } } else { e=1; } if(e) { Set_Color(BLACK,GREEN); Show_String(">>ERROR!",2,70); } } else if(OK==5) { if(!e) { OK=0; OSTaskSuspend(CURSOR_TASK_PRIO); Show_Main(VALUE1,VALUE2,VALUE3,1); } else { OK=0; e=0; LCD_Clear(2,20,236,100,BLACK); LCD_DrawEdit(input); Set_Cursor(8,132); } VALUE1=0; VALUE2=0; VALUE3=0; } else; } else if(touch.KEY==12) { OS_ENTER_CRITICAL(); if(LEN>0) { LEN--; } if(cursor.x>=8) { LCD_Clear(cursor.x,cursor.y,8,16,WHITE); cursor.x-=8; if(cursor.x<8) { cursor.x=8; } } OS_EXIT_CRITICAL(); } else if(touch.KEY==13) { if(flag==0) { flag=1; button1.str="stop"; button1.len=4; button1.line_color=GREEN; LCD_DrawButton(button1); OSTaskResume(TIMER_TASK_PRIO); } else { flag=0; button1.str="start"; button1.len=5; button1.line_color=BLACK; LCD_DrawButton(button1); OSTaskSuspend(TIMER_TASK_PRIO); } } else if(touch.KEY==14) { OSTaskSuspend(TIMER_TASK_PRIO); Show_KeyMap(); OSTaskResume(CURSOR_TASK_PRIO); } else if(touch.KEY==99)//無效輸入 {} else; OSTimeDlyHMSM(0,0,0,50); Led_Off(1); } Exti_Set(1); } }
/* ********************************************************************************************************* * RESUMETASKS ********************************************************************************************************* */ void TaskResume(void) { INT8U i; for ( i = 1; i <= N_TASKS+1; i++) OSTaskResume(i); }
void MainTask(void *arg) { ADI_AFE_DEV_HANDLE hDevice; int16_t dft_results[DFT_RESULTS_COUNT]; q15_t dft_results_q15[DFT_RESULTS_COUNT]; q31_t dft_results_q31[DFT_RESULTS_COUNT]; q31_t magnitude[DFT_RESULTS_COUNT / 2]; q15_t phase[DFT_RESULTS_COUNT / 2]; fixed32_t magnitude_result[DFT_RESULTS_COUNT / 2 - 1]; fixed32_t phase_result[DFT_RESULTS_COUNT / 2 - 1]; char msg[MSG_MAXLEN]; uint8_t err; done = 0; uint16_t pressure_analog; uint32_t pressure; nummeasurements = 0; uint32_t rtcCount; ADI_I2C_RESULT_TYPE i2cResult; // Initialize driver. rtc_Init(); // Calibrate. rtc_Calibrate(); // Initialize UART. if (uart_Init()) { FAIL("ADI_UART_SUCCESS"); } // Initialize I2C. i2c_Init(&i2cDevice); // Initialize flags. bRtcAlarmFlag = bRtcInterrupt = bWdtInterrupt = false; // Get the current count. if (adi_RTC_GetCount(hRTC, &rtcCount)) { FAIL("adi_RTC_GetCount failed"); } // Initialize the AFE API. if (adi_AFE_Init(&hDevice)) { FAIL("adi_AFE_Init"); } // AFE power up. if (adi_AFE_PowerUp(hDevice)) { FAIL("adi_AFE_PowerUp"); } // Excitation Channel Power-up. if (adi_AFE_ExciteChanPowerUp(hDevice)) { FAIL("adi_AFE_ExciteChanPowerUp"); } // TIA Channel Calibration. if (adi_AFE_TiaChanCal(hDevice)) { FAIL("adi_AFE_TiaChanCal"); } // Excitation Channel Calibration (Attenuation Enabled). if (adi_AFE_ExciteChanCalAtten(hDevice)) { FAIL("adi_AFE_ExciteChanCalAtten"); } // Update FCW in the sequence. seq_afe_acmeas2wire[3] = SEQ_MMR_WRITE(REG_AFE_AFE_WG_FCW, FCW); // Update sine amplitude in the sequence. seq_afe_acmeas2wire[4] = SEQ_MMR_WRITE(REG_AFE_AFE_WG_AMPLITUDE, SINE_AMPLITUDE); // Recalculate CRC in software for the AC measurement, because we changed. // FCW and sine amplitude settings. adi_AFE_EnableSoftwareCRC(hDevice, true); // Perform the impedance measurement. if (adi_AFE_RunSequence(hDevice, seq_afe_acmeas2wire, (uint16_t *)dft_results, DFT_RESULTS_COUNT)) { FAIL("Impedance Measurement"); } // Set RTC alarm. printf("rtcCount: %d\r\n", rtcCount); if (ADI_RTC_SUCCESS != adi_RTC_SetAlarm(hRTC, rtcCount + 120)) { FAIL("adi_RTC_SetAlarm failed"); } // Enable RTC alarm. if (ADI_RTC_SUCCESS != adi_RTC_EnableAlarm(hRTC, true)) { FAIL("adi_RTC_EnableAlarm failed"); } // Read the initial impedance. q31_t magnitudecal; q15_t phasecal; convert_dft_results(dft_results, dft_results_q15, dft_results_q31); arm_cmplx_mag_q31(dft_results_q31, &magnitudecal, 2); phasecal = arctan(dft_results[1], dft_results[0]); printf("raw rcal data: %d, %d\r\n", dft_results[1], dft_results[0]); printf("rcal (magnitude, phase) = (%d, %d)\r\n", magnitudecal, phasecal); // Create the message queue for communicating between the ISR and this task. dft_queue = OSQCreate(&dft_queue_msg[0], DFT_QUEUE_SIZE); // Hook into the DFT interrupt. if (ADI_AFE_SUCCESS != adi_AFE_RegisterAfeCallback( hDevice, ADI_AFE_INT_GROUP_CAPTURE, AFE_DFT_Callback, BITM_AFE_AFE_ANALOG_CAPTURE_IEN_DFT_RESULT_READY_IEN)) { FAIL("adi_AFE_RegisterAfeCallback"); } if (ADI_AFE_SUCCESS != adi_AFE_ClearInterruptSource( hDevice, ADI_AFE_INT_GROUP_CAPTURE, BITM_AFE_AFE_ANALOG_CAPTURE_IEN_DFT_RESULT_READY_IEN)) { FAIL("adi_AFE_ClearInterruptSource (1)"); } packed32_t q_result; void *q_result_void; OS_Q_DATA q_data; uint16_t q_size; bool inflated = false; while (true) { // Wait for the user to press the button. printf("MainTask: waiting for button.\n"); OSSemPend(ux_button_semaphore, 0, &err); if (err != OS_ERR_NONE) { FAIL("OSSemPend: MainTask"); } // TODO: fix bug when pressing button multiple times. // Have the pump task inflate the cuff. printf("MainTask: button detected. Resuming pump task.\n"); err = OSTaskResume(TASK_PUMP_PRIO); if (err != OS_ERR_NONE) { FAIL("OSTaskResume: MainTask (1)"); } // Wait a bit. printf("MainTask: waiting a bit.\n"); err = OSTimeDlyHMSM(0, 0, 1, 0); if (err != OS_ERR_NONE) { FAIL("OSTimeDlyHMSM: MainTask (3)"); } // Enable the DFT interrupt. printf("MainTask: enabling DFT interrupt.\n"); if (ADI_AFE_SUCCESS != adi_AFE_EnableInterruptSource( hDevice, ADI_AFE_INT_GROUP_CAPTURE, BITM_AFE_AFE_ANALOG_CAPTURE_IEN_DFT_RESULT_READY_IEN, true)) { FAIL("adi_AFE_EnableInterruptSource"); } PRINT("START\r\n"); printf("START\r\n"); while (true) { // Wait on the queue to get DFT data from the ISR (~76 Hz). //printf("MainTask: pending on DFT queue.\n"); q_result_void = OSQPend(dft_queue, 0, &err); q_result.pointer = q_result_void; if (err != OS_ERR_NONE) { FAIL("OSQPend: dft_queue"); } OSQQuery(dft_queue, &q_data); q_size = q_data.OSNMsgs; // Right after we get this data, get the transducer's value from the // Arduino. //printf("MainTask: getting transducer value via I2C.\n"); i2cResult = adi_I2C_MasterReceive(i2cDevice, I2C_PUMP_SLAVE_ADDRESS, 0x0, ADI_I2C_8_BIT_DATA_ADDRESS_WIDTH, i2c_rx, 3, false); if (i2cResult != ADI_I2C_SUCCESS) { FAIL("adi_I2C_MasterReceive: get pressure from Arduino"); } // Get the analog pressure value from the Arduino. if (i2c_rx[0] == ARDUINO_PRESSURE_AVAILABLE || i2c_rx[0] == ARDUINO_STILL_INFLATING) { pressure_analog = i2c_rx[1] | (i2c_rx[2] << 8); } else { FAIL("Corrupted or unexpected data from Arduino."); } // Convert the analog value to mmHg. pressure = transducer_to_mmhg(pressure_analog); //printf("MainTask: got pressure value: %d mmHg.\n", pressure); // If the pressure is below the threshold, we're done; break the loop. if (inflated && pressure < LOWEST_PRESSURE_THRESHOLD_MMHG) { PRINT("END\r\n"); printf("END\r\n"); inflated = false; break; } else if (pressure > LOWEST_PRESSURE_THRESHOLD_MMHG * 1.1) { inflated = true; } // Convert DFT results to 1.15 and 1.31 formats. dft_results[0] = q_result.parts.magnitude; dft_results[1] = q_result.parts.phase; convert_dft_results(dft_results, dft_results_q15, dft_results_q31); // Compute the magnitude using CMSIS. arm_cmplx_mag_q31(dft_results_q31, magnitude, DFT_RESULTS_COUNT / 2); // Calculate final magnitude values, calibrated with RCAL. fixed32_t magnituderesult; magnituderesult = calculate_magnitude(magnitudecal, magnitude[0]); q15_t phaseresult; phaseresult = arctan(dft_results[1], dft_results[0]); fixed32_t phasecalibrated; // Calibrate with phase from rcal. phasecalibrated = calculate_phase(phasecal, phaseresult); // TODO: dispatch to another thread? //printf("MainTask: sending data via UART.\n");; print_PressureMagnitudePhase("", pressure, magnituderesult, phasecalibrated, q_size); nummeasurements++; } // We're done measuring, for now. Disable the DFT interrupts. printf("MainTask: disabling DFT interrupts.\n"); if (ADI_AFE_SUCCESS != adi_AFE_EnableInterruptSource( hDevice, ADI_AFE_INT_GROUP_CAPTURE, BITM_AFE_AFE_ANALOG_CAPTURE_IEN_DFT_RESULT_READY_IEN, false)) { FAIL("adi_AFE_EnableInterruptSource (false)"); } // Tell the pump task to deflate the cuff. printf("MainTask: resuming pump task to deflate the cuff.\n"); err = OSTaskResume(TASK_PUMP_PRIO); if (err != OS_ERR_NONE) { FAIL("OSTaskResume: MainTask (2)"); } // Suspend until the pump finishes deflating. We can then go back to // listening for the user input. printf("MainTask: suspending to wait for pump task.\n"); err = OSTaskSuspend(OS_PRIO_SELF); if (err != OS_ERR_NONE) { FAIL("OSTaskSuspend: MainTask (3)"); } // Tell the UX that we're done for now. UX_Disengage(); } }
void protocol_task(void *p_arg) { OS_ERR err; static uint8_t Date_Handle_Flag = 0; uint8_t temp = 0; p_arg = p_arg; while(1) { OSTaskSemPend(0,OS_OPT_PEND_BLOCKING,0,&err); if( !Date_Handle_Flag) //Uart3_Recv_STA && { Date_Handle_Flag = 1; //Uart3_Recv_STA = 0; } if(Date_Handle_Flag) { temp = Hekr_RecvData_Handle(Uart3_Recv_Buffer); if(Valid_Data_Update == temp) { //接收的数据保存在 Valid_Data 数组里 //User Code if(Valid_Data[0] == 0x01) { LED0 = 1; OSTaskSuspend((OS_TCB*)&Led0TaskTCB,&err); printf("挂起LED任务\n\r"); } else { LED0 = 0; OSTaskResume((OS_TCB*)&Led0TaskTCB,&err); printf("恢复LED任务\n\r"); } if(Valid_Data[1] == 0x01) { OSTaskDel((OS_TCB*)&FloatTaskTCB,&err); printf("删除float任务\n\r"); } else { //创建浮点测试任务 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 )0, (OS_TICK )0, (void * )0, (OS_OPT )OS_OPT_TASK_STK_CHK|OS_OPT_TASK_STK_CLR, (OS_ERR * )&err); } } if(Hekr_Module_State_Update == temp) { //接收的数据保存在 Module_Status 数组里 //User Code } Date_Handle_Flag = 0; } OSTimeDlyHMSM(0,0,0,10,OS_OPT_TIME_HMSM_STRICT,&err); //延时10ms } }
void OSStatTaskCPUUsageInit (OS_ERR *p_err) { OS_ERR err; OS_TICK dly; CPU_SR_ALLOC(); #ifdef OS_SAFETY_CRITICAL if (p_err == (OS_ERR *)0) { OS_SAFETY_CRITICAL_EXCEPTION(); return; } #endif #if (OS_CFG_TMR_EN > 0u) OSTaskSuspend(&OSTmrTaskTCB, &err); if (err != OS_ERR_NONE) { *p_err = err; return; } #endif OSTimeDly((OS_TICK )2, /* Synchronize with clock tick */ (OS_OPT )OS_OPT_TIME_DLY, (OS_ERR *)&err); if (err != OS_ERR_NONE) { *p_err = err; return; } CPU_CRITICAL_ENTER(); OSStatTaskCtr = (OS_TICK)0; /* Clear idle counter */ CPU_CRITICAL_EXIT(); dly = (OS_TICK)0; if (OSCfg_TickRate_Hz > OSCfg_StatTaskRate_Hz) { dly = (OS_TICK)(OSCfg_TickRate_Hz / OSCfg_StatTaskRate_Hz); } if (dly == (OS_TICK)0) { dly = (OS_TICK)(OSCfg_TickRate_Hz / (OS_RATE_HZ)10); } OSTimeDly(dly, /* Determine MAX. idle counter value */ OS_OPT_TIME_DLY, &err); #if (OS_CFG_TMR_EN > 0u) OSTaskResume(&OSTmrTaskTCB, &err); if (err != OS_ERR_NONE) { *p_err = err; return; } #endif CPU_CRITICAL_ENTER(); OSStatTaskTimeMax = (CPU_TS)0; OSStatTaskCtrMax = OSStatTaskCtr; /* Store maximum idle counter count */ OSStatTaskRdy = OS_STATE_RDY; CPU_CRITICAL_EXIT(); *p_err = OS_ERR_NONE; }