// ARTK kernel.cpp

// A pre-emptive multitasking kernel for Arduino

//

// History:

// Release 0.1 June 2012 Paul H. Schimpf

// Release 0.2 June 2012 Paul H. Schimpf

// Some changes to squeeze out bits of memory

// Release 0.3 Moved cli() to top of sema wait routine, as a

// higher priority waker could preempt while count

// is being checked

//

// Acknowledgement:

// Thank you to Raymond J. A. Buhr and Donald L. Bailey for inspiration

// and ideas from "An Introduction to Real-Time Systems." While there are

// significant differences, there are also similarities in the structure

// and implementation of ARTK and Tempo.

/******* License ***********************************************************

This file is part of ARTK - Arduino Real-Time Kernel

ARTK is free software: you can redistribute it and/or modify

it under the terms of the GNU General Public License as published by

the Free Software Foundation, either version 3 of the License, or

(at your option) any later version.

ARTK is distributed in the hope that it will be useful,

but WITHOUT ANY WARRANTY; without even the implied warranty of

MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

GNU General Public License for more details.

You should have received a copy of the GNU General Public License

along with ARTK. If not, see <http://www.gnu.org/licenses/>.

****************************************************************************/

// Usage Notes:

// ARTK makes use of the Arduino TimerOne library, which is distributed with it.

// You must NOT implement a setup() function

// Implement a Setup() function instead - ARTK will call it for you

// You must NOT implement a loop() function

// Implement a Main() function instead, which will be the lowest priority task

// See the file ARTKtest.ino for example usage

#include <stdarg.h> // for va_xxx

#include <stdio.h> // for vsnprintf

#include <Arduino.h> // for Serial

#include <TimerOne.h>

#include <kernel.h>

// -----------------------------------------------------------------

// globals

const char *release = "0.3_custom" ;

const int year = 2014 ;

int glargeModel = FALSE ;

int gtimerUsec = TIMER_USEC ;

unsigned char *glastSP = 0 ;

Scheduler *Scheduler::InstancePtr = 0 ;

DQNodeManager *DQNodeManager::instPtr = 0;

TaskManager *TaskManager::instPtr = 0;

//----------------------------------------------------------------

// Doubly-linked list manipulation

// also known as addLast

void DNode::insertBefore(DNode *pLink)

}

// also known as removeFront

DNode *DNode::removeNext()

{

DNode *pLink ;

if (isEmpty()) return NULL ;

pLink = pNext ;

pNext = pLink->pNext ;

pLink->pNext->pPrev = this ;

// self reference of both is important for remove() to be safe

pLink->pPrev = pLink ;

pLink->pNext = pLink ;

return (pLink) ;

}

void DNode::remove()

}

//--------------------------------------------------------------------

// Sleep Queue

// The Sleep Queue is sorted singly linked list of DQNode (Delta Queue Node)

// These are sorted in increasing order and keep track of the tick counts remaining

// The counts remaining for a particular entry is the sum off all dcounts

// up to and including that entry

void DQNodeManager::Instance() {

}

DQNode *DQNodeManager::getFreeDQNode() {

unsigned char i;

for (i = 0; i < MAX_THREAD_LIST; i++) {

if (!DQList[i].inUse) {

DQList[i].inUse = !DQList[i].inUse;

return &DQList[i];

}

}

return NULL;

}

void DQNodeManager::releaseDQNode(DQNode *addr) {

}

DQNode *pSleepHead = NULL ;

// add a task to sleep q in sorted position

void addSleeper(Task *pTask, unsigned int count)

}

// If the count of the first task on the sleep queue is 0 then remove it

Task *removeWaker()

{

Task *pTask ;

DQNode *pTemp ;

pTask = NULL ;

if ( (pSleepHead != NULL) && (pSleepHead->dcount == 0) )

{

pTemp = pSleepHead ;

pSleepHead = pTemp->pNext ;

pTask = pTemp->pTask ;

DQNodeManager::instPtr->releaseDQNode(pTemp);

}

return pTask ;

}

// Decrements the counter of the first node in the sleep queue

void sleepDecrement()

}

// search for a task and remove it from the sleep queue

void removeSleeper(Task *pTask)

}

//-------------------------------------------------------------

// Scheduler

//

Scheduler::Scheduler()

}

/****

// got rid of this extra layer by making stack member public (so shoot me)

int Scheduler::stackLeft()

{

return ((unsigned char *)(SP)-activeTask->stack) ;

}

****/

// called when a new task is created

char Scheduler::addNewTask(Task *t)

}

// reduce the count of active tasks by one

void Scheduler::removeTask()

}

// Selects the next task and performs a context switch

void Scheduler::resched()

}

// Called by a task when it is ready to yield

void Scheduler::relinquish()

}

// Creates an instance of the scheduler only if none exists

void Scheduler::Instance()

}

void Scheduler::startMultiTasking()

}

// Constructor for class Task

/*Task::Task(void (*rootFnPtr)(), uint8_t taskPriority, unsigned stackSize) : mylink()

{

rootFn = rootFnPtr ;

inUse = FALSE;

//Printf("stack at %d\n", stack) ;

//stack = (unsigned char *) new char[stackSize] ;

//char *goo = new char[10] ;

//stack = (unsigned char *) goo ;

firstRun = TRUE ;

pStack = &stack[stackSize-1] ;

// Initialize the stack so that the root function

// for this task returns to taskDone().

*pStack-- = (unsigned char)((long)Task::taskDone & 0x00ff) ;

*pStack-- = (unsigned char)(((long)Task::taskDone >> 8) & 0x00ff) ;

if (glargeModel)

*pStack-- = (unsigned char)(((long)Task::taskDone >> 16) & 0x00ff) ;

// next put the entry function on the stack so we return to it after

// returning from a context switch

*pStack-- = (unsigned char)((long)rootFnPtr & 0x00ff) ;

*pStack-- = (unsigned char)(((long)rootFnPtr >> 8) & 0x00ff) ;

if (glargeModel)

*pStack-- = (unsigned char)(((long)rootFnPtr >> 16) & 0x00ff) ;

// what goes next on the stack are 32 registers and SREG = 33

// for (int i=0 ; i <33 ; i++) *pStack-- = 0 ;

priority = taskPriority ;

// Ask the scheduler to add this task to the ready list

Scheduler::InstancePtr->addNewTask(this) ;

/****

Printf("Initialized Process Descriptor Table for:\n") ;

Printf("SP=%x, IP=%x\n", pStack, rootFnPtr) ;

//Printf("Stack Dump:\n") ;

//unsigned char *temp = &stack[stackSize-1] ;

//while (temp>=pStack) Printf("%hhx ", *temp--) ;

//Printf("\n") ;

****/

//}

Task::Task() {

}

// When the root function for a task returns, it executes

// this function.

void Task::taskDone()

}

// the calling task is put to sleep for cnt ticks of the system timer

void Task::task_sleep(unsigned int cnt)

}

void Task::PushScheduler() {

}

void TaskManager::Instance() {

}

Task* TaskManager::getFreeTask() {

unsigned char i;

for (i = 0; i < MAX_THREAD_LIST; i++) {

if (!listTask[i].inUse) {

listTask[i].inUse = !listTask[i].inUse;

return &listTask[i];

}

}

return NULL;

}

void TaskManager::releaseTask(Task *addr) {

}

void timerISR()

}

//--------------------------------------------------------------------------

// Semaphore Class

/*Semaphore::Semaphore(int initialCount) : taskList()

{

count = initialCount ;

}

void Semaphore::wait()

{

cli() ; // no preempt while check and possibly modify count

// if available, give it and return

if (count > 0)

{

count-- ;

sei() ;

}

else

{

// block the caller

Task* active = Scheduler::InstancePtr->activeTask ;

active->makeTaskBlocked() ;

// move the active task to this semaphore queue

taskList.addLast(&active->mylink) ;

Scheduler::InstancePtr->resched() ; // this call reenables

}

}

int Semaphore::wait(unsigned int timeout)

{

// set the task status to not timed out (yet)

Task *active = Scheduler::InstancePtr->activeTask ;

active->timedOut = FALSE ;

cli() ; // no preempt while check and possibly modify count

// if available, give it and return

if (count>0)

{

count-- ;

return ACQUIRED_SEMA ;

}

// if specified a 0 wait can return now

if (timeout == 0) {

sei() ;

return TIMED_OUT ;

}

// otherwise, this task needs to sleep until either timeout

// or this semaphore is signaled

// cli() ; // to keep sleepq and sematimedblocked consistent

// add the calling task to the sleep queue

addSleeper(active, timeout) ;

// move the calling task to the semaphore queue and context switch

active->makeTaskSemaphoreTimedBlocked() ;

taskList.addLast(&active->mylink) ;

Scheduler::InstancePtr->resched() ; // this call will reenable

// the calling task returns here after being swapped back in

// it is now the active task again, so check to see if its timed out flag

// was set by the timerISR at some point

if (active->timedOut)

return TIMED_OUT ;

return ACQUIRED_SEMA ;

}

void Semaphore::signal()

{

Task *t ;

// an ISR can call this, so make sure we don't allow that to happen

// while a task is inside

cli() ;

count++ ; // increment the semaphore count

// Remove the task at the front of this semaphore queue

if (!taskList.isEmpty())

{

count-- ;

t = (Task *)taskList.removeFront() ;

// It may have been flagged with a timeout and not swapped in yet,

// so in that event we override the timedout flag so it knows it

// now has the semaphore when it swaps back in

t->timedOut = FALSE ;

// If the task is still in a timed wait remove it from the sleep q

if (t->myState() == SEM_TIMED_BLOCKED) removeSleeper(t) ;

// the task is now ready to run

t->makeTaskReady() ;

Scheduler::InstancePtr->addready(t) ;

// if the waiting task is higher priority, reschedule

if (t->priority > Scheduler::InstancePtr->activeTask->priority)

{

Scheduler::InstancePtr->activeTask->makeTaskReady() ;

Scheduler::InstancePtr->addready(Scheduler::InstancePtr->activeTask) ;

Scheduler::InstancePtr->resched() ;

}

}

sei() ; // can allow an ISR in now

}*/

//--------------------------------------------------------------------------

// User-accessible constructs

//Semaphore *ARTK_mutex ; // used by the CS macro

// extern void Idle() ;

void Idle()

}

Task *ARTK_CreateTask(void (*rootFnPtr)(), unsigned stacksize)

{

Task *task = TaskManager::instPtr->getFreeTask();

//Printf("Get %d task\n", task);

if (rootFnPtr==Idle) {

task->setFunction(rootFnPtr);

//task->setPriority(0);

task->PushScheduler();

}

else {

task->setFunction(rootFnPtr);

task->PushScheduler();

}

return task ;

}

void ARTK_TerminateMultitasking()

}

/*Semaphore *ARTK_CreateSema(int initial_count)

{

Semaphore *s;

s = new Semaphore(initial_count);

return s;

}*/

void ARTK_SetOptions(int iLargeModel, int iTimerUsec)

}

// like printf - to the Arduino Serial Monitor

void Printf(char *fmt, ... )

}

//-------------------------------------------------------------------------

// Main and Idle tasks, startup functions

extern void Setup() ;

void setup()

}

void loop()

{

//Printf("Something is wrong\n") ;

}