timer.c

基于cc1000和avr128处理器的指定路由多跳网络的试验程序

/*
****************************************************************************
*              宁波中科集成电路设计中心  版权所有 Copyright 2005
*						http:\\www.nbicc.com
*文件名：  timer.h
*程序员：  夏鹏	[e-mail]
*主要内容  定时器

*如有问题或BUG，请登录www.wsn.net.cn 提问或用邮件和作者联系
****************************************************************************
*/

#include "timer.h"
#include "fun.h"
#include "os.h"
//static result_t TimerStdControlStart(void);
static result_t TimerTimerFired(uint8_t id);		// 加入定时要触发的程序
static void     TimerAdjustInterval(void);
static result_t TimerDefaultFired(uint8_t id);
static void     TimerEnqueue(uint8_t value);
static uint8_t  TimerDequeue(void);
static void     TimerSignalOneTimer(void);
static void     TimerHandleFire(void);
static result_t TimerClockFire(void);
static void     TimerHPLClockSetInterval(uint8_t value);
static result_t TimerHPLClockSetRate(char interval, char scale);
static uint32_t TimerM_mState;
static uint8_t  TimerM_setIntervalFlag;
static uint8_t  TimerM_mScale;

static uint8_t  TimerM_mInterval;
static int8_t   TimerM_queue_head;
static int8_t   TimerM_queue_tail;
static uint8_t  TimerM_queue_size;
static uint8_t  TimerM_queue[NUM_TIMERS];

static uint8_t HPLClock_set_flag;
static uint8_t HPLClock_mscale;
static uint8_t HPLClock_nextScale;
static uint8_t HPLClock_minterval;

struct TimerM_timer_s {
	uint8_t type;
	int32_t ticks;
	int32_t ticksLeft;
} TimerM_mTimerList[NUM_TIMERS];
///
/*
static result_t TimerStdControlStart(void)
{
	return SUCCESS;
}
 */
static result_t TimerHPLClockSetRate(char interval, char scale)
{
	scale &= 0x7;
	scale |= 0x8;
	{ uint8_t atomicState = AtomicStart();
    {
		* (volatile unsigned char *)(0x37 + 0x20) &= ~(1 << 0);
		* (volatile unsigned char *)(0x37 + 0x20) &= ~(1 << 1);
		* (volatile unsigned char *)(0x30 + 0x20) |= 1 << 3;
		
		
		* (volatile unsigned char *)(0x33 + 0x20) = scale;
		* (volatile unsigned char *)(0x32 + 0x20) = 0;
		* (volatile unsigned char *)(0x31 + 0x20) = interval;
		* (volatile unsigned char *)(0x37 + 0x20) |= 1 << 1;
    }
    AtomicEnd(atomicState); }
	return SUCCESS;
}

static void TimerHPLClockSetInterval(uint8_t value)
{
	* (volatile unsigned char *)(0x31 + 0x20) = value;
}

static void TimerAdjustInterval(void)
{
	uint8_t i;
	uint8_t val = TimerM_maxTimerInterval;
	
	if (TimerM_mState) {
		for (i = 0; i < NUM_TIMERS; i++) {
			if (TimerM_mState & (0x1 << i) && TimerM_mTimerList[i].ticksLeft < val) {
				val = TimerM_mTimerList[i].ticksLeft;
            }
        }
		{ uint8_t atomicState = AtomicStart();
        {
			TimerM_mInterval = val;
			TimerHPLClockSetInterval(TimerM_mInterval);
			TimerM_setIntervalFlag = 0;
        }
        AtomicEnd(atomicState); }
    }
	else {
		{ uint8_t atomicState = AtomicStart();
        {
			TimerM_mInterval = TimerM_maxTimerInterval;
			TimerHPLClockSetInterval(TimerM_mInterval);
			TimerM_setIntervalFlag = 0;
        }
		AtomicEnd(atomicState); }
    }
	PowerManagementAdjust();
}

result_t TimerTimerStop(uint8_t id)
{
	
	if (id >= NUM_TIMERS) 
	{
		return FAIL;
	}
	if (TimerM_mState & (0x1 << id)) {
		{ uint8_t atomicState = AtomicStart();
        TimerM_mState &= ~(0x1 << id);
        AtomicEnd(atomicState); }
		if (!TimerM_mState) {
			TimerM_setIntervalFlag = 1;
        }
		return SUCCESS;
    }
	return FAIL;
}

static result_t TimerDefaultFired(uint8_t id)
{
	return SUCCESS;
}

static result_t TimerTimerFired(uint8_t id)
{
	unsigned char result;
	switch (id) {
    case 1:    //hladd
	   
      	result = Timer0_1_Fired();
		break;
		
    case 0:
	    result = Timer0_0_Fired() ;
		break;
		
    default:
		result = TimerDefaultFired(id);
    }
	return result;

}

static uint8_t TimerDequeue(void)
{
	if (TimerM_queue_size == 0) {
		return NUM_TIMERS;
    }
	if (TimerM_queue_head == NUM_TIMERS - 1) {
		TimerM_queue_head = -1;
    }
	TimerM_queue_head++;
	TimerM_queue_size--;
	return TimerM_queue[(uint8_t )TimerM_queue_head];
}

static void TimerSignalOneTimer(void)
{
	uint8_t itimer = TimerDequeue();
	
	if (itimer < NUM_TIMERS) {
		TimerTimerFired(itimer);
    }
}

static void TimerEnqueue(uint8_t value)
{
	if (TimerM_queue_tail == NUM_TIMERS - 1) {
		TimerM_queue_tail = -1;
    }
	TimerM_queue_tail++;
	TimerM_queue_size++;
	TimerM_queue[(uint8_t )TimerM_queue_tail] = value;
}

static void TimerHandleFire(void)
{
	uint8_t i;
	TimerM_setIntervalFlag = 1;
	if (TimerM_mState) 
	{
		for (i = 0; i < NUM_TIMERS; i++) 
		{
			if (TimerM_mState & (0x1 << i)) 
			{
				TimerM_mTimerList[i].ticksLeft -= TimerM_mInterval + 1;
				if (TimerM_mTimerList[i].ticksLeft <= 2) 
				{
					if (TimerM_mTimerList[i].type == TIMER_REPEAT) 
					{
						TimerM_mTimerList[i].ticksLeft += TimerM_mTimerList[i].ticks;
                    }
					else 
                    {
						TimerM_mState &= ~(0x1 << i);
                    }
					TimerEnqueue(i);
					OSPostTask(TimerSignalOneTimer);
                }
            }
        }
    }
	TimerAdjustInterval();
}

static result_t TimerClockFire(void)
{
	OSPostTask(TimerHandleFire);
	return SUCCESS;
}

result_t TimerStdControlInit(void)
{
	TimerM_mState = 0;
	TimerM_setIntervalFlag = 0;
	TimerM_queue_head = TimerM_queue_tail = -1;
	TimerM_queue_size = 0;
	TimerM_mScale = 3;
	TimerM_mInterval = TimerM_maxTimerInterval;
	return TimerHPLClockSetRate(TimerM_mInterval, TimerM_mScale);
}

result_t TimerTimerStart(uint8_t id, char type, uint32_t interval)
{
	uint8_t diff;
	
	if (id >= NUM_TIMERS) {
		return FAIL;
    }
	if (type > 1) {
		return FAIL;
    }
	TimerM_mTimerList[id].ticks = interval;
	TimerM_mTimerList[id].type = type;
	
	{ uint8_t atomicState = AtomicStart();
    {
		diff = * (volatile unsigned char *)(0x32 + 0x20);
		interval += diff;
		TimerM_mTimerList[id].ticksLeft = interval;
		TimerM_mState |= 0x1 << id;
		if (interval < TimerM_mInterval) {
			TimerM_mInterval = interval;
			TimerHPLClockSetInterval(TimerM_mInterval);
			TimerM_setIntervalFlag = 0;
			PowerManagementAdjust();
        }
    }
    AtomicEnd(atomicState); }
	return SUCCESS;
}

void __attribute((signal))  __vector_15(void)
{   
    
	{ uint8_t atomicState = AtomicStart();
    {
		if (HPLClock_set_flag) {
			HPLClock_mscale = HPLClock_nextScale;
			HPLClock_nextScale |= 0x8;
			* (volatile unsigned char *)(0x33 + 0x20) = HPLClock_nextScale;
			
			* (volatile unsigned char *)(0x31 + 0x20) = HPLClock_minterval;
			HPLClock_set_flag = 0;
        }
    }
    AtomicEnd(atomicState); }
	TimerClockFire();
}