#define F_CPU 8000000L
#define LED1 0
#define LED2 1
#define LED_PORT PORTB
#define LED_DDR DDRB

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

ISR(USART_RX_vect)
{
switch(UDR)
{
case '1': LED_PORT |= 1<<LED2; break;
case '0': LED_PORT &= ~(1<<LED2); break;
default: break;
}
}

int main(void)
{
#define baudrate 14400L
#define bauddivider (F_CPU/(16*baudrate)-1)
#define HI(x) ((x)>>8)
#define LO(x) ((x) & 0xFF)

UBRRL = HI(bauddivider);
UBRRH = LO(bauddivider);
UCSRA = 0;
UCSRB = 1<<RXEN|1<<TXEN|1<<RXCIE|0<<TXCIE;
UCSRC = 0<<UMSEL|1<<UCSZ0|1<<UCSZ1;

LED_DDR = 1<<LED1|1<<LED2;
LED_PORT = 0xFF;

sei();

while(1)
{
LED_PORT ^= 1<<LED1;
_delay_ms(1000);
}

return 0;
}

    UBRRL = LO(bauddivider);
    UBRRH = HI(bauddivider);

#if !defined _C_UART_H_
#define _C_UART_H_

#include <ioavr.h>
#include <intrinsics.h>
#include "C_IO.h"
#include "_string.h"

#define XTAL 8000000L
#define baudrate 9600L
#define bauddivider (XTAL/(16*baudrate)-1)

// синглтон класс UART.
class C_UART : public C_IO
{
private:
// Буфер данных для передачи.
char* pTxBuffer;
// Буфер принятых данных.
char* pRxBuffer;
// Счетчик и объем передаваемых данных.
// Когда они равны передатчик готов передавать следующие данные.
volatile unsigned int uiTxCounter;
volatile unsigned int uiTxSize;
// Счетчик и объем принимаемых данных.
// Когда равны приемник получил необходимый объем данных.
volatile unsigned int uiRxCounter;
volatile unsigned int uiRxSize;
// Конструктор и инициализация USART.
C_UART();
// чтобы нельзя было передавать как параметр функции.
C_UART(const C_UART&);
// для запрета присваивания одного объекта другому
C_UART& operator = (const C_UART&);
// Обработчики прерываний.
#pragma vector = USART_TXC_vect
__interrupt static void TxHandler(void);
#pragma vector = USART_RXC_vect
__interrupt static void RxHandler(void);

public:
// функция, с помощью которой осуществляется ВЕСЬ доступ
// к методам и данным класса.
// Пример синтаксиса вызова: C_UART::instance()->some_function();
static C_UART* Instance();
// Передача заданного и незаданного кол. байт.
bool Send(char* pBuffer, unsigned int uiSize);
bool Send(char* pBuffer);
// Прием заданного количества байт.
bool Receive(char* pBuffer, unsigned int uiSize);
};
#endif

#include "uart.h"

/***********************************МЕТОДЫ*************************************/
// Конструктор с инициализацией USART
C_UART::C_UART()
{
UBRRL = bauddivider & 0x00FF;
UBRRH = (bauddivider>>8)&0x00FF;
UCSRC = (1<<UCSZ1) | (1<<UCSZ0);
uiTxCounter = 0;
uiTxSize = 0;
uiRxCounter = 0;
uiRxSize = 0;
}

// благодаря static объект создается единственный
// раз при первом обращении к instance()
C_UART* C_UART::Instance()
{
static C_UART SingleUART;
return &SingleUART;
}

// Копирование в буфер данных с заданным числом байт, разрешение прерываний
// на передачу, копирование 0-го байта в UDR
bool C_UART::Send(char *pBuffer, unsigned int uiSize)
{
if(!uiSize || !pBuffer || uiTxSize) return false;
uiTxSize = uiSize;
pTxBuffer = pBuffer;
uiTxCounter = 1;
UCSRB |= (1<<TXEN) | (1<<TXCIE);
UDR = pTxBuffer[0];
while(uiTxSize); // ожидание готовности передачи всех данных
return true;
}

// Копирование в буфер данных, разрешение прерываний
// на передачу, копирование 0-го байта в UDR
bool C_UART::Send(char *pBuffer)
{
unsigned int uiSize = strlength(pBuffer);
return (Send(pBuffer,uiSize));
}

// Установка кол. принимаемых байт, адреса приемного буфера, разрешение
// прерываний на прием
bool C_UART::Receive(char *pBuffer, unsigned int uiSize)
{
if(!uiSize || !pBuffer || uiRxSize) return false;
uiRxSize = uiSize;
pBuffer = pRxBuffer;
*pRxBuffer = 0;
uiRxCounter = 0;
UCSRB |= (1<<RXEN) | (1<<RXCIE);
while(uiRxSize); // ожидание готовности приема заданного кол. байт
return true;
}

/******************************ОБРАБОТЧИКИ ПРЕРЫВАНИЙ**************************/
// Копирование в приемный буфер через статический указатель экземпляра принятых
// данных, при достижении требуемого кол. байт запрещение прерываний на прием и
// обнуление размера буфера
#pragma vector = USART_RXC_vect
__interrupt void C_UART::RxHandler(void)
{
C_UART::Instance()->pRxBuffer[C_UART::Instance()->uiRxCounter++] = UDR;
if(C_UART::Instance()->uiRxCounter == C_UART::Instance()->uiRxSize)
{
C_UART::Instance()->uiRxSize = 0;
UCSRB &= ~((1<<RXEN) | (1<<RXCIE));
}
}

// Копирование след. байт находящихся в буферепосле отправки 1-го, при
// достижении требуемого кол. передаваемых байт запрещение прерываний на
// передачу и обнуление размера буфера
#pragma vector = USART_TXC_vect
__interrupt void C_UART::TxHandler(void)
{
if(C_UART::Instance()->uiTxCounter == C_UART::Instance()->uiTxSize)
{
C_UART::Instance()->uiTxSize = 0;
UCSRB &= ~((1<<TXEN) | (1<<TXCIE));
}
else UDR = C_UART::Instance()->pTxBuffer[C_UART::Instance()->uiTxCounter++];
}