cmxsamp.c

CMEX source code RTOS for atmel atmega128

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

#include <cxfuncs.h>
#include <iom103.h> 
#include <string.h>

#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 task6_slot;	/* task 6 global slot number */
byte task5_slot;	/* task 5 global slot number */
byte task7_slot;	/* task 7 global slot number */
byte task8_slot;	/* task 8 global slot number */

byte t0_cnt;		/* used by interrupt, for counter */
byte go_ahead;		/* used by interrupt, to determine when to send messages */

char int_mesg[] = {"interrupt mesg"};	/* message that interrupt will send */

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 task2();
void task3();
void task4();
void task5();
void task6();
void task7();
void task8();
void common_error();


void task1()
{
	byte status;

	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 */
	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()
{
	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);
	K_Task_End();	/* now end task, put into IDLE state */
}
void task3()
{

	K_Task_Start(task4_slot);		/* go fire up task 4 now */
	K_Task_End();		/* let task end, becomes IDLE */
}

void task4()
{
	byte status;

	while(1)
		{
		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()
{
	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 */
		if (strcmp(mesg_in1,int_mesg))
			{
			while(1)
				{
				;	/* make sure correct address passed. */
				}
			}
		}
	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()
{
	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()
{
	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()
{
	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()
{
	while(1)
		{
		;
		}
}

main()
{
	byte status;
	K_OS_Init();	 /* initialize ram and things */
	status = K_Task_Create(5,&task1_slot,task1,256,32);	/* create task 1 */
	status = K_Task_Create(3,&task2_slot,task2,256,32);	/* create task 2 */
	status = K_Task_Create(6,&task3_slot,task3,256,32);	/* create task 3 */
	status = K_Task_Create(2,&task4_slot,task4,256,32);	/* create task 4 */
	status = K_Task_Create(4,&task5_slot,task5,256,32);	/* create task 5 */
	status = K_Task_Create(4,&task6_slot,task6,256,32);	/* create task 6 */
	status = K_Task_Create(0xfe,&task7_slot,task7,256,32);	/* create task 7 */
	status = K_Task_Create(0xfe,&task8_slot,task8,256,32); /* create task 8 */
	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 */

	/*
	the following will set up the CMX timer tick. When the interrupt
	happens, the interrupt code will properly call the K_OS_Intrp_Entry
	assembly lanquage routine, call the K_OS_Tick_Update function, then call
	the K_OS_Intrp_Exit assembly routine. Set for 20MHZ crystal
	*/

	TIMSK = 0x02;	/* enable timer 0 compare interrupt */
	TCCR0 = 0x0C;	/* select TCK0 / 64 and auto clear when compare occurs */
	OCR0 = 0xa0;	/* select compare value */

	K_OS_Start();			/* enter CMX RTOS */
}