#define TX_BUFFER_SIZE 128
char tx_buffer[TX_BUFFER_SIZE];

#if TX_BUFFER_SIZE<256
unsigned char tx_wr_index,tx_rd_index,tx_counter;
#else
unsigned int tx_wr_index,tx_rd_index,tx_counter;
#endif

// USART0 Transmitter interrupt service routine
interrupt [USART0_TXC] void usart0_tx_isr(void)
{
if (tx_counter)
   {
   --tx_counter;
   UDR0 = tx_buffer[tx_rd_index];
   if (++tx_rd_index == TX_BUFFER_SIZE)
      tx_rd_index=0;
   };
}

// Write a character to the USART0 Transmitter buffer
#pragma used+
int COM_putchar(unsigned char c)
{
while (tx_counter == TX_BUFFER_SIZE);
#asm("cli")
if (tx_counter || ((UCSR0A & DATA_REGISTER_EMPTY)==0))
   {
   tx_buffer[tx_wr_index]=c;
   if (++tx_wr_index == TX_BUFFER_SIZE)
   {        
      tx_wr_index=0;
   }
   ++tx_counter;
   }
else
   UDR0=c;
#asm("sei")
return 1;//<!
}

в main:

unsigned long int tx_cnt; // счётчик переданных байт
_включили_таймер
   if( ++tx_cnt < 65535 )
   {      
      COM_putchar(0x55);    
   }
_остановили_таймер

interrupt [ USART0_TXC] void usart0_TXC_isr(void)

interrupt [ USART0_DRE ] void usart0_UDRE_isr(void)

#define USART0_DRE 20
#define USART0_TXC 21

//#define _USART0_TXC_INTERRUPT_
void COM_init( unsigned int ubrr )
{
    UBRR0H = (unsigned char) (ubrr>>8);                       //Setting baudrate
    UBRR0L = (unsigned char) ubrr;                            //Setting baudrate
    #ifdef _USART0_TXC_INTERRUPT_
      UCSR0B = ( 1 << RXEN0 ) | ( 1 << TXEN0 );                     //Enable receiver and transmitter
    #else
      UCSR0B = ( 1 << RXEN0 )  ( 1 << TXEN0 ) | (1 << UDRIE0) |;                     //Enable receiver
    #endif
    UCSR0C = ( 1 << UCSZ01 ) | ( 1 << UCSZ00 );  //8N1...see Datasheet for more information
    UCSR0A=0x00;
    COM_rx_reset();
    COM_tx_reset();                                               //Reset buffers etc.        
}
void COM_rx_reset( void )
{
    COM_rx_off();       // Disable RX interrupt
    rx_i = rx_wr_i = 0;           //Init variables
    rx_overflow = rx_ack = 0;     //Zero overflow flag
    rx_buffer[ rx_wr_i ] = '\0';  //Buffer init.
}  

void COM_tx_reset( void )
{
    COM_tx_off();       // Disable RX interrupt
    tx_wr_index = 0;
    tx_rd_index = 0;
    tx_counter = 0;    
}

void COM_rx_on( void )
{
    UCSR0B |= ( 1 << RXCIE0 );  // Enable RX interrupt
}


void COM_rx_off( void )
{
    UCSR0B &= ~( 1 << RXCIE0 ); // Disable RX interrupt
}

void COM_tx_on( void )
{    
    UCSR0B |= ( 1 << TXCIE0 );  // Enable TX interrupt
}

void COM_tx_off( void )
{
    UCSR0B &= ~( 1 << TXCIE0 ); // Disable TX interrupt
}

#ifdef _USART0_TXC_INTERRUPT_

//<! USART0_TXC - tx complete

interrupt [ USART0_TXC ] void usart0_TXC_isr(void)
{
if ( tx_counter )
   {
   --tx_counter;
   UDR0 = tx_buffer[tx_rd_index];
   if (++tx_rd_index == TX_BUFFER_SIZE)
      tx_rd_index=0;
   };
}

#else

//<! USART0_DRE - usart data register emptry

interrupt [ USART0_DRE ] void usart0_UDRE_isr(void)
{
if ( tx_counter )
   {
   --tx_counter;
   UDR0 = tx_buffer[tx_rd_index];
   if (++tx_rd_index == TX_BUFFER_SIZE)
      tx_rd_index=0;
   };
}

#endif

...
void main(void)
{
...
//<! USART0 initialization (UBRR = 0x01 = 115200 @ 3.6864MHz)
COM_init(0x01);  
...
}

interrupt [USART1_RXC] void usart1_rx_isr(void)
{
char status,data;
status=UCSR1A;
data=UDR1;
if ((status & (FRAMING_ERROR | PARITY_ERROR | DATA_OVERRUN))==0)
   {
   rx_buffer1[rx_wr_index1]=data;
   if (++rx_wr_index1 == RX1_BUFFER_SIZE) rx_wr_index1=0;
   if (++rx_counter1 == RX1_BUFFER_SIZE)
      {
      rx_counter1=0;
      rx_buffer_overflow1=1;
      };
   };
}

int COM_tx_on( void )
{
   UCSR0B |= ( 1 << UDRIE0 );  // Enable TX UDRE interrupt
   return 1;
}

void COM_tx_off( void )
{                                
      UCSR0B &= ~( 1 << UDRIE0 );  // Disable TX interrupt
}

//<! USART0_DRE - usart data register emptry
interrupt [ USART0_DRE ] void usart0_UDRE_isr(void)
{  
   if ( tx_counter > 0 )
   {                  
      #asm("cli")
      --tx_counter; //<! неделимая операция
      #asm("sei")
      UDR0 = tx_buffer[tx_rd_index];
      if (++tx_rd_index == TX_BUFFER_SIZE)
         tx_rd_index=0;
   }
   else
   {
      COM_tx_off();
   }  
}

int COM_putchar(unsigned char c)
{          
   char tx = 0;
   while( !tx )
   {
      if( !CTS )
      {          
         if( tx_counter != TX_BUFFER_SIZE )
         {      
            tx_buffer[tx_wr_index]=c;
            COM_tx_on();        
            if (++tx_wr_index == TX_BUFFER_SIZE)
            {        
               tx_wr_index=0;
            }  
            #asm("cli")          
            ++tx_counter;            
            #asm("sei")
            tx = 1; //<! break from while
         }  
      }      
   }      
   return 1;
}

//<! USART0_DRE - usart data register emptry
interrupt [ USART0_DRE ] void usart0_UDRE_isr(void)
{  
   if ( tx_counter > 0 )
   {                  
    //  #asm("cli")    <-- aaarrr Лишнее действие: прерывания уже запрещены
      --tx_counter; //<! неделимая операция
    //  #asm("sei")    <-- aaarrr А это уже просто опасно
      UDR0 = tx_buffer[tx_rd_index];
      if (++tx_rd_index == TX_BUFFER_SIZE)
         tx_rd_index=0;
   }
   else
   {
      COM_tx_off();
   }  
}

int COM_putchar(unsigned char c)
{          
   char tx = 0;
   while( !tx )
   {
      if( !CTS )
      {          
         if( tx_counter != TX_BUFFER_SIZE )
         {      
            tx_buffer[tx_wr_index]=c;
//            COM_tx_on();    <-- aaarrr Здесь включать передатчик рано, он может тут же запретить UDR        
            if (++tx_wr_index == TX_BUFFER_SIZE)
            {        
               tx_wr_index=0;
            }  
            #asm("cli")          
            ++tx_counter;            
            #asm("sei")
            COM_tx_on();
            tx = 1; //<! break from while
         }  
      }      
   }      
   return 1;
}

//  #asm("cli")    <-- aaarrr Лишнее действие: прерывания уже запрещены

//  #asm("sei")    <-- aaarrr А это уже просто опасно