File content as of revision 0:331db0b44b67:
//******************************************************************************
//*
//* FULLNAME: Single-Chip Microcontroller Real-Time Operating System
//*
//* NICKNAME: scmRTOS
//*
//* PURPOSE: OS Kernel Header. Declarations And Definitions
//*
//* Version: 3.10
//*
//* $Revision: 256 $
//* $Date:: 2010-01-22 #$
//*
//* Copyright (c) 2003-2010, Harry E. Zhurov
//*
//* Permission is hereby granted, free of charge, to any person
//* obtaining a copy of this software and associated documentation
//* files (the "Software"), to deal in the Software without restriction,
//* including without limitation the rights to use, copy, modify, merge,
//* publish, distribute, sublicense, and/or sell copies of the Software,
//* and to permit persons to whom the Software is furnished to do so,
//* subject to the following conditions:
//*
//* The above copyright notice and this permission notice shall be included
//* in all copies or substantial portions of the Software.
//*
//* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
//* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
//* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
//* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
//* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
//* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH
//* THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
//*
//* =================================================================
//* See http://scmrtos.sourceforge.net for documentation, latest
//* information, license and contact details.
//* =================================================================
//*
//*****************************************************************************
#ifndef OS_KERNEL_H
#define OS_KERNEL_H
#include <stddef.h>
#include <commdefs.h>
#include <usrlib.h>
//------------------------------------------------------------------------------
//==============================================================================
extern "C" void OS_Start(TStackItem* sp);
#if scmRTOS_CONTEXT_SWITCH_SCHEME == 0
extern "C" void OS_ContextSwitcher(TStackItem** Curr_SP, TStackItem* Next_SP);
#else
extern "C" TStackItem* OS_ContextSwitchHook(TStackItem* sp);
#endif
//==============================================================================
//------------------------------------------------------------------------------
//
//
// NAME : OS
//
// PURPOSE : Namespace for all OS stuff
//
// DESCRIPTION: Includes: Kernel,
// Processes,
// Mutexes,
// Event Flags,
// Byte-wide Channels,
// Arbitrary-type Channels,
// Messages
//
namespace OS
{
class TBaseProcess;
INLINE inline void SetPrioTag(TProcessMap& pm, const TProcessMap PrioTag) { pm |= PrioTag; }
INLINE inline void ClrPrioTag(TProcessMap& pm, const TProcessMap PrioTag) { pm &= ~PrioTag; }
//--------------------------------------------------------------------------
//
// NAME : TKernel
//
/// Implements kernel-level operations such as
/// process management, process-level scheduling,
/// ISR-level scheduling, system timing.
//
// DESCRIPTION:
//
//
class TKernel
{
//-----------------------------------------------------------
//
// Declarations
//
friend class TISRW;
friend class TISRW_SS;
friend class TBaseProcess;
friend class TMutex;
friend class TEventFlag;
friend class TChannel;
friend class TBaseMessage;
template<typename T, word size, class S> friend class channel;
template<typename T> friend class message;
friend void Run();
friend void WakeUpProcess(TBaseProcess& p);
friend void ForceWakeUpProcess(TBaseProcess& p);
friend inline bool IsProcessSleeping(const TBaseProcess& p);
friend inline bool IsProcessSuspended(const TBaseProcess& p);
friend inline dword GetTickCount();
//-----------------------------------------------------------
//
// Data
//
private:
byte CurProcPriority;
TProcessMap ReadyProcessMap;
TBaseProcess* ProcessTable[scmRTOS_PROCESS_COUNT+1];
volatile byte ISR_NestCount;
#if scmRTOS_CONTEXT_SWITCH_SCHEME == 1
byte SchedProcPriority;
#endif
#if scmRTOS_SYSTEM_TICKS_ENABLE == 1
volatile dword SysTickCount;
#endif
//-----------------------------------------------------------
//
// Functions
//
public:
INLINE TKernel()
: CurProcPriority(pr0)
, ReadyProcessMap( (1 << (scmRTOS_PROCESS_COUNT + 1)) - 1) // set all processes ready
, ISR_NestCount(0)
{
}
private:
INLINE inline void RegisterProcess(TBaseProcess* const p);
void Sched();
INLINE void Scheduler() { if(ISR_NestCount) return; else Sched(); }
INLINE inline void SchedISR();
#if scmRTOS_CONTEXT_SWITCH_SCHEME == 1
INLINE inline bool IsContextSwitchDone() const volatile;
#endif
INLINE void SetProcessReady (const byte pr) { TProcessMap PrioTag = GetPrioTag(pr); SetPrioTag( ReadyProcessMap, PrioTag); }
INLINE void SetProcessUnready(const byte pr) { TProcessMap PrioTag = GetPrioTag(pr); ClrPrioTag( ReadyProcessMap, PrioTag); }
public:
INLINE inline void SystemTimer();
#if scmRTOS_CONTEXT_SWITCH_SCHEME == 1
INLINE inline TStackItem* ContextSwitchHook(TStackItem* sp);
#endif
}; // End of TKernel class definition
//--------------------------------------------------------------------------
extern TKernel Kernel;
//--------------------------------------------------------------------------
//
/// BaseProcess
///
/// Implements base class-type for application processes
//
// DESCRIPTION:
//
//
class TBaseProcess
{
friend class TKernel;
friend class TISRW;
friend class TISRW_SS;
friend class TEventFlag;
friend class TMutex;
friend class TBaseMessage;
template<typename T, word size, class S> friend class channel;
template<typename T> friend class message;
friend void Run();
friend void WakeUpProcess(TBaseProcess& p);
friend void ForceWakeUpProcess(TBaseProcess& p);
friend bool IsProcessSleeping(const TBaseProcess& p);
friend bool IsProcessSuspended(const TBaseProcess& p);
public:
#if SEPARATE_RETURN_STACK == 0
TBaseProcess( TStackItem* Stack, word stack_size, TPriority pr, void (*exec)() );
#else
TBaseProcess( TStackItem* Stack, TStackItem* RStack, TPriority pr, void (*exec)() );
#endif
static void Sleep(TTimeout timeout = 0);
protected:
TStackItem* StackPointer;
word StackSize;
TTimeout Timeout;
TPriority Priority;
};
//--------------------------------------------------------------------------
//--------------------------------------------------------------------------
//
/// process
///
/// Implements template for application processes instantiation
//
// DESCRIPTION:
//
//
#if SEPARATE_RETURN_STACK == 0
template<TPriority pr, word stack_size>
class process : public TBaseProcess
{
public:
INLINE_PROCESS_CTOR process();
#ifdef DEBUG_STACK
word UsedStackSize();
#endif //DEBUG_STACK
OS_PROCESS static void Exec();
private:
TStackItem Stack[stack_size/sizeof(TStackItem)];
};
template<TPriority pr, word stack_size>
OS::process<pr, stack_size>::process() : TBaseProcess( &Stack[stack_size/sizeof(TStackItem)]
, stack_size // debug
, pr
, reinterpret_cast<void (*)()>(Exec) )
{
}
#ifdef DEBUG_STACK
template<TPriority pr, word stack_size>
word process<pr,stack_size>::UsedStackSize()
{
TStackItem* Idx = Stack;
while(*(Idx++) == STACK_FILL_CONST);
return ((Stack + (StackSize/sizeof(TStackItem))) - Idx)*sizeof(TStackItem);
}
#endif //DEBUG_STACK
#else
template<TPriority pr, word stack_size, word rstack_size>
class process : public TBaseProcess
{
public:
INLINE_PROCESS_CTOR process();
OS_PROCESS static void Exec();
private:
TStackItem Stack [stack_size/sizeof(TStackItem)];
TStackItem RStack[rstack_size/sizeof(TStackItem)];
};
template<TPriority pr, word stack_size, word rstack_size>
process<pr, stack_size, rstack_size>::process() : TBaseProcess( &Stack[stack_size/sizeof(TStackItem)]
, &RStack[rstack_size/sizeof(TStackItem)]
, pr
, reinterpret_cast<void (*)()>(Exec))
{
}
#endif
//--------------------------------------------------------------------------
//--------------------------------------------------------------------------
//
// Miscellaneous
//
//
INLINE inline void Run();
INLINE inline void LockSystemTimer() { TCritSect cs; LOCK_SYSTEM_TIMER(); }
INLINE inline void UnlockSystemTimer() { TCritSect cs; UNLOCK_SYSTEM_TIMER(); }
void WakeUpProcess(TBaseProcess& p);
void ForceWakeUpProcess(TBaseProcess& p);
INLINE inline void Sleep(TTimeout t = 0) { TBaseProcess::Sleep(t); }
INLINE inline bool IsProcessSleeping(const TBaseProcess& p)
{
TCritSect cs;
if(p.Timeout)
return true;
else
return false;
}
INLINE inline bool IsProcessSuspended(const TBaseProcess& p)
{
TCritSect cs;
if(Kernel.ReadyProcessMap & GetPrioTag(p.Priority))
return false;
else
return true;
}
//--------------------------------------------------------------------------
#if scmRTOS_SYSTEM_TICKS_ENABLE == 1
INLINE inline dword GetTickCount() { TCritSect cs; return Kernel.SysTickCount; }
#endif
#if scmRTOS_SYSTIMER_HOOK_ENABLE == 1
INLINE_SYS_TIMER_HOOK void SystemTimerUserHook();
#endif
#if scmRTOS_CONTEXT_SWITCH_USER_HOOK_ENABLE == 1
INLINE_CONTEXT_SWITCH_HOOK void ContextSwitchUserHook();
#endif
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
//
/// Register Process
///
/// Places pointer to process in kernel's process table
//
void OS::TKernel::RegisterProcess(OS::TBaseProcess* const p)
{
ProcessTable[p->Priority] = p;
}
//------------------------------------------------------------------------------
//
/// System Timer Implementation
///
/// Performs process's timeouts checking and
/// moving processes to ready-to-run state
//
void OS::TKernel::SystemTimer()
{
SYS_TIMER_CRIT_SECT();
#if scmRTOS_SYSTEM_TICKS_ENABLE == 1
SysTickCount++;
#endif
#if scmRTOS_PRIORITY_ORDER == 0
const byte BaseIndex = 0;
#else
const byte BaseIndex = 1;
#endif
for(byte i = BaseIndex; i < (scmRTOS_PROCESS_COUNT + BaseIndex); i++)
{
TBaseProcess* p = ProcessTable[i];
if(p->Timeout > 0)
{
if(--p->Timeout == 0)
{
SetProcessReady(p->Priority);
}
}
}
}
//------------------------------------------------------------------------------
//
/// ISR optimized scheduler
///
/// !!! IMPORTANT: This function must be call from ISR services only !!!
//
//
#if scmRTOS_CONTEXT_SWITCH_SCHEME == 0
void OS::TKernel::SchedISR()
{
byte NextPrty = GetHighPriority(ReadyProcessMap);
if(NextPrty != CurProcPriority)
{
TStackItem* Next_SP = ProcessTable[NextPrty]->StackPointer;
TStackItem** Curr_SP_addr = &(ProcessTable[CurProcPriority]->StackPointer);
CurProcPriority = NextPrty;
OS_ContextSwitcher(Curr_SP_addr, Next_SP);
}
}
#else
void OS::TKernel::SchedISR()
{
byte NextPrty = GetHighPriority(ReadyProcessMap);
if(NextPrty != CurProcPriority)
{
SchedProcPriority = NextPrty;
RaiseContextSwitch();
}
}
//------------------------------------------------------------------------------
bool OS::TKernel::IsContextSwitchDone() const volatile
{
byte cur = CurProcPriority; ///< reading to temporary vars is performed due to
byte sched = SchedProcPriority; ///< suppress warning about order of volatile access
return cur == sched;
}
//------------------------------------------------------------------------------
TStackItem* OS::TKernel::ContextSwitchHook(TStackItem* sp)
{
ProcessTable[CurProcPriority]->StackPointer = sp;
sp = ProcessTable[SchedProcPriority]->StackPointer;
#if scmRTOS_CONTEXT_SWITCH_USER_HOOK_ENABLE == 1
ContextSwitchUserHook();
#endif
CurProcPriority = SchedProcPriority;
return sp;
}
//------------------------------------------------------------------------------
#endif // scmRTOS_CONTEXT_SWITCH_SCHEME
//-----------------------------------------------------------------------------
/// Start Operation
INLINE inline void OS::Run()
{
TStackItem* sp = Kernel.ProcessTable[pr0]->StackPointer;
OS_Start(sp);
}
#include <OS_Services.h>
#endif // OS_KERNEL_H
Daniel Peter