template<> void TProc2::Exec()
{
    for(;;)
    {
      ef.Wait();
      PORTC |= (1 << 3);

    }
}
//---------------------------------------------------------------------------
template<> void TProc3::Exec()
{
    for(;;)
    {

       Sleep(20);
       ef.Signal();
      PORTC &= ~(1 << 3);
    }
}

    ACSR |= (1 << ACBG) | (1 << ACIE); /* Ref ON, IE ON */  
    DDRB |= (1 << 4);                  /* AIN1*/

void OS::TKernel::SchedISR()
{
    TPriority NextPrty = GetHighPriority(ReadyProcessMap);
    if(NextPrty != CurProcPriority)
    {
        SchedProcPriority    = NextPrty;
        RaiseContextSwitch();
    }
}

#define  scmRTOS_CONTEXT_SWITCH_SCHEME      1

#if scmRTOS_CONTEXT_SWITCH_SCHEME == 1

    INLINE inline void RaiseContextSwitch() { SPM_CONTROL_REG |= (1 << SPMIE);  } // enable SPM interrupt
    INLINE inline void BlockContextSwitch() { SPM_CONTROL_REG &= ~(1 << SPMIE); } // disable SPM interrupt

#if scmRTOS_CONTEXT_SWITCH_SCHEME == 1

    INLINE inline void RaiseContextSwitch() { SPM_CONTROL_REG |= (1 << SPMIE);  } // enable SPM interrupt
    INLINE inline void BlockContextSwitch() { SPM_CONTROL_REG &= ~(1 << SPMIE); } // disable SPM interrupt

//    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.
//
//
#define  scmRTOS_CONTEXT_SWITCH_SCHEME      1

#define CONTEXT_SWITCH_ISR_VECTOR  SPM_READY_vect

#define CONTEXT_SWITCH_ISR_VECTOR  ANA_COMP_vect

#define  scmRTOS_CONTEXT_SWITCH_SCHEME      0

#define  scmRTOS_CONTEXT_SWITCH_SCHEME      1

//---------------------------------------------------------------------------
//  "Hello, scope!" pins in pin_macros.h notation.
#define TIMER1_ISR      D,5,H
#define TIMER1_TO_PROC1 B,0,H
#define PROC1           B,1,H
#define PROC2           B,2,H
#define PROC3           B,3,H
#define TIMER_HOOK      B,4,H
#define IDLE_HOOK       B,5,H


//---------------------------------------------------------------------------
//
//      Process types
//

// demonstrate process switching from Proc2 to Proc3 in sleep() or ef.signal() call
#if PROC2_HIGHER_THAN_PROC3
# define PROC2_PRIO OS::pr1
# define PROC3_PRIO OS::pr2
#else
# define PROC2_PRIO OS::pr2
# define PROC3_PRIO OS::pr1
#endif


typedef OS::process<OS::pr0, 120, 32> TProc1;
typedef OS::process<PROC2_PRIO, 160, 32> TProc2;
typedef OS::process<PROC3_PRIO, 120, 32> TProc3;

template<> void TProc1::exec();
template<> void TProc2::exec();
template<> void TProc3::exec();

//---------------------------------------------------------------------------
//
//      Process objects
//
TProc1 Proc1;
TProc2 Proc2;
TProc3 Proc3;

//---------------------------------------------------------------------------
tick_count_t tick_count;    // global variable for OS::GetTickCount testing

OS::TEventFlag Timer1_Ovf;  // set in TIMER1_COMPA_vect(), waited in Proc1
OS::TEventFlag ef;          // set in Proc3, waited in Proc2

//---------------------------------------------------------------------------
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();
}

#if scmRTOS_CONTEXT_SWITCH_SCHEME == 0
     public  OS_ContextSwitcher
#else
     extern  OS_ContextSwitchHook
#endif

#if scmRTOS_CONTEXT_SWITCH_SCHEME == 1
    // Setup analog comparator as software interrupt source
    #if PORT_TOGGLE_BY_PIN_WRITE      // see pin_macros.h for PORT_TOGGLE_BY_PIN_WRITE definition and sing
    ACSR = (1 << ACBG);        // Ref ON, interrupt on both edges
    #else
    ACSR = (1 << ACBG) | (1 << ACIS1);    // Ref ON, falling edge
    #endif
    DRIVER(RAISE_PIN,OUT);    // AIN1 - output
    // analog comparator propagation and synchronization delay
    _delay_us(2);
    ACSR |= (1 << ACI);    // needed for new chips with improved sbi/cbi behavior
    ACSR |= (1 << ACIE);
#endif

USART_Init:
  out UBRRH, r17
  out UBRRL, r16
  ldi r16, (1<<RXEN)|(1<<TXEN)
  out UCSRB,r16
  ldi r16, (1<<USBS)|(3<<UCSZ0)
  out UCSRC,r16
  ret
end

void uart_init(uint16_t baud_div)
{
        UBRRH = baud_div >> 8;
        UBRRL = baud_div;
        UCSRB = (1<<RXEN)|(1<<TXEN);
        UCSRC = (1<<USBS)|(3<<UCSZ0);
}

uart_init:
/* prologue: function */
/* frame size = 0 */
    out 64-32,r25
    out 41-32,r24
    ldi r24,lo8(24)
    out 42-32,r24
    ldi r24,lo8(14)
    out 64-32,r24
/* epilogue start */
    ret

void USART_Init( unsigned int baudrate, bool usart_number)
{
    if(!usart_number)
    {
        // установка частоты бод
        UBRR0H = (unsigned char) (baudrate>>8);                  
        UBRR0L = (unsigned char) baudrate;
        // Разрешить передачу
        UCSR0B = ( 1 << TXEN0 );
        // Установка формата фреймов: 8 data 1stop
        UCSR0C = (1<<UCSZ01)|(1<<UCSZ00);              
    }
    else
    {  
        // установка частоты бод
        UBRR1H = (unsigned char) (baudrate>>8);                  
        UBRR1L = (unsigned char) baudrate;
        // Разрешить прием и передачу
        UCSR1B = ( ( 1 << RXEN1 ) | ( 1 << TXEN1 ) );
        // Установка формата фреймов: 7 data 2stop
        UCSR1C = (1<<USBS1)|(1<<UCSZ11);              
    }        
}

const char __flash cTrPr15[5] = {0x55,0x34,0x0a,0x41,0xd4};

unsigned char USART_Receive( void )
{
  ....
}

// Передача команд по MODBUS
template<> void TProc1::Exec()
{

    for(;;)
    {
        Sleep(900);
        // Запретить прием
        UCSR0B &= ~( 1 << RXEN0 );
        // Запретить прерывания на прием USART0
        UCSR0B &= ~(1<<RXCIE0);
//---------------------------------------------------------------------------
        ...... передача по USART0 типа
      // Ждять пока будет пуст буфер передачи
      while ( !(UCSR0A & (1<<UDRE0)) );                             
      // Передача байта
      UDR0 = data;                     

//---------------------------------------------------------------------------
        // Разрешить прием  
        UCSR0B |= (1 << RXEN0);
        // Разрешить прерывания на прием USART0
        UCSR0B |= (1<<RXCIE0);
    }
}

template<> void TProc2::Exec()
{
    __watchdog_reset();

    unsigned char i;
    
    for(;;)
    {
        // Ожидание Timer1_CompA через 90 мс  
        Sleep(150);
        Timer1_CompA.Wait();
        .... пердача типа
        while ( !(UCSR1A & (1<<UDRE1)) );                             
        UDR1 = data;         
     }
}

// Прием по Modbus
template<> void TProc3::Exec()
{
    for(;;)
    {
//        Sleep(1);
        // Сброс флага приема
        Usart0_rxc.Wait();
        cRxBuf[cRxBufCount] = UDR0;
        cRxBufCount++;
    }
}

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

    ENABLE_NESTED_INTERRUPTS();

    Timer1_CompA.SignalISR();
}
//---------------------------------------------------------------------------
#pragma vector=USART0_RXC_vect
OS_INTERRUPT void Usart0_rxc_ISR()
{
    OS::TISRW_SS ISRW;

    ENABLE_NESTED_INTERRUPTS();

    Usart0_rxc.SignalISR();
}

#pragma vector=USART0_RXC_vect
OS_INTERRUPT void Usart0_rxc_ISR()
{
    OS::TISRW_SS ISRW;

    cRxBuf[cRxBufCount] = UDR0;
    cRxBufCount++;

    Usart0_rxc.SignalISR();
}