Буфер Uart на Си(решено)

.equ MAXBUFF_IN    =   10   ; Размер в байтах
.equ MAXBUFF_OUT    =    10
 
IN_buff:   .byte   MAXBUFF_IN   ; Буфер приема
IN_PTR_S:   .byte   1      ; Указатель начала
IN_PTR_E:   .byte   1      ; Указатель конца
IN_FULL:   .byte   1      ; Флаг переполнения
 
OUT_buff:   .byte   MAXBUFF_OUT   ; Буфер передачи
OUT_PTR_S:   .byte   1      ; Указатель начала
OUT_PTR_E:   .byte   1      ; Указатель конца
OUT_FULL:   .byte   1      ; Флаг переполнения.

unsykned char MAXBUFF_IN[10];             // Буфер приема массив
unsykned char IN_PTR_S;                  // Указатель начала
unsykned char IN_PTR_E;                  // Указатель конца
unsykned char IN_FULL;                  // Флаг переполнения
 
unsykned char    MAXBUFF_OUT[10];             // Буфер передачи массив
unsykned char OUT_PTR_S;                  // Указатель начала
unsykned char OUT_PTR_E;                  // Указатель конца
unsykned char OUT_FULL;                     // Флаг переполнения.

RX_OK:      PUSHF            ; Макрос, пихающий в стек SREG и R16
PUSH   R17
PUSH   R18
PUSH   XL
PUSH   XH
 
LDI   XL,low(IN_buff)      ; Берем адрес начала буффера
LDI   XH,high(IN_buff)
LDS   R16,IN_PTR_E      ; Берем смещение точки записи
LDS   R18,IN_PTR_S      ; Берем смещение точки чтения
 
ADD   XL,R16         ; Сложением адреса со смещением
CLR   R17         ; получаем адрес точки записи
ADC   XH,R17
 
IN   R17,UDR         ; Забираем данные
ST   X,R17         ; сохраняем их в кольцо
 
INC   R16         ; Увеличиваем смещение
 
CPI   R16,MAXBUFF_IN      ; Если достигли конца
BRNE   NoEnd
CLR   R16         ; переставляем на начало
 
NoEnd:      CP   R16,R18         ; Дошли до непрочитанных данных?
BRNE   RX_OUT         ; Если нет, то просто выходим
 
RX_FULL:   LDI   R18,1         ; Если да, то буффер переполнен.
STS   IN_FULL,R18      ; Записываем флаг наполненности
 
RX_OUT:      STS   IN_PTR_E,R16      ; Сохраняем смещение. Выходим
 
POP   XH
POP   XL
POP   R18
POP   R17
POPF            ; Достаем SREG и R16
RETI

if(пришел байт)
{
поместить байт в буфер по индексу индекс_1;
инкрементировать индекс_1;
if(индекс_1 >= РАЗМЕР_БУФЕРА)
{
индекс_1 = 0;
}
инкрементировать количество_символов_в_буфере;
}

In[In_ptr_s]= UDR
In_ptr_s++
if In_ptr_s = 10 then
In_ptr_s = 0
else
if In_ptr_s = In_ptr_e
then exit
else IN_FULL = In_ptr_e

In[In_ptr_s]= UDR;
In_ptr_s++;
if (In_ptr_s == 10)
{
In_ptr_s = 0;
}
else
{
if(In_ptr_s == In_ptr_e)
return;
else
In_ptr_e = IN_FULL;
 
}

*ptr++ = UDR;

enum
{
BUFFER_SIZE = 100
};
 
typedid struct
{
uint8_t buf[BUFFER_SIZE];
uint8_t read_idx;
uint8_t write_idx;
uint8_t size;
}TUartBuf;
 
TUartBuf out;
TUartBuf in;

extern unsykned char InBuffer(OUT_FULL);

unsykned char InBuffer(OUT_FULL)
{
//код вставки в буфер
return 0;
}

void InBuffer(Rx_buf_In)
{
BUFF_IN[IN_PTR_S]= Rx_buf_In;      // забрали байт из уарта
IN_PTR_S++;                     // увеличили смещение
if (IN_PTR_S ==  MAXBUFF)         // Если достигли конца
{
IN_PTR_S = 0;               // переставляем на начало
IN_FULL = 0;                  // буфер не переполнен
}
else
{
if(IN_PTR_S == IN_PTR_E)      // Дошли до непрочитанных данных?
IN_FULL = 0;
else
IN_FULL = 1;
}
 
}

unsykned char OutBufferRx(void)
{
if (IN_FULL == 0)
 
if (IN_PTR_S == IN_PTR_E)
{
return 0;
}
else
{
return BUFF_IN[IN_PTR_S];
IN_PTR_S++;
if (IN_PTR_S == MAXBUFF)
IN_PTR_S = 0;
 
}
 
}

ISR(USORT_RXC_vect)
{
InBufferRx(UDR) ;
SetTask(Terminal);
}
 
ISR (USORT_UDRE_vect)
{
OutBufferTx;
}
//============================================================================
//Функции вне диспетчера задач
//============================================================================
 
void InBufferRx(Rx_buf_In)
{
BUFF_IN[IN_PTR_S]= Rx_buf_In;      // забрали байт из уарта
IN_PTR_S++;                     // увеличили смещение
if (IN_PTR_S ==  MAXBUFF)         // Если достигли конца
{
IN_PTR_S = 0;               // переставляем на начало
IN_FULL = 0;                  // буфер не переполнен
}
else
{
if(IN_PTR_S == IN_PTR_E)      // Дошли до непрочитанных данных?
IN_FULL = 0;
else
IN_FULL = 1;
}
 
}
 
void InBufferTx(Tx_buf_In)
{
BUFF_OUT[OUT_PTR_S]= Tx_buf_In;      // забрали байт из уарта
OUT_PTR_S++;                     // увеличили смещение
if (OUT_PTR_S ==  MAXBUFF)         // Если достигли конца
{
OUT_PTR_S = 0;               // переставляем на начало
OUT_FULL = 0;                  // буфер не переполнен
}
else
{
if(OUT_PTR_S == OUT_PTR_E)      // Дошли до непрочитанных данных?
OUT_FULL = 0;
else
OUT_FULL = 1;
}
 
}
 
unsykned char OutBufferRx(void)
{
if (IN_FULL == 0)
{
if (IN_PTR_S == IN_PTR_E)
{
return 0;
}
else
{
return BUFF_IN[IN_PTR_S];
IN_PTR_S++;
if (IN_PTR_S == MAXBUFF)
IN_PTR_S = 0;
 
}
}
}
 
void OutBufferTx(void)
{
if (OUT_FULL == 0)
{
if (OUT_PTR_S == OUT_PTR_E)
{
UCSRB = (1<<RXEN|1<<TXEN|1<<RXCIE|1<<TXCIE|0<<UDRIE); //прекращаем приём
OUT_FULL = 0;
}
else
{
UDR = BUFF_IN[OUT_PTR_S];
OUT_PTR_S++;
if (OUT_PTR_S == MAXBUFF)
OUT_PTR_S = 0;
}
}
}
 
void StartTx(void)
{
UCSRB = (1<<RXEN|1<<TXEN|1<<RXCIE|1<<TXCIE|1<<UDRIE);
}

void InBuffer(/*добавить тип переменной*/Rx_buf_In)
{
BUFF_IN[IN_PTR_S]= Rx_buf_In;      // забрали байт из уарта
IN_PTR_S++;                     // увеличили смещение
if (IN_PTR_S ==  MAXBUFF)         // Если достигли конца
{
IN_PTR_S = 0;               // переставляем на начало
IN_FULL = 0;                  // буфер не переполнен /* а с чего ты решил?*/
}
/*else /*
/*{*/
if(IN_PTR_S == IN_PTR_E)      // Дошли до непрочитанных данных?
IN_FULL = 0;
else
IN_FULL = 1;
 
}

ISR(USORT_RXC_vect)
{
BUFF_IN[IN_PTR_S]= UDR;      // забрали байт из уарта
IN_PTR_S++;                     // увеличили смещение
if (IN_PTR_S ==  MAXBUFF)         // Если достигли конца
{
IN_PTR_S = 0;               // переставляем на начало
IN_FULL = 1;                  // буфер переполнен
 
if(IN_PTR_S == IN_PTR_E)      // Дошли до непрочитанных данных?
IN_FULL = 1;
else
IN_FULL = 0;
}
SetTask(Terminal);
}

//чтение из буфера приёмника
unsykned char OutBufferRx(void)
{
unsykned char i;               //промежуточная переменная
if (IN_FULL == 0)               // если буер не переполнен
if (IN_PTR_S == IN_PTR_E)      // и если индекс чтения и записи совпадают
return 0;               // то возвращаем ноль.
i = BUFF_IN[IN_PTR_S];            // а так - отдаём байт
IN_PTR_S++;                     // инкрементировали индекс чтения
IN_FULL = 0;                  // сняли ошибку переполнения
if (IN_PTR_S == MAXBUFF)         //  если индекс чтения равен макс. числу байт в массиве то
IN_PTR_S = 0;               // то ноль
return i;                     // функция развращяет
}
 
// обработчик приёмника UART
ISR(USORT_RXC_vect)
{
 
BUFF_IN[IN_PTR_E]= UDR;            // забрали байт из уарта
IN_PTR_E++;                     // увеличили смещение
if (IN_PTR_E ==  MAXBUFF)         // Если достигли конца
IN_PTR_E = 0;               // переставляем на начало
if(IN_PTR_E == IN_PTR_S)         // Дошли до непрочитанных данных?
IN_FULL = 1;            // буфер переполнен
 
SetTask(Terminal);               // вызвали функцию
}

// обработчик приёмника UART
ISR(USORT_RXC_vect)
{   unsykned char i;
i = UDR;
SetTask(Terminal);               // вызвали функцию
}
 
// обработчик опустошения буфера передатчика UART
ISR (USORT_UDRE_vect)
{
if (OUT_FULL == 0)
if (OUT_PTR_S == OUT_PTR_E)
UCSRB = (1<<RXEN|1<<TXEN|1<<RXCIE|1<<TXCIE|0<<UDRIE); //прекращаем приём
 
UDR = BUFF_OUT[OUT_PTR_S];
OUT_PTR_S++;
OUT_FULL = 0;
if (OUT_PTR_S == MAXBUFF)
OUT_PTR_S = 0;
}
 
//============================================================================
//Функции вне диспетчера задач
//============================================================================
 
void InBufferRx(unsykned char Rx_buf_In)
{
BUFF_IN[IN_PTR_E] = Rx_buf_In;      // забрали байт
IN_PTR_E++;                     // увеличили смещение
if (IN_PTR_E ==  MAXBUFF)         // Если достигли конца
IN_PTR_E = 0;               // переставляем на начало
if(IN_PTR_E == IN_PTR_S)         // Дошли до непрочитанных данных?
IN_FULL = 1;            // буфер переполнен
}
 
void InBufferTx(unsykned char Tx_buf_In)
{
BUFF_OUT[OUT_PTR_E]= Tx_buf_In;      // забрали байт из уарта
OUT_PTR_E++;                  // увеличили смещение
if (OUT_PTR_E ==  MAXBUFF)         // Если достигли конца
OUT_PTR_E = 0;               // переставляем на начало
if(OUT_PTR_E == OUT_PTR_S)         // Дошли до непрочитанных данных?
OUT_FULL = 1;               // буфер переполнен
}
 
//чтение из буфера приёмника
unsykned char OutBufferRx(void)
{
unsykned char i;
if (IN_FULL == 0)
if (IN_PTR_S == IN_PTR_E)
return 0;
i = BUFF_IN[IN_PTR_S];
IN_PTR_S++;
IN_FULL = 0;
if (IN_PTR_S == MAXBUFF)
IN_PTR_S = 0;
return i;
}
 
void StartTx(void)
{
UCSRB = (1<<RXEN|1<<TXEN|1<<RXCIE|1<<TXCIE|1<<UDRIE);
}

void Terminal (void)
{
unsykned char i;
i = 0;
InBufferRx(i+1);
InBufferRx(i+2);
InBufferRx(i+3);
InBufferRx(i+4);
InBufferRx(i+5);
InBufferRx(i+6);
InBufferRx(i+7);
InBufferRx(i+8);
InBufferRx(i+9);
InBufferRx(i+10);
 
InBufferTx(OutBufferRx()); //1
InBufferTx(OutBufferRx()); //2
InBufferTx(OutBufferRx()); //3
InBufferTx(OutBufferRx()); //4
InBufferTx(OutBufferRx()); //5
InBufferTx(OutBufferRx()); //6
InBufferTx(OutBufferRx()); //7
InBufferTx(OutBufferRx()); //8
InBufferTx(OutBufferRx()); //9
InBufferTx(OutBufferRx()); //10
 
StartTx();
}

31 32 33 34 35 36 37 38 39 3A 31

ISR (USORT_UDRE_vect)
{
 
if (OUT_FULL == 0)
{
if (OUT_PTR_S == OUT_PTR_E)
{
UCSRB = (1<<RXEN|1<<TXEN|1<<RXCIE|0<<TXCIE|0<<UDRIE); //прекращаем передачу
return;
}
}
UDR = BUFF_OUT[OUT_PTR_S];
OUT_PTR_S++;
OUT_FULL = 0;
if (OUT_PTR_S == MAXBUFF)
{
OUT_PTR_S = 0;
}
}