NetBurner Community Forum

Code: Select all

#include "predef.h"
#include <stdio.h>
#include <ctype.h>
#include <startnet.h>
#include <autoupdate.h>
#include <dhcpclient.h>
#include <sim.h>
#include <cfinter.h>
#include <intcdefs.h>


extern "C" {
void UserMain(void * pd);
}


static uint32_t taskCount;
static uint32_t addTaskCount;
static uint32_t isrCount;
static OS_SEM   taskSem;
static OS_SEM   addTaskSem;
static int      taskToPost;

const char * AppName="pit_sem";

INTERRUPT( exPitISR, 0x2400 )
{
    sim2.pit[1].pcsr |= 0x0004; // Clear pit irq flag
    isrCount++;
    if (taskToPost) {
        OSSemPost( &addTaskSem );
    }
    else {
        OSSemPost( &taskSem );
    }
}

void InitPit()
{
    SETUP_PIT1_ISR( exPitISR, 4 );
    sim2.pit[1].pmr = 61035; // set count
    sim2.pit[1].pcsr = 0x0C1B; // set prescale = 4096, rld, and enable
}

void SecondaryTask( void * pd )
{
    while (1) {
        OSSemPend( &taskSem, 0 );
        taskCount++;
        iprintf("Semaphore posted, consumed by task A\r\n");
        iprintf("    isrCount: %ld\r\n", isrCount);
        iprintf("    taskCount: %ld\r\n\r\n", taskCount);
    }
}

void TertiaryTask( void * pd )
{
    while (1) {
        OSSemPend( &addTaskSem, 0 );
        addTaskCount++;
        iprintf("Semaphore posted, consumed by task B\r\n");
        iprintf("    isrCount: %ld\r\n", isrCount);
        iprintf("    addTaskCount: %ld\r\n\r\n", addTaskCount);
    }
}

void UserMain(void * pd)
{
    InitializeStack();/* Setup the TCP/IP stack buffers etc.. */

    GetDHCPAddressIfNecessary();/*Get a DHCP address if needed*/
    /*You may want to add a check for the return value from this function*/
    /*See the function definition in  \nburn\include\dhcpclient.h*/

    OSChangePrio(MAIN_PRIO);/* Change our priority from highest to something in the middle */

    EnableAutoUpdate();/* Enable the ability to update code over the network */

    StartHTTP();/* Start the web serrver */

    OSSemInit( &taskSem, 0 );
    OSSemInit( &addTaskSem, 0 );

    OSSimpleTaskCreatewName( SecondaryTask, MAIN_PRIO - 2, "Secondary Task" );
    OSSimpleTaskCreatewName( TertiaryTask, MAIN_PRIO - 1, "Tertiary Task" );

    iprintf("Application started\n");

    InitPit();
    while (1)
    {
        OSTimeDly(TICKS_PER_SECOND / 2);
        if (charavail()) {
            getchar();
            taskToPost = !taskToPost;
        }
    }
}

Code: Select all

Timer *myTimer;

void mySemaphorePoster()
{
	//post semaphore
}

void main()
{
	bool callRepeatedly = true;
	myTimer = new Timer(mySemaphorePoster);
	myTimer->Start(1000, callRepeatedly);
}

Code: Select all

struct Function
{
	void ( *function )();
};

struct OneShotTimerElement
{
	unsigned long timeOffset;
	std::list<Function> functionList;
	std::list<BackgroundTimer *> timerList;
};

std::list<OneShotTimerElement> OneShotTimerList;

void TimerExpired(BackgroundTimer *timer)
{
	if(timer->numRunningTimers-- == 1 && !timer->canceled)
	{
		switch(timer->executionLocation)
		{
		case EXECUTE_INTERRUPT:
			timer->function();
			break;

// This references a special task of mine that you won't have
//		case EXECUTE_MISC:
//			QueueFunction(timer->function);
//			break;
		default:
			break;
		}

		if(timer->continuous)
		{
			timer->Start(timer->timeLimit);
		}
		else
		{
			if(timer->selfDestruct)
			{
				delete timer;
			}
		}
	}
}

void CheckOneShotTimers()
{
	if(OneShotTimerList.size())
	{
		//if a time offset of 0 somehow gets in the list, this might be bad, but it would only happen if they specified a time of 0
		if(!(--OneShotTimerList.front().timeOffset))
		{
			std::list<BackgroundTimer *>::iterator iter;
			iter = OneShotTimerList.front().timerList.begin();

			//call all the functions in the list
			while(iter != OneShotTimerList.front().timerList.end())
			{
				TimerExpired(*iter);//->function();
				iter++;
			}

			OneShotTimerList.pop_front();
		}
	}
}

char NewOneShotTimer(BackgroundTimer *timer, unsigned long ms)
{
	if(!functionTimerInitialized)
	{
		return false;
	}

	if(OneShotTimerList.size())
	{
		std::list<OneShotTimerElement>::iterator iter;
		iter = OneShotTimerList.begin();
		while(iter != OneShotTimerList.end())
		{
			if(iter->timeOffset == ms)
			{
				iter->timerList.push_back(timer);
				return true;
			}
			if(ms > iter->timeOffset)
			{
				ms -= iter->timeOffset;//the offset times are cumulative
				iter++;
			}
			else
			{
				OneShotTimerElement element;
				element.timerList.push_back(timer);
				element.timeOffset = ms;
				OneShotTimerList.insert(iter, element);

				iter->timeOffset -= ms;//adjust the next timer
				return true;
			}
		}
		//if we hit here it was bigger than all other remaining timers, put it at the end
	}

	OneShotTimerElement element;
	element.timerList.push_back(timer);
	element.timeOffset = ms;
	OneShotTimerList.push_back(element);
	return true;
}

Code: Select all

#ifndef _TIMERS_H_
#define _TIMERS_H_

#include <nbtime.h>

#define EXECUTE_INTERRUPT 0
#define EXECUTE_MISC 1

class BackgroundTimer;

char NewOneShotTimer(BackgroundTimer *timer, unsigned long ms);

//background timer
class BackgroundTimer
{

public:
	bool canceled;
//	time_t startTime;
	unsigned int timeLimit;//in ms
	unsigned int numRunningTimers;
	bool continuous;
	bool selfDestruct;
	void ( *function )();
	char executionLocation;//run in interrupt or misc task
//	BackgroundTimer() {selfDestruct = false; canceled = false; numRunningTimers = 0;}
	BackgroundTimer(void ( *func )(), bool repeat = false, char execLocation = EXECUTE_INTERRUPT)
	{
		selfDestruct = false;
		executionLocation = execLocation;
		canceled = false;
		numRunningTimers = 0;
		function = func;
		continuous = repeat;
	}
	void Cancel() {canceled = true;}
	void SetSelfDestruct(bool destroy) {selfDestruct = destroy;}
	void Start(unsigned int msec)
	{
//		startTime = time(NULL);
		timeLimit = msec;

		//queue timer
		if(NewOneShotTimer(this, msec))
		{
			numRunningTimers++;
			canceled = false;
		}
	}
};




//don't initialize in an interrupt
//don't set new function in interrupt
class Timer
{
	BackgroundTimer *bgTimer;

public:
	Timer() {bgTimer = 0;}
	Timer(void ( *func )(), bool repeat = false, char execLocation = EXECUTE_INTERRUPT)
	{
		if(!InInterrupt())
		{
			bgTimer = new BackgroundTimer(func, repeat, execLocation);
		}
		else
		{
			//can't create timer in interrupt
			bgTimer = 0;
		}
	}
	~Timer()
	{
		if(bgTimer)
		{
			if(bgTimer->numRunningTimers)
			{
				bgTimer->SetSelfDestruct(true);
				bgTimer->Cancel();
			}
			else
			{
				delete bgTimer;
			}
		}
	}
	void SetFunction(void ( *func )(), bool repeat = false, char execLocation = EXECUTE_INTERRUPT)
	{
		if(bgTimer)
		{
			bgTimer->SetSelfDestruct(true);
			bgTimer->Cancel();
		}

		bgTimer = new BackgroundTimer(func, repeat, execLocation);
		/*if(!InInterrupt()) //this references my interrupt file, just don't create a timer inside an interrupt
		{
			bgTimer = new BackgroundTimer(func, repeat, execLocation);
		}
		else
		{
			//can't create timer in interrupt
			bgTimer = 0;
		}*/
	}
	void Start(unsigned int msec, bool repeat = false) {if(bgTimer) {bgTimer->continuous = repeat; bgTimer->Start(msec);}}
	void Stop() {if(bgTimer) {bgTimer->Cancel();}}

};

char OneShotTimer(void ( *function )(), unsigned long ms);
void CheckOneShotTimers();

#endif

Code: Select all

//	if (OSTaskCreate(PostTo_MySemaphore_Task,
//					(void*) MyData,	//or NULL to not pass in data
//					(void*) &PostTo_MySemaphore_TaskStk[USER_TASK_STK_SIZE],
//					(void*) PostTo_MySemaphore_TaskStk, PRIO_FOR_POST_TO_MYSEMAPHORE_TASK)
//		!= OS_NO_ERR) { // Handle error

Code: Select all

#include......


OS_SEM PollTimer;

...
...
INTERRUPT(exPitISR, 0x2400)
{
	sim2.pit[1].pcsr |= 0x0004;  											// clear the PIT IRQ flag
	OSSemPost(&PollTimer);													// post semaphore for DataPoll() routine
}

void InitPIT()
{
    SETUP_PIT1_ISR( exPitISR, 4 );											// setup PIT to trigger ISR
    sim2.pit[1].pmr = 61035; 												// set count
    sim2.pit[1].pcsr = 0x0C1B; 												// set prescale = 4096, rld, and enable
}

void DataPoll()
{
	while (1)

		OSSemPend( &PollTimer, 0);
		sys_poll();
		// reset CWT
		sim2.scm.cwsr = 0x55;
		sim2.scm.cwsr = 0xAA;
		iprintf("ISR Complete. \r\n");
	}
}

void UserMain(void*pd)
{
...
...
    OSSemInit( &PollTimer, 0 );												// Initialize semaphore

    OSSimpleTaskCreatewName(DataPoll, MAIN_PRIO -2, "Timed Data Poll");		// create task with higher priority than main and UDPReaderMain 

    InitPIT();

    while(1)
   {
   ...
   }

}

Code: Select all

 OSSimpleTaskCreatewName(DataPoll, MAIN_PRIO -2, "Timed Data Poll");