main_timer0.c

ucos简单示例

#include "../SOURCE/includes.h"               // uC/OS interface
#include "../inc/44b.h"
#include "../inc/44blib.h"
#include "../inc/def.h"

/*
*********************************************************************************************************
*                                              CONSTANTS
*********************************************************************************************************
*/
// Stack size, in sizeof OS_STK, or int 32bit
#ifdef SEMIHOSTED
#define	TASK_STK_SIZE		(64+SEMIHOSTED_STACK_NEEDS)
#else
#define	TASK_STK_SIZE		256
#endif			

#define TASK_START_ID	0		/* Application tasks                             */
#define TASK1_ID	1
#define TASK2_ID	2
#define TASK3_ID	3
#define TASK4_ID	4
//#define TASK5_ID	5

#define TASK_START_PRIO	0		/* Application tasks priorities                  */
#define TASK1_PRIO	1
#define TASK2_PRIO	2
#define TASK3_PRIO	3
#define TASK4_PRIO	4
//#define TASK5_PRIO	5

#define printf Uart_Printf

/*
*********************************************************************************************************
*                                              VARIABLES
*********************************************************************************************************
*/
OS_STK	TaskStartStk[TASK_STK_SIZE];	/* Startup    task stack                         */
OS_STK	Task1Stk[TASK_STK_SIZE];	/* Task #1    task stack                         */
OS_STK	Task2Stk[TASK_STK_SIZE];	/* Task #2    task stack                         */
OS_STK	Task3Stk[TASK_STK_SIZE];	/* Task #3    task stack                         */
OS_STK	Task4Stk[TASK_STK_SIZE];	/* Task #4    task stack                         */
//OS_STK	Task5Stk[TASK_STK_SIZE];	/* Task #5    task stack                         */

OS_EVENT	*AckMbox;			/* Message mailboxes for Tasks #4 and #5         */
OS_EVENT	*TxMbox;

/*
*********************************************************************************************************
*                                         FUNCTION PROTOTYPES
*********************************************************************************************************
*/
void	TaskStart (void *pdata);
void	Task1(void *pdata);
void	Task2(void *pdata);
void	Task3(void *pdata);
void	Task4(void *pdata);
void	Task5(void *pdata);
void	sys_init(void);
void	InitTick(INT16U tick);
INT8U	TestSRAM(void);

INT8U TestSRAM(void)
{
	INT8U status=0;
	INT16U *i;
	printf("Begin to write the SRAM.\n");
	for(i=(INT16U *)0x2000000; i<(INT16U *)0x4000000; i++)
	{
		printf("0X%x\r", i);
		*i = 0x0;
		*i = 0x55aa;
	}
	printf("\nBegin to test the SRAM.\n");
	for(i=(INT16U *)0x2000000; i<(INT16U *)0x4000000; i++)
	{
		printf("0X%x\r", i);
		if(*i != 0x55aa)
		{
			printf("ERROR address: %xd\n", i);
			status = 1;
			break;
		}
	}
	printf("End of testing SRAM.\n");
	return status;
}

/*
*********************************************************************************************************
*                                                  MAIN
*********************************************************************************************************
*/
int Main(int argc, char **argv)
{
	sys_init();
//	TestSRAM();
//	Delay(0);
//	Uart_Printf("\n Mettler Toledo S3C44B0 Main Starts !\n");

	/* needed by uC/OS */
	OSInit();

	OSTimeSet(0L);

	/* create the start task */
	OSTaskCreateExt(TaskStart,
			(void *)0,
			&TaskStartStk[TASK_STK_SIZE - 1],
			TASK_START_PRIO,
			TASK_START_ID, 
			&TaskStartStk[0],
			TASK_STK_SIZE,
			(void *)0,
			0);

	/* start the operating system */
	OSStart();

	return 0;
}                            

/*
*********************************************************************************************************
*                                               STARTUP TASK
*********************************************************************************************************
*/
void TaskStart (void *pdata)
{
	// enable Ticker, 64 ticks per second
	InitTick(OS_TICKS_PER_SEC);

	AckMbox = OSMboxCreate((void *)0);			/* Create 2 message mailboxes               */
	TxMbox  = OSMboxCreate((void *)0);

	/*
	* create the tasks in uC/OS and assign decreasing
	* priority to them
	*/

	OSTaskCreateExt(Task1,
			(void *)0,
			&Task1Stk[TASK_STK_SIZE - 1],
			TASK1_PRIO,
			TASK1_ID,
			&Task1Stk[0],
			TASK_STK_SIZE,
			(void *)0,
			0);

	OSTaskCreateExt(Task2,
			(void *)0,
			&Task2Stk[TASK_STK_SIZE - 1],
			TASK2_PRIO,
			TASK2_ID,
			&Task2Stk[0],
			TASK_STK_SIZE,
			(void *)0,
			0);

	OSTaskCreateExt(Task3,
			(void *)0,
			&Task3Stk[TASK_STK_SIZE - 1],
			TASK3_PRIO,
			TASK3_ID,
			&Task3Stk[0],
			TASK_STK_SIZE,
			(void *)0,
			0);

	OSTaskCreateExt(Task4,
			(void *)0,
			&Task4Stk[TASK_STK_SIZE - 1],
			TASK4_PRIO,
			TASK4_ID,
			&Task4Stk[0],
			TASK_STK_SIZE,
			(void *)0,
			0);

/*	OSTaskCreateExt(Task5,
			(void *)0,
			&Task5Stk[TASK_STK_SIZE - 1],
			TASK5_PRIO,
			TASK5_ID,
			&Task5Stk[0],
			TASK_STK_SIZE,
			(void *)0,
			0);
*/
	OSTaskDel(OS_PRIO_SELF);			// Delete current task
}

/*
*********************************************************************************************************
*                                               TASK #1
*********************************************************************************************************
*/
void Task1(void *Id)
{
	while(1)
	{
		rPDATB=rPDATB&0x5ff;
		rPDATE &= 0x1f7;
		OSTimeDly(OS_TICKS_PER_SEC);
		rPDATB=rPDATB|0x200;
		rPDATE |= 0x008;
		OSTimeDly(OS_TICKS_PER_SEC);
	}
}

/*
*********************************************************************************************************
*                                               TASK #2
*********************************************************************************************************
*/
void Task2(void *Id)
{
	while(1)
	{
		rPDATB=rPDATB&0x3ff;
		OSTimeDly(OS_TICKS_PER_SEC/2);
		rPDATB=rPDATB|0x400;
		OSTimeDly(OS_TICKS_PER_SEC/2);
	}
}

/*
*********************************************************************************************************
*                                               TASK #3
*********************************************************************************************************
*/
void Task3(void *pdata)
{
	char	txmsg;
	char	*rxmsg;
	INT8U	err;

	txmsg	= '0';
	while(1)
	{
		OSMboxPost(TxMbox, (void *)&txmsg);
		rxmsg = (char *)OSMboxPend(AckMbox, 0, &err);
		if(err == OS_NO_ERR)
		{
			printf("%c", *rxmsg);
			if(*rxmsg == 'Z')
				printf("\n");
		}
		txmsg++;
		if(txmsg > '9')
			txmsg = '0';

		OSTimeDlyHMSM(0,0,1,0);
	}
}

/*
*********************************************************************************************************
*                                               TASK #4
*********************************************************************************************************
*/
void Task4(void *pdata)
{
	char	txmsg;
	char	*rxmsg;
	INT8U	err;

	txmsg	= 'A';
	while(1)
	{
		rxmsg = (char *)OSMboxPend(TxMbox, 0, &err);
		if(err == OS_NO_ERR)
			printf("%c", *rxmsg);
		OSMboxPost(AckMbox, (void *)&txmsg);
		txmsg++;
		if(txmsg > 'Z')
			txmsg = 'A';
	}
}

//--------------------------------------------------------
// interrupt controler initilization
//--------------------------------------------------------
void intcon_init(void)
{
	rINTMOD = 0;		// all interrupt sources configed as IRQ
	rI_ISPC = 0x7ffffff;	// clear all intrrupt request
	rINTCON = 0x05;		// irq interrupt available
//	rINTCON = 0x01;
}

//--------------------------------------------------------
// globel interrupt enable
//--------------------------------------------------------
void globle_int_enable(unsigned char bEnabled)
{
	if(bEnabled)
		rINTMSK &= ~BIT_GLOBAL;
	else
		rINTMSK |= (BIT_GLOBAL|BIT_EINT3);
}


#define IRQ_VECTOR_OFFSET	(0x70)

//-------------------------------------------------------
// globle variables
//-------------------------------------------------------
volatile static int isrCount = 0;		// tick counter
//volatile static unsigned int Dump_Pool[16];

//-------------------------------------------------------
// OS_Tick Hook Fubction
//-------------------------------------------------------
void tick_hook(void)
{
//	Uart_Printf("tick_hook()\n");
//	isrCount++;
#ifdef OS_USE_RTC_TICK
	rI_ISPC = (unsigned int)BIT_TICK;
#else
	rI_ISPC = (unsigned int)BIT_TIMER0;
#endif	
}

//-------------------------------------------------------
// install a new ISR
// this function must be synchronized
//-------------------------------------------------------
unsigned int ISR_Install(unsigned int offset, void *pf_ISR)
{
	unsigned int pOldEntry;

	// get absolute address of IRQ vector
	// _ISR_STARTADDRESS : see Option.h
	offset += _ISR_STARTADDRESS;

	// get the Old ISR service routine entry point
	pOldEntry = *((unsigned int *)offset);
	
	// install new interrupt service routine
	*((unsigned int *)offset) = (unsigned int)pf_ISR;

	return pOldEntry;
}

//-------------------------------------------------------
// must be synchronized
//-------------------------------------------------------
void tick_off(void)
{
#ifdef OS_USE_RTC_TICK
	rRTCCON = (unsigned char)1;
	
	rTICNT = (unsigned char)0;
	
	rRTCCON = (unsigned char)0;
#endif
}

//--------------------------------------------------------
// set or clear TICK interrupt mask
// this function must be synchronized
//--------------------------------------------------------
void tick_int_enable(unsigned char bEnabled)
{
#ifdef OS_USE_RTC_TICK
	if(bEnabled) {
		// clear interrupt pending first	
		rI_ISPC = (unsigned int)BIT_TICK;
		rINTMSK &= (unsigned int)~BIT_TICK;
	}
	else 
		rINTMSK |= (unsigned int)BIT_TICK;
#else
	if(bEnabled) {
		// clear interrupt pending first	
		rI_ISPC = (unsigned int)BIT_TIMER0;
		rINTMSK &= (unsigned int)~BIT_TIMER0;
	}
	else 
		rINTMSK |= (unsigned int)BIT_TIMER0;
#endif
}

void InitTick(INT16U tick)
{
#ifdef OS_USE_RTC_TICK
//Initalize RTC tick that is used by OS.
//If OS used RTC tick, tick is always set to 64
	rRTCCON = (unsigned char)1;

	rTICNT = (unsigned char)(0x01 | 0x80);

	rRTCCON = (unsigned char)0;

#else
//Initialize timer0 that is used OS.
	//dead zone=0, pre0= 100
	rTCFG0= 0x00000064;
	//all interrupt, mux0= 1/4, mux1~mux5=1/2
	rTCFG1= 0x00000001;

	//set T0 count
	rTCNTB0= 160*(1000/tick);

	//update T0
	rTCON= 0x00000002;

	//T0,auto reload and start
	rTCON= 0x00000009;

#endif

	tick_int_enable(1);	
}

__inline void Sleep(INT16U mSec)
{
	OSTimeDlyHMSM(0,0,0,(INT16U)(mSec));
}

void Isr_Init(void)
{
    U32 i;

     for(i=_RAM_STARTADDRESS;i<(_RAM_STARTADDRESS+0x20);i+=4)
    {
	*((volatile unsigned *)i)=0xEA000000+0x1FFE;
    }
}
	
void sys_init(void)
{
	rSYSCFG=CACHECFG;		// Using 8KB Cache
	ChangePllValue(PLL_M,PLL_P,PLL_S);
	globle_int_enable(0);
//       Isr_Init();      
	tick_off();
	tick_int_enable(0);	
	intcon_init();
	isrCount = 0;	
	
	// Set the function of the pins
	Port_Init();
	Uart_Init(0, 115200);
	Uart_Select(0);

	/* ---- Tell the world who we are ---------------------------------- */
	// print To UART0
	printf("\n\r            uCOS-II %d Running\n", OS_VERSION) ;
	printf("*===========================================*\n"); 
	printf("*=  梅特勒-托利多常州称重设备系统有限公司  =*\n"); 
	printf("*===========================================*\n"); 
	printf("*============== 商用衡器事业部 =============*\n"); 
 	printf("*=============  86-519-6642040  ============*\n"); 
	printf("*===           Version 2.0 2004          ===*\n"); 
	printf("*===========================================*\n"); 

	// hook the tick ISR
#ifdef  OS_USE_RTC_TICK
	pISR_TICK=(unsigned)OSTickISR;
#else
	pISR_TIMER0 = (unsigned)OSTickISR;
//	ISR_Install(IRQ_VECTOR_OFFSET, (void *)OSTickISR);
#endif

	globle_int_enable(1);
}