New to C++ Embedded Systems Programming

[datta016]

Hi all, I'm generally not a poster, however, I am being introduced to C++ Embedded Systems Programming (a field I am admittedly relatively ignorant to--the embedded programming part, not the C++ =P). I have been given a sample problem and I am a little confused on how to go about starting/solving it. The following is the objective:

To make an application that will utilize the following:
Message Queues,
Semaphores,
Timers,
Priority Levels,
Task Delays,
data synchronization (by using message queue)

Your class will contain the following:

Task 1:

* Highest priority task
* Pends on Timer event (which should be set to occur every 1 second)
* Sends message to Task 3
* releases Task 3's semaphore after sending messages

Task 2:

* Middle priority task
* pends on semaphore
* receives message queue and prints out the spare cycles.
* utilizes task delay after getting message queue information (10 msecs)
* clears cycle count being incremented in Task 4

Task 3:

* Lower priority task then Task 2
* Sends Message to task 2 (Should see that Task 2 will then run taking time from task 3)
* Message sent to task 2 will contain cycle count being calculated in Task 4

Task 4:

* Lowest priority task
* Counts Spare Cycle Time (only the lowest priority task in the system can do this.


All in all I am a bit confused as to what a semaphore is, through Wikipedia I was able to come up with the general definition of it being a protected variable... in addition to this I am a bit lost in how to incorporate timers and cycles in C++, something I have never handled before.

ANY help that can be provided would be absolutely appreciated. Also, in advance, I apologize if I am asking for too much. I just need some guidance with this, as mentioned above, this is a bit new to me.

Thank you all for your time.

[vcsasc]

Hi,

I am also interested in similar interest in Windows OS.I am also a beginner.
If you OS is Microsoft Windows related, You can refer the following books.

1) Windows Internals -4th Edtion- David Solomon and Mark Russinovich.
2) Windows System Programming - Johnson M Hart
Meanwhile,I try some ideas for task 1( at least) .Can you post,some more detail ?

[datta016]

WELL!!! It's been a couple weeks =P BUT, I was able to figure it all out. It honestly wasn't that difficult. The OS (or RTOS rather) I was using is known as vxWorks. There is some outstanding documentation that comes along with it--and I recommend all who would like to venture into RTOS programming to check them out. I was able to solve the problem with the following as references (mind you, prior to these references I didn't even know what an RTOS was):

BOOKS:
VxWorks Kernel API Reference Vol 2, 6.3
VxWorks Kernel Programmers Guide, 6.3

ONLINE:
Intro to Reentrancy - http://www.embedded.com/story/OEG20010311S0005

Round-Robin Scheduling - http://en.wikipedia.org/wiki/Round-robin_scheduling

Interrupts - http://en.wikipedia.org/wiki/Interrupt

EDF (Least Time To Go) - http://en.wikipedia.org/wiki/Earliest_deadline_first_scheduling

Dynamic Memory Allocation - http://en.wikipedia.org/wiki/Memory_allocation

Fixed Priority Pre-Emptive Scheduling - http://en.wikipedia.org/wiki/Fixed_priority_pre-emptive_scheduling

RTOS - http://en.wikipedia.org/wiki/RTOS

Effective Use of RTOS Programming for Multithreaded Arc - http://www.embedded.com/columns/showArticle.jhtml?articleID=192501328

Mutex:
Dekker - http://en.wikipedia.org/wiki/Dekker%27s_algorithm#Pseudocode
Peterson - http://en.wikipedia.org/wiki/Peterson%27s_algorithm
Lamport - http://en.wikipedia.org/wiki/Lamport%27s_bakery_algorithm

Critical Section – http://en.wikipedia.org/wiki/Critical_section

INCREDIBLE HELP -> http://www.cs.ru.nl/lab/vxworks/www.rt.db.erau.edu/toc/TableOfContents.html

[datta016]

And here is the code... I do recommend to try this on your own though... copying mine will do nothing for you. Enjoy!

/*INCLUDES*/
#include <vxWorks.h>
#include <taskLib.h>
#include <sysLib.h>
#include <semLib.h>
#include <time.h>
#include <stdio.h>


/*GLOBAL DEFINITIONS*/
#define LOWR 104       //Priority Level for taskFour
#define LOW 103        //Priority Level for taskThree
#define MID 102        //Priority Level for taskTwo
#define HIGH 101       //Priority Level for taskOne
#define MAX_MSGS 10    //Maximum messages for MQ
#define MAX_LNTH 50    //Maximum length for MQ


//Declare SPARE_CYCLE struct type:
struct SPARE_CYCLE {
   int Count;
} Cycle;


/*MESSAGE QUEUE ID's*/
MSG_Q_ID msgQId1;
MSG_Q_ID msgQId2;


/*DECLARE TASK FUNCTIONS*/
void taskOne(void);   //Highest Priority Task  - 101
void taskTwo(void);   //Medium Priority Task   - 102
void taskThree(void); //Low Priority Task      - 103
void taskFour(void);  //Lowest Priority Task   - 104


/*CREATE SEMAPHORE*/
SEM_ID semMutex;


/*TASK INITIATOR FUNCTION*/
void init(void)
{
	/*INITIATE COUNT CYCLE FOR TASK 4*/
	Cycle.Count = 0;
	
	
	/*WELCOME BANNER*/
	printf("\n\n\n############++++++++++++------------"
			"RUNNING"
			"------------++++++++++++############\n\n\n");
	
	
	/*PREPARE MESSAGE QUEUES*/
	//Message Queue 1:
	if((msgQId1 = msgQCreate(MAX_MSGS, MAX_LNTH, MSG_Q_FIFO))
			== NULL)
		printf("\n\n\n\t\t\t!!!!!SPAWNING OF msgQId1 FAILED!!!!!\n\n\n");
	
	//Message Queue 2:
	if((msgQId2 = msgQCreate(MAX_MSGS, MAX_LNTH, MSG_Q_FIFO))
			== NULL)
		printf("\n\n\n\t\t\t!!!!!SPAWNING OF msgQId2 FAILED!!!!!\n\n\n");
	
	
	/*PREPARE SEMAPHORE*/
	//Setup semMutex (PRIORITY-BASED SEMAPHORE):
	if((semMutex = semMCreate(SEM_Q_PRIORITY | SEM_INVERSION_SAFE))
			== NULL)
		printf("\n\n\n\t\t\t!!!!!SPAWNING OF semMutex FAILED!!!!!\n\n\n");
	
	
	/*PREPARE TASKS*/
	//Declare tid's for tasks:
	int taskIdOne;
	int taskIdTwo;
	int taskIdThree;
	int taskIdFour;
	
	//Task 1 -> HIGH:
	if((taskIdOne = taskSpawn("tsk1", HIGH, 0, 20000, (FUNCPTR)taskOne,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0)) == ERROR)
		printf("\n\n\n\t\t\t!!!!!SPAWNING OF taskOne FAILED!!!!!\n\n\n");
	
	//Task 2 -> MID:
	if((taskIdTwo = taskSpawn("tsk2", MID, 0, 20000, (FUNCPTR)taskTwo,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0)) == ERROR)
		printf("\n\n\n\t\t\t!!!!!SPAWNING OF taskTwo FAILED!!!!!\n\n\n");
	
	//Task 3 -> LOW:
	if((taskIdThree = taskSpawn("tsk3", LOW, 0, 20000, (FUNCPTR)taskThree,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0)) == ERROR)
		printf("\n\n\n\t\t\t!!!!!SPAWNING OF taskThree FAILED!!!!!\n\n\n");
	
	//Task 4 -> LOWR:
	if((taskIdFour = taskSpawn("tsk4", LOWR, 0, 20000, (FUNCPTR)taskFour,
			0, 0, 0, 0, 0, 0, 0, 0, 0, 0)) == ERROR)
		printf("\n\n\n\t\t\t!!!!!SPAWNING OF taskFour FAILED!!!!!\n\n\n");
}


/*DEFINITION OF TASK 1 - HIGH*/
void taskOne(void)
{
	//Lock Semaphore:
	semTake(semMutex, WAIT_FOREVER);
	printf("TASK 1: Semaphore Locked...\n");
	printf("\n\t\tTASK 1 TIMER IS SET TO EXECUTE IN %d SECOND.\n\n",
			sysClkRateGet()/60);
	
	//Delay task to occur every second:
	taskDelay(sysClkRateGet());


	/*MESSAGE SENDING*/
	//Prepare Message Going to Task 3:
	char message1[] = "Message from Task 1 Received.\n\t..Sending Message..\n";

	//Send Message to Task3:
	if(msgQSend(msgQId1, message1, MAX_LNTH, WAIT_FOREVER, MSG_PRI_URGENT)
			== ERROR)
		printf("\n\n\n\t\t\t!!!!!taskOne: msgQSend TO taskThree FAILED!!!!!\n\n\n");
	else
		printf("TASK 1: Message Sent To Task 3...\n");


	//Unlock Semaphore:
	printf("TASK 1: Semaphore Released...\n");
	semGive(semMutex);

	//Exit Task 1:
	printf("...............................TASK 1 EXITED.\n\n");
}


/*DEFINITION OF TASK 2 - MID*/
void taskTwo(void)
{
	/*MESSAGE RECEIVING*/
	//Receive Message from Task 3:
	char msgBuf[MAX_LNTH];
	if(msgQReceive(msgQId2, msgBuf, MAX_LNTH, WAIT_FOREVER)
			== ERROR)
		printf("\n\n\n\t\t\t!!!!!taskThree: msgQReceive FROM taskThree FAILED!!!!!\n\n\n");
	else
		printf("TASK 2: Message from Task 3 Received.\n\tCYCLE COUNT: %i\n", msgBuf);

	//Cleanup and Delete Message Queue 2:
	msgQDelete(msgQId2);
	
	
	/*10 MILLISECOND TASK DELAY (=10 000 000 NANOSECONDS)*/
	struct timespec nsTime;
	nsTime.tv_sec = 0;
	nsTime.tv_nsec = 10000000;
	nanosleep(&nsTime, NULL);
	
	
	//Clear Task 4's Cycle Count:
	Cycle.Count = 0;
	printf("TASK 2: CYCLE COUNT CLEARED: %i\n", Cycle.Count);
	
	//Exit Task 2:
	printf("...............................TASK 2 EXITED.\n\n");
}


/*DEFINITION OF TASK 3 - LOW*/
void taskThree(void)
{
	//Lock Semaphore Released By Task 1:
	semTake(semMutex, WAIT_FOREVER);
	printf("TASK 3: Semaphore Locked...\n");
	
		
	/*MESSAGE RECEIVING*/
	//Receive Message from Task 1:
	char msgBuf[MAX_LNTH];
	if(msgQReceive(msgQId1, msgBuf, MAX_LNTH, WAIT_FOREVER)
			== ERROR)
		printf("\n\n\n\t\t\t!!!!!taskThree: msgQReceive FROM taskOne FAILED!!!!!\n\n\n");
	else
		printf("TASK 3: %s\n", msgBuf);
	
	//Cleanup and Delete Message Queue 1
	msgQDelete(msgQId1);

	
	/*MESSAGE SENDING*/
	//Send Message to Task 2
	if(msgQSend(msgQId2, (char*)&(Cycle.Count), MAX_LNTH, WAIT_FOREVER, MSG_PRI_NORMAL)
			== ERROR)
		printf("\n\n\n\t\t\t!!!!!taskThree: msgQSend TO taskTwo FAILED!!!!!\n\n\n");


	//Unlock Semaphore:
	printf("TASK 3: Semaphore Released...\n");
	semGive(semMutex);
	
	//Exit Task 3:
	printf("...............................TASK 3 EXITED.\n\n");
}


/*DEFINITION OF TASK 4 - LOWR*/
void taskFour(void)
{
	while(1)
		Cycle.Count++;
}