.dseg

.equ    BUF_SIZE = 64    ; размер буфера, может быть n^2 <= 256


buf:    .byte    3 + BUF_SIZE; счетчик занятых ячеек, индекс чтения, состояние буфера, буфер

.cseg


;------------------------------------------------
init_buf:
;------------------------------------------------
; инициализация буфера
; используются r16, r28, r29

; в Y адрес структуры, задающей буфер    
    mov    YL, LOW(buf)
    mov    YH, HIGH(buf)
    clr    r16
    std    Y, r16
    std    Y+1, r16
    std    Y+2, r16
    ret


;------------------------------------------------
write_buf:
;------------------------------------------------
; в r16 байт для записи
; используются регисты r17, r18, r28, r29

; в Y адрес структуры, задающей буфер    
    mov    YL, LOW(buf)
    mov    YH, HIGH(buf)

; если буфер полный не записывать, установить флаг переполнения
    ld    r17, Y
    cpi    r17, BUF_SIZE - 1
    brcs    L1
    ldi    r17, 1
    std    Y+2, r17
    ret
L1:    
; определить индекс для записи
; i = (rindex + count) & (BUF_SIZE - 1)
    ld    r18, Y + 1
    add    r18, r17
    andi    r18, BUF_SIZE-1
    
; увеличить счетчик занятых ячеек в буфере
; count++
    inc    r17
    st    Y, r17

; buf[i] = data;
    clr    r17
    add    YL, r18
    adc    YH, r17
    std    Y+3, r16
    ret

;------------------------------------------------
read_buf:
;------------------------------------------------
; возвращает байт в r16
; используются регисты r16, r17, r28, r29

; в Y адрес структуры, задающей буфер    
    mov    YL, LOW(buf)
    mov    YH, HIGH(buf)

; c = buf[rindex]
    ldd    r16, Y+3

    cli

; count--
    ld    r17, Y
    dec    r17
    st    Y, r17
    
; rindex = (rindex + 1) & BUF_SIZE - 1
    ldd    r17, Y+1
    dec    r17
    andi    r17, BUF_SIZE-1
    std    Y+1, r16
    sei
    ret

#include "uart.h"

unsigned char U0_RxBufGetIndex = 0;
unsigned char U0_RxBufPutIndex = 0;
unsigned char U0_RxBufSize = BUF0RXSIZE;
unsigned int U0_RxBuffer[BUF0RXSIZE] = {0};

void USART0_Ring_Flush(void){
  U0_RxBufGetIndex = U0_RxBufPutIndex;
  return;
}

int UART0_getc (void){
  int proxy = 0;
  if(U0_RxBufPutIndex != U0_RxBufGetIndex){
    //proxy = U0_RxBuffer[U0_RxBufGetIndex] & (~(((!!PARITY)<<RXB80)<<8));
    proxy = U0_RxBuffer[U0_RxBufGetIndex];
    U0_RxBufGetIndex = (U0_RxBufGetIndex+1)&(U0_RxBufSize-1);  
    // modulo UART0_RxBufSize
    return (proxy);    
  }
  return (EOF);
}

#ifdef __ICCAVR__
#pragma vector = USART_RX_vect
__interrupt void USART_RX_Handler(void){
#else
ISR(USART_RX_vect){
#endif

  unsigned char status;
//  unsigned char resh;
  status = UCSR0A;
  //resh = UCSR0B;
  
  // Read flags
  U0_RxBuffer[U0_RxBufPutIndex] = (status & ((1<<FE0)|(1<<DOR0)|(1<<UPE0))) << 8;
  
  // Filter the 9th bit, then return
  //U0_RxBuffer[U0_RxBufPutIndex] |= _BLV(resh, RXB80) << 8; //(resh >> 1) & 0x01;

  U0_RxBuffer[U0_RxBufPutIndex] |= UDR0;
  // normal ready, save into the Data Ring Buffer

  U0_RxBufPutIndex=(U0_RxBufPutIndex+1)&(U0_RxBufSize-1);
  // PutIndex modulo BufferSize

  if(U0_RxBufPutIndex == U0_RxBufGetIndex) {
    U0_RxBufPutIndex--;
    U0_RxBufPutIndex &= U0_RxBufSize-1;
    // PutIndex modulo BufferSize
  }
  return;
}

  U0_RxBuffer[(U0_RxBufPutIndex++)&(U0_RxBufSize-1)] |= UDR0;