#ifdef SPMCR
#define SPM_CONTROL_REG SPMCR
#elif defined(SPMCSR)
#define SPM_CONTROL_REG SPMCSR
#else
#error SPM_CONTROL_REG is not defined
#endif

        RaiseContextSwitch();
        do
        {
            EnableContextSwitch();
            DUMMY_INSTR();
            DisableContextSwitch();
        }
        while(!IsContextSwitchDone());

INLINE inline void EnableInterrupts() { __enable_interrupt();  }
INLINE inline void DisableInterrupts() { __disable_interrupt(); }

#pragma segment="CSTACK"
#pragma segment="RSTACK"

#define  ABS_WORD(x)  (*((volatile word*)x))

INLINE inline TStackItem* GetDataSP()   { return reinterpret_cast<TStackItem*>(ABS_WORD(28)); }
INLINE inline TStackItem* GetReturnSP() { return reinterpret_cast<TStackItem*>(SP); }

INLINE inline void SetISRStackPointers()
{
    ABS_WORD(28) = reinterpret_cast<word>(__segment_end("CSTACK"));
    SP = reinterpret_cast<word>(__segment_end("RSTACK")) - 1;
}

INLINE inline void SetDataSP(TStackItem* sp)   { ABS_WORD(28) = reinterpret_cast<word>(sp); }
INLINE inline void SetReturnSP(TStackItem* sp) { SP = reinterpret_cast<word>(sp); }

namespace OS
{
    INLINE inline void EnableContextSwitch()  { EnableInterrupts();  }
    INLINE inline void DisableContextSwitch() { DisableInterrupts(); }
}

svn co http://scmrtos.svn.sourceforge.net/svnroot/scmrtos/branches/pre-v400/Samples/AVR/IAR scmRTOS-samples

svn up

//---------------------------------------------------------------------------
#include <scmRTOS.h>
//---------------------------------------------------------------------------
// Типы процессов

typedef OS::process<OS::pr0, 120, 32> TProc1;
typedef OS::process<OS::pr1, 160, 32> TProc2;

//---------------------------------------------------------------------------
// Создание объектов процессов (выделение под них памяти)

TProc1 Proc1;
TProc2 Proc2;
//---------------------------------------------------------------------------
dword T;                         // global variable for OS::GetTickCount testing
                                 //
OS::TEventFlag ef;               //
OS::TEventFlag Timer1_Ovf;       //

dword Count;
dword Value;

//---------------------------------------------------------------------------
int main()
{
    // Порт C0 на вывод
    DDRC |= (1 << 0);
    // Порт C1 на вывод
    DDRC |= (1 << 1);

    // Старт таймера 1 с прескаллером 1
    TCCR1B |= (1 << CS10);    
    // Разрешить прерывания таймера 1
    TIMSK  |= (1 << OCIE1A);  

    // Старт системного таймера (таймер 0)
    TCCR0 = 0x03;            
    // Разрешить прерывания таймера 0
    TIMSK |=  (1 << TOIE0);  
    
    // Пуск ОС
    OS::Run();
}
//---------------------------------------------------------------------------
template<> void TProc1::Exec()
{
    // бесконечный цыкл процесса 1
    for(;;)
    {
        // ожидание переполнения таймера 1
        Timer1_Ovf.Wait();
        PORTC ^= (1 << 0);
    }
}
//---------------------------------------------------------------------------
template<> void TProc2::Exec()
{
    // бесконечный цыкл процесса 2
    for(;;)
    {
       // ef.Wait();
        PORTC ^= (1 << 1);
        T += OS::GetTickCount();
        Sleep(10);

    }
}
//---------------------------------------------------------------------------
void OS::SystemTimerUserHook() { }
//---------------------------------------------------------------------------
void OS::IdleProcessUserHook() { }
//---------------------------------------------------------------------------
#pragma vector=TIMER1_COMPA_vect
OS_INTERRUPT void Timer1_period_ISR()
{
    OS::TISRW_SS ISRW;

    ENABLE_NESTED_INTERRUPTS();
    PORTC ^= (1 << 0);

    Timer1_Ovf.SignalISR();
}
//---------------------------------------------------------------------------

//---------------------------------------------------------------------------
void OS::SystemTimerUserHook() { }
//---------------------------------------------------------------------------
void OS::IdleProcessUserHook() { }
//---------------------------------------------------------------------------
#pragma vector=TIMER1_COMPA_vect
OS_INTERRUPT void Timer1_period_ISR()
{
    OS::TISRW_SS ISRW;

    ENABLE_NESTED_INTERRUPTS();
    PORTC ^= (1 << 0);

    Timer1_Ovf.SignalISR();
}

#  if defined(SPM_READY_vect)
#    define CONTEXT_SWITCH_ISR_VECTOR  SPM_READY_vect
#    define SPM_CONTROL_REG SPMCSR
#  elif defined(SPM_RDY_vect)
#    define CONTEXT_SWITCH_ISR_VECTOR  SPM_RDY_vect
#    define SPM_CONTROL_REG SPMCR
#  else
#    error "SPM ready interrupt vector not defined"

#    define SPM_CONTROL_REG SPMCSR

int main()
{
    TCCR1B = (1 << WGM12) | (1 << CS10);    // CTC mode, clk/1
    OCR1A  = 40000U;
    TIMSK = (1 << OCIE1A); // Timer1 OC interrupt enable

    // Start System Timer
    TCCR0  = (1 << CS01) | (1 << CS00); // clk/64
    TIMSK |= (1 << TOIE0);

    DRIVER(TIMER1_ISR,OUT);
    DRIVER(TIMER_HOOK,OUT);
    DRIVER(IDLE_HOOK,OUT);
    //
    OS::run();
}

    DDRC |= (1 << 0);

    TCNT0 = 0xf0;
    TCCR0 = 0x05;                  
    TIMSK |=  (1 << TOIE0);

template<> void TProc1::Exec()
{
    for(;;)
    {
        PORTC ^= (1 << 0);
        Sleep(500);
    }
}
//---------------------------------------------------------------------------
template<> void TProc2::Exec()
{
    for(;;)
    {
        Sleep(10);
    }
}
//---------------------------------------------------------------------------
void OS::SystemTimerUserHook()
{
    TCNT0 = 0xf0;
}