timer.c 12.2 KB
Newer Older
1 2 3
/*
 * File      : timer.c
 * This file is part of RT-Thread RTOS
D
dzzxzz 已提交
4
 * COPYRIGHT (C) 2006 - 2012, RT-Thread Development Team
5 6 7
 *
 * The license and distribution terms for this file may be
 * found in the file LICENSE in this distribution or at
8
 * http://www.rt-thread.org/license/LICENSE
9 10 11 12 13 14 15 16
 *
 * Change Logs:
 * Date           Author       Notes
 * 2006-03-12     Bernard      first version
 * 2006-04-29     Bernard      implement thread timer
 * 2006-06-04     Bernard      implement rt_timer_control
 * 2006-08-10     Bernard      fix the periodic timer bug
 * 2006-09-03     Bernard      implement rt_timer_detach
17
 * 2009-11-11     LiJin        add soft timer
18
 * 2010-05-12     Bernard      fix the timer check bug.
19
 * 2010-11-02     Charlie      re-implement tick overflow issue
20 21 22 23 24
 */

#include <rtthread.h>
#include <rthw.h>

25
/* hard timer list */
26
static rt_list_t rt_timer_list = RT_LIST_OBJECT_INIT(rt_timer_list);
27

28
#ifdef RT_USING_TIMER_SOFT
29
/* soft timer list */
30
static rt_list_t rt_soft_timer_list;
31 32 33
static struct rt_thread timer_thread;
ALIGN(RT_ALIGN_SIZE)
static rt_uint8_t timer_thread_stack[RT_TIMER_THREAD_STACK_SIZE];
34
#endif
35

36
#ifdef RT_USING_HOOK
D
dzzxzz 已提交
37 38 39
extern void (*rt_object_take_hook)(struct rt_object *object);
extern void (*rt_object_put_hook)(struct rt_object *object);
static void (*rt_timer_timeout_hook)(struct rt_timer *timer);
40 41 42 43

/**
 * @addtogroup Hook
 */
D
dzzxzz 已提交
44

45 46 47 48 49
/*@{*/

/**
 * This function will set a hook function, which will be invoked when timer
 * is timeout.
50
 *
51 52
 * @param hook the hook function
 */
D
dzzxzz 已提交
53
void rt_timer_timeout_sethook(void (*hook)(struct rt_timer *timer))
54 55 56 57 58 59 60
{
	rt_timer_timeout_hook = hook;
}

/*@}*/
#endif

61
static void _rt_timer_init(rt_timer_t timer,
D
dzzxzz 已提交
62
						   void (*timeout)(void *parameter), void *parameter,
63
						   rt_tick_t time, rt_uint8_t flag)
64 65
{
	/* set flag */
D
dzzxzz 已提交
66
	timer->parent.flag  = flag;
67 68 69 70 71

	/* set deactivated */
	timer->parent.flag &= ~RT_TIMER_FLAG_ACTIVATED;

	timer->timeout_func = timeout;
D
dzzxzz 已提交
72
	timer->parameter    = parameter;
73

D
dzzxzz 已提交
74 75
	timer->timeout_tick = 0;
	timer->init_tick    = time;
76

77
	/* initialize timer list */
78 79 80
	rt_list_init(&(timer->list));
}

81 82 83 84 85 86 87 88 89
static rt_tick_t rt_timer_list_next_timeout(rt_list_t* timer_list)
{
	struct rt_timer* timer;
	if (rt_list_isempty(timer_list)) return RT_TICK_MAX;
	
	timer = rt_list_entry(timer_list->next, struct rt_timer, list);
	return timer->timeout_tick;
}

90 91 92
/**
 * @addtogroup Clock
 */
D
dzzxzz 已提交
93

94 95 96
/*@{*/

/**
97 98
 * This function will initialize a timer, normally this function is used to
 * initialize a static timer object.
99 100 101 102 103 104 105 106
 *
 * @param timer the static timer object
 * @param name the name of timer
 * @param timeout the timeout function
 * @param parameter the parameter of timeout function
 * @param time the tick of timer
 * @param flag the flag of timer
 */
107
void rt_timer_init(rt_timer_t timer,
D
dzzxzz 已提交
108 109
				   const char *name,
				   void (*timeout)(void *parameter), void *parameter,
110
				   rt_tick_t time, rt_uint8_t flag)
111 112 113 114
{
	/* timer check */
	RT_ASSERT(timer != RT_NULL);

115
	/* timer object initialization */
116 117 118 119 120
	rt_object_init((rt_object_t)timer, RT_Object_Class_Timer, name);

	_rt_timer_init(timer, timeout, parameter, time, flag);
}

121
/**
122 123 124
 * This function will detach a timer from timer management.
 *
 * @param timer the static timer object
125
 *
126 127 128 129 130
 * @return the operation status, RT_EOK on OK; RT_ERROR on error
 */
rt_err_t rt_timer_detach(rt_timer_t timer)
{
	register rt_base_t level;
131

132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160
	/* timer check */
	RT_ASSERT(timer != RT_NULL);

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

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

	/* enable interrupt */
	rt_hw_interrupt_enable(level);

	rt_object_detach((rt_object_t)timer);

	return -RT_EOK;
}

#ifdef RT_USING_HEAP
/**
 * This function will create a timer
 *
 * @param name the name of timer
 * @param timeout the timeout function
 * @param parameter the parameter of timeout function
 * @param time the tick of timer
 * @param flag the flag of timer
 *
 * @return the created timer object
 */
161 162
rt_timer_t rt_timer_create(const char *name, void (*timeout)(void *parameter),
		void *parameter, rt_tick_t time, rt_uint8_t flag)
163
{
D
dzzxzz 已提交
164
	struct rt_timer *timer;
165 166

	/* allocate a object */
D
dzzxzz 已提交
167
	timer = (struct rt_timer *)rt_object_allocate(RT_Object_Class_Timer, name);
168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187
	if (timer == RT_NULL)
	{
		return RT_NULL;
	}

	_rt_timer_init(timer, timeout, parameter, time, flag);

	return timer;
}

/**
 * This function will delete a timer and release timer memory
 *
 * @param timer the timer to be deleted
 *
 * @return the operation status, RT_EOK on OK; RT_ERROR on error
 */
rt_err_t rt_timer_delete(rt_timer_t timer)
{
	register rt_base_t level;
188

189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211
	/* timer check */
	RT_ASSERT(timer != RT_NULL);

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

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

	/* enable interrupt */
	rt_hw_interrupt_enable(level);

	rt_object_delete((rt_object_t)timer);

	return -RT_EOK;
}
#endif

/**
 * This function will start the timer
 *
 * @param timer the timer to be started
 *
B
bernard.xiong@gmail.com 已提交
212
 * @return the operation status, RT_EOK on OK, -RT_ERROR on error
213 214 215
 */
rt_err_t rt_timer_start(rt_timer_t timer)
{
D
dzzxzz 已提交
216
	struct rt_timer *t;
217
	register rt_base_t level;
218
	rt_list_t *n, *timer_list;
219 220 221

	/* timer check */
	RT_ASSERT(timer != RT_NULL);
D
dzzxzz 已提交
222 223
	if (timer->parent.flag & RT_TIMER_FLAG_ACTIVATED)
		return -RT_ERROR;
224

225
	RT_OBJECT_HOOK_CALL(rt_object_take_hook, (&(timer->parent)));
226

B
bernard.xiong@gmail.com 已提交
227 228
	/* get timeout tick, the max timeout tick shall not great than RT_TICK_MAX/2 */
	RT_ASSERT(timer->init_tick < RT_TICK_MAX/2);
229 230
	timer->timeout_tick = rt_tick_get() + timer->init_tick;

231 232 233
	/* disable interrupt */
	level = rt_hw_interrupt_disable();

234
#ifdef RT_USING_TIMER_SOFT
235
	if (timer->parent.flag & RT_TIMER_FLAG_SOFT_TIMER)
236
	{
237 238
		/* insert timer to soft timer list */
		timer_list = &rt_soft_timer_list;
239 240
	}
	else
241
#endif
242
	{
243
		/* insert timer to system timer list */
244 245
		timer_list = &rt_timer_list;
	}
246

247 248 249 250 251
	for (n = timer_list->next; n != timer_list; n = n->next)
	{
		t = rt_list_entry(n, struct rt_timer, list);
		
		/*
252 253
		 * It supposes that the new tick shall less than the half duration of
		 * tick max.
254 255
		 */
		if ((t->timeout_tick - timer->timeout_tick) < RT_TICK_MAX/2)
256 257
		{
			rt_list_insert_before(n, &(timer->list));
258
			break;
259
		}
260
	}
261 262 263 264 265
	/* no found suitable position in timer list */
	if (n == timer_list)
	{
		rt_list_insert_before(n, &(timer->list));
	}
266

267 268 269 270 271
	timer->parent.flag |= RT_TIMER_FLAG_ACTIVATED;

	/* enable interrupt */
	rt_hw_interrupt_enable(level);

272 273 274 275 276 277 278 279 280 281 282 283 284
#ifdef RT_USING_TIMER_SOFT
	if (timer->parent.flag & RT_TIMER_FLAG_SOFT_TIMER)
	{
		/* check whether timer thread is ready */
		if (timer_thread.stat != RT_THREAD_READY)
		{
			/* resume timer thread to check soft timer */
			rt_thread_resume(&timer_thread);
			rt_schedule();
		}
	}
#endif

285 286 287 288 289 290 291 292
	return -RT_EOK;
}

/**
 * This function will stop the timer
 *
 * @param timer the timer to be stopped
 *
B
bernard.xiong@gmail.com 已提交
293
 * @return the operation status, RT_EOK on OK, -RT_ERROR on error
294 295 296 297 298 299 300
 */
rt_err_t rt_timer_stop(rt_timer_t timer)
{
	register rt_base_t level;

	/* timer check */
	RT_ASSERT(timer != RT_NULL);
D
dzzxzz 已提交
301 302
	if (!(timer->parent.flag & RT_TIMER_FLAG_ACTIVATED))
		return -RT_ERROR;
303

304
	RT_OBJECT_HOOK_CALL(rt_object_put_hook, (&(timer->parent)));
305 306 307 308 309 310 311 312 313 314

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

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

	/* enable interrupt */
	rt_hw_interrupt_enable(level);

315 316 317
	/* change stat */
	timer->parent.flag &= ~RT_TIMER_FLAG_ACTIVATED;

318 319 320 321 322 323 324 325 326 327
	return RT_EOK;
}

/**
 * This function will get or set some options of the timer
 *
 * @param timer the timer to be get or set
 * @param cmd the control command
 * @param arg the argument
 *
B
bernard.xiong@gmail.com 已提交
328
 * @return RT_EOK
329
 */
D
dzzxzz 已提交
330
rt_err_t rt_timer_control(rt_timer_t timer, rt_uint8_t cmd, void *arg)
331 332 333 334 335 336 337
{
	/* timer check */
	RT_ASSERT(timer != RT_NULL);

	switch (cmd)
	{
	case RT_TIMER_CTRL_GET_TIME:
D
dzzxzz 已提交
338
		*(rt_tick_t *)arg = timer->init_tick;
339 340 341
		break;

	case RT_TIMER_CTRL_SET_TIME:
D
dzzxzz 已提交
342
		timer->init_tick = *(rt_tick_t *)arg;
343 344 345 346 347 348 349 350 351 352 353 354 355 356 357
		break;

	case RT_TIMER_CTRL_SET_ONESHOT:
		timer->parent.flag &= ~(1 << RT_TIMER_FLAG_PERIODIC);
		break;

	case RT_TIMER_CTRL_SET_PERIODIC:
		timer->parent.flag |= (1 << RT_TIMER_FLAG_PERIODIC);
		break;
	}

	return RT_EOK;
}

/**
358
 * This function will check timer list, if a timeout event happens, the
359 360
 * corresponding timeout function will be invoked.
 *
B
bernard.xiong@gmail.com 已提交
361
 * @note this function shall be invoked in operating system timer interrupt.
362
 */
363
void rt_timer_check(void)
364 365
{
	struct rt_timer *t;
366
	rt_tick_t current_tick;
367 368
	register rt_base_t level;

D
dzzxzz 已提交
369
	RT_DEBUG_LOG(RT_DEBUG_TIMER, ("timer check enter\n"));
370 371 372 373 374 375

	current_tick = rt_tick_get();

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

376
	while (!rt_list_isempty(&rt_timer_list))
377
	{
378
		t = rt_list_entry(rt_timer_list.next, struct rt_timer, list);
D
dzzxzz 已提交
379

380
		/*
381 382
		 * It supposes that the new tick shall less than the half duration of
		 * tick max.
383 384
		 */
		if ((current_tick - t->timeout_tick) < RT_TICK_MAX/2)
385
		{
386
			RT_OBJECT_HOOK_CALL(rt_timer_timeout_hook, (t));
387 388 389 390 391 392 393

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

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

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

D
dzzxzz 已提交
397
			RT_DEBUG_LOG(RT_DEBUG_TIMER, ("current tick: %d\n", current_tick));
398

399 400
			if ((t->parent.flag & RT_TIMER_FLAG_PERIODIC) &&
					(t->parent.flag & RT_TIMER_FLAG_ACTIVATED))
401 402
			{
				/* start it */
403
				t->parent.flag &= ~RT_TIMER_FLAG_ACTIVATED;
404 405
				rt_timer_start(t);
			}
406 407 408 409 410
			else
			{
				/* stop timer */
				t->parent.flag &= ~RT_TIMER_FLAG_ACTIVATED;
			}
411
		}
D
dzzxzz 已提交
412 413
		else
			break;
414 415 416 417 418
	}

	/* enable interrupt */
	rt_hw_interrupt_enable(level);

D
dzzxzz 已提交
419
	RT_DEBUG_LOG(RT_DEBUG_TIMER, ("timer check leave\n"));
420 421
}

422 423 424 425 426 427
/**
 * This function will return the next timeout tick in the system.
 *
 * @return the next timeout tick in the system
 */
rt_tick_t rt_timer_next_timeout_tick(void)
428
{
429
	return rt_timer_list_next_timeout(&rt_timer_list);
430 431
}

432
#ifdef RT_USING_TIMER_SOFT
433 434 435 436
/**
 * This function will check timer list, if a timeout event happens, the
 * corresponding timeout function will be invoked.
 */
D
dzzxzz 已提交
437
void rt_soft_timer_check(void)
438 439 440 441
{
	rt_tick_t current_tick;
	rt_list_t *n;
	struct rt_timer *t;
442

D
dzzxzz 已提交
443
	RT_DEBUG_LOG(RT_DEBUG_TIMER, ("software timer check enter\n"));
444

445 446
	current_tick = rt_tick_get();

D
dzzxzz 已提交
447
	for (n = rt_soft_timer_list.next; n != &(rt_soft_timer_list);)
448 449
	{
		t = rt_list_entry(n, struct rt_timer, list);
D
dzzxzz 已提交
450

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

459 460 461 462 463 464 465 466 467
			/* 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);

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

D
dzzxzz 已提交
471
			RT_DEBUG_LOG(RT_DEBUG_TIMER, ("current tick: %d\n", current_tick));
472

473 474
			if ((t->parent.flag & RT_TIMER_FLAG_PERIODIC) &&
					(t->parent.flag & RT_TIMER_FLAG_ACTIVATED))
475 476 477 478 479 480 481 482 483 484 485
			{
				/* start it */
				t->parent.flag &= ~RT_TIMER_FLAG_ACTIVATED;
				rt_timer_start(t);
			}
			else
			{
				/* stop timer */
				t->parent.flag &= ~RT_TIMER_FLAG_ACTIVATED;
			}
		}
486
		else break; /* not check anymore */
487 488
	}

D
dzzxzz 已提交
489
	RT_DEBUG_LOG(RT_DEBUG_TIMER, ("software timer check leave\n"));
490 491
}

492
/* system timer thread entry */
D
dzzxzz 已提交
493
static void rt_thread_timer_entry(void *parameter)
494
{
495 496
	rt_tick_t next_timeout;
	
497 498
	while (1)
	{
499 500 501 502 503 504 505 506 507 508
		next_timeout = rt_timer_list_next_timeout(&rt_soft_timer_list);
		if (next_timeout == RT_TICK_MAX)
		{
			rt_thread_suspend(rt_thread_self());
			rt_schedule();
		}
		else
		{
			rt_thread_delay(next_timeout);
		}
509

D
dzzxzz 已提交
510
		/* lock scheduler */
511
		rt_enter_critical();
D
dzzxzz 已提交
512
		/* check software timer */
513
		rt_soft_timer_check();
D
dzzxzz 已提交
514
		/* unlock scheduler */
515
		rt_exit_critical();
516
	}
517
}
518
#endif
519

520 521 522
/**
 * @ingroup SystemInit
 *
523
 * This function will initialize system timer
524 525 526
 *
 * @deprecated since 1.1.0, this function does not need to be invoked
 * in the system initialization.
527
 */
D
dzzxzz 已提交
528
void rt_system_timer_init(void)
529
{
B
bernard.xiong 已提交
530
}
531

B
bernard.xiong 已提交
532 533 534
/**
 * @ingroup SystemInit
 *
535
 * This function will initialize system timer thread
B
bernard.xiong 已提交
536
 */
D
dzzxzz 已提交
537
void rt_system_timer_thread_init(void)
B
bernard.xiong 已提交
538 539
{
#ifdef RT_USING_TIMER_SOFT
540 541
	rt_list_init(&rt_soft_timer_list);

D
dzzxzz 已提交
542
	/* start software timer thread */
543 544 545 546 547
	rt_thread_init(&timer_thread,
				   "timer",
				   rt_thread_timer_entry, RT_NULL,
				   &timer_thread_stack[0], sizeof(timer_thread_stack),
				   RT_TIMER_THREAD_PRIO, 10);
548 549

	/* startup */
550 551
	rt_thread_startup(&timer_thread);
#endif
552
}
553

554
/*@}*/