Dependencies:   keypad SDHCFileSystem mbed FPointer wave_player

Files at this revision

API Documentation at this revision

Comitter:
daryl2110
Date:
Mon Feb 20 07:36:06 2012 +0000
Commit message:

Changed in this revision

FATFileSystem.lib Show annotated file Show diff for this revision Revisions of this file
FPointer.lib Show annotated file Show diff for this revision Revisions of this file
SDHCFileSystem.lib Show annotated file Show diff for this revision Revisions of this file
keypad.lib Show annotated file Show diff for this revision Revisions of this file
main.cpp Show annotated file Show diff for this revision Revisions of this file
mbed.bld Show annotated file Show diff for this revision Revisions of this file
scmRTOS/Common/OS_Kernel.cpp Show annotated file Show diff for this revision Revisions of this file
scmRTOS/Common/OS_Kernel.h Show annotated file Show diff for this revision Revisions of this file
scmRTOS/Common/OS_Services.cpp Show annotated file Show diff for this revision Revisions of this file
scmRTOS/Common/OS_Services.h Show annotated file Show diff for this revision Revisions of this file
scmRTOS/Common/scmRTOS.h Show annotated file Show diff for this revision Revisions of this file
scmRTOS/Common/scmRTOS_defs.h Show annotated file Show diff for this revision Revisions of this file
scmRTOS/Common/usrlib.cpp Show annotated file Show diff for this revision Revisions of this file
scmRTOS/Common/usrlib.h Show annotated file Show diff for this revision Revisions of this file
scmRTOS/CortexM3/OS_Target.h Show annotated file Show diff for this revision Revisions of this file
scmRTOS/CortexM3/OS_Target_asm.s Show annotated file Show diff for this revision Revisions of this file
scmRTOS/CortexM3/OS_Target_cpp.cpp Show annotated file Show diff for this revision Revisions of this file
scmRTOS/CortexM3/commdefs.h Show annotated file Show diff for this revision Revisions of this file
scmRTOS/CortexM3/device.h Show annotated file Show diff for this revision Revisions of this file
scmRTOS/scmRTOS_TARGET_CFG.h Show annotated file Show diff for this revision Revisions of this file
scmRTOS_config.h Show annotated file Show diff for this revision Revisions of this file
wave_player.lib Show annotated file Show diff for this revision Revisions of this file
diff -r 000000000000 -r 879af6e11219 FATFileSystem.lib
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/FATFileSystem.lib	Mon Feb 20 07:36:06 2012 +0000
@@ -0,0 +1,1 @@
+http://mbed.org/users/mbed_unsupported/code/fatfilesystem/
\ No newline at end of file
diff -r 000000000000 -r 879af6e11219 FPointer.lib
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/FPointer.lib	Mon Feb 20 07:36:06 2012 +0000
@@ -0,0 +1,1 @@
+http://mbed.org/users/AjK/code/FPointer/#56e309e76c19
diff -r 000000000000 -r 879af6e11219 SDHCFileSystem.lib
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/SDHCFileSystem.lib	Mon Feb 20 07:36:06 2012 +0000
@@ -0,0 +1,1 @@
+http://mbed.org/users/davervw/code/SDHCFileSystem/#248d03543f5f
diff -r 000000000000 -r 879af6e11219 keypad.lib
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/keypad.lib	Mon Feb 20 07:36:06 2012 +0000
@@ -0,0 +1,1 @@
+http://mbed.org/users/yoonghm/code/keypad/#e48ba5b4c497
diff -r 000000000000 -r 879af6e11219 main.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/main.cpp	Mon Feb 20 07:36:06 2012 +0000
@@ -0,0 +1,207 @@
+#include "mbed.h"
+#include "scmRTOS.h"
+#include "wave_player.h"
+#include "SDHCFileSystem.h"
+#include "keypad.h"
+
+BusOut     SevenSegments(p21, p22, p23, p24, p25, p26, p27);
+BusOut     Leds(p28, p29, p30);
+Keypad     keypad(p15, p14, p13, p12, p20, p19, p17, p16);
+
+Serial          xbee(p9, p10);
+DigitalOut      rst1(p11);
+SDFileSystem    sd(p5, p6, p7, p8, "sd");
+AnalogOut       AudioOut(p18);
+wave_player     waver(&AudioOut);
+
+
+#define  MAXBUS     2
+#define  MAXLEN     4
+#define  ENDKEYIX  14
+char     BusNumber[MAXBUS][MAXLEN];
+char     BusInput[MAXLEN];
+volatile char     BusDisplay[MAXLEN]; // Updated by ISR?? for 7-segment LED refresh
+char     Keytable[] = { 0x30, 0x6D, 0x79, 0x00,
+                        0x33, 0x5B, 0x5F, 0x00,
+                        0x70, 0xFF, 0x7B, 0x00,
+                        0x00, 0x75, 0x00, 0x00
+                      };
+
+
+int req;
+/*
+ * ISR to update completed bus number input into BusNumer[][]
+ */
+uint32_t cbAfterInput(uint32_t keyIX) {
+    bool     finish = false;
+    static int NumIX = 0;    // Point to current index of Bus number
+
+    if (NumIX < MAXLEN - 1) {
+        if (keyIX != ENDKEYIX) {
+            BusInput[NumIX] = Keytable[keyIX];
+            //printf("Entered = %02X\n", BusInput[NumIX]);
+            NumIX++;
+        } else {
+            finish = true;
+        }
+    }
+
+    if (finish || NumIX == MAXLEN - 1) {
+        int i;
+        for (i = 0; i < MAXBUS; i++) {
+            if ( (BusNumber[i][0] == 0)) {
+                memcpy((void *) &BusNumber[i][0], &BusInput[0], 3);
+                printf("Entered %02X%02X%02X\n",
+                       BusNumber[i][0], BusNumber[i][1], BusNumber[i][2]);
+                break;
+            }
+        }
+        if (i == MAXBUS -1)
+            printf("BusNumber buffer is full\n");
+
+        NumIX = 0;
+    }
+    return 0;
+}
+
+/*
+ * Update a bus number into BusDisplay for 7-segment LED
+ */
+void Refresh7SegmentLedISR() {
+    if (BusDisplay[0] != 0) {
+        printf("BusDisplay %02X%02X%02X\n",
+               BusDisplay[0],BusDisplay[1],BusDisplay[2]);
+        for (int i = 0; i< MAXLEN-1; i++) {
+            Leds = 0x01 << i;
+            SevenSegments = BusDisplay[i];
+            wait_ms(50); // Change to Sleep(20000) in RTOS
+        }
+    }
+}
+
+void UpdateBusDisplayISR() {
+    static  int BusIX = -1;
+
+    BusIX = ++BusIX % MAXBUS;
+
+    if (BusNumber[BusIX][0] != 0)
+        memcpy((void *)BusDisplay, BusNumber[BusIX], MAXLEN);
+}
+
+
+Ticker   UpdateBusDisplay;
+Ticker   Refresh7SegmentLed;
+
+//---------------------------------------------------------------------------
+//
+//      Process types
+//
+typedef OS::process<OS::pr0, 5000> TProc1;
+typedef OS::process<OS::pr1, 3000> TProc2;
+typedef OS::process<OS::pr2, 3000> TProc3;
+
+//---------------------------------------------------------------------------
+//
+//      Process objects
+//
+TProc1 Proc1;
+TProc2 Proc2;
+TProc3 Proc3;
+
+//---------------------------------------------------------------------------
+//
+//      IO Pins
+//
+DigitalOut led1(LED1);
+DigitalOut led2(LED2);
+
+//---------------------------------------------------------------------------
+//
+//      Event Flags to test
+//
+OS::TEventFlag XBee;
+
+
+//---------------------------------------------------------------------------
+//
+int main() {
+    // configure IO pins
+    //printf("\nInitialising ...\n");
+    rst1   = 0; //Set reset pin to 0
+    led1  = 0;//Set LED1 to 0
+    led2 = 0;//Set LED2 to 0
+    wait_ms(1);//Wait at least one millisecond
+    rst1   = 1;//Set reset pin to 1
+    wait_ms(1);//Wait another millisecond
+
+    // run
+    OS::Run();
+}
+
+//---------------------------------------------------------------------------
+template<> OS_PROCESS void TProc1::Exec() {
+
+    for (;;) {
+        if (xbee.readable()) {
+            req = xbee.getc();
+            //printf("req = %c\n", req);
+            XBee.SignalISR();
+            Sleep(2000);
+        }
+    }
+}
+
+//---------------------------------------------------------------------------
+template<> OS_PROCESS void TProc2::Exec() {
+    for (;;) {
+        XBee.Wait();
+        if (req == 'r') {
+            //printf("Came here 2 \n");
+            FILE *fp = fopen("/sd/wf/Bus.wav","r");
+            waver.play(fp);
+            //printf("playing");
+            fseek(fp, 0, SEEK_SET);
+            fclose(fp);
+            FILE *fp1 = fopen("/sd/wf/30.wav","r");
+            waver.play(fp1);
+            fseek(fp1, 0, SEEK_SET);
+            fclose(fp1);
+            FILE *fp2 = fopen("/sd/wf/coming.wav","r");
+            waver.play(fp2);
+            fseek(fp2, 0, SEEK_SET);
+            fclose(fp2);
+        }
+    }
+}
+
+//---------------------------------------------------------------------------
+template<> OS_PROCESS void TProc3::Exec() {
+
+    for (;;) {
+        printf("Start\n");
+        UpdateBusDisplay.attach(&UpdateBusDisplayISR, 1.0);
+        Refresh7SegmentLed.attach(&Refresh7SegmentLedISR, 1.3);
+
+        memset((void*)BusNumber, 0, MAXBUS * MAXLEN);
+        memset((void*)BusInput,  0, MAXLEN);
+        memset((void*)BusDisplay, 0, MAXLEN);
+        keypad.CallAfterInput(&cbAfterInput);
+        keypad.Start();
+    }
+}
+/*
+//---------------------------------------------------------------------------
+void OS::SystemTimerUserHook() {
+    static int cnt=0;
+    if (++cnt == 2000) {
+        cnt = 0;
+        led2.write(1);
+
+    }
+}
+*/
+//---------------------------------------------------------------------------
+void OS::IdleProcessUserHook() {
+    __WFI();
+}
+//-----------------------------------------------------------------------------
diff -r 000000000000 -r 879af6e11219 mbed.bld
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/mbed.bld	Mon Feb 20 07:36:06 2012 +0000
@@ -0,0 +1,1 @@
+http://mbed.org/users/mbed_official/code/mbed/builds/e2ac27c8e93e
diff -r 000000000000 -r 879af6e11219 scmRTOS/Common/OS_Kernel.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/scmRTOS/Common/OS_Kernel.cpp	Mon Feb 20 07:36:06 2012 +0000
@@ -0,0 +1,115 @@
+//******************************************************************************
+//*
+//*     FULLNAME:  Single-Chip Microcontroller Real-Time Operating System
+//*
+//*     NICKNAME:  scmRTOS
+//*
+//*     PURPOSE:  OS Kernel Source
+//*
+//*     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.
+//*     =================================================================
+//*
+//******************************************************************************
+
+#include "scmRTOS.h"
+
+using namespace OS;
+//------------------------------------------------------------------------------
+OS::TKernel OS::Kernel;
+
+//------------------------------------------------------------------------------
+#if scmRTOS_CONTEXT_SWITCH_SCHEME == 0
+void TKernel::Sched()
+{
+    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 TKernel::Sched()
+{
+    byte NextPrty = GetHighPriority(ReadyProcessMap);
+    if(NextPrty != CurProcPriority)
+    {
+        SchedProcPriority = NextPrty;
+    
+        RaiseContextSwitch();
+        do
+        {
+            EnableContextSwitch();
+            DUMMY_INSTR();
+            DisableContextSwitch();
+        } 
+        while(!IsContextSwitchDone());
+    }
+}
+//------------------------------------------------------------------------------
+TStackItem* OS_ContextSwitchHook(TStackItem* sp) { return OS::Kernel.ContextSwitchHook(sp); }
+//------------------------------------------------------------------------------
+#endif // scmRTOS_CONTEXT_SWITCH_SCHEME
+//------------------------------------------------------------------------------
+void TBaseProcess::Sleep(TTimeout timeout)
+{
+    TCritSect cs;
+
+    Kernel.ProcessTable[Kernel.CurProcPriority]->Timeout = timeout;
+    Kernel.SetProcessUnready(Kernel.CurProcPriority);
+    Kernel.Scheduler();
+}
+//------------------------------------------------------------------------------
+void OS::WakeUpProcess(TBaseProcess& p)
+{
+    TCritSect cs;
+
+    if(p.Timeout)
+    {
+        p.Timeout = 0;
+        Kernel.SetProcessReady(p.Priority);
+        Kernel.Scheduler();
+    }
+}
+//------------------------------------------------------------------------------
+void OS::ForceWakeUpProcess(TBaseProcess& p)
+{
+    TCritSect cs;
+
+    p.Timeout = 0;
+    Kernel.SetProcessReady(p.Priority);
+    Kernel.Scheduler();
+}
+//------------------------------------------------------------------------------
+
diff -r 000000000000 -r 879af6e11219 scmRTOS/Common/OS_Kernel.h
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/scmRTOS/Common/OS_Kernel.h	Mon Feb 20 07:36:06 2012 +0000
@@ -0,0 +1,426 @@
+//******************************************************************************
+//*
+//*     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, TPriority pr, void (*exec)() );
+    #else
+        TBaseProcess( TStackItem* Stack, TStackItem* RStack, TPriority pr, void (*exec)() );
+    #endif
+
+        static void Sleep(TTimeout timeout = 0);
+
+    protected:
+        TStackItem* StackPointer;
+        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();
+
+            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)]
+                                                              , pr
+                                                              , reinterpret_cast<void (*)()>(Exec) )
+        {
+        }
+
+    #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
+
diff -r 000000000000 -r 879af6e11219 scmRTOS/Common/OS_Services.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/scmRTOS/Common/OS_Services.cpp	Mon Feb 20 07:36:06 2012 +0000
@@ -0,0 +1,298 @@
+//******************************************************************************
+//*
+//*     FULLNAME:  Single-Chip Microcontroller Real-Time Operating System
+//*
+//*     NICKNAME:  scmRTOS
+//*
+//*     PURPOSE:  OS Services Source
+//*
+//*     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.
+//*     =================================================================
+//*
+//******************************************************************************
+
+#include "scmRTOS.h"
+
+using namespace OS;
+
+//------------------------------------------------------------------------------
+//
+//
+//      TEventFlag
+//
+//
+bool OS::TEventFlag::Wait(TTimeout timeout)
+{
+    TCritSect cs;
+
+    if(Value)                                           // if flag already signaled
+    {
+        Value = efOff;                                  // clear flag
+        return true;
+    }
+    else
+    {
+        TBaseProcess* p = Kernel.ProcessTable[Kernel.CurProcPriority];
+        p->Timeout = timeout;
+        TProcessMap PrioTag = GetPrioTag(Kernel.CurProcPriority);
+
+        SetPrioTag(ProcessMap, PrioTag);                // put current process to the wait map
+        ClrPrioTag(Kernel.ReadyProcessMap, PrioTag);    // remove current process from the ready map
+
+        Kernel.Scheduler();
+
+        p->Timeout = 0;
+
+        if( !(ProcessMap & PrioTag) )                   // if waked up by signal() or signal_ISR()
+            return true;
+
+        ClrPrioTag(ProcessMap, PrioTag);                // otherwise waked up by timeout or by
+        return false;                                   // OS::ForceWakeUpProcess(), remove process from the wait map
+    }
+}
+//------------------------------------------------------------------------------
+void OS::TEventFlag::Signal()
+{
+    TCritSect cs;
+    if(ProcessMap)                                          // if any process waits for event
+    {
+        TProcessMap Timeouted = Kernel.ReadyProcessMap;     // Process has its tag set in ReadyProcessMap if timeout expired
+                                                            // or it was waked up by OS::ForceWakeUpProcess()
+
+        if( ProcessMap & ~Timeouted )                       // if any process has to be waked up
+        {
+            SetPrioTag(Kernel.ReadyProcessMap, ProcessMap); // place all waiting processes to the ready map
+            ClrPrioTag(ProcessMap, ~Timeouted);             // remove all non-timeouted processes from the waiting map.
+                                                            // Used to check that process waked up by signal() or signalISR()
+                                                            // and not by timeout or OS::ForceWakeUpProcess()
+            Kernel.Scheduler();
+            return;
+        }
+    }
+    Value = efOn;
+}
+//------------------------------------------------------------------------------
+
+//------------------------------------------------------------------------------
+//
+//
+//      TMutex
+//
+//
+void OS::TMutex::Lock()
+{
+    TCritSect cs;
+
+    TProcessMap PrioTag = GetPrioTag(Kernel.CurProcPriority);
+    while(ValueTag)
+    {
+        SetPrioTag(ProcessMap, PrioTag);             // mutex already locked by another process, put current process to the wait map
+        ClrPrioTag(Kernel.ReadyProcessMap, PrioTag); // remove current process from the ready map
+
+        Kernel.Scheduler();
+    }
+    ValueTag = PrioTag;                              // mutex has been successfully locked
+}
+//------------------------------------------------------------------------------
+void OS::TMutex::Unlock()
+{
+    TCritSect cs;
+
+    TProcessMap PrioTag = GetPrioTag(Kernel.CurProcPriority);
+    if(ValueTag != PrioTag) return;                  // the only process that had locked mutex can unlock the mutex
+    ValueTag = 0;
+    if(ProcessMap)
+    {
+        byte pr = GetHighPriority(ProcessMap);
+        PrioTag = GetPrioTag(pr);
+        ClrPrioTag(ProcessMap, PrioTag);             // remove next ready process from the wait map
+        SetPrioTag(Kernel.ReadyProcessMap, PrioTag); // place next process to the ready map
+        Kernel.Scheduler();
+    }
+}
+//------------------------------------------------------------------------------
+void OS::TMutex::UnlockISR()
+{
+    TCritSect cs;
+
+    ValueTag = 0;
+    if(ProcessMap)
+    {
+        byte pr = GetHighPriority(ProcessMap);
+        TProcessMap PrioTag = GetPrioTag(pr);
+        ClrPrioTag(ProcessMap, PrioTag);             // remove next ready process from the wait map
+        SetPrioTag(Kernel.ReadyProcessMap, PrioTag); // place next process to the ready map
+    }
+}
+//------------------------------------------------------------------------------
+
+
+//------------------------------------------------------------------------------
+//
+//
+//      TChannel
+//
+//
+void OS::TChannel::CheckWaiters(TProcessMap& pm)
+{
+    if(pm)
+    {
+        byte pr = GetHighPriority(pm);
+        TProcessMap PrioTag = GetPrioTag(pr);
+        ClrPrioTag(pm, PrioTag);                     // remove next ready process from the wait map
+        SetPrioTag(Kernel.ReadyProcessMap, PrioTag); // place next process to the ready map
+        Kernel.Scheduler();
+    }
+}
+//------------------------------------------------------------------------------
+void OS::TChannel::Push(byte x)
+{
+    TCritSect cs;
+
+    while (!Cbuf.get_free_size())
+    {
+        TProcessMap PrioTag = GetPrioTag(Kernel.CurProcPriority);
+        SetPrioTag  (ProducersProcessMap, PrioTag);  // channel is full, put current process to the wait map
+        ClrPrioTag(Kernel.ReadyProcessMap, PrioTag); // remove current process from the ready map
+        Kernel.Scheduler();                          // wait until waked-up by Pop() or Read()
+    }
+
+    Cbuf.put(x);
+    CheckWaiters(ConsumersProcessMap);
+}
+//------------------------------------------------------------------------------
+byte OS::TChannel::Pop()
+{
+    TCritSect cs;
+    byte x;
+
+    while(!Cbuf.get_count())
+    {
+        TProcessMap PrioTag = GetPrioTag(Kernel.CurProcPriority);
+        SetPrioTag(ConsumersProcessMap, PrioTag);    // channel is empty, put current process to the wait map
+        ClrPrioTag(Kernel.ReadyProcessMap, PrioTag); // remove current process from the ready map
+        Kernel.Scheduler();                          // wait until waked up by Push() or Write()
+    }
+    x = Cbuf.get();
+    CheckWaiters(ProducersProcessMap);
+    return x;
+}
+//------------------------------------------------------------------------------
+void OS::TChannel::Write(const byte* data, const byte count)
+{
+    TCritSect cs;
+
+    while(Cbuf.get_free_size() < count)
+    {
+        TProcessMap PrioTag = GetPrioTag(Kernel.CurProcPriority);
+        SetPrioTag(ProducersProcessMap, PrioTag);    // channel has not enough space, put current process to the wait map
+        ClrPrioTag(Kernel.ReadyProcessMap, PrioTag); // remove current process from the ready map
+        Kernel.Scheduler();                          // wait until waked up by Read() or Pop()
+    }
+
+    Cbuf.write(data, count);
+    CheckWaiters(ConsumersProcessMap);
+}
+//------------------------------------------------------------------------------
+void OS::TChannel::Read(byte* const data, const byte count)
+{
+    TCritSect cs;
+
+    while(Cbuf.get_count() < count)
+    {
+        TProcessMap PrioTag = GetPrioTag(Kernel.CurProcPriority);
+        SetPrioTag(ConsumersProcessMap, PrioTag);    // channel doesn't contain enough data, put current process to the wait map
+        ClrPrioTag(Kernel.ReadyProcessMap, PrioTag); // remove current process from the ready map
+        Kernel.Scheduler();                          // wait until waked up by Write() or Push()
+    }
+
+    Cbuf.read(data, count);
+    CheckWaiters(ProducersProcessMap);
+}
+//------------------------------------------------------------------------------
+
+//------------------------------------------------------------------------------
+//
+//              OS::message template
+//
+//          Function-members implementation
+//
+//
+//------------------------------------------------------------------------------
+bool OS::TBaseMessage::wait(TTimeout timeout)
+{
+    TCritSect cs;
+
+    if(NonEmpty)                                                  // message alredy send
+    {
+        NonEmpty = false;
+        return true;
+    }
+    else
+    {
+        TBaseProcess* p = Kernel.ProcessTable[Kernel.CurProcPriority];
+        p->Timeout = timeout;
+        TProcessMap PrioTag = GetPrioTag(Kernel.CurProcPriority);
+
+        SetPrioTag(ProcessMap, PrioTag);                          // put current process to the wait map
+        ClrPrioTag(Kernel.ReadyProcessMap, PrioTag);              // remove current process from the ready map
+        Kernel.Scheduler();                                       // wait until wake up
+
+        p->Timeout = 0;
+        if( !(ProcessMap & PrioTag) )                             // if waked up by send() or sendISR()
+            return true;
+
+        ClrPrioTag(ProcessMap, PrioTag);                          // otherwise waked up by timeout or by
+            return false;                                         // OS::ForceWakeUpProcess(), remove process from wait map
+    }
+}
+//------------------------------------------------------------------------------
+void OS::TBaseMessage::send()
+{
+    TCritSect cs;
+
+    if(ProcessMap)
+    {
+        TProcessMap Timeouted = Kernel.ReadyProcessMap;         // Process has its tag set in ReadyProcessMap if timeout expired,
+                                                                // or it was waked up by OS::ForceWakeUpProcess()
+        if( ProcessMap & ~Timeouted )                           // if any process has to be waked up
+        {
+            SetPrioTag(Kernel.ReadyProcessMap, ProcessMap);     // place all waiting processes to the ready map
+            ClrPrioTag(ProcessMap, ~Timeouted);                 // remove all non-timeouted processes from the waiting map.
+            Kernel.Scheduler();
+            return;
+        }
+    }
+
+    NonEmpty = true;
+}
+//------------------------------------------------------------------------------
+
diff -r 000000000000 -r 879af6e11219 scmRTOS/Common/OS_Services.h
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/scmRTOS/Common/OS_Services.h	Mon Feb 20 07:36:06 2012 +0000
@@ -0,0 +1,467 @@
+//******************************************************************************
+//*
+//*     FULLNAME:  Single-Chip Microcontroller Real-Time Operating System
+//*
+//*     NICKNAME:  scmRTOS
+//*
+//*     PURPOSE:  OS Services 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_SERVICES_H
+#define OS_SERVICES_H
+
+namespace OS
+{
+    //--------------------------------------------------------------------------
+    //
+    //       NAME       :   Mutex
+    //
+    /// Binary semaphore for support of mutual exclusion
+    //
+    //       DESCRIPTION:
+    //
+    //
+    class TMutex
+    {
+    public:
+        INLINE TMutex() : ProcessMap(0), ValueTag(0) { }
+        void Lock();
+        void Unlock();
+        void UnlockISR();
+
+        INLINE bool LockSoftly()     { TCritSect cs; if(ValueTag) return false; else Lock(); return true; }
+        INLINE bool IsLocked() const { TCritSect cs; if(ValueTag) return true; else return false; }
+
+    private:
+        TProcessMap ProcessMap;
+        TProcessMap ValueTag;
+
+    };
+    //--------------------------------------------------------------------------
+
+    //--------------------------------------------------------------------------
+    //
+    ///  Event Flag
+    ///
+    ///  Intended for processes synchronization and
+    ///  event notification one (or more) process by another
+    //
+    //       DESCRIPTION:
+    //
+    //
+    class TEventFlag
+    {
+    public:
+        enum TValue { efOn = 1, efOff= 0 };     // prefix 'ef' means: "Event Flag"
+
+    public:
+        INLINE TEventFlag(TValue init_val = efOff) : ProcessMap(0), Value(init_val) { }
+
+        bool Wait(TTimeout timeout = 0);
+        void Signal();
+        INLINE void Clear() { TCritSect cs; Value = efOff; }
+        INLINE inline void SignalISR();
+        INLINE bool IsSignaled() { TCritSect cs; if(Value == efOn) return true; else return false; }
+
+    private:
+        TProcessMap ProcessMap;
+        TValue      Value;
+    };
+    //--------------------------------------------------------------------------
+
+    //--------------------------------------------------------------------------
+    //
+    ///  TChannel
+    ///
+    ///  Byte-wide data channel for transferring "raw" data
+    //
+    //       DESCRIPTION:
+    //
+    //
+    class TChannel
+    {
+    public:
+        INLINE TChannel(byte* buf, byte size) : Cbuf(buf, size) { }
+        void Push(byte x);
+        byte Pop();
+        void Write(const byte* data, const byte count);
+        void Read(byte* const data, const byte count);
+
+        INLINE byte GetCount() const { TCritSect cs; return Cbuf.get_count(); }
+
+    private:
+        TProcessMap ProducersProcessMap;
+        TProcessMap ConsumersProcessMap;
+        usr::TCbuf Cbuf;
+
+    private:
+        void CheckWaiters(TProcessMap& pm);
+    };
+    //--------------------------------------------------------------------------
+
+
+    //--------------------------------------------------------------------------
+    //
+    //       NAME       :  channel
+    //
+    //       PURPOSE    :  Data channel for transferring data
+    //                     objects of arbitrary type
+    //
+    //       DESCRIPTION:
+    //
+    //
+    template<typename T, word Size, typename S = byte>
+    ///  channel
+    ///
+    ///  Data channel for transferring data objects of arbitrary type
+    class channel
+    {
+    public:
+        INLINE channel() : ProducersProcessMap(0)
+                         , ConsumersProcessMap(0)
+                         , pool()
+        {
+        }
+
+        //----------------------------------------------------------------
+        //
+        //    Data transfer functions
+        //
+        void write(const T* data, const S cnt);
+        bool read (T* const data, const S cnt, TTimeout timeout = 0);
+
+        void push      (const T& item);
+        void push_front(const T& item);
+
+        bool pop     (T& item, TTimeout timeout = 0);
+        bool pop_back(T& item, TTimeout timeout = 0);
+
+
+        //----------------------------------------------------------------
+        //
+        //    Service functions
+        //
+        INLINE S get_count()     const { TCritSect cs; return pool.get_count();     }
+        INLINE S get_free_size() const { TCritSect cs; return pool.get_free_size(); }
+        void flush();
+        //const T& operator[](const S index) { TCritSect cs; return pool[index]; }
+
+
+    private:
+        TProcessMap ProducersProcessMap;
+        TProcessMap ConsumersProcessMap;
+        usr::ring_buffer<T, Size, S> pool;
+
+    private:
+        void CheckWaiters(TProcessMap& pm);
+    };
+
+    //--------------------------------------------------------------------------
+
+    //--------------------------------------------------------------------------
+    //
+    /// message
+    ///
+    /// Template for messages
+    //
+    //       DESCRIPTION:
+    //
+    //
+    class TBaseMessage
+    {
+    public:
+        INLINE TBaseMessage() : ProcessMap(0), NonEmpty(false) { }
+
+        bool wait  (TTimeout timeout = 0);
+        void send();
+        INLINE inline void sendISR();
+        INLINE bool is_non_empty() const { TCritSect cs; return NonEmpty;  }
+        INLINE void reset       ()       { TCritSect cs; NonEmpty = false; }
+
+    private:
+        TProcessMap ProcessMap;
+        bool NonEmpty;
+    };
+    //--------------------------------------------------------------------------
+    template<typename T>
+    class message : public TBaseMessage
+    {
+    public:
+        INLINE message() : TBaseMessage()   { }
+        INLINE const T& operator=(const T& msg) { TCritSect cs; Msg = msg; return Msg; }
+        INLINE operator     T() const       { TCritSect cs; return Msg; }
+
+    private:
+        T Msg;
+    };
+    //--------------------------------------------------------------------------
+}
+//------------------------------------------------------------------------------
+//
+//          Function-members implementation
+//
+//------------------------------------------------------------------------------
+void OS::TEventFlag::SignalISR()
+{
+    TCritSect cs;
+    if(ProcessMap)                                          // if any process waits for event
+    {
+        TProcessMap Timeouted = Kernel.ReadyProcessMap;     // Process has its tag set in ReadyProcessMap if timeout
+                                                            // expired, or it was waked up by OS::ForceWakeUpProcess()
+        if( ProcessMap & ~Timeouted )                       // if any process has to be waked up
+        {
+            SetPrioTag(Kernel.ReadyProcessMap, ProcessMap); // place all waiting processes to the ready map
+            ClrPrioTag(ProcessMap, ~Timeouted);             // remove all non-timeouted processes from the waiting map.
+            return;
+        }
+    }
+    Value = efOn;
+}
+//------------------------------------------------------------------------------
+template<typename T, word Size, typename S>
+void OS::channel<T, Size, S>::CheckWaiters(TProcessMap& pm)
+{
+    if(pm)
+    {
+        TProcessMap Timeouted = Kernel.ReadyProcessMap;
+
+        SetPrioTag(Kernel.ReadyProcessMap, pm);       // place all waiting processes to the ready map
+        ClrPrioTag(pm, ~Timeouted);                   // remove waiting processes from the wait map
+        Kernel.Scheduler();
+    }
+}
+//------------------------------------------------------------------------------
+template<typename T, word Size, typename S>
+void OS::channel<T, Size, S>::push(const T& item)
+{
+    TCritSect cs;
+
+    while(!pool.get_free_size())
+    {
+        TProcessMap PrioTag = GetPrioTag(Kernel.CurProcPriority);
+        SetPrioTag(ProducersProcessMap, PrioTag);     // channel is full, put current process to the wait map
+        ClrPrioTag(Kernel.ReadyProcessMap, PrioTag);  // remove current process from the ready map
+        Kernel.Scheduler();
+    }
+
+    pool.push_back(item);
+    CheckWaiters(ConsumersProcessMap);
+}
+//------------------------------------------------------------------------------
+template<typename T, word Size, typename S>
+void OS::channel<T, Size, S>::push_front(const T& item)
+{
+    TCritSect cs;
+
+    while(!pool.get_free_size())
+    {
+        TProcessMap PrioTag = GetPrioTag(Kernel.CurProcPriority);
+        SetPrioTag(ProducersProcessMap, PrioTag);     // channel is full, put current process to the wait map
+        ClrPrioTag(Kernel.ReadyProcessMap, PrioTag);  // remove current process from the ready map
+        Kernel.Scheduler();
+    }
+
+    pool.push_front(item);
+    CheckWaiters(ConsumersProcessMap);
+}
+//------------------------------------------------------------------------------
+template<typename T, word Size, typename S>
+bool OS::channel<T, Size, S>::pop(T& item, TTimeout timeout)
+{
+    TCritSect cs;
+
+    if(pool.get_count())
+    {
+        item = pool.pop();
+        CheckWaiters(ProducersProcessMap);
+        return true;
+    }
+    else
+    {
+        TBaseProcess* p = Kernel.ProcessTable[Kernel.CurProcPriority];
+        p->Timeout = timeout;
+
+        TProcessMap PrioTag = GetPrioTag(Kernel.CurProcPriority);
+        for(;;)
+        {
+            SetPrioTag(ConsumersProcessMap, PrioTag);     // channel is empty, put current process to the wait map
+            ClrPrioTag(Kernel.ReadyProcessMap, PrioTag);  // remove current process from the ready map
+            Kernel.Scheduler();
+
+            if(pool.get_count())
+            {
+                p->Timeout = 0;
+                item = pool.pop();
+                CheckWaiters(ProducersProcessMap);
+                return true;
+            }
+
+            if(ConsumersProcessMap & PrioTag)             // waked up by timer when timeout expired
+            {                                             // or by OS::ForceWakeUpProcess()
+
+                p->Timeout = 0;                           // non-zero if waked up by ForceWakeUpProcess()
+                ClrPrioTag(ConsumersProcessMap, PrioTag); // remove current process from the wait map
+                return false;
+            }
+        }
+    }
+}
+//------------------------------------------------------------------------------
+template<typename T, word Size, typename S>
+bool OS::channel<T, Size, S>::pop_back(T& item, TTimeout timeout)
+{
+    TCritSect cs;
+
+    if(pool.get_count())
+    {
+        item = pool.pop_back();
+        CheckWaiters(ProducersProcessMap);
+        return true;
+    }
+    else
+    {
+        TBaseProcess* p = Kernel.ProcessTable[Kernel.CurProcPriority];
+        p->Timeout = timeout;
+
+        TProcessMap PrioTag = GetPrioTag(Kernel.CurProcPriority);
+        for(;;)
+        {
+            SetPrioTag(ConsumersProcessMap, PrioTag);     // channel is empty, put current process to the wait map
+            ClrPrioTag(Kernel.ReadyProcessMap, PrioTag);  // remove current process from the ready map
+            Kernel.Scheduler();
+
+            if(pool.get_count())
+            {
+                p->Timeout = 0;
+                item = pool.pop_back();
+                CheckWaiters(ProducersProcessMap);
+                return true;
+            }
+
+            if(ConsumersProcessMap & PrioTag)             // waked up by timer when timeout expired
+            {                                             // or by OS::ForceWakeUpProcess()
+
+                p->Timeout = 0;                           // non-zero if waked up by ForceWakeUpProcess()
+                ClrPrioTag(ConsumersProcessMap, PrioTag); // remove current process from the wait map
+                return false;
+            }
+        }
+    }
+}
+//------------------------------------------------------------------------------
+template<typename T, word Size, typename S>
+void OS::channel<T, Size, S>::flush()
+{
+    TCritSect cs;
+    pool.flush();
+    CheckWaiters(ProducersProcessMap);
+}
+//------------------------------------------------------------------------------
+template<typename T, word Size, typename S>
+void OS::channel<T, Size, S>::write(const T* data, const S count)
+{
+    TCritSect cs;
+
+    while(pool.get_free_size() < count)
+    {
+        TProcessMap PrioTag = GetPrioTag(Kernel.CurProcPriority);
+        SetPrioTag(ProducersProcessMap, PrioTag);     // channel does not have enough space, put current process to the wait map
+        ClrPrioTag(Kernel.ReadyProcessMap, PrioTag);  // remove current process from the ready map
+        Kernel.Scheduler();
+    }
+
+    pool.write(data, count);
+    CheckWaiters(ConsumersProcessMap);
+}
+//------------------------------------------------------------------------------
+template<typename T, word Size, typename S>
+bool OS::channel<T, Size, S>::read(T* const data, const S count, TTimeout timeout)
+{
+    TCritSect cs;
+
+    TBaseProcess* p = Kernel.ProcessTable[Kernel.CurProcPriority];
+    p->Timeout = timeout;
+
+    TProcessMap PrioTag = GetPrioTag(Kernel.CurProcPriority);
+    while(pool.get_count() < count)
+    {
+        SetPrioTag(ConsumersProcessMap, PrioTag);     // channel doesn't contain enough data, put current process to the wait map
+        ClrPrioTag(Kernel.ReadyProcessMap, PrioTag);  // remove current process from the ready map
+        Kernel.Scheduler();
+
+        if(ConsumersProcessMap & PrioTag)             // waked up by timer when timeout expired
+        {                                             // or by OS::ForceWakeUpProcess()
+
+            p->Timeout = 0;                           // non-zero if waked up by ForceWakeUpProcess()
+            ClrPrioTag(ConsumersProcessMap, PrioTag); // remove current process from the wait map
+            return false;
+        }
+    }
+
+    p->Timeout = 0;
+    pool.read(data, count);
+    CheckWaiters(ProducersProcessMap);
+
+    return true;
+}
+//------------------------------------------------------------------------------
+
+//------------------------------------------------------------------------------
+//
+//              OS::message template
+//
+//          Function-members implementation
+//
+//
+//------------------------------------------------------------------------------
+void OS::TBaseMessage::sendISR()
+{
+    TCritSect cs;
+
+    if(ProcessMap)
+    {
+        TProcessMap Timeouted = OS::Kernel.ReadyProcessMap;     // Process has it's tag set in ReadyProcessMap if timeout
+                                                                // expired, or it was waked up by  OS::ForceWakeUpProcess()
+        if( ProcessMap & ~Timeouted )                           // if any process has to be waked up
+        {
+            SetPrioTag(Kernel.ReadyProcessMap, ProcessMap);     // place all waiting processes to the ready map
+            ClrPrioTag(ProcessMap, ~Timeouted);                 // remove all non-timeouted processes from the waiting map.
+            return;
+        }
+    }
+    NonEmpty = true;
+}
+//------------------------------------------------------------------------------
+#endif // OS_SERVICES_H
diff -r 000000000000 -r 879af6e11219 scmRTOS/Common/scmRTOS.h
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/scmRTOS/Common/scmRTOS.h	Mon Feb 20 07:36:06 2012 +0000
@@ -0,0 +1,58 @@
+//******************************************************************************
+//*
+//*     FULLNAME:  Single-Chip Microcontroller Real-Time Operating System
+//*
+//*     NICKNAME:  scmRTOS
+//*
+//*     PURPOSE:  Main RTOS header file
+//*
+//*     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 scmRTOS_H
+#define scmRTOS_H
+
+//-----------------------------------------------------------------------------
+//
+//    !!! The order of includes is important !!!
+//
+#include <stddef.h>
+#include <commdefs.h>
+#include <usrlib.h>
+#include <OS_Target.h>
+
+//------------------------------------------------------------------------------
+
+
+#endif // scmRTOS_H
+
diff -r 000000000000 -r 879af6e11219 scmRTOS/Common/scmRTOS_defs.h
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/scmRTOS/Common/scmRTOS_defs.h	Mon Feb 20 07:36:06 2012 +0000
@@ -0,0 +1,374 @@
+//******************************************************************************
+//*
+//*     FULLNAME:  Single-Chip Microcontroller Real-Time Operating System
+//*
+//*     NICKNAME:  scmRTOS
+//*
+//*     PURPOSE:  Macros And Common 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 scmRTOS_DEFS_H
+#define scmRTOS_DEFS_H
+
+#include <commdefs.h>
+
+//------------------------------------------------------------------------------
+
+//-----------------------------------------------------------------------------
+//
+//
+///   Macro for Channel Type definition
+//
+//
+#define DefineChannel(Name, Capacity)                                            \
+class Name : public OS::TChannel                                                 \
+{                                                                                \
+public:                                                                          \
+    Name() : OS::TChannel(buf, sizeof(buf)) { }                                  \
+                                                                                 \
+private:                                                                         \
+    byte buf[Capacity];                                                          \
+                                                                                 \
+}
+//-----------------------------------------------------------------------------
+//
+//    Check CONFIG Macro Definitions
+//
+//
+
+//----------------- scmRTOS_SYSTIMER_NEST_INTS_ENABLE -------------------------
+#ifndef scmRTOS_SYSTIMER_NEST_INTS_ENABLE
+#error "Error: Config macro scmRTOS_SYSTIMER_NEST_INTS_ENABLE must be defined!"
+#endif
+
+#if (scmRTOS_SYSTIMER_NEST_INTS_ENABLE < 0) || (scmRTOS_SYSTIMER_NEST_INTS_ENABLE > 1)
+#error "Error: scmRTOS_SYSTIMER_NEST_INTS_ENABLE must have values 0 or 1 only!"
+#endif
+
+//----------------- scmRTOS_SYSTEM_TICKS_ENABLE -------------------------------
+#ifndef scmRTOS_SYSTEM_TICKS_ENABLE
+#error "Error: Config macro scmRTOS_SYSTEM_TICKS_ENABLE must be defined!"
+#endif
+
+#if (scmRTOS_SYSTEM_TICKS_ENABLE < 0) || (scmRTOS_SYSTEM_TICKS_ENABLE > 1)
+#error "Error: scmRTOS_SYSTEM_TICKS_ENABLE must have values 0 or 1 only!"
+#endif
+
+
+//----------------- scmRTOS_SYSTIMER_HOOK_ENABLE ------------------------------
+#ifndef scmRTOS_SYSTIMER_HOOK_ENABLE
+#error "Error: Config macro scmRTOS_SYSTIMER_HOOK_ENABLE must be defined!"
+#endif
+
+#if (scmRTOS_SYSTIMER_HOOK_ENABLE < 0) || (scmRTOS_SYSTIMER_HOOK_ENABLE > 1)
+#error "Error: scmRTOS_SYSTIMER_HOOK_ENABLE must have values 0 or 1 only!"
+#endif
+
+//-------------- scmRTOS_CONTEXT_SWITCH_USER_HOOK_ENABLE ----------------------
+#ifndef scmRTOS_CONTEXT_SWITCH_USER_HOOK_ENABLE
+#error "Error: Config macro scmRTOS_CONTEXT_SWITCH_USER_HOOK_ENABLE must be defined!"
+#endif
+
+#if (scmRTOS_CONTEXT_SWITCH_USER_HOOK_ENABLE < 0) || (scmRTOS_CONTEXT_SWITCH_USER_HOOK_ENABLE > 1)
+#error "Error: scmRTOS_CONTEXT_SWITCH_USER_HOOK_ENABLE must have values 0 or 1 only!"
+#endif
+
+//----------------- scmRTOS_IDLE_HOOK_ENABLE ----------------------------------
+#ifndef scmRTOS_IDLE_HOOK_ENABLE
+#error "Error: Config macro scmRTOS_IDLE_HOOK_ENABLE must be defined!"
+#endif
+
+#if (scmRTOS_IDLE_HOOK_ENABLE < 0) || (scmRTOS_IDLE_HOOK_ENABLE > 1)
+#error "Error: scmRTOS_IDLE_HOOK_ENABLE must have values 0 or 1 only!"
+#endif
+
+//----------------- scmRTOS_CONTEXT_SWITCH_SCHEME -----------------------------
+#ifndef scmRTOS_CONTEXT_SWITCH_SCHEME
+#error "Error: Config macro scmRTOS_CONTEXT_SWITCH_SCHEME must be defined!"
+#endif
+
+#if (scmRTOS_CONTEXT_SWITCH_SCHEME < 0) || (scmRTOS_CONTEXT_SWITCH_SCHEME > 1)
+#error "Error: scmRTOS_CONTEXT_SWITCH_SCHEME must have values 0 or 1 only!"
+#endif
+
+
+//----------------- scmRTOS_PRIORITY_ORDER ------------------------------------
+#ifndef scmRTOS_PRIORITY_ORDER
+#error "Error: Config macro scmRTOS_PRIORITY_ORDER must be defined!"
+#endif
+
+#if (scmRTOS_PRIORITY_ORDER < 0) || (scmRTOS_PRIORITY_ORDER > 1)
+#error "Error: scmRTOS_PRIORITY_ORDER must have values 0 or 1 only!"
+#endif
+
+//----------------- User Hooks inlining ------------------------------------
+#ifndef INLINE_SYS_TIMER_HOOK
+#define INLINE_SYS_TIMER_HOOK
+#endif
+
+#ifndef INLINE_CONTEXT_SWITCH_HOOK
+#define INLINE_CONTEXT_SWITCH_HOOK
+#endif
+
+
+//-----------------------------------------------------------------------------
+//
+///    Priority and process map type definitions
+//
+//
+namespace OS
+{
+    #if scmRTOS_PROCESS_COUNT < 8
+        typedef byte TProcessMap;
+    #elif scmRTOS_PROCESS_COUNT < 16
+        typedef word TProcessMap;
+    #else
+        typedef dword TProcessMap;
+    #endif
+    //------------------------------------------------------
+#if scmRTOS_PRIORITY_ORDER == 0
+    enum TPriority {
+        #if scmRTOS_PROCESS_COUNT   > 0
+            pr0,
+        #endif
+        #if scmRTOS_PROCESS_COUNT   > 1
+            pr1,
+        #endif
+        #if scmRTOS_PROCESS_COUNT   > 2
+            pr2,
+        #endif
+        #if scmRTOS_PROCESS_COUNT   > 3
+            pr3,
+        #endif
+        #if scmRTOS_PROCESS_COUNT   > 4
+            pr4,
+        #endif
+        #if scmRTOS_PROCESS_COUNT   > 5
+            pr5,
+        #endif
+        #if scmRTOS_PROCESS_COUNT   > 6
+            pr6,
+        #endif
+        #if scmRTOS_PROCESS_COUNT   > 7
+            pr7,
+        #endif
+        #if scmRTOS_PROCESS_COUNT   > 8
+            pr8,
+        #endif
+        #if scmRTOS_PROCESS_COUNT   > 9
+            pr9,
+        #endif
+        #if scmRTOS_PROCESS_COUNT   > 10
+            pr10,
+        #endif
+        #if scmRTOS_PROCESS_COUNT   > 11
+            pr11,
+        #endif
+        #if scmRTOS_PROCESS_COUNT   > 12
+            pr12,
+        #endif
+        #if scmRTOS_PROCESS_COUNT   > 13
+            pr13,
+        #endif
+        #if scmRTOS_PROCESS_COUNT   > 14
+            pr14,
+        #endif
+        #if scmRTOS_PROCESS_COUNT   > 15
+            pr15,
+        #endif
+        #if scmRTOS_PROCESS_COUNT   > 16
+            pr16,
+        #endif
+        #if scmRTOS_PROCESS_COUNT   > 17
+            pr17,
+        #endif
+        #if scmRTOS_PROCESS_COUNT   > 18
+            pr18,
+        #endif
+        #if scmRTOS_PROCESS_COUNT   > 19
+            pr19,
+        #endif
+        #if scmRTOS_PROCESS_COUNT   > 20
+            pr20,
+        #endif
+        #if scmRTOS_PROCESS_COUNT   > 21
+            pr21,
+        #endif
+        #if scmRTOS_PROCESS_COUNT   > 22
+            pr22,
+        #endif
+        #if scmRTOS_PROCESS_COUNT   > 23
+            pr23,
+        #endif
+        #if scmRTOS_PROCESS_COUNT   > 24
+            pr24,
+        #endif
+        #if scmRTOS_PROCESS_COUNT   > 25
+            pr25,
+        #endif
+        #if scmRTOS_PROCESS_COUNT   > 26
+            pr26,
+        #endif
+        #if scmRTOS_PROCESS_COUNT   > 27
+            pr27,
+        #endif
+        #if scmRTOS_PROCESS_COUNT   > 28
+            pr28,
+        #endif
+        #if scmRTOS_PROCESS_COUNT   > 29
+            pr29,
+        #endif
+        #if scmRTOS_PROCESS_COUNT   > 30
+            pr30,
+        #endif
+        #if (scmRTOS_PROCESS_COUNT   > 31) || (scmRTOS_PROCESS_COUNT   < 1)
+            #error "Invalid Process Count specification! Must be from 1 to 31."
+        #endif
+            prIDLE
+    };
+#else   // scmRTOS_PRIORITY_ORDER == 1
+    enum TPriority {
+            prIDLE,
+        #if scmRTOS_PROCESS_COUNT   > 30
+            pr30,
+        #endif
+        #if scmRTOS_PROCESS_COUNT   > 29
+            pr29,
+        #endif
+        #if scmRTOS_PROCESS_COUNT   > 28
+            pr28,
+        #endif
+        #if scmRTOS_PROCESS_COUNT   > 27
+            pr27,
+        #endif
+        #if scmRTOS_PROCESS_COUNT   > 26
+            pr26,
+        #endif
+        #if scmRTOS_PROCESS_COUNT   > 25
+            pr25,
+        #endif
+        #if scmRTOS_PROCESS_COUNT   > 24
+            pr24,
+        #endif
+        #if scmRTOS_PROCESS_COUNT   > 23
+            pr23,
+        #endif
+        #if scmRTOS_PROCESS_COUNT   > 22
+            pr22,
+        #endif
+        #if scmRTOS_PROCESS_COUNT   > 21
+            pr21,
+        #endif
+        #if scmRTOS_PROCESS_COUNT   > 20
+            pr20,
+        #endif
+        #if scmRTOS_PROCESS_COUNT   > 19
+            pr19,
+        #endif
+        #if scmRTOS_PROCESS_COUNT   > 18
+            pr18,
+        #endif
+        #if scmRTOS_PROCESS_COUNT   > 17
+            pr17,
+        #endif
+        #if scmRTOS_PROCESS_COUNT   > 16
+            pr16,
+        #endif
+        #if scmRTOS_PROCESS_COUNT   > 15
+            pr15,
+        #endif
+        #if scmRTOS_PROCESS_COUNT   > 14
+            pr14,
+        #endif
+        #if scmRTOS_PROCESS_COUNT   > 13
+            pr13,
+        #endif
+        #if scmRTOS_PROCESS_COUNT   > 12
+            pr12,
+        #endif
+        #if scmRTOS_PROCESS_COUNT   > 11
+            pr11,
+        #endif
+        #if scmRTOS_PROCESS_COUNT   > 10
+            pr10,
+        #endif
+        #if scmRTOS_PROCESS_COUNT   > 9
+            pr9,
+        #endif
+        #if scmRTOS_PROCESS_COUNT   > 8
+            pr8,
+        #endif
+        #if scmRTOS_PROCESS_COUNT   > 7
+            pr7,
+        #endif
+        #if scmRTOS_PROCESS_COUNT   > 6
+            pr6,
+        #endif
+        #if scmRTOS_PROCESS_COUNT   > 5
+            pr5,
+        #endif
+        #if scmRTOS_PROCESS_COUNT   > 4
+            pr4,
+        #endif
+        #if scmRTOS_PROCESS_COUNT   > 3
+            pr3,
+        #endif
+        #if scmRTOS_PROCESS_COUNT   > 2
+            pr2,
+        #endif
+        #if scmRTOS_PROCESS_COUNT   > 1
+            pr1,
+        #endif
+        #if scmRTOS_PROCESS_COUNT   > 0
+            pr0
+        #endif
+        #if (scmRTOS_PROCESS_COUNT   > 31) || (scmRTOS_PROCESS_COUNT   < 1)
+            #error "Invalid Process Count specification! Must be from 1 to 31."
+        #endif
+    };
+#endif //scmRTOS_PRIORITY_ORDER
+}
+//-----------------------------------------------------------------------------
+//
+//     Process's constructor inlining control: default behaviour
+//
+#ifndef INLINE_PROCESS_CTOR
+#define INLINE_PROCESS_CTOR
+#endif
+
+
+//-----------------------------------------------------------------------------
+
+#endif // scmRTOS_DEFS_H
diff -r 000000000000 -r 879af6e11219 scmRTOS/Common/usrlib.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/scmRTOS/Common/usrlib.cpp	Mon Feb 20 07:36:06 2012 +0000
@@ -0,0 +1,140 @@
+//******************************************************************************
+//*
+//*     FULLNAME:  Single-Chip Microcontroller Real-Time Operating System
+//*
+//*     NICKNAME:  scmRTOS
+//*               
+//*     PURPOSE:  User Suport Library Source
+//*               
+//*     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.
+//*     =================================================================
+//*
+//******************************************************************************
+
+#include <usrlib.h>
+#include <commdefs.h>
+
+using namespace usr;
+
+//------------------------------------------------------------------------------
+//
+///   Circular buffer function-member description
+//
+//
+//
+TCbuf::TCbuf(byte* const Address, const byte Size) :
+        buf(Address),
+        size(Size),
+        count(0),
+        first(0),
+        last(0)
+{
+}
+//------------------------------------------------------------------------------
+bool TCbuf::write(const byte* data, const byte Count)
+{
+    if( Count > (size - count) )
+        return false;
+
+    for(byte i = 0; i < Count; i++)
+        push(*(data++));
+
+    return true;
+}
+//------------------------------------------------------------------------------
+void TCbuf::read(byte* data, const byte Count)
+{
+    byte N = Count <= count ? Count : count;
+
+    for(byte i = 0; i < N; i++)
+        data[i] = pop();
+}
+//------------------------------------------------------------------------------
+byte TCbuf::get_byte(const byte index) const
+{
+    byte x = first + index;
+
+    if(x < size)
+        return buf[x];
+    else
+        return buf[x - size];
+}
+
+//------------------------------------------------------------------------------
+bool TCbuf::put(const byte item)
+{
+    if(count == size)
+        return false;
+
+    push(item);
+    return true;
+}
+//------------------------------------------------------------------------------
+byte TCbuf::get()
+{
+    if(count)
+        return pop();
+    else
+        return 0;
+}
+//------------------------------------------------------------------------------
+//
+/// \note
+/// For internal purposes.
+/// Use this function with care - it doesn't perform free size check.
+//
+void TCbuf::push(const byte item)
+{
+    buf[last] = item;
+    last++;
+    count++;
+
+    if(last == size)
+        last = 0;
+}
+//------------------------------------------------------------------------------
+//
+/// \note
+/// For internal purposes.
+/// Use this function with care - it doesn't perform free size check.
+//
+byte TCbuf::pop()
+{
+    byte item = buf[first];
+
+    count--;
+    first++;
+    if(first == size)
+        first = 0;
+
+    return item;
+}
+//------------------------------------------------------------------------------
diff -r 000000000000 -r 879af6e11219 scmRTOS/Common/usrlib.h
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/scmRTOS/Common/usrlib.h	Mon Feb 20 07:36:06 2012 +0000
@@ -0,0 +1,298 @@
+//******************************************************************************
+//*
+//*     FULLNAME:  Single-Chip Microcontroller Real-Time Operating System
+//*
+//*     NICKNAME:  scmRTOS
+//*               
+//*     PURPOSE:  User Suport Library Header
+//*               
+//*     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 USRLIB_H
+#define USRLIB_H
+
+#include <commdefs.h>
+
+//------------------------------------------------------------------------------
+//
+//  DESCRIPTON: user namespace for some useful types and functions
+//
+//
+namespace usr
+{
+    //------------------------------------------------------------------------------
+    //
+    ///     The Circular Buffer
+    //
+    ///         Byte-wide FIFO.
+    //
+    ///         Allows to:
+    ///             add byte,
+    ///             get byte,
+    ///             write bytes from array,
+    ///             read bytes to array,
+    ///             and some other service actions.
+    //
+    class TCbuf
+    {
+    public:
+        TCbuf(byte* const Address, const byte Size);
+        bool write(const byte* data, const byte Count);
+        void read(byte* const data, const byte Count);
+        byte get_count() const { return count; }
+        byte get_free_size() const { return size - count; }
+        byte get_byte(const byte index) const;
+        void clear() { count = 0; last = first; }
+        bool put(const byte item);
+        byte get();
+
+    private:
+       //------------------------------------------------------------------------------
+       //
+       //  DESCRIPTON: For internal purposes
+       //
+        void push(const byte item); ///< Use this function with care - it doesn't perform free size check
+        byte pop();                 ///< Use this function with care - it doesn't perform count check
+       //------------------------------------------------------------------------------
+
+    private:
+        byte* buf;
+        byte  size;
+        volatile byte count;
+        byte  first;
+        byte  last;
+    };
+    //------------------------------------------------------------------------------
+
+
+
+    //-----------------------------------------------------------------------
+    //
+    ///     The Ring Buffer Template
+    ///
+    ///         Carries out FIFO functionality for
+    ///         arbitrary data types
+    ///
+    ///         Allows to:
+    ///             add item to back (default),
+    ///             add item to front,
+    ///             get item at front (default),
+    ///             get item from back,
+    ///             write items from array,
+    ///             read items to array and some other actions
+    //
+    //
+    //
+    template<typename T, word Size, typename S = byte>
+    class ring_buffer
+    {
+    public:
+        ring_buffer() : Count(0), First(0), Last(0) { }
+
+        //----------------------------------------------------------------
+        //
+        //    Data transfer functions
+        //
+        bool write(const T* data, const S cnt);
+        void read(T* const data, const S cnt);
+
+        bool push_back(const T item);
+        bool push_front(const T item);
+
+        T pop_front();
+        T pop_back();
+
+        bool push(const T item) { return push_back(item); }
+        T pop() { return pop_front(); }
+
+        //----------------------------------------------------------------
+        //
+        //    Service functions
+        //
+        S get_count() const { return Count; }
+        S get_free_size() const { return Size - Count; }
+        T& operator[](const S index);
+        void flush() { Count = 0; Last = First; }
+
+    private:
+        //--------------------------------------------------------------
+        //  DESCRIPTON: For internal purposes
+        //              Use this functions with care: it don't perform
+        //              free size and count check
+        //
+        void push_item(const T item);
+        void push_item_front(const T item);
+        T pop_item();
+        T pop_item_back();
+        //--------------------------------------------------------------
+
+    private:
+        S  Count;
+        S  First;
+        S  Last;
+        T  Buf[Size];
+    };
+    //------------------------------------------------------------------
+}
+//---------------------------------------------------------------------------
+
+
+//------------------------------------------------------------------------------
+//
+//    The ring buffer function-member definitions
+//
+//
+//
+template<typename T, word Size, typename S>
+bool usr::ring_buffer<T, Size, S>::write(const T* data, const S cnt)
+{
+    if( cnt > (Size - Count) )
+        return false;
+
+    for(S i = 0; i < cnt; i++)
+        push_item(*(data++));
+
+    return true;
+}
+//------------------------------------------------------------------------------
+template<typename T, word Size, typename S>
+void usr::ring_buffer<T, Size, S>::read(T* data, const S cnt)
+{
+    S nItems = cnt <= Count ? cnt : Count;
+
+    for(S i = 0; i < nItems; i++)
+        data[i] = pop_item();
+}
+//------------------------------------------------------------------------------
+template<typename T, word Size, typename S>
+T& usr::ring_buffer<T, Size, S>::operator[](const S index)
+{
+    S x = First + index;
+
+    if(x < Size)
+        return Buf[x];
+    else
+        return Buf[x - Size];
+}
+
+//------------------------------------------------------------------------------
+template<typename T, word Size, typename S>
+bool usr::ring_buffer<T, Size, S>::push_back(const T item)
+{
+    if(Count == Size)
+        return false;
+
+    push_item(item);
+    return true;
+}
+//------------------------------------------------------------------------------
+template<typename T, word Size, typename S>
+bool usr::ring_buffer<T, Size, S>::push_front(const T item)
+{
+    if(Count == Size)
+        return false;
+
+    push_item_front(item);
+    return true;
+}
+//------------------------------------------------------------------------------
+template<typename T, word Size, typename S>
+T usr::ring_buffer<T, Size, S>::pop_front()
+{
+    if(Count)
+        return pop_item();
+    else
+        return Buf[First];
+}
+//------------------------------------------------------------------------------
+template<typename T, word Size, typename S>
+T usr::ring_buffer<T, Size, S>::pop_back()
+{
+    if(Count)
+        return pop_item_back();
+    else
+        return Buf[First];
+}
+//------------------------------------------------------------------------------
+template<typename T, word Size, typename S>
+void usr::ring_buffer<T, Size, S>::push_item(const T item)
+{
+    Buf[Last] = item;
+    Last++;
+    Count++;
+
+    if(Last == Size)
+        Last = 0;
+}
+//------------------------------------------------------------------------------
+template<typename T, word Size, typename S>
+void usr::ring_buffer<T, Size, S>::push_item_front(const T item)
+{
+    if(First == 0)
+        First = Size - 1;
+    else
+        --First;
+    Buf[First] = item;
+    Count++;
+}
+//------------------------------------------------------------------------------
+template<typename T, word Size, typename S>
+T usr::ring_buffer<T, Size, S>::pop_item()
+{
+    T item = Buf[First];
+
+    Count--;
+    First++;
+    if(First == Size)
+        First = 0;
+
+    return item;
+}
+//------------------------------------------------------------------------------
+template<typename T, word Size, typename S>
+T usr::ring_buffer<T, Size, S>::pop_item_back()
+{
+
+    if(Last == 0)
+        Last = Size - 1;
+    else
+        --Last;
+
+    Count--;
+    return Buf[Last];;
+}
+//------------------------------------------------------------------------------
+
+
+#endif // USRLIB_H
diff -r 000000000000 -r 879af6e11219 scmRTOS/CortexM3/OS_Target.h
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/scmRTOS/CortexM3/OS_Target.h	Mon Feb 20 07:36:06 2012 +0000
@@ -0,0 +1,236 @@
+//******************************************************************************
+//*
+//*     FULLNAME:  Single-Chip Microcontroller Real-Time Operating System
+//*
+//*     NICKNAME:  scmRTOS
+//*
+//*     PROCESSOR: ARM Cortex-M3 
+//*
+//*     TOOLKIT:   RVCT (ARM)
+//*               
+//*     PURPOSE:   Target Dependent Stuff Header. Declarations And Definitions
+//*               
+//*     Version: 3.10
+//*
+//*     $Revision: 195 $
+//*     $Date:: 2008-06-19 #$
+//*
+//*     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.
+//*     =================================================================
+//*
+//******************************************************************************
+//*     Ported by Andrey Chuikin, Copyright (c) 2008-2010
+
+#ifndef scmRTOS_CORTEXM3_H
+#define scmRTOS_CORTEXM3_H
+
+#include <commdefs.h>
+
+//------------------------------------------------------------------------------
+//
+//    Compiler and Target checks
+//
+//
+#ifndef __ARMCC_VERSION
+#error "This file should only be compiled with ARM RVCT Compiler"
+#endif // __ARMCC_VERSION
+
+#if __TARGET_ARCH_ARM != 0 || __TARGET_ARCH_THUMB != 4
+#error "This file must be compiled for ARMv7-M (Cortex-M3) processor only."
+#endif
+
+//------------------------------------------------------------------------------
+//
+//    Target specific types
+//
+//
+typedef dword TStackItem;
+typedef dword TStatusReg;
+
+//-----------------------------------------------------------------------------
+//
+//    Configuration macros
+//
+//
+#define OS_PROCESS    __attribute__((__noreturn__))
+#define OS_INTERRUPT 
+#define DUMMY_INSTR() __NOP()
+#define INLINE_PROCESS_CTOR INLINE inline
+
+//-----------------------------------------------------------------------------
+//
+//   Uncomment macro value below for SystemTimer() run in critical section
+// 
+//   This is useful (and necessary) when target processor has hardware 
+//   enabled nested interrups. Cortex-M3 have such interrupts.
+// 
+#define SYS_TIMER_CRIT_SECT()  TCritSect cs
+
+//-----------------------------------------------------------------------------
+// Separate return stack not required
+#define SEPARATE_RETURN_STACK   0
+
+//-----------------------------------------------------------------------------
+// Software interrupt stack switching not supported in Cortex-M3 port
+// because processor implements hardware stack switching.
+// So, system timer isr wrapper can't be choosen at project level
+//
+#define scmRTOS_ISRW_TYPE       TISRW
+
+//-----------------------------------------------------------------------------
+//
+//    scmRTOS Context Switch Scheme
+//
+//    The macro defines a context switch manner. Value 0 sets direct context
+//    switch in the scheduler and in the OS ISRs. This is the primary method.
+//    Value 1 sets the second way to switch context - by using of software 
+//    interrupt. See documentation fo details.
+//    Cortex-M3 port supports software interrupt switch method only.
+//
+#define  scmRTOS_CONTEXT_SWITCH_SCHEME 1
+
+//-----------------------------------------------------------------------------
+//
+//     Include project-level configurations
+//    !!! The order of includes is important !!!
+//
+#include "../../scmRTOS_config.h"
+#include "../scmRTOS_TARGET_CFG.h"
+#include <scmRTOS_defs.h>
+#include <LPC17xx.h>
+
+//-----------------------------------------------------------------------------
+//
+//     The Critital Section Wrapper
+//
+//
+#define __enable_interrupt()  __enable_irq()
+#define __disable_interrupt() __disable_irq()
+
+#define __set_interrupt_state(status) __set_PRIMASK(status)
+#define __get_interrupt_state() __get_PRIMASK()
+
+class TCritSect
+{
+public:
+    TCritSect () : StatusReg(__get_interrupt_state()) { __disable_interrupt(); }
+    ~TCritSect() { __set_interrupt_state(StatusReg); }
+
+private:
+    TStatusReg StatusReg;
+};
+//-----------------------------------------------------------------------------
+
+//-----------------------------------------------------------------------------
+//
+//     Priority stuff
+//
+//
+namespace OS
+{
+INLINE inline OS::TProcessMap GetPrioTag(const byte pr) { return static_cast<OS::TProcessMap> (1 << pr); }
+
+#if scmRTOS_PRIORITY_ORDER == 0
+    INLINE inline byte GetHighPriority(TProcessMap pm)
+    {
+        byte pr = 0;
+
+        while( !(pm & 0x0001) )
+        {
+            pr++;
+            pm >>= 1;
+        }
+        return pr;
+    }
+#else
+    INLINE inline byte GetHighPriority(TProcessMap pm) { return (31 - __clz(pm)); }
+#endif // scmRTOS_PRIORITY_ORDER
+}
+
+//-----------------------------------------------------------------------------
+//
+//     Interrupt and Interrupt Service Routines support
+//
+INLINE inline TStatusReg GetInterruptState( )             { return __get_interrupt_state(); }
+INLINE inline void       SetInterruptState(TStatusReg sr) { __set_interrupt_state(sr);      }
+
+INLINE inline void EnableInterrupts()  { __enable_interrupt();  }
+INLINE inline void DisableInterrupts() { __disable_interrupt(); }
+
+
+namespace OS
+{
+    INLINE inline void EnableContextSwitch()  { EnableInterrupts(); }
+    INLINE inline void DisableContextSwitch() { DisableInterrupts(); }
+}
+
+#include <OS_Kernel.h>
+
+namespace OS
+{
+    //--------------------------------------------------------------------------
+    //
+    //      NAME       :   OS ISR support 
+    //
+    //      PURPOSE    :   Implements common actions on interrupt enter and exit 
+    //                     under the OS
+    //
+    //      DESCRIPTION:
+    //
+    //
+    class TISRW
+    {
+    public:
+        INLINE  TISRW()  { ISR_Enter(); }
+        INLINE  ~TISRW() { ISR_Exit();  }
+
+    private:
+        //-----------------------------------------------------
+        INLINE void ISR_Enter()
+        {
+            TCritSect cs;
+            Kernel.ISR_NestCount++;
+        }
+        //-----------------------------------------------------
+        INLINE void ISR_Exit()
+        {
+            TCritSect cs;
+            if(--Kernel.ISR_NestCount) return;
+            Kernel.SchedISR();
+        }
+        //-----------------------------------------------------
+    };
+
+    // No software interrupt stack switching provided,
+    // TISRW_SS declared to be the same as TISRW for porting compability
+    #define TISRW_SS    TISRW
+    
+} // ns OS
+//-----------------------------------------------------------------------------
+
+#endif // scmRTOS_CORTEXM3_H
+//-----------------------------------------------------------------------------
+
diff -r 000000000000 -r 879af6e11219 scmRTOS/CortexM3/OS_Target_asm.s
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/scmRTOS/CortexM3/OS_Target_asm.s	Mon Feb 20 07:36:06 2012 +0000
@@ -0,0 +1,178 @@
+; ******************************************************************************
+; *
+; *     FULLNAME:  Single-Chip Microcontroller Real-Time Operating System
+; *
+; *     NICKNAME:  scmRTOS
+; *
+; *     PROCESSOR: ARM Cortex-M3 
+; *
+; *     TOOLKIT:   EWARM (IAR Systems)
+; *               
+; *     PURPOSE:   Target Dependent Low-Level Stuff
+; *               
+; *     Version: 3.10
+; *
+; *     $Revision: 195 $
+; *     $Date:: 2008-06-19 #$
+; *
+; *     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.
+; *     =================================================================
+; *
+; ******************************************************************************
+; *     Ported by Andrey Chuikin, Copyright (c) 2008-2010
+
+; #include "scmRTOS_TARGET_CFG.h"
+
+; -----------------------------------------------------------------------------
+;   PUBLIC FUNCTIONS
+;
+    EXTERN  OS_ContextSwitchHook
+
+    EXPORT  OS_Start
+    EXPORT  PendSV_Handler
+
+; -----------------------------------------------------------------------------
+;   EQUATES
+;
+NVIC_INT_CTRL        EQU     0xE000ED04  ; Interrupt control state register.
+NVIC_PENDSVSET       EQU     0x10000000  ; Value to trigger PendSV exception.
+
+NVIC_SYSPRI14        EQU     0xE000ED22  ; System priority register (priority 14).
+NVIC_PENDSV_PRI      EQU           0xFF  ; PendSV priority value (lowest).
+NVIC_SYSPRI15        EQU     0xE000ED23  ; System priority register (priority 15).
+NVIC_ST_PRI          EQU           0xFF  ; SysTick priority value (lowest).
+
+NVIC_ST_CTRL         EQU    0xE000E010   ; SysTick Ctrl & Status Reg.
+NVIC_ST_RELOAD       EQU    0xE000E014   ; SysTick Reload  Value Reg.
+NVIC_ST_CTRL_CLK_SRC EQU    0x00000004   ; Clock Source.
+NVIC_ST_CTRL_INTEN   EQU    0x00000002   ; Interrupt enable.
+NVIC_ST_CTRL_ENABLE  EQU    0x00000001   ; Counter mode.
+
+; should be the same as in scmRTOS_TARGET_CFG.h
+SYSTICKFREQ          EQU    100000000
+SYSTICKINTRATE       EQU    1000
+
+; -----------------------------------------------------------------------------
+;       CODE GENERATION DIRECTIVES
+; 
+        AREA TEXT, CODE, READONLY
+        THUMB
+
+; -----------------------------------------------------------------------------
+;       HANDLE PendSV EXCEPTION
+;       void PendSV_Handler(void)
+; 
+;  Note(s) : 1) PendSV is used to cause a context switch.  This is a recommended method for performing
+;               context switches with Cortex-M3.  This is because the Cortex-M3 auto-saves half of the
+;               processor context on any exception, and restores same on return from exception.  So only
+;               saving of R4-R11 is required and fixing up the stack pointers.  Using the PendSV exception
+;               this way means that context saving and restoring is identical whether it is initiated from
+;               a thread or occurs due to an interrupt or exception.
+; 
+;            2) Pseudo-code is:
+;               a) Get the process SP, if 0 then skip (goto f) the saving part (first context switch);
+;               b) Save remaining regs r4-r11 on process stack;
+;               c) Call OS_ContextSwitchHook for save current task SP and get new task SP;
+;               d) Restore R4-R11 from new process stack;
+;               e) Perform exception return which will restore remaining context.
+;               f) Get SP for the first context switch (R2 hold it);
+;                  run SysTick; goto d);
+; 
+;            3) On entry into PendSV handler:
+;               a) The following have been saved on the process stack (by processor):
+;                  xPSR, PC, LR, R12, R0-R3
+;               b) Processor mode is switched to Handler mode (from Thread mode)
+;               c) Stack is Main stack (switched from Process stack)
+; 
+;            4) Since PendSV is set to lowest priority in the system (by OS_Start() below), we
+;               know that it will only be run when no other exception or interrupt is active, and
+;               therefore safe to assume that context being switched out was using the process stack (PSP).
+; 
+PendSV_Handler
+    CPSID   I                 ;  Prevent interruption during context switch
+    MRS     R0, PSP           ;  PSP is process stack pointer
+    CBZ     R0, nosave        ;  Skip register save the first time    
+
+    STMDB R0!, {R4-R11}       ;  Save remaining regs r4-11 on process stack
+    ;  At this point, entire context of process has been saved                                                            
+
+    PUSH    {R14}                        ;  Save LR exc_return value
+    LDR     R1, =OS_ContextSwitchHook    ;  OS_ContextSwitchHook();
+    BLX     R1
+    POP     {R14}
+    
+ContextRestore
+    ;  R0 is new process SP;
+    LDMIA R0!, {R4-R11}         ;  Restore r4-11 from new process stack
+    MSR     PSP, R0           ;  Load PSP with new process SP
+    ORR     LR, LR, #0x04     ;  Ensure exception return uses process stack
+    CPSIE   I
+    BX      LR                ;  Exception return will restore remaining context
+nosave
+    MOV R0, R2                ;  R2 hold the first task SP
+    
+    LDR     R1, =NVIC_ST_CTRL ;  Enable and run SysTick
+    LDR     R2, =(NVIC_ST_CTRL_CLK_SRC | NVIC_ST_CTRL_INTEN | NVIC_ST_CTRL_ENABLE)
+    STR     R2, [R1]
+    
+    B   ContextRestore
+
+   
+; -----------------------------------------------------------------------------
+;       START MULTITASKING
+;       void OS_Start(TStackItem* sp)
+; 
+;  Note(s) : 1) OS_Start() MUST:
+;               a) Setup PendSV and SysTick exception priority to lowest;
+;               b) Setup SysTick (reload value);
+;               c) Enable interrupts (tasks will run with interrupts enabled).
+; 
+OS_Start
+    LDR     R1, =NVIC_SYSPRI14      ;  Set the PendSV exception priority (lowest)
+    LDR     R2, =NVIC_PENDSV_PRI
+    STRB    R2, [R1]
+    LDR     R1, =NVIC_SYSPRI15      ;  Set the SysTick exception priority (lowest)
+    LDR     R2, =NVIC_ST_PRI
+    STRB    R2, [R1]
+    
+    LDR     R1, =NVIC_ST_RELOAD     ;  Setup SysTick
+    LDR     R2, =(SYSTICKFREQ/SYSTICKINTRATE-1)  
+    STR     R2, [R1]
+
+    MOV     R2, R0                  ;  Save the first task stack
+    MOVS    R0, #0                  ;  Set the PSP to 0 for initial context switch call
+    MSR     PSP, R0
+
+    LDR     R0, =NVIC_INT_CTRL      ;  Trigger the PendSV exception (causes context switch)
+    LDR     R1, =NVIC_PENDSVSET
+    STR     R1, [R0]
+
+    CPSIE   I                       ;  Enable interrupts at processor level
+loop
+    B       loop                    ;  Should never get here
+
+
+    END
diff -r 000000000000 -r 879af6e11219 scmRTOS/CortexM3/OS_Target_cpp.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/scmRTOS/CortexM3/OS_Target_cpp.cpp	Mon Feb 20 07:36:06 2012 +0000
@@ -0,0 +1,131 @@
+//******************************************************************************
+//*
+//*     FULLNAME:  Single-Chip Microcontroller Real-Time Operating System
+//*
+//*     NICKNAME:  scmRTOS
+//*
+//*     PROCESSOR: ARM Cortex-M3 
+//*
+//*     TOOLKIT:   EWARM (IAR Systems)
+//*               
+//*     PURPOSE:   Target Dependent Stuff Source
+//*               
+//*     Version: 3.10
+//*
+//*     $Revision: 195 $
+//*     $Date:: 2008-06-19 #$
+//*
+//*     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.
+//*     =================================================================
+//*
+//******************************************************************************
+//*     Ported by Andrey Chuikin, Copyright (c) 2008-2010
+
+
+#include <scmRTOS.h>
+
+using namespace OS;
+
+//------------------------------------------------------------------------------
+//
+//       OS Process's constructor
+//
+//       Performs:  
+//           * initializing process data;
+//           * registering of the process in kernel;
+//           * preparing stack frame;
+//                  
+//
+TBaseProcess::TBaseProcess(TStackItem* Stack, TPriority pr, void (*exec)())
+    : StackPointer(Stack)
+    , Timeout(0)
+    , Priority(pr)
+{
+    Kernel.RegisterProcess(this);
+
+    //---------------------------------------------------------------
+    //
+    //  Prepare Process Stack Frame
+    //
+    *(--StackPointer)  = 0x01000000L;             // xPSR
+    *(--StackPointer)  = reinterpret_cast<dword>(exec); // Entry Point
+    StackPointer -= 14;                           // emulate "push R14,R12,R3,R2,R1,R0,R11-R4"
+    
+    // The code below can be used for debug purpose. In this case comment
+    // line above and uncomment block below.
+/*
+    *(--StackPointer)  = 0xFFFFFFFEL;             // R14 (LR) (init value will cause fault if ever used)
+    *(--StackPointer)  = 0x12121212L;             // R12
+    *(--StackPointer)  = 0x03030303L;             // R3
+    *(--StackPointer)  = 0x02020202L;             // R2
+    *(--StackPointer)  = 0x01010101L;             // R1
+    *(--StackPointer)  = 0x00000000L;             // R0
+
+                                                  // Remaining registers saved on process stack
+    *(--StackPointer)  = 0x11111111L;             // R11
+    *(--StackPointer)  = 0x10101010L;             // R10
+    *(--StackPointer)  = 0x09090909L;             // R9
+    *(--StackPointer)  = 0x08080808L;             // R8
+    *(--StackPointer)  = 0x07070707L;             // R7
+    *(--StackPointer)  = 0x06060606L;             // R6
+    *(--StackPointer)  = 0x05050505L;             // R5
+    *(--StackPointer)  = 0x04040404L;             // R4
+*/
+}
+//------------------------------------------------------------------------------
+//
+//   Idle Process
+//
+typedef process<prIDLE, scmRTOS_IDLE_PROCESS_STACK_SIZE> TIdleProcess;
+
+TIdleProcess IdleProcess;
+
+template<> OS_PROCESS void TIdleProcess::Exec()
+{
+    for(;;)
+    {
+        #if scmRTOS_IDLE_HOOK_ENABLE == 1
+        IdleProcessUserHook();
+        #endif
+    }
+}
+//------------------------------------------------------------------------------
+OS_INTERRUPT void OS::SysTick_Handler()
+{
+    scmRTOS_ISRW_TYPE ISR;
+
+    Kernel.SystemTimer();
+    
+#if scmRTOS_SYSTIMER_NEST_INTS_ENABLE == 0
+    DISABLE_NESTED_INTERRUPTS();
+#endif
+    
+#if scmRTOS_SYSTIMER_HOOK_ENABLE == 1
+    SystemTimerUserHook();
+#endif
+}
+//------------------------------------------------------------------------------
+
diff -r 000000000000 -r 879af6e11219 scmRTOS/CortexM3/commdefs.h
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/scmRTOS/CortexM3/commdefs.h	Mon Feb 20 07:36:06 2012 +0000
@@ -0,0 +1,71 @@
+//******************************************************************************
+//*
+//*     FULLNAME:  Single-Chip Microcontroller Real-Time Operating System
+//*
+//*     NICKNAME:  scmRTOS
+//*
+//*     PROCESSOR: ARM Cortex-M3 
+//*
+//*     TOOLKIT:   EWARM (IAR Systems)
+//*
+//*     PURPOSE:   Common Type Definitions
+//*
+//*     Version: 3.10
+//*
+//*     $Revision: 195 $
+//*     $Date:: 2008-06-19 #$
+//*
+//*     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.
+//*     =================================================================
+//*
+//******************************************************************************
+//*     Ported by Andrey Chuikin, Copyright (c) 2008-2010
+
+
+#ifndef COMMONDEFS_H
+#define COMMONDEFS_H
+
+#ifndef __IAR_SYSTEMS_ASM__
+
+typedef unsigned char  byte;
+typedef signed char    sbyte;
+typedef unsigned short word;
+typedef unsigned long  dword;
+
+typedef volatile byte  sfr_byte;
+typedef volatile word  sfr_word;
+typedef volatile dword sfr_dword;
+
+#define INLINE _Pragma("inline=forced")
+
+#endif // __IAR_SYSTEMS_ASM__
+
+#endif // COMMONDEFS_H
+
+//-----------------------------------------------------------------------------
+
+/*============================================================================*/
+
diff -r 000000000000 -r 879af6e11219 scmRTOS/CortexM3/device.h
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/scmRTOS/CortexM3/device.h	Mon Feb 20 07:36:06 2012 +0000
@@ -0,0 +1,60 @@
+//******************************************************************************
+//*
+//*     FULLNAME:  Single-Chip Microcontroller Real-Time Operating System
+//*
+//*     NICKNAME:  scmRTOS
+//*
+//*     PROCESSOR: ARM Cortex-M3 
+//*
+//*     TOOLKIT:   EWARM (IAR Systems)
+//*
+//*     PURPOSE:   Device Definitions
+//*
+//*     Version: 3.10
+//*
+//*     $Revision: 196 $
+//*     $Date:: 2008-06-19 #$
+//*
+//*     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.
+//*     =================================================================
+//*
+//******************************************************************************
+//*     Ported by Andrey Chuikin, Copyright (c) 2008-2010
+
+#ifndef DEVICE_H
+#define DEVICE_H
+
+#include <commdefs.h>
+
+//------------------------------------------------------------------------------
+// Definitions for some processor registers in order to not include specific
+// header file for various Cortex-M3 processor derivatives.
+#define CPU_ICSR            ( ( sfr_dword *) 0xE000ED04 )   // Interrupt Control State Register
+#define CPU_SYSTICKCSR      ( ( sfr_dword *) 0xE000E010 )   // SysTick Control and Status Register
+#define CPU_SYSTICKCSR_EINT 0x02                            // Bit for enable/disable SysTick interrupt
+
+
+#endif  /* DEVICE_H */
diff -r 000000000000 -r 879af6e11219 scmRTOS/scmRTOS_TARGET_CFG.h
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/scmRTOS/scmRTOS_TARGET_CFG.h	Mon Feb 20 07:36:06 2012 +0000
@@ -0,0 +1,102 @@
+//******************************************************************************
+//*
+//*     FULLNAME:  Single-Chip Microcontroller Real-Time Operating System
+//*
+//*     NICKNAME:  scmRTOS
+//*
+//*     PROCESSOR: ARM Cortex-M3 
+//*
+//*     TOOLKIT:   EWARM (IAR Systems)
+//*
+//*     PURPOSE:   Project Level Target Extensions Config
+//*
+//*     Version: 3.10
+//*
+//*     $Revision: 196 $
+//*     $Date:: 2008-06-19 #$
+//*
+//*     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.
+//*     =================================================================
+//*
+//******************************************************************************
+//*     mbed port by Igor Skochinsky
+
+#ifndef  scmRTOS_TARGET_CFG_H
+#define  scmRTOS_TARGET_CFG_H
+
+#include "device.h"
+
+// Define SysTick clock frequency and its interrupt rate in Hz.
+#define SYSTICKFREQ     100000000
+#define SYSTICKINTRATE  1000
+
+//------------------------------------------------------------------------------
+//
+//       System Timer stuff
+//
+//
+namespace OS
+{
+extern "C" void SysTick_Handler();
+}
+
+#define  LOCK_SYSTEM_TIMER()    ( *CPU_SYSTICKCSR &= ~CPU_SYSTICKCSR_EINT )
+#define  UNLOCK_SYSTEM_TIMER()  ( *CPU_SYSTICKCSR |=  CPU_SYSTICKCSR_EINT )
+
+//------------------------------------------------------------------------------
+//
+//       Context Switch ISR stuff
+//
+//
+namespace OS
+{
+#if scmRTOS_IDLE_HOOK_ENABLE == 1
+    void IdleProcessUserHook();
+#endif
+
+#if scmRTOS_CONTEXT_SWITCH_SCHEME == 1
+
+    INLINE inline void RaiseContextSwitch() { *CPU_ICSR |= 0x10000000; }
+
+    #define ENABLE_NESTED_INTERRUPTS()
+    
+    #if scmRTOS_SYSTIMER_NEST_INTS_ENABLE == 0
+        #define DISABLE_NESTED_INTERRUPTS() TCritSect cs
+    #else
+        #define DISABLE_NESTED_INTERRUPTS()
+    #endif
+
+#else
+    #error "Cortex-M3 port supports software interrupt switch method only!"
+
+#endif // scmRTOS_CONTEXT_SWITCH_SCHEME
+
+}
+//-----------------------------------------------------------------------------
+
+#endif // scmRTOS_TARGET_CFG_H
+//-----------------------------------------------------------------------------
+
diff -r 000000000000 -r 879af6e11219 scmRTOS_config.h
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/scmRTOS_config.h	Mon Feb 20 07:36:06 2012 +0000
@@ -0,0 +1,133 @@
+//******************************************************************************
+//*
+//*     FULLNAME:  Single-Chip Microcontroller Real-Time Operating System
+//*
+//*     NICKNAME:  scmRTOS
+//*
+//*     PROCESSOR: ARM Cortex-M3 
+//*
+//*     TOOLKIT:   EWARM (IAR Systems)
+//*
+//*     PURPOSE:   Project Level Configuration
+//*
+//*     Version: 3.10
+//*
+//*     $Revision: 196 $
+//*     $Date:: 2008-06-19 #$
+//*
+//*     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.
+//*     =================================================================
+//*
+//******************************************************************************
+//*     Ported by Andrey Chuikin, Copyright (c) 2008-2010
+
+#ifndef  scmRTOS_CONFIG_H
+#define  scmRTOS_CONFIG_H
+
+#ifndef __IAR_SYSTEMS_ASM__
+#include <commdefs.h>
+
+typedef word TTimeout;
+
+#endif // __IAR_SYSTEMS_ASM__
+
+#include "device.h"
+//------------------------------------------------------------------------------
+//
+//    Specify scmRTOS Process Count. Must be less than 31
+//
+//
+#define  scmRTOS_PROCESS_COUNT                  3
+
+//-----------------------------------------------------------------------------
+//
+//    scmRTOS System Timer 
+// 
+//    Nested Interrupts enable macro. Value 1 means that interrupts are
+//    globally enabled within System Timer ISR (this is default for Cortex-M3).
+// 
+//
+#define scmRTOS_SYSTIMER_NEST_INTS_ENABLE 1
+
+//-----------------------------------------------------------------------------
+//
+//    scmRTOS System Timer Tick Counter Enable
+//
+//
+#define  scmRTOS_SYSTEM_TICKS_ENABLE        1
+
+
+//-----------------------------------------------------------------------------
+//
+//    scmRTOS System Timer Hook
+//
+//
+#define  scmRTOS_SYSTIMER_HOOK_ENABLE       0
+
+//-----------------------------------------------------------------------------
+//
+//    scmRTOS Idle Process Hook
+//
+//
+#define  scmRTOS_IDLE_HOOK_ENABLE           1
+
+//-----------------------------------------------------------------------------
+//
+//    scmRTOS Idle Process Stack size (in bytes)
+//    (20 * sizeof(TStackItem)) - it's a minimum allowed value.
+//
+#define scmRTOS_IDLE_PROCESS_STACK_SIZE       (20 * sizeof(TStackItem))
+
+//-----------------------------------------------------------------------------
+//
+//    scmRTOS Priority Order
+//
+//    This macro defines the order of the process's priorities. Default,
+//    the ascending order is used. Alternatively, the descending priority 
+//    order can be used. On some platforms the descending order is preferred
+//    because of performance.   
+// 
+//    Default (corresponding to ascending order) value of macro is 0.  
+//    Alternative (corresponding to descending order) value of macro is 1.  
+//
+//    On Cortex-M3 the descending order is preferred for performance reason.
+//
+#define  scmRTOS_PRIORITY_ORDER 1
+
+//-----------------------------------------------------------------------------
+//
+//    scmRTOS Context Switch User Hook enable
+// 
+//    The macro enables/disables user defined hook called from system
+//    Context Switch Hook function.
+//
+//
+#define  scmRTOS_CONTEXT_SWITCH_USER_HOOK_ENABLE  0
+
+
+#endif // scmRTOS_CONFIG_H
+//-----------------------------------------------------------------------------
+
diff -r 000000000000 -r 879af6e11219 wave_player.lib
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/wave_player.lib	Mon Feb 20 07:36:06 2012 +0000
@@ -0,0 +1,1 @@
+http://mbed.org/users/sravet/code/wave_player/#acc3e18e77ad