Exemplo n.º 1
0
void timer_create_init()
{
    /* 创建定时器1 */
    timer1 = rt_timer_create("timer1",  /* 定时器名字是 timer1 */
        timeout1, /* 超时时回调的处理函数 */
        RT_NULL, /* 超时函数的入口参数 */
        10, /* 定时长度,以OS Tick为单位,即10个OS Tick */
        RT_TIMER_FLAG_PERIODIC); /* 周期性定时器 */
    /* 启动定时器 */
    if (timer1 != RT_NULL)
        rt_timer_start(timer1);
    else
        tc_stat(TC_STAT_END | TC_STAT_FAILED);

    /* 创建定时器2 */
    timer2 = rt_timer_create("timer2",   /* 定时器名字是 timer2 */
        timeout2, /* 超时时回调的处理函数 */
        RT_NULL, /* 超时函数的入口参数 */
        30, /* 定时长度为30个OS Tick */
        RT_TIMER_FLAG_ONE_SHOT); /* 单次定时器 */

    /* 启动定时器 */
    if (timer2 != RT_NULL)
        rt_timer_start(timer2);
    else
        tc_stat(TC_STAT_END | TC_STAT_FAILED);
}
Exemplo n.º 2
0
/* normally the tone frequency should be 31 to 4978, refer to piches.h */
void tone(uint8_t pin, uint16_t frequency, unsigned long duration)
{
    static struct rt_timer timer2, timer3;
    rt_timer_t timer;

    RT_ASSERT(frequency * 2 < UINT16_MAX);
    if(pin < 2 || pin > 3)
        return;
    if (pin == 2)
    {
        timer = &timer2;
    }
    else if (pin == 3)
    {
        timer = &timer3;
    }
    rt_timer_stop(timer);
    rt_timer_init(timer, "pwmkill",
                  pwm_shutdown, (void*) pin,
                  rt_tick_from_millisecond(duration),
                  RT_TIMER_FLAG_ONE_SHOT);
    TIM_config(pin, frequency);
    pwmConfig(pin, UINT8_MAX / 2);
    rt_timer_start(timer);
}
Exemplo n.º 3
0
rt_err_t rt_completion_wait(struct rt_completion *completion, rt_int32_t timeout)
{
    rt_err_t result;
    rt_base_t level;
    rt_thread_t thread;
    RT_ASSERT(completion != RT_NULL);

    result = RT_EOK;
    thread = rt_thread_self();

    level = rt_hw_interrupt_disable();
    if (completion->flag != RT_COMPLETED)
    {
        /* only one thread can suspend on complete */
        RT_ASSERT(rt_list_isempty(&(completion->suspended_list)));

        if (timeout == 0)
        {
            result = -RT_ETIMEOUT;
            goto __exit;
        }
        else
        {
            /* reset thread error number */
            thread->error = RT_EOK;

            /* suspend thread */
            rt_thread_suspend(thread);
            /* add to suspended list */
            rt_list_insert_before(&(completion->suspended_list), &(thread->tlist));

            /* current context checking */
            RT_DEBUG_NOT_IN_INTERRUPT;

            /* start timer */
            if (timeout > 0)
            {
                /* reset the timeout of thread timer and start it */
                rt_timer_control(&(thread->thread_timer), RT_TIMER_CTRL_SET_TIME, &timeout);
                rt_timer_start(&(thread->thread_timer));
            }
            /* enable interrupt */
            rt_hw_interrupt_enable(level);

            /* do schedule */
            rt_schedule();

            /* thread is waked up */
            result = thread->error;

            level = rt_hw_interrupt_disable();
            /* clean completed flag */
            completion->flag = RT_UNCOMPLETED;
        }
    }

__exit:
    rt_hw_interrupt_enable(level);
    return result;
}
Exemplo n.º 4
0
static void s3c2410_adc_stylus_action(void)
{
	rt_uint32_t data0;
	rt_uint32_t data1;

	data0 = ADCDAT0;
	data1 = ADCDAT1;

	ts.xp += data0 & S3C2410_ADCDAT0_XPDATA_MASK;
	ts.yp += data1 & S3C2410_ADCDAT1_YPDATA_MASK;
	ts.count ++;

	if (ts.count < (1<<ts.shift))
	{
		ADCTSC = S3C2410_ADCTSC_PULL_UP_DISABLE | AUTOPST;
		ADCCON |= S3C2410_ADCCON_ENABLE_START;
	}
	else
	{
		if (touch->first_down_report)
		{
			report_touch_input(1);
			ts.xp = 0;
			ts.yp = 0;
			ts.count = 0;
			touch->first_down_report = 0;
		}
		/* start timer */
		rt_timer_start(touch->poll_timer);
		ADCTSC = WAIT4INT(1);
	}

	SUBSRCPND |= BIT_SUB_ADC;
}
Exemplo n.º 5
0
void rtgui_timer_start(rtgui_timer_t* timer)
{
	RT_ASSERT(timer != RT_NULL);

	/* start rt-thread timer */
	rt_timer_start(&(timer->timer));
}
Exemplo n.º 6
0
/**
 * This function will check timer list, if a timeout event happens, the
 * corresponding timeout function will be invoked.
 *
 */
void rt_soft_timer_check()
{
	rt_tick_t current_tick;
	rt_list_t *n;
	struct rt_timer *t;

#ifdef RT_TIMER_DEBUG
	rt_kprintf("software timer check enter\n");
#endif

	current_tick = rt_tick_get();

	for (n = rt_soft_timer_list.next; n != &(rt_soft_timer_list); )
	{
		t = rt_list_entry(n, struct rt_timer, list);
		
		/*
		 * It supposes that the new tick shall less than the half duration of tick max.
		 */
		if ((current_tick - t->timeout_tick) < RT_TICK_MAX/2)
		{
#ifdef RT_USING_HOOK
			if (rt_timer_timeout_hook != RT_NULL) rt_timer_timeout_hook(t);
#endif
			/* move node to the next */
			n = n->next;

			/* remove timer from timer list firstly */
			rt_list_remove(&(t->list));

			/* call timeout function */
			t->timeout_func(t->parameter);

			/* re-get tick */
			current_tick = rt_tick_get();

#ifdef RT_TIMER_DEBUG
			rt_kprintf("current tick: %d\n", current_tick);
#endif

			if ((t->parent.flag & RT_TIMER_FLAG_PERIODIC) &&
					(t->parent.flag & RT_TIMER_FLAG_ACTIVATED))
			{
				/* start it */
				t->parent.flag &= ~RT_TIMER_FLAG_ACTIVATED;
				rt_timer_start(t);
			}
			else
			{
				/* stop timer */
				t->parent.flag &= ~RT_TIMER_FLAG_ACTIVATED;
			}
		}
		else break; /* not check anymore */
	}

#ifdef RT_TIMER_DEBUG
	rt_kprintf("software timer check leave\n");
#endif
}
Exemplo n.º 7
0
static rt_err_t _rt_rms_init(struct rt_rms *rms,
                             rt_uint8_t period,
                             rt_uint8_t wcet)
{
    /* init rms list */
    rt_list_init(&(rms->rlist));

    rms->thread->stat = RT_RMS_INIT;
    rms->period = period;
    rms->wcet = wcet;
    rms->utilization = (float)wcet / period;

    utilization += rms->utilization;
    RT_ASSERT(utilization <= 1);
    /* init the rms timer for activating next job */
    rt_timer_init(&(rms->rms_timer),
                  rms->thread->name,
                  rt_rms_wakeup,
                  (void *)rms->period,
                  rms->period,
                  RT_TIMER_FLAG_PERIODIC);
    /* start the rms timer */
    rt_timer_start(&(rms->rms_timer));

    return RT_RMS_EOK;
}
Exemplo n.º 8
0
/**
 * This function will let current thread sleep for some ticks.
 *
 * @param tick the sleep ticks
 *
 * @return RT_EOK
 *
 */
rt_err_t rt_thread_sleep(rt_tick_t tick)
{
	register rt_base_t temp;
	struct rt_thread *thread;

	/* disable interrupt */
	temp = rt_hw_interrupt_disable();
	/* set to current thread */
	thread = rt_current_thread;
	RT_ASSERT(thread != RT_NULL);

	/* suspend thread */
	rt_thread_suspend(thread);

	/* reset the timeout of thread timer and start it */
	rt_timer_control(&(thread->thread_timer), RT_TIMER_CTRL_SET_TIME, &tick);
	rt_timer_start(&(thread->thread_timer));

	/* enable interrupt */
	rt_hw_interrupt_enable(temp);

	rt_schedule();

	/* clear error number of this thread to RT_EOK */
	if (thread->error == -RT_ETIMEOUT)
		thread->error = RT_EOK;

	return RT_EOK;
}
Exemplo n.º 9
0
static int logStartBlock(int id, unsigned int period)
{
  int i;
  
  for (i=0; i<LOG_MAX_BLOCKS; i++)
    if (logBlocks[i].id == id) break;
  
  if (i >= LOG_MAX_BLOCKS) {
    ERROR("Trying to start block id %d that doesn't exist.", id);
    return ENOENT;
  }
  
  DEBUG("Starting block %d with period %dms\n", id, period);
  
  if (period>0)
  {
    //xTimerChangePeriod(logBlocks[i].timer, M2T(period), 100);
	  logBlocks[i].timer->init_tick = M2T(period);
    //xTimerStart(logBlocks[i].timer, 100);
	rt_timer_start(logBlocks[i].timer);
  } else {
    // single-shoot run
    workerSchedule(logRunBlock, &logBlocks[i]);
  }
  
  return 0;
}
Exemplo n.º 10
0
int mgpot_shortrng(Mgpot *mg, int threadid, int threadcount) {
#ifdef MGPOT_TIMER
  rt_timerhandle timer = rt_timer_create();
  float totaltime=0, lasttime, elapsedtime;
#endif

  TIMING( rt_timer_start(timer); );
Exemplo n.º 11
0
/**
 * This function will check timer list, if a timeout event happens, the
 * corresponding timeout function will be invoked.
 *
 * @note this function shall be invoked in operating system timer interrupt.
 */
void rt_timer_check(void)
{
    struct rt_timer *t;
    rt_tick_t current_tick;
    register rt_base_t level;

    RT_DEBUG_LOG(RT_DEBUG_TIMER, ("timer check enter\n"));

    current_tick = rt_tick_get();

    /* disable interrupt */
    level = rt_hw_interrupt_disable();

    while (!rt_list_isempty(&rt_timer_list[RT_TIMER_SKIP_LIST_LEVEL-1]))
    {
        t = rt_list_entry(rt_timer_list[RT_TIMER_SKIP_LIST_LEVEL - 1].next,
                          struct rt_timer, row[RT_TIMER_SKIP_LIST_LEVEL - 1]);

        /*
         * It supposes that the new tick shall less than the half duration of
         * tick max.
         */
        if ((current_tick - t->timeout_tick) < RT_TICK_MAX/2)
        {
            RT_OBJECT_HOOK_CALL(rt_timer_timeout_hook, (t));

            /* remove timer from timer list firstly */
            _rt_timer_remove(t);

            /* call timeout function */
            t->timeout_func(t->parameter);

            /* re-get tick */
            current_tick = rt_tick_get();

            RT_DEBUG_LOG(RT_DEBUG_TIMER, ("current tick: %d\n", current_tick));

            if ((t->parent.flag & RT_TIMER_FLAG_PERIODIC) &&
                (t->parent.flag & RT_TIMER_FLAG_ACTIVATED))
            {
                /* start it */
                t->parent.flag &= ~RT_TIMER_FLAG_ACTIVATED;
                rt_timer_start(t);
            }
            else
            {
                /* stop timer */
                t->parent.flag &= ~RT_TIMER_FLAG_ACTIVATED;
            }
        }
        else
            break;
    }

    /* enable interrupt */
    rt_hw_interrupt_enable(level);

    RT_DEBUG_LOG(RT_DEBUG_TIMER, ("timer check leave\n"));
}
Exemplo n.º 12
0
int write_grid(const char* ofile, float gridspacing, float cx, float cy, float cz, long int numplane, long int numcol, long int numpt, const float* eners) {
  /* Write the current energy grid to a .dx file for later reading */
  FILE* dx_out;
  int i, j, k;
  int arrpos;
  int numentries;
  float starttime, endtime;
  rt_timerhandle timer;

  arrpos=0;
  dx_out = fopen(ofile, "w");

  if (dx_out ==  NULL) {
    fprintf(stderr, "Error: Couldn't open output dxfile %s. Exiting...", ofile);
    return 1;
  }

  timer = rt_timer_create();
  rt_timer_start(timer);

  /* start the timer */
  starttime = rt_timer_timenow(timer);

  /* Write a dx header */
  fprintf(dx_out, "# Data from cionize 1.0\n#\n# Potential (kT/e at 298.15K)\n#\n");
  fprintf(dx_out, "object 1 class gridpositions counts %li %li %li\n", numpt, numcol, numplane);
  fprintf(dx_out, "origin %12.6e %12.6e %12.6e\n", cx, cy, cz);
  fprintf(dx_out, "delta %12.6e %12.6e %12.6e\n", gridspacing, 0.0, 0.0);
  fprintf(dx_out, "delta %12.6e %12.6e %12.6e\n", 0.0, gridspacing, 0.0);
  fprintf(dx_out, "delta %12.6e %12.6e %12.6e\n", 0.0, 0.0, gridspacing);
  fprintf(dx_out, "object 2 class gridconnections counts %li %li %li\n", numpt, numcol, numplane);
  fprintf(dx_out, "object 3 class array type double rank 0 items %li data follows\n", numplane * numcol * numpt);

  /* Write the main data array */
  numentries = 0;
  for (i=0; i<numpt; i++) {
    for (j=0; j<numcol; j++) {
      for (k=0; k<numplane; k++) {
        arrpos = (k*numcol * numpt + j*numpt + i);
        fprintf(dx_out, "%-13.6e ", POT_CONV * eners[arrpos]);
        if (numentries % 3 == 2) fprintf(dx_out, "\n");
        numentries = numentries + 1;
      }
    }
  }

  /* Write the opendx footer */
  if (arrpos % 3 != 2) fprintf(dx_out, "\n");
  fprintf(dx_out, "attribute \"dep\" string \"positions\"\nobject \"regular positions regular connections\" class field\ncomponent \"positions\" value 1\ncomponent \"connections\" value 2\ncomponent \"data\" value 3");

  fclose(dx_out);

  /* check our time */
  endtime = rt_timer_timenow(timer);
  printf("Time for grid output: %.1f\n", endtime - starttime);
  rt_timer_destroy(timer);

  return 0;
}
Exemplo n.º 13
0
void rtgui_timer_start(rtgui_timer_t *timer)
{
    RT_ASSERT(timer != RT_NULL);

    /* start rt-thread timer */
    timer->state = RTGUI_TIMER_ST_RUNNING;
    rt_timer_start(&(timer->timer));
}
Exemplo n.º 14
0
static rt_err_t timer_start(void)
{
    timer_test = rt_timer_create("timer1",timeout_callbak,RT_NULL,timeout_value,RT_TIMER_FLAG_PERIODIC); 					
    if (timer_test != RT_NULL){
        rt_timer_start(timer_test);
	}
    return 0;
}
void timer_static_init()
{
    /* 初始化定时器 */
    rt_timer_init(&timer1, "timer1",  /* 定时器名字是 timer1 */
        timeout1, /* 超时时回调的处理函数 */
        RT_NULL, /* 超时函数的入口参数 */
        10, /* 定时长度,以OS Tick为单位,即10个OS Tick */
        RT_TIMER_FLAG_PERIODIC); /* 周期性定时器 */
    rt_timer_init(&timer2, "timer2",   /* 定时器名字是 timer2 */
        timeout2, /* 超时时回调的处理函数 */
        RT_NULL, /* 超时函数的入口参数 */
        30, /* 定时长度为30个OS Tick */
        RT_TIMER_FLAG_ONE_SHOT); /* 单次定时器 */

    /* 启动定时器 */
    rt_timer_start(&timer1);
    rt_timer_start(&timer2);
}
Exemplo n.º 16
0
/*
 * Save the rendered image to disk.
 */
static void renderio(scenedef * scene) {
    flt iotime;
    char msgtxt[256];
    rt_timerhandle ioth; /* I/O timer handle */

    ioth=rt_timer_create();
    rt_timer_start(ioth);

    if (scene->imgbufformat == RT_IMAGE_BUFFER_RGB96F) {
        if (scene->imgprocess & RT_IMAGE_NORMALIZE) {
            normalize_rgb96f(scene->hres, scene->vres, (float *) scene->img);
            rt_ui_message(MSG_0, "Post-processing: normalizing pixel values.");
        }

        if (scene->imgprocess & RT_IMAGE_GAMMA) {
            gamma_rgb96f(scene->hres, scene->vres, (float *) scene->img,
                         scene->imggamma);
            rt_ui_message(MSG_0, "Post-processing: gamma correcting pixel values.");
        }
    } else if (scene->imgbufformat == RT_IMAGE_BUFFER_RGB24) {
        if (scene->imgprocess & (RT_IMAGE_NORMALIZE | RT_IMAGE_GAMMA))
            rt_ui_message(MSG_0, "Can't post-process 24-bit integer image data");
    }

    /* support cropping of output images for SPECMPI benchmarks */
    if (scene->imgcrop.cropmode == RT_CROP_DISABLED) {
        writeimage(scene->outfilename, scene->hres, scene->vres,
                   scene->img, scene->imgbufformat, scene->imgfileformat);
    } else {
        /* crop image before writing if necessary */
        if (scene->imgbufformat == RT_IMAGE_BUFFER_RGB96F) {
            float *imgcrop;
            imgcrop = image_crop_rgb96f(scene->hres, scene->vres, scene->img,
                                        scene->imgcrop.xres, scene->imgcrop.yres,
                                        scene->imgcrop.xstart, scene->imgcrop.ystart);
            writeimage(scene->outfilename, scene->imgcrop.xres, scene->imgcrop.yres,
                       imgcrop, scene->imgbufformat, scene->imgfileformat);
            free(imgcrop);
        } else if (scene->imgbufformat == RT_IMAGE_BUFFER_RGB24) {
            unsigned char *imgcrop;
            imgcrop = image_crop_rgb24(scene->hres, scene->vres, scene->img,
                                       scene->imgcrop.xres, scene->imgcrop.yres,
                                       scene->imgcrop.xstart, scene->imgcrop.ystart);
            writeimage(scene->outfilename, scene->imgcrop.xres, scene->imgcrop.yres,
                       imgcrop, scene->imgbufformat, scene->imgfileformat);
            free(imgcrop);
        }
    }

    rt_timer_stop(ioth);
    iotime = rt_timer_time(ioth);
    rt_timer_destroy(ioth);

    sprintf(msgtxt, "    Image I/O Time: %10.4f seconds", iotime);
    rt_ui_message(MSG_0, msgtxt);
}
Exemplo n.º 17
0
static void init_per_get_time(void)
{
	rt_timer_init(&get_time_timer, "rtc", /* 定时器名字是 timer1 */
				  per_get_time, 	   	/* 超时时回调的处理函数 */
				  RT_NULL, 			 	/* 超时函数的入口参数 */
				  100, 				 	/* 定时长度,以OS Tick为单位,即100个OS Tick */
				  RT_TIMER_FLAG_SOFT_TIMER | RT_TIMER_FLAG_PERIODIC); /* 周期性定时器 */
	
	rt_timer_start(&get_time_timer);
}
/// Start or restart timer
osStatus osTimerStart(osTimerId timer_id, uint32_t millisec)
{
	rt_err_t result;
	
	result = rt_timer_start(timer_id);
	if (result == RT_EOK)
		return osOK;
	else
		return osErrorOS;
}
Exemplo n.º 19
0
static rt_err_t rt_key_open(rt_device_t dev, rt_uint16_t oflag)
{
	rt_timer_t timer;
	
	timer = rt_timer_create("timer", timer_callback, &s_dev_key, rt_tick_from_millisecond(KEY_TIMER_INTERVAL), RT_TIMER_FLAG_PERIODIC/* | RT_TIMER_FLAG_SOFT_TIMER */);
	RT_ASSERT(timer != RT_NULL);
	rt_timer_start(timer);
	
	return RT_EOK;
}
Exemplo n.º 20
0
/**
 * This function will check timer list, if a timeout event happens, the
 * corresponding timeout function will be invoked.
 */
void rt_soft_timer_check(void)
{
    rt_tick_t current_tick;
    rt_list_t *n;
    struct rt_timer *t;

    RT_DEBUG_LOG(RT_DEBUG_TIMER, ("software timer check enter\n"));

    current_tick = rt_tick_get();

    for (n = rt_soft_timer_list[RT_TIMER_SKIP_LIST_LEVEL-1].next;
         n != &(rt_soft_timer_list[RT_TIMER_SKIP_LIST_LEVEL-1]);)
    {
        t = rt_list_entry(n, struct rt_timer, row[RT_TIMER_SKIP_LIST_LEVEL-1]);

        /*
         * It supposes that the new tick shall less than the half duration of
         * tick max.
         */
        if ((current_tick - t->timeout_tick) < RT_TICK_MAX / 2)
        {
            RT_OBJECT_HOOK_CALL(rt_timer_timeout_hook, (t));

            /* move node to the next */
            n = n->next;

            /* remove timer from timer list firstly */
            _rt_timer_remove(t);

            /* call timeout function */
            t->timeout_func(t->parameter);

            /* re-get tick */
            current_tick = rt_tick_get();

            RT_DEBUG_LOG(RT_DEBUG_TIMER, ("current tick: %d\n", current_tick));

            if ((t->parent.flag & RT_TIMER_FLAG_PERIODIC) &&
                (t->parent.flag & RT_TIMER_FLAG_ACTIVATED))
            {
                /* start it */
                t->parent.flag &= ~RT_TIMER_FLAG_ACTIVATED;
                rt_timer_start(t);
            }
            else
            {
                /* stop timer */
                t->parent.flag &= ~RT_TIMER_FLAG_ACTIVATED;
            }
        }
        else break; /* not check anymore */
    }

    RT_DEBUG_LOG(RT_DEBUG_TIMER, ("software timer check leave\n"));
}
Exemplo n.º 21
0
void vMBMasterPortTimersRespondTimeoutEnable()
{
    rt_tick_t timer_tick = MB_MASTER_TIMEOUT_MS_RESPOND * RT_TICK_PER_SECOND / 1000;

    /* Set current timer mode, don't change it.*/
    vMBMasterSetCurTimerMode(MB_TMODE_RESPOND_TIMEOUT);

    rt_timer_control(&timer, RT_TIMER_CTRL_SET_TIME, &timer_tick);

    rt_timer_start(&timer);
}
Exemplo n.º 22
0
void vMBMasterPortTimersConvertDelayEnable()
{
    rt_tick_t timer_tick = MB_MASTER_DELAY_MS_CONVERT * RT_TICK_PER_SECOND / 1000;

    /* Set current timer mode, don't change it.*/
    vMBMasterSetCurTimerMode(MB_TMODE_CONVERT_DELAY);

    rt_timer_control(&timer, RT_TIMER_CTRL_SET_TIME, &timer_tick);

    rt_timer_start(&timer);
}
Exemplo n.º 23
0
void vMBMasterPortTimersT35Enable()
{
    rt_tick_t timer_tick = (50 * usT35TimeOut50us)
            / (1000 * 1000 / RT_TICK_PER_SECOND);

    /* Set current timer mode, don't change it.*/
    vMBMasterSetCurTimerMode(MB_TMODE_T35);

    rt_timer_control(&timer, RT_TIMER_CTRL_SET_TIME, &timer_tick);

    rt_timer_start(&timer);
}
Exemplo n.º 24
0
/// Start or restart timer
osStatus osTimerStart(osTimerId timer_id, uint32_t millisec)
{
    rt_err_t result;
    rt_tick_t ticks;

    ticks = rt_tick_from_millisecond(millisec);
    rt_timer_control(timer_id, RT_TIMER_CTRL_SET_TIME, &ticks);
    result = rt_timer_start(timer_id);
    if (result == RT_EOK)
        return osOK;
    else
        return osErrorOS;
}
Exemplo n.º 25
0
int rt_application_init()
{
    timer1 = rt_timer_create("timer1",  
        timeout1, 
        RT_NULL, 
        100, 
        RT_TIMER_FLAG_PERIODIC); 
    
    if (timer1 != RT_NULL)
        rt_timer_start(timer1);
  
    return 0;
}
Exemplo n.º 26
0
Arquivo: key.c Projeto: mangqu/LED_RTT
void EXTI9_5_IRQHandler(void)
{
	if ((EXTI_GetITStatus(key1_exti_line) == SET) ||
		(EXTI_GetITStatus(key2_exti_line) == SET))
	{
		/* disable interrupt */
		EXTI_Enable(1, 0);
		EXTI_Enable(2, 0);

		/* start timer */
		rt_timer_start(key->poll_timer);

		EXTI_ClearITPendingBit(key1_exti_line | key2_exti_line);
	}
}
Exemplo n.º 27
0
//thread_mpu 线程初始化
void thread_mpu_timer_init(void)
{
	/* 初始化一个信号量 */
	rt_sem_init(&sem_mpu,"mpu",0 ,RT_IPC_FLAG_FIFO);
	
	/* 创建定时器mpu */
	rt_timer_init(&tim_mpu,
					"mpu", 				/* 定时器名字 */
					timer_mpu, 				/* 超时时回调的处理函数*/
					RT_NULL,				/* 超时函数的入口参数*/
					MPU_UPDATE_PERIOD, 					/* 定时长度,以OS Tick为单位*/
					RT_TIMER_FLAG_PERIODIC);/* 周期性定时器*/	
	/* 启动定时器*/
	rt_timer_start(&tim_mpu);
}
Exemplo n.º 28
0
//定时器初始化
void thread_hmc_timer_init(void)
{
	/* 初始化一个信号量 */
	rt_sem_init(&sem_hmc,"hmc",0 ,RT_IPC_FLAG_FIFO);
		
	/* 创建定时器hmc */
	rt_timer_init(&tim_hmc,					/* 控制块 */
					"hmc", 					/* 定时器名字 */
					timer_hmc, 				/* 超时时回调的处理函数*/
					RT_NULL,				/* 超时函数的入口参数*/
					20, 					/* 定时长度,以OS Tick为单位*/
					RT_TIMER_FLAG_PERIODIC);/* 周期性定时器*/	
	/* 启动定时器*/
	rt_timer_start(&tim_hmc);

}
Exemplo n.º 29
0
void timer_conrol(void)
{
    timeout_value+=10;
    rt_timer_control(timer_test, RT_TIMER_CTRL_SET_TIME, (void *)&timeout_value);
//    rt_kprintf("timer timeout time set to %d !\n", timeout_value);
    if (timeout_value==500)    {
        rt_timer_stop(timer_test); /* 停止定时器 */
        rt_kprintf("timer stoped !\n");
    }
    if (timeout_value>=510) {
        /* 再次启动定时器 */
        rt_timer_start(timer_test);
        timeout_value=10;
        rt_timer_control(timer_test, RT_TIMER_CTRL_SET_TIME, (void *)&timeout_value);
    }

}
Exemplo n.º 30
0
/* init gsm */
void _gsm_startup(void)
{
    rt_err_t result;


    //    二. RT  相关初始化
    //-------------   sem  init  ---------------------------------
    //  创建DF 读写信号量
    rt_sem_init( &sem_DF, "sem_DF", 0, 0 );
    rt_sem_release( &sem_DF);


    rt_mq_init( &mq_GSM, "mq_GSM", &GSM_rawinfo[0], 1400 - sizeof( void * ), GSM_RAWINFO_SIZE, RT_IPC_FLAG_FIFO );

    //---------  timer_gsm ----------
    // 1. create  timer     100ms=Dur
    timer_gsm = rt_timer_create("tim_gsm", timeout_gsm, RT_NULL, 100, RT_TIMER_FLAG_PERIODIC); //| RT_TIMER_FLAG_SOFT_TIMER);
    //  2. start timer
    if(timer_gsm != RT_NULL)
        rt_timer_start(timer_gsm);


    result = rt_thread_init(&gsm_thread,
                            "GsmThrd",
                            gsm_thread_entry, RT_NULL,
                            &gsm_thread_stack[0], sizeof(gsm_thread_stack),
                            Prio_GSM, 10);

    if (result == RT_EOK)
    {
        rt_thread_startup(&gsm_thread);
    }

    Device_GSM.type	= RT_Device_Class_Char;
    Device_GSM.init	= Device_GSM_init;
    Device_GSM.open	=  Device_GSM_open;
    Device_GSM.close	=  Device_GSM_close;
    Device_GSM.read	=  Device_GSM_read;
    Device_GSM.write	=  Device_GSM_write;
    Device_GSM.control = Device_GSM_control;

    rt_device_register( &Device_GSM, "GsmDev", RT_DEVICE_FLAG_RDWR | RT_DEVICE_FLAG_STANDALONE );
    rt_device_init( &Device_GSM );

}