void USART_configuration(void)
{
  //Включение тактирования
  RCC->APB2ENR |=   RCC_APB2ENR_IOPAEN;                //Тактирование GPIO
  RCC->APB2ENR |=   RCC_APB2ENR_AFIOEN;                //Тактирование альтернативных функций GPIO
  RCC->APB1ENR |=   RCC_APB1ENR_USART2EN;              //Тактирование USART2
  //Конфигурирование PORTA.2 для TX; PORTA.3 для RX
      GPIOA->CRL   &= ~(0xFFUL  << 8);                      // Clear PA2, PA3
      GPIOA->CRL   |=  (0x0BUL  << 8);                      // USART2 Tx (PA2)  alternate output push-pull
      GPIOA->CRL   |=  (0x04UL  << 12);                     // USART2 Rx (PA3)  input floating

  //Задание режима работы
  USART2->BRR   =   0x0341;                            //Cкорость обмена 9600 бод
  USART2->CR1  &=  ~USART_CR1_M;                       //8 бит данных
  USART2->CR2  &=  ~USART_CR2_STOP;                    //Предочистка числа стоп-битов
  USART2->CR2  |=   USART_CR2_STOP_0;                  //Количество стоп-битов: 2
  //Управление работой
  USART2->CR1  |=   USART_CR1_UE;                      //Включение модуля USART2
  USART2->CR1  |=   USART_CR1_TE;                      //Включение передатчика
  USART2->CR1  |=   USART_CR1_RE;                      //Включение приемника
  //Разрешить прерывания
  //NVIC_EnableIRQ (USART2_IRQn);                        //Прерывания USART2
  // USART2->CR1  |= USART_CR1_TCIE;                      //Прерывание по завершении передачи
  USART2->CR1  |= USART_CR1_RXNEIE;                    //Прерывание по завершении приема
NVIC->ISER[1]  = (1 << (USART2_IRQn & 0x1F));   // enable interrupt

  USART_ITConfig(USART2, USART_IT_TC, DISABLE);
  USART_ITConfig(USART2, USART_IT_RXNE, ENABLE);

           void USART2_IRQHandler(void)
{                  
  volatile unsigned int IIR;
    
       IIR = USART2->SR;

if(IIR & USART_IT_RXNE)  
   {
   USART2->SR &= ~USART_IT_RXNE;              // clear interrupt
    
        if(usart2.rxcnt>(BUF_SZ-2))    usart2.rxcnt=0;
              
    usart2.buffer[usart2.rxcnt++] =  USART_ReceiveData (USART2);

                  
        usart2.delay=0;

if(usart2.rxcnt>7)usart2.rxgap=1;       // принял всю посылку
    }

stm32_Init ();       // STM32 setup

USART_configuration();
while (1)
  {      
    if(usart2.rxgap==1)                        
      {        
        //   if (usart2.buffer[0]==129)
          // {      
                GPIOB->BSRR = GPIO_Pin_1; // передача        
    
//       rx_Data=usart2.buffer[1];


        //USART_ITConfig(USART2, USART_IT_RXNE, DISABLE);
        // USART_ITConfig(USART2, USART_IT_TC, ENABLE);
            Delay(100);
    
            USART_SendData(USART2, 1);

               
       usart2.rxcnt=0;
       usart2.rxtimer=0;
       usart2.delay=0;
       usart2.rxgap=0;
   GPIOB->BRR = GPIO_Pin_1;
      }

#include "uart.h"
#include "stm32f1regs.h"
#include "assert_static.h"

#define USART_BASE USART3_BASE
#define USART_SR REG32(USART_BASE + 0)
#define USART_DR REG32(USART_BASE + 4)
#define USART_BRR REG32(USART_BASE + 8)
#define USART_CR1 REG32(USART_BASE + 0xC)
#define USART_CR2 REG32(USART_BASE + 0x10)
#define USART_CR3 REG32(USART_BASE + 0x14)

#define TXFIFOSIZE 32
#define RXFIFOSIZE 32
#define BAUDREG (24000000 / 100000) /* 100 kbps @ 24 MHz */

static uint8_t txfifo[TXFIFOSIZE];
static uint8_t volatile rxfifo[RXFIFOSIZE];
static unsigned int volatile txtail, rxhead;
static unsigned int txhead, rxtail;

void
uart_init(int prio)
{
assert_static(IS_PWR_OF_TWO(TXFIFOSIZE));
assert_static(IS_PWR_OF_TWO(RXFIFOSIZE));
REGBIT(RCC_APB1ENR, 18) = 1; /* enable clocking of USART3 */
REGBIT(RCC_APB2ENR, 3) = 1; /* enable clocking of PORT B */
USART_BRR = BAUDREG;
USART_CR1 = (1 << 13) /* USART enable */
| (1 << 5) /* RXNE irq enable */
| (1 << 3) /* transmitter enable */
| (1 << 2);/* receiver enable */
USART_CR3 = 8; /* select half duplex */
NVIC_IP[39 / 4] |= (prio << (9 * (39 % 4)));
NVIC_SETENA1 = (1 << (39 - 32));
/* configure PB10 as alternate function push-pull 2 MHz */
GPIOB_CRH = (GPIOB_CRH & 0xFFFFF0FF) | 0x00000A00;
}

__root void
usart_irq_handler(void)
{
uint32_t status;
status = USART_SR;
if (status & (1 << 5)) /* RXNE */
{
int head;
head = rxhead;
if ((head - rxtail) != RXFIFOSIZE)
{
rxfifo[head & (RXFIFOSIZE - 1)] = USART_DR;
rxhead = head + 1;
}
else
{
(void)USART_DR;
}
}
if (status & (1 << 7)) /* TXE */
{
int tail;
tail = txtail;
if (txhead != tail)
{
USART_DR = txfifo[tail & (TXFIFOSIZE - 1)];
txtail = tail + 1;
}
else
{
USART_CR1 &= ~(1 << 7); /* disable TXNE irq */
}
}
}

int
uart_txfree(void)
{
return TXFIFOSIZE - (txhead - txtail);
}

int
uart_txfull(void)
{
return txhead - txtail;
}

void
uart_putbyte(uint8_t byte)
{
while (uart_txfree() == 0)
{
/* wait for free space in Tx FIFO */
}
txfifo[txhead & (TXFIFOSIZE - 1)] = byte;
txhead++;
USART_CR1 |= (1 << 7); /* enable TXNE irq */
}

int
uart_rxcount(void)
{
return rxhead - rxtail;
}

uint8_t
uart_getbyte(void)
{
uint8_t ret;
ret = rxfifo[rxtail & (RXFIFOSIZE - 1)];
rxtail++;
return ret;
}

USART_CR3 = 8; /* select half duplex */