void putchar( char c ) {
    if ( !c )
    return( 0 );
    Transmit_Byte( c );  /*функция отправки сообщения в последовательный порт*/
}

int putchar( int c ) {
    Transmit_Byte( c );  /*выводит байт в UART*/
   return c;
}

#define UART_TX_BUFFER_SIZE0 64
#define UART_TX_BUFFER_MASK0 ( UART_TX_BUFFER_SIZE0 - 1 )

static unsigned char UART_TxBuf0[UART_TX_BUFFER_SIZE0];
static volatile unsigned char UART_TxHead0;
static volatile unsigned char UART_TxTail0;

void Transmit_Byte( unsigned char data0 ) {
    unsigned char tmphead0;

    tmphead0 = ( UART_TxHead0 + 1 ) & UART_TX_BUFFER_MASK0;
    while ( tmphead0 == UART_TxTail0 );
    UART_TxBuf0[tmphead0] = data0;
    UART_TxHead0 = tmphead0;
    UCSR0B |= (1<<UDRIE0);
}


#pragma vector=USART_UDRE_vect
__interrupt void USART0_TX_interrupt( void ) {
    unsigned char tmptail0;

    if ( UART_TxHead0 != UART_TxTail0 ) {
        tmptail0 = ( UART_TxTail0 + 1 ) & UART_TX_BUFFER_MASK0;
    UART_TxTail0 = tmptail0;
    UDR0=UART_TxBuf0[tmptail0];
    }
    else {
    UCSR0B &= ~(1<<UDRIE0);
    }
}

void uart_t::send(uint8_t byte)
{
    uint8_t Tmp = (TxHead + 1) & (UART_TX_BUFF_SIZE - 1);
    while(Tmp == TxTail)
       ;       // Buffer full
    TxBuffer[ TxHead ] = byte;
    TxHead = Tmp;
    UCSRB |= (1<<UDRIE);
}

inline void  uart_t::UDRE_handler(void)
{
    uint8_t Tmp = TxTail;
    UDR = TxBuffer[ Tmp ];
    TxTail = Tmp = (Tmp + 1) & (UART_TX_BUFF_SIZE - 1);
    if(Tmp == TxHead)
        UCSRB &= ~(1<<UDRIE);
}

union {
volatile uint8_t TxTail;
uint8_t TxTail_int;
};

inline void  uart_t::UDRE_handler(void)
{
    UDR = TxBuffer[ TxTail_int ];
    TxTail_int = (TxTail_int + 1) & (UART_TX_BUFF_SIZE - 1);
    if(TxTail_int == TxHead)
        UCSRB &= ~(1<<UDRIE);
}

void uart_t::send(uint8_t byte)
{
    uint8_t Tmp = TxHead;
    while((uint8_t)(Tmp - TxTail) >=  (uint8_t) UART_TX_BUFF_SIZE)
    ; // Buffer full
    TxBuffer[ Tmp++ & (UART_TX_BUFF_SIZE - 1) ] = byte;
    TxHead = Tmp;
    UCSRB |= (1<<UDRIE);
}

inline void uart_t::UDRE_Handler()
{
    uint8_t Tmp = TxTail;
    UDR = TxBuffer[ Tmp++ & (UART_TX_BUFF_SIZE - 1) ];
    TxTail = Tmp;
    if(Tmp == TxHead)
        UCSRB &= ~(1<<UDRIE);
}

//----------------------------------------------------------------------------
void boutchar( char ch )
{
    if(    status_word & STW_THR_BUSY )
    {    tbuf.buf[tbuf.tail & TBUF_SIZE_MSK] = ch;
              tbuf.tail++;
    }
    else
    {
        status_word |= STW_THR_BUSY;
        U0THR = ch;
    }
}
//----------------------------------------------------------------------------
__irq __arm  void uart_isr(void)
{
bint ch;

    while( !((ch = (U0IIR&IIR_MASK)) & IIR_IP) )        // Check Pending Bit
    {
        // What caused the interrupt?
        switch( ch )
        {

        case IIR_THRE:    // The THRE+TEMPT+FIFO is empty. If there is another
                        //    characters in the TX buffer, load its now to FIFO->THRE.
            if( tbuf.tail != tbuf.head )
            {   for( int ii=0; ( tbuf.tail != tbuf.head )&&( ii < TR_FIFO_SIZE ); ii++ )
                    U0THR = tbuf.buf[(tbuf.head++) & TBUF_SIZE_MSK];
            }
            else
                status_word &= (~STW_THR_BUSY);
            break;

.......

if( tbuf.tail != tbuf.head )
                    U0THR = tbuf.buf[(tbuf.head++) & TBUF_SIZE_MSK];
            else
                status_word &= (~STW_THR_BUSY);

    
    uint8_t Tmp = TxTail;
    UDR = TxBuffer[ Tmp++ & (UART_TX_BUFF_SIZE - 1) ];
    TxTail = Tmp;
    if(Tmp == TxHead)
        UCSRB &= ~(1<<UDRIE);

     82          void send1( BYTE ch )
   \                     send1:
     83          {
   \   00000000   ....               LDI     R30, LOW(TxTail)
   \   00000002   ....               LDI     R31, (TxTail) >> 8
   \   00000004   8121               LDD     R18, Z+1
     84              while( (BYTE)(TxHead - TxTail) >=  UART_TX_BUFF_SIZE)
   \                     ??send1_0:
   \   00000006   8130               LD      R19, Z
   \   00000008   2F12               MOV     R17, R18
   \   0000000A   1B13               SUB     R17, R19
   \   0000000C   3410               CPI     R17, 64
   \   0000000E   F7D8               BRCC    ??send1_0
     85; // Buffer full
     86          
     87              TxBuffer[ TxTail++ & (UART_TX_BUFF_SIZE - 1) ] = ch;
   \   00000010   8120               LD      R18, Z
   \   00000012   2F12               MOV     R17, R18
   \   00000014   9513               INC     R17
   \   00000016   8310               ST      Z, R17
   \   00000018   E0F0               LDI     R31, 0
   \   0000001A   732F               ANDI    R18, 0x3F
   \   0000001C   2FE2               MOV     R30, R18
   \   0000001E   ....               SUBI    R30, LOW((-(TxBuffer) & 0xFFFF))
   \   00000020   ....               SBCI    R31, (-(TxBuffer) & 0xFFFF) >> 8
   \   00000022   8300               ST      Z, R16
     88          }
   \   00000024   9508               RET

     91          void send2( BYTE ch )
   \                     send2:
     92          {
   \   00000000   2F3B               MOV     R19, R27
   \   00000002   2F4A               MOV     R20, R26
     93          BYTE Tmp = ( TxTail + 1 )&(UART_TX_BUFF_SIZE - 1);    
   \   00000004   ....               LDI     R30, LOW(TxTail)
   \   00000006   ....               LDI     R31, (TxTail) >> 8
   \   00000008   8110               LD      R17, Z
   \   0000000A   9513               INC     R17
   \   0000000C   731F               ANDI    R17, 0x3F
   \   0000000E   8121               LDD     R18, Z+1
     94          
     95              while( TxHead == Tmp )
   \                     ??send2_0:
   \   00000010   1721               CP      R18, R17
   \   00000012   F3F1               BREQ    ??send2_0
     96; // Buffer full
     97          
     98              TxBuffer[ TxTail ] = ch;
   \   00000014   81A0               LD      R26, Z
   \   00000016   E0B0               LDI     R27, 0
   \   00000018   ....               SUBI    R26, LOW((-(TxBuffer) & 0xFFFF))
   \   0000001A   ....               SBCI    R27, (-(TxBuffer) & 0xFFFF) >> 8
   \   0000001C   930C               ST      X, R16
     99              TxTail = Tmp;
   \   0000001E   8310               ST      Z, R17
    100          }
   \   00000020   2FA4               MOV     R26, R20
   \   00000022   2FB3               MOV     R27, R19
   \   00000024   9508               RET

     82          void send1( BYTE ch )
   \                     send1:
     83          {
   \   00000000   ....               LDI     R30, LOW(TxTail)
   \   00000002   ....               LDI     R31, (TxTail) >> 8
     84              while( (BYTE)(TxHead - TxTail) >=  UART_TX_BUFF_SIZE)
   \                     ??send1_0:
   \   00000004   8111               LDD     R17, Z+1
   \   00000006   8120               LD      R18, Z
   \   00000008   1B12               SUB     R17, R18
   \   0000000A   3410               CPI     R17, 64
   \   0000000C   F7D8               BRCC    ??send1_0
     85        ; // Buffer full
     86          
     87              TxBuffer[ TxTail++ & (UART_TX_BUFF_SIZE - 1) ] = ch;
   \   0000000E   8120               LD      R18, Z
   \   00000010   2F12               MOV     R17, R18
   \   00000012   9513               INC     R17
   \   00000014   8310               ST      Z, R17
   \   00000016   E0F0               LDI     R31, 0
   \   00000018   732F               ANDI    R18, 0x3F
   \   0000001A   2FE2               MOV     R30, R18
   \   0000001C   ....               SUBI    R30, LOW((-(TxBuffer) & 0xFFFF))
   \   0000001E   ....               SBCI    R31, (-(TxBuffer) & 0xFFFF) >> 8
   \   00000020   8300               ST      Z, R16
     88          }
   \   00000022   9508               RET

     91          void send2( BYTE ch )
   \                     send2:
     92          {
   \   00000000   2F3B               MOV     R19, R27
   \   00000002   2F4A               MOV     R20, R26
     93          BYTE Tmp = ( TxTail + 1 )&(UART_TX_BUFF_SIZE - 1);    
   \   00000004   ....               LDI     R30, LOW(TxTail)
   \   00000006   ....               LDI     R31, (TxTail) >> 8
   \   00000008   8110               LD      R17, Z
   \   0000000A   9513               INC     R17
   \   0000000C   731F               ANDI    R17, 0x3F
     94          
     95              while( TxHead == Tmp )
   \                     ??send2_0:
   \   0000000E   8121               LDD     R18, Z+1
   \   00000010   1721               CP      R18, R17
   \   00000012   F3E9               BREQ    ??send2_0
     96        ; // Buffer full
     97          
     98              TxBuffer[ TxTail ] = ch;
   \   00000014   81A0               LD      R26, Z
   \   00000016   E0B0               LDI     R27, 0
   \   00000018   ....               SUBI    R26, LOW((-(TxBuffer) & 0xFFFF))
   \   0000001A   ....               SBCI    R27, (-(TxBuffer) & 0xFFFF) >> 8
   \   0000001C   930C               ST      X, R16
     99              TxTail = Tmp;
   \   0000001E   8310               ST      Z, R17
    100          }
   \   00000020   2FA4               MOV     R26, R20
   \   00000022   2FB3               MOV     R27, R19
   \   00000024   9508               RET

  TxBuffer[ TxHead ] = byte;
    TxHead = Tmp;
    UCSRB |= (1<<UDRIE);

    TxHead = Tmp;
    UCSRB |= (1<<UDRIE);
  TxBuffer[ TxHead ] = byte;

  uint8_t * ptr = &TxBuffer[ TxHead ];
    TxHead = Tmp;
    UCSRB |= (1<<UDRIE);
    *ptr = byte;

#include <avr/io.h>
uint8_t i;
inline void ppi() {
        uint8_t temp = i + 1;
        i = temp;
}

void foo(uint8_t n) {
        while(n--) {
                ppi();
                PORTB = 0;
        }
}

foo:
    tst r24
    breq .L6
    lds r18,i
    mov r25,r24
.L5:
    out 56-32,__zero_reg__
    subi r25,lo8(-(-1))
    brne .L5
    add r18,r24
    sts i,r18
.L6:
    ret

  uint8_t * ptr = &TxBuffer[ TxHead ];
    TxHead = Tmp;
    UCSRB |= (1<<UDRIE);
    *ptr = byte;

    UCSRB |= (1<<UDRIE);
    TxBuffer[ TxHead ] = byte;
    TxHead = Tmp;

class TCritSect
{
public:
    TCritSect () : StatusReg( SREG ) { cli(); }
    ~TCritSect() { SREG = StatusReg; }
private:
    TStatusReg StatusReg;
};

    INLINE inline dword GetTickCount() { TCritSect cs; return Kernel.SysTickCount; }

   dword tmp;
   cs.StatusReg = SREG;
   cli();
   tmp = Kernel.SysTickCount;
   SREG = cs.StatusReg;
   return tmp;

   cs.StatusReg = SREG;
   cli();
   SREG = cs.StatusReg;
   return Kernel.SysTickCount;