#include "interface/uart.h"
uint8_t pushToDebugBuffer(uint8_t symbol){
DEBUG_TX_INT_LOCK();
while(debugPushCursor == debugPopCursor){
  DEBUG_TX_INT_UNLOCK();
  SLEEP();
  DEBUG_TX_INT_LOCK();
}
*debugPushCursor = symbol;
debugPushCursor = nextAddress(debugPushCursor);
DEBUG_TX_INT_UNLOCK();
if(!globIntFlags.isDebugPortBusy) popFromDebugBuffer(); //если передача когда-то закончилась, то возобновляем её
return symbol;
}

//SPECPREFIX пустой, если заголовок подключается из uart.c, и равен extern, если другими
SPECPREFIX uint8_t debugBuffer[32];
SPECPREFIX volatile uint8_t *debugPushCursor;
SPECPREFIX volatile uint8_t *debugPopCursor;

#define DEBUG_TX_INT_LOCK(s)  CLEARBIT(UCSR1B, TXCIE1)
#define DEBUG_TX_INT_UNLOCK(s)  SETBIT(UCSR1B, TXCIE1)
*******

Фрагмент кода прерывания:

******
#include "interface/uart.h"
INTERRUPT(/*SIG_UART0_TRANS*/SIG_USART1_TRANS){
// например,  
debugPopCursor++;
}
******

#include <avr/io.h>
#include <avr/interrupt.h>

uint8_t volatile debugPopCursor;
// достуап к debugPopCursor в режиме приложения
void AppMode (uint8_t* Tmp )
{
while(*Tmp == debugPopCursor)
  {
   debugPopCursor++;
  }

  Tmp = &debugPopCursor;
  debugPopCursor -= 10;
}

// достуап к debugPopCursor в режиме прерывания
ISR(USART_TX_vect)
{
    debugPopCursor++;
}

uint8_t volatile debugPopCursor;
// достуап к debugPopCursor в режиме приложения
void AppMode (uint8_t* Tmp )
{
148:    fc 01           movw    r30, r24
14a:    05 c0           rjmp    .+10     ; 0x156 <AppMode+0xe>
while(*Tmp == debugPopCursor)
  {
   debugPopCursor++;
14c:    80 91 0d 01     lds    r24, 0x010D
150:    8f 5f           subi    r24, 0xFF; 255
152:    80 93 0d 01     sts    0x010D, r24
156:    90 91 0d 01     lds    r25, 0x010D
15a:    80 81           ld    r24, Z
15c:    89 17           cp    r24, r25
15e:    b1 f3           breq    .-20     ; 0x14c <AppMode+0x4>
  }

  Tmp = &debugPopCursor;
  debugPopCursor -= 10;
160:    80 91 0d 01     lds    r24, 0x010D
164:    8a 50           subi    r24, 0x0A; 10
166:    80 93 0d 01     sts    0x010D, r24
16a:    08 95           ret

0000016c <__vector_20>:
}

// достуап к debugPopCursor в режиме прерывания
ISR(USART_TX_vect)
{
16c:    1f 92           push    r1
16e:    0f 92           push    r0
170:    0f b6           in    r0, 0x3f; 63
172:    0f 92           push    r0
174:    11 24           eor    r1, r1
176:    8f 93           push    r24
    debugPopCursor++;
178:    80 91 0d 01     lds    r24, 0x010D
17c:    8f 5f           subi    r24, 0xFF; 255
17e:    80 93 0d 01     sts    0x010D, r24
182:    8f 91           pop    r24
184:    0f 90           pop    r0
186:    0f be           out    0x3f, r0; 63
188:    0f 90           pop    r0
18a:    1f 90           pop    r1
18c:    18 95           reti

//----uart.c--------
uint8_t debugBuffer[32];   //кольцевой буфер
uint8_t volatile  *debugPushCursor;  //_указатель_ для функции записи
uint8_t volatile  *debugPopCursor;  //_указатель_ для функции чтения

//запись символа в кольцевой буфер
void pushToDebugBuffer(uint8_t symbol){
DEBUG_TX_INT_LOCK();  //макрос, запрещающий прерывание и изменение курсора чтения
while(debugPushCursor == debugPopCursor){//если буфер полон, то ожидаем прерывания
  DEBUG_TX_INT_UNLOCK();  //разрешаем прерывания и изменения курсора чтения
  SLEEP();      //ожидание прерывания
  DEBUG_TX_INT_LOCK();  //прерывание пришло, запрещаем изменение курсора чтения (может, можно убрать)
}
*debugPushCursor = symbol;  //буфер не полон, записываем символ
debugPushCursor = nextAddress(debugPushCursor); //приращиваем курсор записи (из-за того, что быфер кольцевой, простая операция ++ не канает
DEBUG_TX_INT_UNLOCK(); //разрешаем работу прерывания и изменение курсора чтения
return;
}

//функция чтения из кольцевого буфера
//вызывается только из прерывания
void popFromDebugBuffer(void){
uint8_t *nextPopCursorPosition;
if((nextPopCursorPosition = nextAddress(debugPopCursor)) != debugPushCursor){
  //если следующая позиция настроена на ожидание ввода от курсора pushCursor, то весь буфер передан (догнали курсор снизу), выходим.
  //здесь оказываемся, если ещё есть чего передавать
  globIntFlags.isDebugPortBusy=true;
  UDR1 = *debugPopCursor; //передаём в UART из текущего курсора чтения
  debugPopCursor = nextPopCursorPosition; //прибавлем курсор на будущее
} else {
  globIntFlags.isDebugPortBusy=false;
}
return;
}

//приращение курсора, в данном примере просто для иллюстрации
//вычислитель следующего адреса в кольцевом буфере на основе заданного указателя
uint8_t *nextAddress (uint8_t *pointer){
pointer++;
if(pointer == debugBuffer + sizeof(debugBuffer)){ //если указатель вылез за верх. границу буфера, ставим на начало
  pointer = debugBuffer; //здесь ставим на начало
}
return pointer;
}

//-----interrupt.c-------
extern uint8_t debugBuffer[32];   //кольцевой буфер
extern uint8_t volatile  *debugPushCursor;  //_указатель_ для функции записи
extern uint8_t volatile  *debugPopCursor;  //_указатель_ для функции чтения

//прерывание по отправке байта в порт
INTERRUPT(SIG_USART1_TRANS){
popFromDebugBuffer(); //функция приращения курсора чтения и отправки байта в порт, здесь не важно, из чего она состоит. Кстати, код функции описан в первом файле. Наверное, это не принципиально ?
}

uint8_t * volatile  debugPushCursor;  //_указатель_ для функции записи