main2.c

ucos简单示例

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



#if 0
// allocate memory for tasks' stacks 
#ifdef SEMIHOSTED
#define	STACKSIZE	(64+SEMIHOSTED_STACK_NEEDS)
#else
#define	STACKSIZE	256
#endif
OS_STK Stack1[STACKSIZE]= {0, };
OS_STK Stack2[STACKSIZE]= {0, };
OS_STK Stack3[STACKSIZE]= {0, };

// mailbox event control blocks 
OS_EVENT *Mbox1;
OS_EVENT *Mbox2;
OS_EVENT *Mbox3;

char PassMsg[] = "SW44B0";

/*tick_hook() and isrCount just for compiling,not for program */
//-------------------------------------------------------
// 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++;
	rI_ISPC = (unsigned int)1 << 20;
	
}

void Task1(void *Id)
{
	char *Msg;
	INT8U err;

	Uart_Printf("Task1() called\r\n");
#if 0
	for(;;){
		// wait for a message from the input mailbox 
		

		// print task's id 
		Uart_Printf("%c", *(char *)Id);
		//OSTimeDly(5);

		
	}
#endif
    	while(1)	
	{
		Msg = (char *)OSMboxPend(Mbox1, 0, &err);
		OSSchedLock();
		Uart_Printf( "@@@\n");
		Uart_Printf( "@@@  task 1 running ... \n" );
		Uart_Printf( "@@@     Q__Q    \n" );
		Uart_Printf( "@@@    /____\\   \n" );
		Uart_Printf( "@@@    \\____/   \n" );
		Uart_Printf( "@@@     /\\/\\    \n" );
		Uart_Printf( "@@@  __(\\\\//)__ \n" );
		Uart_Printf( "@@@  >__/w w\\__< \n" );
		Uart_Printf( "@@@\n" );
//		Uart_Printf( "@@@  go to sleep 10 time-ticks\n" );
		Uart_Printf( "@@@\n" );		
		OSSchedUnlock();	 
	//	Uart_Printf( "@@@Sleep\n" );	
		// post the input message to the output mailbox 
		OSMboxPost(Mbox2, Msg);
	//	Sleep(140);
	}
}

void Task2(void *Id)
{
	char *Msg;
	INT8U err;	

	for(;;){
		Uart_Printf("\n\nTask2() called\n\n\n");
		// wait for a message from the input mailbox 
		Msg = (char *)OSMboxPend(Mbox2, 0, &err);

		
		// post the input message to the output mailbox 
		OSMboxPost(Mbox3, Msg);
	}
}


void Task3(void *Id)
{
	char *Msg;
	INT8U err;

	Uart_Printf("Task3() called\r\n");


	for(;;){
		// wait for a message from the input mailbox 
		Msg = (char *)OSMboxPend(Mbox3, 0, &err);

		OSSchedLock();
		Uart_Printf( "+++ \n" );
		Uart_Printf( "+++  task 3 running ... \n" );
		Uart_Printf( "+++  ╭︿︿︿╮ \n" );
		Uart_Printf( "+++ {/　o　o　\\} \n" );
		Uart_Printf( "+++  (　(oo)　) \n" );
		Uart_Printf( "+++      ︶ \n" );
		Uart_Printf( "+++ \n" );
//		Uart_Printf( "+++  go to sleep 5 time-ticks\n" );
		Uart_Printf( "+++ \n" );
		OSSchedUnlock();
		
		// post the input message to the output mailbox 
		OSMboxPost(Mbox1, Msg);
	}
}

int Main(int argc, char **argv)
{
	char Id1 = '1';
	char Id2 = '2';
	char Id3 = '3';
	
	Port_Init();
	Uart_Init(0,115200);
	Uart_Select(0);

	Uart_Printf("\n ### Main Starts !\n");
	OSInit();

	Mbox1 = OSMboxCreate(PassMsg);
	Mbox2 = OSMboxCreate((void *)0);
	Mbox3 = OSMboxCreate((void *)0);

	OSTaskCreate(Task1, (void *)&Id1, (OS_STK *)&Stack1[STACKSIZE - 1], 8);
	OSTaskCreate(Task2, (void *)&Id2, (OS_STK *)&Stack2[STACKSIZE - 1], 5);
	OSTaskCreate(Task3, (void *)&Id3, (OS_STK *)&Stack3[STACKSIZE - 1], 6);

	OSStart();

	return 0;
}	// main
#else

extern void OSSchedLock(void);


//--------------------------------------------------------
// 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 &= ~(0x03 << 26);
	else
		rINTMSK |= (BIT_GLOBAL|BIT_EINT3);
}



#ifndef  OS_USE_MBOX_SLP

#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++;
	rI_ISPC = (unsigned int)1 << 20;
	
}

//-------------------------------------------------------
// 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)
{
	rRTCCON = (unsigned char)1;
	
	rTICNT = (unsigned char)0;
	
	rRTCCON = (unsigned char)0;

}

//--------------------------------------------------------
// set or clear TICK interrupt mask
// this function must be synchronized
//--------------------------------------------------------
void tick_int_enable(unsigned char bEnabled)
{
//	Uart_Printf("\n11\n"); 
	if(bEnabled) {
//		Uart_Printf("22\n");
		// clear interrupt pending first	
		rI_ISPC = (unsigned int)BIT_TICK;
		rINTMSK &= (unsigned int)~BIT_TICK;
	}
	else 
		rINTMSK |= (unsigned int)BIT_TICK;
//	Uart_Printf("33\n");
}

//--------------------------------------------------------
// start tick function of RTC
// interval = (1 + div) / 128  second
// this function must be synchronized
// div MUST >= 1 && <= 128
//--------------------------------------------------------
void tick_init(unsigned char div)
{
//	Uart_Printf("1\n");
	rRTCCON = (unsigned char)1;
//	Uart_Printf("2\n");
//	ASSERT(div >= 1 && div <= 127);
	rTICNT = (unsigned char)(div | 0x80);
//	Uart_Printf("3\n");
	rRTCCON = (unsigned char)0;
//	Uart_Printf("4\n");		
	tick_int_enable(1);	
//	Uart_Printf("5\n");
}

__inline void Sleep(INT16U uSec)
{
	OSTimeDly((INT16U) (uSec));
}

	#if 0
	void __irq OSTickISR(void) {
		Uart_Printf("OSTickISR()\n");
		isrCount++;
		rI_ISPC = (unsigned int)(0x1<<20);
	}
	#endif
void Isr_Init(void)
{
    U32 i;

     for(i=_RAM_STARTADDRESS;i<(_RAM_STARTADDRESS+0x20);i+=4)
    {
	*((volatile unsigned *)i)=0xEA000000+0x1FFE;
    }
}
#else

#endif

void sys_init(void)
{
       rSYSCFG=SYSCFG_8KB;
       ChangePllValue(PLL_M,PLL_P,PLL_S);
       globle_int_enable(0);
       Isr_Init();      
#ifndef  OS_USE_MBOX_SLP
	tick_off();
	tick_int_enable(0);	
#endif 			
	intcon_init();
	isrCount = 0;	
	
	// Set the function of the pins
	Port_Init();
	Uart_Init(0, 115200);
	Uart_Select(0);

#ifndef  OS_USE_MBOX_SLP
	// hook the tick ISR
	pISR_TICK=(unsigned)OSTickISR;

//	ISR_Install(IRQ_VECTOR_OFFSET, (void *)OSTickISR);
#endif

	globle_int_enable(1);
}
#define	N_DEMO_TASKS 2					// Number of tasks
#define 	N_GUI_TASKS 1
#define 	N_TASKS (N_DEMO_TASKS + N_GUI_TASKS)

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

OS_STK	TaskStk[N_DEMO_TASKS][TASK_STK_SIZE] = {{0, },{0, } };	// Tasks stacks
OS_STK  TaskGuiStk[TASK_GUI_STK_SIZE] = {0, };

#ifndef  OS_USE_MBOX_SLP

#else
OS_EVENT *MboxTimeSlp1;
OS_EVENT *MboxTimeSlp2;
char PassMsg[] = "SW44B0";
#endif

void Task1(void *);
void Task2(void *);
void TaskGUI(void *);

#define printf Uart_Printf

int Main(int argc, char **argv)
{
//	int	task_gui = 10, task_1 = 1, task_2 = 2;

	sys_init();
	
	Delay(0);
	Uart_Printf("\n ### JINYIBEI S3C44B0 Main Starts !\n");
	OSInit();
	Uart_Printf("\n ### osInit Ok !\n");
#ifndef  OS_USE_MBOX_SLP
	
#else
	MboxTimeSlp1 = OSMboxCreate(PassMsg);
	MboxTimeSlp2 = OSMboxCreate((void *)0);
#endif	
	
//	OSTaskCreate(TaskGUI, (void *)0, &TaskGuiStk[TASK_GUI_STK_SIZE-1], 10);
	OSTaskCreate(Task1, (void *)0, &TaskStk[0][TASK_STK_SIZE-1], 4);
	OSTaskCreate(Task2, (void *)0, &TaskStk[1][TASK_STK_SIZE-1], 5);
	OSStart();

	return 0;
}

void Task1(void * pParam)
{
	// enable Ticker, 16 ticks per second
#ifndef  OS_USE_MBOX_SLP
	Uart_Printf(" @@@ Task1 will starts time ticker !\n");
	// why start tick here? see uCOS-II Doc Chapter 8 :
	/* 
	"You MUST enable ticker interrupts AFTER multitasking has started, i.e. after 
	calling OSStart().  In other words, you should initialize and tick interrupts in
	the first task that executes following a call to OSStart().  A common mistake is
	to enable ticker interrupts between calling OSInit() and OSStart() ..."
	*/	
	tick_init(32);	
	Uart_Printf(" @@@ Task1 end time ticker !\n");
#else 
	INT8U err;
       char *Msg;
	
#endif		
	Uart_Printf(" @@@ jinyibei Task1 will starts!\n");
	while(1)	
	{
		#ifndef  OS_USE_MBOX_SLP
	
		#else
		Msg = (char *)OSMboxPend(MboxTimeSlp1, 5, &err);
		#endif
//		OSSchedLock();
		printf( "@@@\n");
		printf( "@@@  JINYIBEI  task 1 running ... \n" );
#if 1	
		printf( "@@@     Q__Q    \n" );
		printf( "@@@    /____\\   \n" );
		printf( "@@@    \\____/   \n" );
		printf( "@@@     /\\/\\    \n" );
		printf( "@@@  __(\\\\//)__ \n" );
		printf( "@@@  >__/w w\\__< \n" );
		printf( "@@@\n" );
		printf( "@@@  go to sleep 5 time-ticks\n" );
		printf( "@@@\n" );
#endif
//		OSSchedUnlock();
		
		#ifndef  OS_USE_MBOX_SLP
			Sleep(5);
		#else
		
		OSMboxPost(MboxTimeSlp2, Msg);
		#endif
	}

}

void Task2(void * pParam)
{
#ifndef  OS_USE_MBOX_SLP
	
#else 
	INT8U err;	
	char *Msg;
	
#endif
	Uart_Printf(" +++ Task2 will starts!\n");
	while(1)	
	{
		#ifndef  OS_USE_MBOX_SLP
		
		#else
		Msg = (char *)OSMboxPend(MboxTimeSlp2, 5, &err);
		#endif
//		OSSchedLock();
		printf( "+++ \n" );
		printf( "+++  JINYIBEI task 2 running ... \n" );
		printf( "+++  ╭︿︿︿╮ \n" );
		printf( "+++ {/　o　o　\\} \n" );
		printf( "+++  (　(oo)　) \n" );
		printf( "+++      ︶ \n" );
		printf( "+++ \n" );
//		printf( "+++  go to sleep 5 time-ticks\n" );
//		printf( "+++ \n" );
//		OSSchedUnlock();
		#ifndef  OS_USE_MBOX_SLP
			Sleep(5);
		#else		
		OSMboxPost(MboxTimeSlp1, Msg);
		#endif
	}
}

extern void MainTask(void);
void TaskGUI(void * pParam)
{
	pParam = pParam;
//	tick_init(1);
//	MainTask();
}

#endif