bugsamp.c

上传一个带源代码的嵌入式实时多任务操作系统CMX

/* the following program does really nothing, except to show the
user different function calls and how to set them up. */

#include <reg167.h>
#include <cxfuncs.h>

#if (defined(WINBUG))
#include <cmxbug.h>		/* prototypes for cmxbug functions */
#endif

#define TSK6_EVENT1 0x0001	/* task 6 event bit 0 */
#define TSK6_EVENT2 0x0002	/* task 6 event bit 1 */
#define TSK6_EVENT3 0x0004	/* task 6 event bit 2 */

#define RESOURCE0	0	/* resource 0 number */

#define MBOX0 0		/* mailbox 0 number */
#define MBOX1 1		/* mailbox 1 number */

#define CYCLIC0 0		/* cyclic timer 0 number */
#define CYCLIC1 1		/* cyclic timer 1 number */

byte task1_slot;	/* task 1 global slot number */
byte task2_slot;	/* task 2 global slot number */
byte task3_slot;	/* task 3 global slot number */
byte task4_slot;	/* task 4 global slot number */
byte task5_slot;	/* task 5 global slot number */
byte task6_slot;	/* task 6 global slot number */
byte task7_slot;	/* task 7 global slot number */
byte task8_slot;	/* task 8 global slot number */

#pragma global		/* allow interrupt access to these variables */
byte t0_cnt;		/* used by interrupt, for counter */
byte go_ahead;		/* used by interrupt, to determine when to send messages */
near char int_mesg[] = {"interrupt mesg"};	/* message that interrupt will send */
#pragma public

volatile byte toggle;		/* used by task 7 and 8 */

/* some messages */

char *mesg_out[5] = { "hello world1",
							"hello world2",
							"hello world3",
							"hello world4",
							"hello world5" };
byte *mesg_in1;	/* message in pointers */
byte *mesg_in2;

byte queue1[20 * 1];	/* queue */

struct {		/* not used in demo, but shows user proper struture for
					fixed memory block */
	byte *dmp_ptr;
	byte array1[10*3];
	} mem1_b;

byte *mem1;

void task1(void);
void task2(void);
void task3(void);
void task4(void);
void task5(void);
void task6(void);
void task7(void);
void task8(void);
void common_error(void);

void task1(void)
{
	byte status;
	word16 cntr;

	mesg_in1 = K_Mesg_Get(MBOX0);	/* go get message, mesg_in should be NULL */
	status = K_Task_Start(task2_slot);	/* trigger task 2 to start */
	mesg_in1 = K_Mesg_Wait(MBOX0,0);		/* now, lets wait for message */
		for (cntr = 0; cntr < 55000; cntr++)
			;		/* just eat up some time, so as to have CMXBug
						TIME ANALYSIS show task doing something. This
						also will simulate task 1 doing some processing */
	K_Mesg_Ack_Sender();							/* ack sender, will be task 2 */
	status = K_Mesg_Send(MBOX1,mesg_out[0]);	/* now send message to mailbox 1 */
	do {
		mesg_in1 = K_Mesg_Get(MBOX0);	/* go retrieve additional messages */
		} while (mesg_in1);			/* if not NULL, then message retrieved */
	if (K_Resource_Get(RESOURCE0) == K_OK)	/* go see if resource 0 available */	
		status = K_Resource_Release(RESOURCE0);		/* now, release it */
	status = K_Resource_Wait(RESOURCE0,0);		/* go get it again, but wait if need be */
	status = K_Task_Start(task5_slot);	/* trigger task 5 */
	K_Task_Wait(3);							/* show that task 5 will wait for resource */
	status = K_Resource_Release(RESOURCE0);			/* now release resource */
	status = K_Task_Start(task3_slot);	/* trigger task 3 */
	K_Task_End();	/* done, go back to IDLE state */
}
void task2(void)
{
	byte status;
	word16 cntr;

	mesg_in2 = K_Mesg_Wait(MBOX1,2);	/* wait for message, will time out */
	status = K_Mesg_Send_Wait(MBOX0,0,mesg_out[0]);	/* now send message, and wit for reply */
	mesg_in2 = K_Mesg_Wait(MBOX1,0);	/*	now wait for message from mailbox 1 */
	cntr = 0;
	do {
		status = K_Mesg_Send(0,mesg_out[cntr]);	/* send 5 messages */ 
		} while (++cntr != 5);
	for (cntr = 0; cntr < 30000; cntr++)
		;		/* just eat up some time, so as to have CMXBug
					TIME ANALYSIS show task doing something. This
					also will simulate task 2 doing some processing */
	K_Task_End();	/* now end task, put into IDLE state */
}
void task3(void)
{
	byte status;
	byte queue_byte;

	K_Que_Create(20,1,queue1,0);	/* create 1'st queue */
	queue_byte = 0x31;		/* one way to pass to queue */
	K_Que_Add_Top(0,&queue_byte);	/* add to top of queue */
	K_Que_Add_Bottom(0,"2");	/* add to bottom of queue, another way */
	queue_byte = 0x33;
	K_Que_Add_Top(0,&queue_byte);	/* add to top of queue */
	status = K_Que_Add_Bottom(0,"4"); /* add to bottom of queue, another way */
	K_Task_Wait(4);					/* wait 4 SYSTEM TICKS */
	status = K_Que_Get_Top(0,&queue_byte);	/* go remove from queue top */
	status = K_Que_Get_Bottom(0,&queue_byte);	/* go remove from queue bottom */
	status = K_Que_Get_Top(0,&queue_byte);	/* go remove from queue top */
	status = K_Que_Get_Bottom(0,&queue_byte);	/* go remove from queue bottom */
	status = K_Que_Get_Bottom(0,&queue_byte);	/* go remove from queue top,
													should be "K_QUE_EMPTY */
	K_Task_Start(task4_slot);		/* go fire up task 4 now */
	K_Task_End();		/* let task end, becomes IDLE */
}

void task4(void)
{
	byte status;

	status = K_Task_Wait(0);	/* wait till task 8 wakes this task */
	/* ... */
	K_Task_End();	/* really NOT needed here, but always good to have
						just incase user removes endless loop */
}

void task5(void)
{
	byte status;
	byte ctr;

	status = K_Resource_Wait(RESOURCE0,0);	/* wait for resource 0 */
	status = K_Resource_Release(RESOURCE0);		/* now release it */
	K_OS_Slice_On();		/* now turn time slicing on */
	status = K_Task_Start(task7_slot);	/* go fire up task 7 now */
	status = K_Task_Start(task8_slot);	/* go fire up task 8 now */
	go_ahead = 1;			/* let interrupt now pass message to this task */

	for (ctr = 0; ctr < 10; ctr++ )	/* loop 10 times */
		{
		mesg_in1 = K_Mesg_Wait(MBOX0,0);		/* wait for message, from mailbox 0 */
		}
	go_ahead = 0;			/* disable interrupts passing more messages */
	do {
	mesg_in1 = K_Mesg_Get(MBOX0);		/* just in case interrupt sent additional
											messages, before task woke up and cleared
											go_ahead variable. FLUSH BUFFER */
	} while(mesg_in1);
	K_Task_End();		/* let task end, becomes IDLE */
}

void task6(void)
{
	word16 events;

	while(1)
		{
		if ((events = K_Event_Wait(TSK6_EVENT1,30,2)) != TSK6_EVENT1)	/* wait for event 1 */
			common_error();											/* should match */
		if ((events = K_Event_Wait(TSK6_EVENT2,30,2)) != TSK6_EVENT2)	/* wait for event 2 */
			common_error();											/* should match */
		if ((events = K_Event_Wait(TSK6_EVENT3,40,2)) != 0)		/* wait for event 3 */
			common_error();											/* should time out */
		}
	K_Task_End();	/* really NOT needed here, but always good to have
						just incase user removes endless loop */
}

void task7(void)
{
	byte ctr;

	ctr = 0;
	while(1)	/* endless loop */
		{
		if (!toggle)	/* this way task 8 will toggle 'toggle' */
			{
			toggle = 1;
			if (++ctr == 10)	/* do 10 iterations */
				break;			/* break out of loop */
			}
		}
	K_Task_End();		/* let task end, becomes IDLE */
}
void task8(void)
{
	byte status;
	byte ctr;

	ctr = 0;
	while(1)	/* endless loop */
		{
		if (toggle)		/* this way task 7 will toggle 'toggle' */
			{
			toggle = 0;
			if (++ctr == 10)	/* do 10 iterations */
				break;			/* break out of loop */
			}
		}
	status = K_Task_Wake(task4_slot);	/* now go wake task 4 up, should be sleeping */
	K_Task_End();		/* let task end, becomes IDLE */
}

void common_error(void)
{
	while(1)
		{
		;
		}
}

int main(void)
{
	byte status;
	K_OS_Init();	 /* initialize ram and things */
#if (defined(WINBUG))
	cmxbug_activate();
#endif
	status = K_Task_Create(5,&task1_slot,task1,128);	/* create task 1 */
	status = K_Task_Name(task1_slot,"TASK1");		/* Name for task */
	status = K_Task_Create(3,&task2_slot,task2,128);	/* create task 2 */
	status = K_Task_Name(task2_slot,"TASK2");		/* Name for task */
	status = K_Task_Create(6,&task3_slot,task3,128);	/* create task 3 */
	status = K_Task_Name(task3_slot,"TASK3");		/* Name for task */
	status = K_Task_Create(2,&task4_slot,task4,128);	/* create task 4 */
	status = K_Task_Name(task4_slot,"TASK4");		/* Name for task */
	status = K_Task_Create(4,&task5_slot,task5,128);	/* create task 5 */
	status = K_Task_Name(task5_slot,"TASK5");		/* Name for task */
	status = K_Task_Create(4,&task6_slot,task6,128);	/* create task 6 */
	status = K_Task_Name(task6_slot,"TASK6");		/* Name for task */
	status = K_Task_Create(0xfe,&task7_slot,task7,128);	/* create task 7 */
	status = K_Task_Name(task7_slot,"TASK7");		/* Name for task */
	status = K_Task_Create(0xfe,&task8_slot,task8,128); /* create task 8 */
	status = K_Task_Name(task8_slot,"TASK8");		/* Name for task */
	status = K_Task_Start(task1_slot);	/* trigger task 1 */
	status = K_Task_Start(task6_slot);	/* trigger task 2 */
	status = K_Timer_Create(CYCLIC0,0,task6_slot,TSK6_EVENT1);	/* set up cyclic timer 0 */
	status = K_Timer_Start(CYCLIC0,10,10);	/* now start cyclic timer 0 */
	status = K_Timer_Create(CYCLIC1,0,task6_slot,TSK6_EVENT2);	/* set up cyclic timer 1 */
	status = K_Timer_Start(CYCLIC1,15,15);	/* now start cyclic timer 1 */
	T4CON = 0X0040;	/* set up interrupts */
	T3CON = 0X0000;
	T4IC = 0X0044;
	T3IC = 0X0048;
	K_OS_Start();			/* enter CMX RTOS */

	return (1);
}