示例#1
0
void rt_task4_thread_entry(void* parameter)
{
	extern void start_transmit(void);
 	extern void stop_transmit(void);
	extern uint8_t check_parameter(void);
//	extern uint8_t self_check(void);
//	extern void cpu_usage_init();
	rt_uint32_t ev;
	
	if((GPIO_ReadInputDataBit(GPIOD, GPIO_Pin_3) == 0))
	{
		coil.usRegCoilBuf |= M(0);
	}
	else
	{
		coil.usRegCoilBuf &= ~M(0);
	}
	
	rt_event_init(&key_event, "key_event", RT_IPC_FLAG_FIFO );
	
	while(1)
	{
		if( rt_event_recv( &key_event, FOOT_PUPD | KEY_PUPD, RT_EVENT_FLAG_OR | RT_EVENT_FLAG_CLEAR, RT_WAITING_FOREVER, &ev ) == RT_EOK ) 
		{
			
				rt_thread_delay(6);
				if( (ev & FOOT_PUPD) && (coil.usRegCoilBuf & M(0)) &&(GPIO_ReadInputDataBit(GPIOA, GPIO_Pin_0) == 0)&& \
					(check_parameter()) && (coil.usRegCoilBuf & M(7)))
				{
					start_transmit();
				}
				else
				{
					stop_transmit();
				}
				
				if(ev & KEY_PUPD)
				{
					if((GPIO_ReadInputDataBit(GPIOD, GPIO_Pin_3) == 0))
					{
						coil.usRegCoilBuf |= M(0);
					}
					else
					{
						coil.usRegCoilBuf &= ~M(0);
					}
				}
		}
		rt_event_recv( &key_event, FOOT_PUPD | KEY_PUPD, RT_EVENT_FLAG_OR | RT_EVENT_FLAG_CLEAR, 2, &ev );
		
		rt_thread_delay(20);
	}
}
示例#2
0
BOOL
xMBPortEventGet( eMBEventType * eEvent )
{
	rt_uint32_t recvedEvent;
	/* waiting forever OS event */
	rt_event_recv(&xSlaveOsEvent,
		EV_READY | EV_FRAME_RECEIVED | EV_EXECUTE | EV_FRAME_SENT,
		RT_EVENT_FLAG_OR | RT_EVENT_FLAG_CLEAR, RT_WAITING_FOREVER,
		&recvedEvent);
	switch (recvedEvent)
	{
	case EV_READY:
		*eEvent = EV_READY;
		break;
	case EV_FRAME_RECEIVED:
		*eEvent = EV_FRAME_RECEIVED;
		break;
	case EV_EXECUTE:
		*eEvent = EV_EXECUTE;
		break;
	case EV_FRAME_SENT:
		*eEvent = EV_FRAME_SENT;
		break;
	}
	return TRUE;
}
/**
 * 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);
    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;
}
示例#4
0
void F_setBzTest(void)
{
		rt_uint8_t	keyCode = 0;
		rt_bool_t	LongKeyStartFlg = 0;
		rt_uint32_t e;
	
			if (rt_event_recv(&sport_timer_event, 0xFFFF,
					RT_EVENT_FLAG_OR | RT_EVENT_FLAG_CLEAR,
					RT_WAITING_FOREVER, &e) == RT_EOK)
			{
				if((e & time_20ms_val) == time_20ms_val)
				{
					F_ReadKeyCode(&keyCode,&LongKeyStartFlg,&ui_action.SleepTimer);
					switch(keyCode)
					{
						case	stop_rest_KeyVal:
						bz_short();
						F_EngineeringModeInit(BeeperTestEventVal);
							break;
						case	enter_KeyVal:
						F_ChooseBzControl();
							break;
						case	resistance_up_KeyVal:
						if(LongKeyStartFlg == 0)	{
							bz_short();
							if(ui_action.Event > BzTest1EventVal)
								ui_action.Event--;
								else
									ui_action.Event = BzTest3EventVal;
						}
							break;
						case	resistance_down_KeyVal:
						if(LongKeyStartFlg == 0)	{
							bz_short();
							ui_action.Event++;
							if(ui_action.Event>BzTest3EventVal)
								ui_action.Event = BzTest1EventVal;
						}
							break;
					}
				}
				//=====================
				if((e & time_100ms_val) == time_100ms_val)
				{
					F_SetDisplayRam(0);
					switch(ui_action.Event) {
						case	BzTest1EventVal:
							F_ShowChooseBz1();
							break;
						case	BzTest2EventVal:
							F_ShowChooseBz2();
							break;
						case	BzTest3EventVal:
							F_ShowChooseBz3();
							break;
					}
					F_Display();
				}
			}
}
示例#5
0
void rt_can_thread_entry(void *parameter)
{
    struct rt_can_msg msg;
    struct can_app_struct *canpara = (struct can_app_struct *) parameter;
    rt_device_t candev;
    rt_uint32_t e;

    candev = rt_device_find(canpara->name);
    RT_ASSERT(candev);
    rt_event_init(&canpara->event, canpara->name, RT_IPC_FLAG_FIFO);
    rt_device_open(candev, (RT_DEVICE_OFLAG_RDWR | RT_DEVICE_FLAG_INT_RX | RT_DEVICE_FLAG_INT_TX));
    rt_device_control(candev, RT_CAN_CMD_SET_FILTER, canpara->filter);
    while (1)
    {
        if (
            rt_event_recv(&canpara->event,
                          ((1 << canpara->filter->items[0].hdr)  |
                           (1 << canpara->filter->items[1].hdr) |
                           (1 << canpara->filter->items[2].hdr) |
                           (1 << canpara->filter->items[3].hdr)),
                          canpara->eventopt,
                          RT_WAITING_FOREVER, &e) != RT_EOK
        )
        {
            continue;
        }
        if (e & (1 << canpara->filter->items[0].hdr))
        {
            msg.hdr = canpara->filter->items[0].hdr;
            while (rt_device_read(candev, 0, &msg, sizeof(msg)) == sizeof(msg))
            {
                rt_device_write(candev, 0, &msg, sizeof(msg));
            }
        }
        if (e & (1 << canpara->filter->items[1].hdr))
        {
            msg.hdr = canpara->filter->items[1].hdr;
            while (rt_device_read(candev, 0, &msg, sizeof(msg)) == sizeof(msg))
            {
                rt_device_write(candev, 0, &msg, sizeof(msg));
            }
        }
        if (e & (1 << canpara->filter->items[2].hdr))
        {
            msg.hdr = canpara->filter->items[2].hdr;
            while (rt_device_read(candev, 0, &msg, sizeof(msg)) == sizeof(msg))
            {
                rt_device_write(candev, 0, &msg, sizeof(msg));
            }
        }
        if (e & (1 << canpara->filter->items[3].hdr))
        {
            msg.hdr = canpara->filter->items[3].hdr;
            while (rt_device_read(candev, 0, &msg, sizeof(msg)) == sizeof(msg))
            {
                rt_device_write(candev, 0, &msg, sizeof(msg));
            }
        }
    }
}
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 */
    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;
}
示例#7
0
static int DownloadCommandToStation(WlanCard *cardinfo,
		HostCmd_DS_COMMAND * Cmd)
{
	HostCmd_DS_COMMAND *CmdPtr;
	WlanCard *card = cardinfo;
	int ret = WLAN_STATUS_SUCCESS;
	rt_uint32_t event;
	CmdPtr = (HostCmd_DS_COMMAND *) Cmd;

	if (!CmdPtr || !CmdPtr->Size)
	{
		WlanDebug(WlanErr,"Download CMD parameter error\r\n");
		ret = WLAN_STATUS_FAILURE;
		goto done;
	}

	card->CurCmd = Cmd;
	//WlanDebug(WlanCmd,"send CMD: 0x%x, len %d, Number %d\n",CmdPtr->Command, CmdPtr->Size, (CmdPtr->SeqNum));
	ret = sbi_host_to_card(card, MVMS_CMD, (u8 *) CmdPtr, CmdPtr->Size);
	card->HisRegCpy &= ~HIS_TxDnLdRdy;

	rt_event_recv(&(cardinfo->cmdwaitevent), CmdWaitQWoken,
			RT_EVENT_FLAG_OR | RT_EVENT_FLAG_CLEAR, RT_WAITING_FOREVER, &event);
	ret = WLAN_STATUS_SUCCESS;

done:
	return ret;
}
示例#8
0
//光流定点算法
void loiter(float x, float y, float yaw)
{
    rt_uint32_t dump;
    if (check_safe(SAFE_ADNS3080))
    {
        x_v_pid.out = 0;
        y_v_pid.out = 0;
        return;
    }
    if (rt_event_recv(&ahrs_event, AHRS_EVENT_ADNS3080, RT_EVENT_FLAG_AND | RT_EVENT_FLAG_CLEAR, RT_WAITING_NO, &dump) == RT_EOK)
    {
        PID_SetTarget(&x_d_pid, pos_X);
        PID_SetTarget(&y_d_pid, pos_y);

        PID_xUpdate(&x_d_pid, ahrs.x);
        PID_xUpdate(&y_d_pid, ahrs.y);

        PID_SetTarget(&x_v_pid, -RangeValue(x_d_pid.out, -10, 10));
        PID_SetTarget(&y_v_pid, -RangeValue(y_d_pid.out, -10, 10));

        PID_xUpdate(&x_v_pid, ahrs.dx);
        PID_xUpdate(&y_v_pid, ahrs.dy);
    }
    stable(+RangeValue(y_v_pid.out, -10, 10), -RangeValue(x_v_pid.out, -10, 10), yaw);
}
示例#9
0
void
jffs2_stop_garbage_collect_thread(struct jffs2_sb_info *c)
{
     struct super_block *sb=OFNI_BS_2SFFJ(c);
     cyg_mtab_entry *mte;
	 rt_uint32_t  e;
	 
     //RT_ASSERT(sb->s_gc_thread_handle);

     D1(printk("jffs2_stop_garbage_collect_thread\n"));
     /* Stop the thread and wait for it if necessary */

     rt_event_send(&sb->s_gc_thread_flags,GC_THREAD_FLAG_STOP);

     D1(printk("jffs2_stop_garbage_collect_thread wait\n"));
	 
     rt_event_recv(&sb->s_gc_thread_flags,
                   GC_THREAD_FLAG_HAS_EXIT,
                   RT_EVENT_FLAG_OR | RT_EVENT_FLAG_CLEAR,
				   RT_WAITING_FOREVER,  &e);

     // Kill and free the resources ...  this is safe due to the flag
     // from the thread.
     rt_thread_detach(&sb->s_gc_thread);
     rt_sem_detach(&sb->s_lock);
     rt_event_detach(&sb->s_gc_thread_flags);
}
void vMBPortSerialEnable(BOOL xRxEnable, BOOL xTxEnable)
{
    rt_uint32_t recved_event;
    if (xRxEnable)
    {
        /* enable RX interrupt */
        serial->ops->control(serial, RT_DEVICE_CTRL_SET_INT, (void *)RT_DEVICE_FLAG_INT_RX);
        /* switch 485 to receive mode */
        rt_pin_write(MODBUS_SLAVE_RT_CONTROL_PIN_INDEX, PIN_HIGH);//PIN_LOW);
    }
    else
    {
        /* switch 485 to transmit mode */
        rt_pin_write(MODBUS_SLAVE_RT_CONTROL_PIN_INDEX, PIN_LOW);//PIN_HIGH);
        /* disable RX interrupt */
        serial->ops->control(serial, RT_DEVICE_CTRL_CLR_INT, (void *)RT_DEVICE_FLAG_INT_RX);
    }
    if (xTxEnable)
    {
        /* start serial transmit */
        rt_event_send(&event_serial, EVENT_SERIAL_TRANS_START);
    }
    else
    {
        /* stop serial transmit */
        rt_event_recv(&event_serial, EVENT_SERIAL_TRANS_START,
                RT_EVENT_FLAG_OR | RT_EVENT_FLAG_CLEAR, 0,
                &recved_event);
    }
}
示例#11
0
void correct_gryo()
{
	rt_uint32_t e;
	rt_uint16_t i;
	rt_int16_t * mpu1, *mpu2, *mpu3;
	rt_int16_t m1, m2, m3;
	rt_kprintf("start sensors correct\n");

	mpu1 = (rt_int16_t *)rt_calloc(255, sizeof(rt_int16_t));
	mpu2 = (rt_int16_t *)rt_calloc(255, sizeof(rt_int16_t));
	mpu3 = (rt_int16_t *)rt_calloc(255, sizeof(rt_int16_t));

	for (i = 0;i < 255;i++)
	{
		if (rt_event_recv(&ahrs_event, AHRS_EVENT_Update,
			RT_EVENT_FLAG_AND | RT_EVENT_FLAG_CLEAR,
			RT_WAITING_FOREVER, &e) == RT_EOK)
		{
			m1 = MoveAve_SMA(mpu_gryo_pitch, mpu1, 255);
			m2 = MoveAve_SMA(mpu_gryo_roll, mpu2, 255);
			m3 = MoveAve_SMA(mpu_gryo_yaw, mpu3, 255);
		}
	}

	MPU6050_Diff[0] -= m1;
	MPU6050_Diff[1] -= m2;
	MPU6050_Diff[2] -= m3;

	rt_free(mpu1);
	rt_free(mpu2);
	rt_free(mpu3);

	rt_kprintf("sensor correct finish.\n");
}
示例#12
0
void fnAlarm(void)
{
	rt_uint32_t e;
	uint8_t buf,int_m,t=0;
	uint16_t delay1,delay2,strength;
	rt_thread_delay_hmsm(0,0,3,0);
	int_m = (clock_m+5)%60;
	rt_kprintf("It is %d:%d now\nAlarm Level %d\n",clock_h,clock_m,t);
	rt_event_send(reg_event,REG_ALARM_MSK);
	while (rt_mq_recv(key_mq,&buf,sizeof(uint8_t),0)!=RT_EOK)
	{
		if (clock_m==int_m)
		{
			t+=1;
			int_m = (int_m+5)%60;
			rt_kprintf("Alarm Level %d\n",t);
		}
		switch (t)
		{
			case 0: delay1 = 500; delay2 = 4500; strength = 400; break;
			case 1: delay1 = 1000; delay2 = 2000; strength = 600; break;
			case 2: delay1 = 500; delay2 = 500; strength = 800; break;
			default: delay1 = 500; delay2 = 250; strength = 1000; break;
		}
		SetAlarm(strength);
		rt_thread_delay_hmsm(0,0,0,delay1);
		SetAlarm(0);
		Animate(delay2);
	}
	rt_event_recv(reg_event,REG_ALARM_MSK,RT_EVENT_FLAG_OR|RT_EVENT_FLAG_CLEAR,0,&e);
	return;
}
示例#13
0
/* 监视GPRS串口线程入口*/
void gprswatch_entry(void* parameter)
{
  rt_err_t result = RT_EOK;
  rt_uint32_t event;
  char gprs_rx_buffer[512]={0x00};
  
  while(1)
  {
      result = rt_event_recv(&rev_event, 
         REV_MASK, RT_EVENT_FLAG_OR | RT_EVENT_FLAG_CLEAR, 
         RT_WAITING_FOREVER, &event);
      if (result == RT_EOK)
      {
        if (event & REV_DATA)
        {
          rt_memset(gprs_rx_buffer,0x00,sizeof(gprs_rx_buffer));
          rt_thread_delay(RT_TICK_PER_SECOND*2);
          rt_device_read(gprs_device, 0, gprs_rx_buffer, 512);
          rt_kprintf(gprs_rx_buffer);
        }
        if (event & REV_STOPWATCH)
        {
          return;
        }
      }
    }
}
void F_setProfileInterval_2(void)
{
		rt_uint8_t	keyCode = 0;
		rt_bool_t	LongKeyStartFlg = 0;
		rt_uint32_t e;
		rt_time_data_t SetWorkoutTime;
	
			if (rt_event_recv(&sport_timer_event, 0xFFFF,
					RT_EVENT_FLAG_OR | RT_EVENT_FLAG_CLEAR,
					RT_WAITING_FOREVER, &e) == RT_EOK)
			{
				if((e & time_20ms_val) == time_20ms_val)
				{
					F_ReadKeyCode(&keyCode,&LongKeyStartFlg,&ui_action.SleepTimer);
					F_LongRestKey(keyCode);
					F_SeatPositionControlAllKey(&keyCode,LongKeyStartFlg);
					F_SetUserKey(keyCode);
					switch(ui_action.Event) 
					{
						case	setProfileLevelEventVal:
						F_setProfileLevelKey(keyCode,LongKeyStartFlg);
							break;
						case	setProfileWorkOutTImeEventVal:
						F_setProfileWorkOutTImeKey(keyCode,LongKeyStartFlg);
							break;
					}
				}
				//=====================
				if((e & time_100ms_val) == time_100ms_val)
				{
					F_SetDisplayRam(0);
					if(ui_action.TemporarySeatPositionEvent == TemporarySeatPositionNormalEventVal) {
						switch(ui_action.Event) 
						{
							case	setProfileLevelEventVal:
							F_showProfileSetLeve(set_profile_data.interval_2_Level.number);
							F_ShowProgfileGraph(sport_data.progfileArry,ProgfileDataSizeVal,CommonModeVal,0,0);
								break;
							case	setProfileWorkOutTImeEventVal:
							SetWorkoutTime.timeH = set_profile_data.interval_2_WorkoutMinTime.number;
							SetWorkoutTime.timeL = 0;
							F_showProfileSetWorkoutTime(SetWorkoutTime);
								break;
						}
					} else {
						F_showSeatPositionStatus(ui_action.TemporarySeatPositionEvent);
					}
					F_Display();
				}
				//=====================
				if((e & time_1s_val) == time_1s_val)
				{
					F_SwitchingSeatPositionDisplayTimer();
				}
			}
}
示例#15
0
static err_t
low_level_output(struct netif *netif, struct pbuf *p)
{
  struct pbuf *q;
  uint32_t Index, IndexNext;
  uint8_t *ptr;

  /* calculate next index */
  IndexNext = LPC_EMAC->TxProduceIndex + 1;
  if(IndexNext > LPC_EMAC->TxDescriptorNumber)
    IndexNext = 0;
#if 0
	/* check whether block is full */
	while (IndexNext == LPC_EMAC->TxConsumeIndex)
	{
		err_t result;
		uint32_t recved;

		/* there is no block yet, wait a flag */
		result = rt_event_recv(&tx_event, 0x01,
			RT_EVENT_FLAG_AND | RT_EVENT_FLAG_CLEAR, RT_WAITING_FOREVER, &recved);
	}
#endif
  
	Index = LPC_EMAC->TxProduceIndex;

	/* calculate next index */
	IndexNext = LPC_EMAC->TxProduceIndex + 1;
	if(IndexNext > LPC_EMAC->TxDescriptorNumber)
		IndexNext = 0;

#if ETH_PAD_SIZE
  pbuf_header(p, -ETH_PAD_SIZE); /* drop the padding word */
#endif

	/* copy data to tx buffer */
	ptr = (uint8_t*)TX_BUF(Index);
  for(q = p; q != NULL; q = q->next) {
		MEMCPY(ptr, q->payload, q->len);
		ptr += q->len;
  }

	TX_DESC_CTRL(Index) = (p->tot_len - 1) & 0x7ff | EMAC_TCTRL_INT | EMAC_TCTRL_LAST;

	/* change index to the next */
	LPC_EMAC->TxProduceIndex = IndexNext;

#if ETH_PAD_SIZE
  pbuf_header(p, ETH_PAD_SIZE); /* reclaim the padding word */
#endif
  
  LINK_STATS_INC(link.xmit);

  return ERR_OK;
}
示例#16
0
/* transmit packet. */
rt_err_t lpc17xx_emac_tx( rt_device_t dev, struct pbuf* p)
{
	rt_uint32_t Index, IndexNext;
	struct pbuf *q;
	rt_uint8_t *ptr;

	/* calculate next index */
	IndexNext = LPC_EMAC->TxProduceIndex + 1;
	if(IndexNext > LPC_EMAC->TxDescriptorNumber) IndexNext = 0;

	/* check whether block is full */
	while (IndexNext == LPC_EMAC->TxConsumeIndex)
	{
		rt_err_t result;
		rt_uint32_t recved;
		
		/* there is no block yet, wait a flag */
		result = rt_event_recv(&tx_event, 0x01, 
			RT_EVENT_FLAG_AND | RT_EVENT_FLAG_CLEAR, RT_WAITING_FOREVER, &recved);

		RT_ASSERT(result == RT_EOK);
	}

	/* lock EMAC device */
	rt_sem_take(&sem_lock, RT_WAITING_FOREVER);

	/* get produce index */
	Index = LPC_EMAC->TxProduceIndex;

	/* calculate next index */
	IndexNext = LPC_EMAC->TxProduceIndex + 1;
	if(IndexNext > LPC_EMAC->TxDescriptorNumber)
		IndexNext = 0;

	/* copy data to tx buffer */
	q = p;
	ptr = (rt_uint8_t*)TX_BUF(Index);
	while (q)
	{
		memcpy(ptr, q->payload, q->len);
		ptr += q->len;
		q = q->next;
	}

	TX_DESC_CTRL(Index) &= ~0x7ff;
	TX_DESC_CTRL(Index) |= (p->tot_len - 1) & 0x7ff;

	/* change index to the next */
	LPC_EMAC->TxProduceIndex = IndexNext;

	/* unlock EMAC device */
	rt_sem_release(&sem_lock);

	return RT_EOK;
}
/**
 * Software simulation serial transmit IRQ handler.
 *
 * @param parameter parameter
 */
static void serial_soft_trans_irq(void* parameter) {
    rt_uint32_t recved_event;
    while (1)
    {
        /* waiting for serial transmit start */
        rt_event_recv(&event_serial, EVENT_SERIAL_TRANS_START, RT_EVENT_FLAG_OR,
                RT_WAITING_FOREVER, &recved_event);
        /* execute modbus callback */
        prvvUARTTxReadyISR();
    }
}
void F_setHeartRateTarget(void)
{
		rt_uint8_t	keyCode = 0;
		rt_bool_t	LongKeyStartFlg = 0;
		rt_uint32_t e;
		rt_time_data_t SetWorkoutTime;
	
			if (rt_event_recv(&sport_timer_event, 0xFFFF,
					RT_EVENT_FLAG_OR | RT_EVENT_FLAG_CLEAR,
					RT_WAITING_FOREVER, &e) == RT_EOK)
			{
				if((e & time_20ms_val) == time_20ms_val)
				{
					F_ReadKeyCode(&keyCode,&LongKeyStartFlg,&ui_action.SleepTimer);
					F_LongRestKey(keyCode);
					F_SeatPositionControlAllKey(&keyCode,LongKeyStartFlg);
					F_SportKey(keyCode);
						switch(ui_action.Event) {
							case	showHeartRateSetTargetEventVal:
							F_setTargetKey(keyCode,LongKeyStartFlg);
								break;
							case	showHeartRateWorkoutEventVal:
							F_setFatBurnWorkOutTImeKey(keyCode,LongKeyStartFlg);
								break;
						}
				}
				//=====================
				if((e & time_100ms_val) == time_100ms_val)
				{
					F_SetDisplayRam(0);
					if(ui_action.TemporarySeatPositionEvent == TemporarySeatPositionNormalEventVal) {
						switch(ui_action.Event) {
							case	showHeartRateSetTargetEventVal:
							F_showSetTargetNum(profile_heartrate_data.TargetTarget.number,0);
								break;
							case	showHeartRateWorkoutEventVal:
							SetWorkoutTime.timeH = profile_heartrate_data.TargetWorkoutMinTime.number;
							SetWorkoutTime.timeL = 0;
							F_showProfileSetWorkoutTime(SetWorkoutTime);
								break;
						}
					} else {
						F_showSeatPositionStatus(ui_action.TemporarySeatPositionEvent);
					}
					F_Display();
				}
				//=====================
				if((e & time_1s_val) == time_1s_val)
				{
					F_SwitchingSeatPositionDisplayTimer();
				}
			}
}
示例#19
0
int wait_int(int flag)
{
    rt_uint32_t ev;
    

    if(flag)
    {
        /*wait for gdo0 to h */
#if 1
        if( rt_event_recv( &cc1101_event, GDO0_H, RT_EVENT_FLAG_AND | RT_EVENT_FLAG_CLEAR, 100, &ev ) != RT_EOK ) 
        {
            rt_kprintf("wait for h failed\r\n");
		  cc1101_hw_init();

            return RT_FALSE;
        }
#else
        while(GPIO_ReadInputDataBit(GPIOC,GPIO_Pin_4)==RESET);
#endif
    }
    else
    {
        /*wait for gdo0 to l */
#if 1
        if( rt_event_recv( &cc1101_event, GDO0_L, RT_EVENT_FLAG_AND | RT_EVENT_FLAG_CLEAR, 100, &ev ) != RT_EOK ) 
        {
            rt_kprintf("wait for l failed\r\n");
		  cc1101_hw_init();

            return RT_FALSE;
        }
#else
        while(GPIO_ReadInputDataBit(GPIOC,GPIO_Pin_4)==SET);
#endif
    }
   
    return RT_TRUE;
}
示例#20
0
void correct_thread_entry(void* parameter)
{
	rt_uint32_t e;
	rt_uint16_t i;
	rt_int16_t * mpu1, *mpu2, *mpu3;
	rt_int16_t m1, m2, m3;
	rt_sem_init(&angle_fix_sem, "angle_fix", 0, RT_IPC_FLAG_FIFO);

	while (1)
	{
		rt_sem_take(&angle_fix_sem, RT_WAITING_FOREVER);
		rt_kprintf("start angle fix\n");

		settings.angle_diff_pitch = 0;
		settings.angle_diff_roll = 0;
		settings.angle_diff_yaw = 0;

		mpu1 = (rt_int16_t *)rt_calloc(255, sizeof(rt_int16_t));
		mpu2 = (rt_int16_t *)rt_calloc(255, sizeof(rt_int16_t));
		mpu3 = (rt_int16_t *)rt_calloc(255, sizeof(rt_int16_t));

		for (i = 0;i < 255;i++)
		{
			if (rt_event_recv(&ahrs_event, AHRS_EVENT_Update,
				RT_EVENT_FLAG_AND | RT_EVENT_FLAG_CLEAR,
				RT_WAITING_FOREVER, &e) == RT_EOK)
			{
				m1 = MoveAve_SMA(ahrs.degree_pitch*1000.0f, mpu1, 255);
				m2 = MoveAve_SMA(ahrs.degree_roll	*1000.0f, mpu2, 255);
				m3 = MoveAve_SMA(ahrs.degree_yaw	*1000.0f, mpu3, 255);
			}
		}

		settings.angle_diff_pitch = -m1 / 1000.0f;
		settings.angle_diff_roll = -m2 / 1000.0f;
		settings.angle_diff_yaw = -m3 / 1000.0f;

		rt_free(mpu1);
		rt_free(mpu2);
		rt_free(mpu3);

		rt_kprintf("pitch:%d	roll:%d	yaw:%d\n",
			(s16)(settings.angle_diff_pitch),
			(s16)(settings.angle_diff_roll),
			(s16)(settings.angle_diff_yaw));

		rt_kprintf("degree fix finish.\n");
		save_settings(&settings, "/setting");
	}
}
示例#21
0
rt_inline rt_err_t stm32_i2c_wait_ev(struct stm32_i2c_bus *bus,
                                  rt_uint32_t ev, rt_uint32_t timeout)
{
    rt_uint32_t res = 0;
    rt_event_recv(&bus->ev, 0x01 << ev,
                  RT_EVENT_FLAG_OR | RT_EVENT_FLAG_CLEAR,
                  timeout, &res);
    if(res != ev)
    {
        return RT_ERROR;
    }
    else
    {
        return RT_EOK;
    }
}
示例#22
0
static void rt_isr_event_entry(void* parameter)
{
	rt_err_t err;
	rt_uint32_t e;

	printf_syn("rt_isr_event_entry()\n");
	say_thread_start();

	while (1) {
		err = rt_event_recv(&isr_event_set
				, EVENT_BIT_NEED_RUN_TIM2_IRQ | EVENT_BIT_NEED_RUN_TIM4_IRQ | EVENT_BIT_NEED_RUN_SI4432_MAC_EXTI_IRQ
				, RT_EVENT_FLAG_OR | RT_EVENT_FLAG_CLEAR, RT_WAITING_FOREVER, &e);

		if (RT_EOK != err) {
			printf_syn("recv isr event error(%d)", err);
		} else {
#if RT_USING_SI4432_MAC
			if (is_bit_set(isr_event_var_flag, EVENT_BIT_NEED_RUN_SI4432_MAC_EXTI_IRQ)) {
				clr_bit(isr_event_var_flag, EVENT_BIT_NEED_RUN_SI4432_MAC_EXTI_IRQ);
				si4432_mac_exti_isr();
			}
#endif
#if RT_USING_ADE7880
			if (is_bit_set(isr_event_var_flag, EVENT_BIT_NEED_RUN_TIM4_IRQ)) {
				clr_bit(isr_event_var_flag, EVENT_BIT_NEED_RUN_TIM4_IRQ);
#if 0 == ADE7880_USE_I2C_HSDC
 				tim4_isr();
#endif
			}
#endif
#if RT_USING_SI4432_MAC
			if (is_bit_set(isr_event_var_flag, EVENT_BIT_NEED_RUN_SI4432_MAC_EXTI_IRQ)) {
				clr_bit(isr_event_var_flag, EVENT_BIT_NEED_RUN_SI4432_MAC_EXTI_IRQ);
				si4432_mac_exti_isr();
			}

			if (is_bit_set(isr_event_var_flag, EVENT_BIT_NEED_RUN_TIM2_IRQ)) {
				clr_bit(isr_event_var_flag, EVENT_BIT_NEED_RUN_TIM2_IRQ);
				tim2_isr();
			}
#endif
		}
	}

	return;
}
示例#23
0
 static void recv_thread_entry(void* parameter)
{
	rt_uint32_t ev =0;
	rt_err_t ret = RT_EOK;
	rt_uint16_t recv_len = 0;
  while(1)
  {
 ret =  rt_event_recv(cmd.recv_event,0x01,RT_EVENT_FLAG_AND|RT_EVENT_FLAG_CLEAR,RT_WAITING_FOREVER,&ev);
	if(ret == RT_EOK)
	{
	 recv_len = rt_device_read(cmd.dev,0,cmd.recv_buf,1024);
	
	if (recv_len > 0)
	{
		int index =0;
		while(index <(recv_len-4))
		{
			if((cmd.recv_buf[index]==0xaa)&&(cmd.recv_buf[index+1]==0xaf)&&(cmd.recv_buf[index+2]>0)&&(cmd.recv_buf[index+2]<0xf1))
			{
					if(cmd.recv_buf[index+3]<50)
					{
						uint8_t cmd_len = cmd.recv_buf[index+3];
						if(cmd_len+index<recv_len)
						{
							cmd.Data_Receive_Anl( &cmd.recv_buf[index],cmd_len+5);
							index+=cmd_len+5;
						}
						else
						{
							index++;
						}
					}
					else
					{
						index+=4;
					}
			}
			else
			{
			 index++;
			}
		}
	}
	}
	}
}
示例#24
0
static void LD_thread_entry(void* parameter)
{
	rt_uint32_t evt;
//	rt_base_t level;
	/* 关闭中断*/
	rt_kprintf("进入LD专用线程!\r\n");
	while(1)
	{
		if(rt_event_recv(&event,(1 << 0), RT_EVENT_FLAG_AND | RT_EVENT_FLAG_CLEAR,50,&evt)== RT_EOK)
		{	
		//level = rt_hw_interrupt_disable();
		rt_enter_critical();
		//	rt_kprintf("mp3 playing..\r\n");	
			ProcessInt0(); 
		//	rt_hw_interrupt_enable(level);
			rt_exit_critical();
		}
	}
}
示例#25
0
//定高算法
void althold(float height)
{
    rt_uint32_t dump;
    if (check_safe(SAFE_SONAR))
    {
        h_v_pid.out = 0;
        return;
    }

    //等待超声波模块信号
    if (rt_event_recv(&ahrs_event, AHRS_EVENT_SONAR, RT_EVENT_FLAG_AND | RT_EVENT_FLAG_CLEAR, RT_WAITING_NO, &dump) == RT_EOK)
    {
        //双环定高
        PID_SetTarget(&h_d_pid, 60.0f);
        PID_xUpdate(&h_d_pid, ahrs.height);

        PID_SetTarget(&h_v_pid, -RangeValue(h_d_pid.out, -50, +50));
        PID_xUpdate(&h_v_pid, ahrs.height_v);
        h_v_pid.out = RangeValue(h_v_pid.out, -300, 300);
    }
}
示例#26
0
void F_eepromErrMode(void)
{
		rt_uint32_t e;
	
			if (rt_event_recv(&sport_timer_event, 0xFFFF,
					RT_EVENT_FLAG_OR | RT_EVENT_FLAG_CLEAR,
					RT_WAITING_FOREVER, &e) == RT_EOK)
			{
				if((e & time_20ms_val) == time_20ms_val)
				{
					
				}
				//=====================
				if((e & time_100ms_val) == time_100ms_val)
				{
					F_SetDisplayRam(0);
					F_ShowEepromErr();
					F_Display();
				}
			}
}
示例#27
0
void hm_heatcal_thread_entry(void* parameter)
{
    rt_uint32_t event_set = 0;
    float heat_used = 0;
    cal_event = rt_event_create("H_cal", RT_IPC_FLAG_FIFO);
    RT_ASSERT(cal_event);

    while(1) {
        if(rt_event_recv(cal_event, TDC_DATA_FULL_EVENT,
                         RT_EVENT_FLAG_AND | RT_EVENT_FLAG_CLEAR, RT_WAITING_FOREVER,
                         &event_set)==RT_EOK) {
            if((rt_mutex_take(temp_lock, rt_tick_from_millisecond(LOCK_TACK_WAIT_TIME_MS)) ||
                (rt_mutex_take(tof_lock, rt_tick_from_millisecond(LOCK_TACK_WAIT_TIME_MS)))) != RT_EOK) {
                rt_kprintf("TOF and temprature take lock error\n");
            }
            heat_used += do_heat_cal();
            rt_mutex_release(tof_lock);
            rt_mutex_release(temp_lock);
            heat_print(heat_used);
        }
    }
}
示例#28
0
static void
jffs2_garbage_collect_thread(unsigned long data)
{
     struct jffs2_sb_info *c=(struct jffs2_sb_info *)data;
     struct super_block *sb=OFNI_BS_2SFFJ(c);
     cyg_mtab_entry *mte;
     rt_uint32_t flag = 0;
	 
     D1(printk("jffs2_garbage_collect_thread START\n"));

     while(1) {
          rt_event_recv(&sb->s_gc_thread_flags,
                        GC_THREAD_FLAG_TRIG | GC_THREAD_FLAG_STOP,
                        RT_EVENT_FLAG_OR | RT_EVENT_FLAG_CLEAR,
				        cyg_current_time() + CYGNUM_JFFS2_GS_THREAD_TICKS,  
						&flag);

          if (flag & GC_THREAD_FLAG_STOP)
               break;

          D1(printk("jffs2: GC THREAD GC BEGIN\n"));

          mte=(cyg_dir *) sb->s_root;
          RT_ASSERT(mte != NULL);
//          rt_mutex_take(&mte->fs->syncmode, RT_WAITING_FOREVER);

          if (jffs2_garbage_collect_pass(c) == -ENOSPC) {
               printf("No space for garbage collection. "
                      "Aborting JFFS2 GC thread\n");
               break;
          }
//          rt_mutex_release(&mte->fs->syncmode);
          D1(printk("jffs2: GC THREAD GC END\n"));
     }

     D1(printk("jffs2_garbage_collect_thread EXIT\n"));
     rt_event_send(&sb->s_gc_thread_flags,GC_THREAD_FLAG_HAS_EXIT);	 
}
示例#29
0
/*GPRS串口发送和接收*/
rt_bool_t gprs_send_data_package(char *cmd,char *ack,uint16_t waittime, uint8_t retrytime)
{
  rt_bool_t res = RT_FALSE; 
  rt_err_t result = RT_EOK;
  rt_uint32_t event;
  char gprs_rx_buffer[512]={0x00};
  rt_thread_t thread;
  
  thread = rt_thread_find("gprswatch");
  if( thread != RT_NULL)
    rt_thread_delete(thread);
  
  do 
  {
    rt_device_write(gprs_device, 0, cmd, rt_strlen(cmd));   
    result = rt_event_recv(&rev_event, 
       REV_MASK, RT_EVENT_FLAG_OR | RT_EVENT_FLAG_CLEAR, 
       waittime*RT_TICK_PER_SECOND, &event);
    if (result == RT_EOK)
    {
      if (event & REV_DATA)
      {
        rt_memset(gprs_rx_buffer,0x00,sizeof(gprs_rx_buffer));
        rt_thread_delay(RT_TICK_PER_SECOND*2);
        rt_device_read(gprs_device, 0, gprs_rx_buffer, 512);
        rt_kprintf(gprs_rx_buffer);
        if((rt_strstr(gprs_rx_buffer,ack))||(rt_strstr(gprs_rx_buffer,"OK")))
          res = RT_TRUE;
        else
          res = RT_FALSE;
      }
    }
    retrytime--;
  }while((!res)&&(retrytime>=1));
  gprswatch();
  return res;
} 
void F_setProfileChoose(void)
{
    rt_uint8_t	keyCode = 0;
    rt_bool_t	LongKeyStartFlg = 0;
    rt_uint32_t e;

    if (rt_event_recv(&sport_timer_event, 0xFFFF,
                      RT_EVENT_FLAG_OR | RT_EVENT_FLAG_CLEAR,
                      RT_WAITING_FOREVER, &e) == RT_EOK)
    {
        if((e & time_20ms_val) == time_20ms_val)
        {
            F_ReadKeyCode(&keyCode,&LongKeyStartFlg,&ui_action.SleepTimer);
            F_LongRestKey(keyCode);
            F_SeatPositionControlAllKey(&keyCode,LongKeyStartFlg);
            F_SetUserKey(keyCode);
            switch(keyCode)
            {
            case	quick_start_KeyVal:
                bz_short();
                F_ProfileSportInit(ui_action.Event);
                break;
            case	enter_KeyVal:
                bz_short();
                F_SetProfileChooseMode();
                break;
            case	stop_rest_KeyVal:
                bz_short();
                ui_action.ProfileEventSave = ui_action.Event;
                F_setProfileInit(setProfileEventVal);
                break;
            case	resistance_up_KeyVal:
                if(LongKeyStartFlg == 0)	{
                    bz_short();
                    ui_action.Event++;
                    if(ui_action.Event>setInterval_2_EventVal)
                        ui_action.Event = setRollingHillEventVal;
                }
                break;
            case	resistance_down_KeyVal:
                if(LongKeyStartFlg == 0)	{
                    bz_short();
                    if(ui_action.Event > setRollingHillEventVal)
                        ui_action.Event--;
                    else
                        ui_action.Event = setInterval_2_EventVal;
                }
                break;
            }
        }
        //=====================
        if((e & time_100ms_val) == time_100ms_val)
        {
            F_SetDisplayRam(0);
            if(ui_action.TemporarySeatPositionEvent == TemporarySeatPositionNormalEventVal) {
                switch(ui_action.Event)
                {
                case	setRollingHillEventVal:
                    F_showRollingHillGraph();
                    F_RollingHillLevelCount(15,sport_data.progfileArry,ProgfileDataSizeVal);
                    F_ShowProgfileGraph(sport_data.progfileArry,ProgfileDataSizeVal,CommonModeVal,0,0);
                    break;
                case	setPeakEventVal:
                    F_showPeakGraph();
                    F_PeakLevelCount(15,sport_data.progfileArry,ProgfileDataSizeVal);
                    F_ShowProgfileGraph(sport_data.progfileArry,ProgfileDataSizeVal,CommonModeVal,0,0);
                    break;
                case	setPlateauEventVal:
                    F_showPlateauGraph();
                    F_PlateauLevelCount(15,sport_data.progfileArry,ProgfileDataSizeVal);
                    F_ShowProgfileGraph(sport_data.progfileArry,ProgfileDataSizeVal,CommonModeVal,0,0);
                    break;
                case	setClimbEventVal:
                    F_showClimbGraph();
                    F_ClimbLevelCount(15,sport_data.progfileArry,ProgfileDataSizeVal);
                    F_ShowProgfileGraph(sport_data.progfileArry,ProgfileDataSizeVal,CommonModeVal,0,0);
                    break;
                case	setInterval_1_EventVal:
                    F_showInterval_1_Graph();
                    F_Interval_1_LevelCount(15,sport_data.progfileArry,ProgfileDataSizeVal);
                    F_ShowProgfileGraph(sport_data.progfileArry,ProgfileDataSizeVal,CommonModeVal,0,0);
                    break;
                case	setInterval_2_EventVal:
                    F_showInterval_2_Graph();
                    F_Interval_2_LevelCount(15,sport_data.progfileArry,ProgfileDataSizeVal);
                    F_ShowProgfileGraph(sport_data.progfileArry,ProgfileDataSizeVal,CommonModeVal,0,0);
                    break;
                }
            } else {
                F_showSeatPositionStatus(ui_action.TemporarySeatPositionEvent);
            }
            F_Display();
        }
        //=====================
        if((e & time_1s_val) == time_1s_val)
        {
            F_SwitchingSeatPositionDisplayTimer();
        }
    }
}