//Инициируем UARTы

void USART1_INI(unsigned char spd, unsigned char par, unsigned char stp)
//spd - скорости обмена
// 10 115200
// 9 57600
// 8 38400
// 7 19200
// 6 9600
// 5 4800
// 4 2400
// 3 1200
// 2 600
//par - паритет
// 0 без паритета
// 1 нечетный паритет
// 2 четный паритет
//stp - число стоп битов
// 0, 1 - 1
// 2 - 2
//
//
//
{
GPIO_InitTypeDef GPIO_InitStructure;
short unsigned int i;



//*********************************************************
//Конфигурируем ножки под ввод вывод


//включаем тактирование портов
RCC->APB2ENR|=RCC_APB2ENR_IOPAEN;//GPIOA


//TX1 PA9
//Ножка назначается на вывод пуш пуль
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_9;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;

GPIO_Init( GPIOA , &GPIO_InitStructure);
//RX1 PA10
//Ножка назначается на ввод
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;

GPIO_Init( GPIOA , &GPIO_InitStructure);

USART1->CR1=0;
USART1->CR1|=USART_CR1_UE;//включили UART
USART1->CR1&=~USART_CR1_M;//8 бит
USART1->CR1&=~USART_CR1_WAKE;// пробуждение по IDLE LINE

//if(par==0){
USART1->CR1&=~USART_CR1_PCE;//без паритета
USART1->CR1&=~USART_CR1_PS;// нечетный паритет
USART1->CR1&=~USART_CR1_M;//8 бит
// }
if(par==1){
USART1->CR1|=USART_CR1_PCE;//паритет
USART1->CR1|=USART_CR1_PS;// нечетный паритет
USART1->CR1|=USART_CR1_M;//9 бит
}
if(par==2){
USART1->CR1|=USART_CR1_PCE;//паритет
USART1->CR1&=~USART_CR1_PS;// четный паритет
USART1->CR1|=USART_CR1_M;//9 бит
}



USART1->CR1|=USART_CR1_PEIE;//общее разрешение прерывания
// USART1->CR1|=USART_CR1_TXEIE;//разрешение прерывания по опустошению буфера передачи
USART1->CR1&=~USART_CR1_TXEIE;//запрещение прерывания по опустошению буфера передачи
USART1->CR1&=~USART_CR1_TCIE;//запрещено прерывание от "передача закончена"
//USART1->CR1|=USART_CR1_TCIE;// прерывание от "передача закончена"
USART1->CR1|=USART_CR1_RXNEIE;// разрешение прерывания по приему
USART1->CR1&=~USART_CR1_IDLEIE;//запрещено прерывание от IDLE
USART1->CR1|=USART_CR1_TE;//передатчик включен
USART1->CR1|=USART_CR1_RE;//приемник включен
USART1->CR1&=~USART_CR1_RWU;//приемник в активном режиме
USART1->CR1&=~USART_CR1_SBK;//запрос передачи длинного 0 выключен

USART1->CR2=0;
//if(stp<=1){//1 стоп
USART1->CR2&=~USART_CR2_STOP;//1 стоп
// }
if(stp==2){//2 стоп
USART1->CR2&=~USART_CR2_STOP;//1 стоп
USART1->CR2|=USART_CR2_STOP_1;//2 стоп
}

USART1->CR3=0;

USART1->SR&=0;//Флаги всех прерываний сбросили


USART1->BRR=0X0480;//19200
if(spd==10){
USART1->BRR=0X00C0;//115200
}

// готовим буферы обмена

//#define rx_buf_long 256
//#define tx_buf_long 256


i=0;
while(i<rx_buf_long){
rx_buf1[i]=0;
i++;
}
i=0;
while(i<tx_buf_long){
tx_buf1[i]=0;
i++;
}

USART1->SR=0;//СБРАСЫВАЕМ ФЛАГИ
// CTS
// LBD
// TC
// RXNE
// IDLE
// NE
//

rx_ptr1=0;
tx_ptr1=0;
//индекс последнего передаваемого элемента буфера
tx_last1=0;

rx_state1=0;
tx_state1=0;

}

void USART1_IRQHandler(void)
{
//прием
if((USART1->SR&USART_SR_RXNE)!=0) {//что то пришло
USART1->SR&=~USART_SR_RXNE;//сбросим флаг
rx_buf1[rx_ptr1]=USART1->DR;
if(rx_ptr1<rx_buf_long){
rx_ptr1++;
}

}//что то пришло

//передача

if((USART1->SR&USART_SR_TC)!=0) {//данные переписались из буфера в сдвиговый регистр и ушли из него
if(tx_state1==1){//идет передача
USART1->SR&=~USART_SR_TC;//сбросим флаг
if(tx_ptr1>=tx_last1){//ушел последний байт
tx_state1=0;
GPIOC->ODR &= ~GPIO_ODR_ODR4;// смотрим этой ножкой момент, когда закончилась передача
USART1->CR1&=~USART_CR1_TCIE ;
}//ушел последний байт
else{//передаем дальше
tx_ptr1++;
USART1->DR=tx_buf1[tx_ptr1];
}//передаем дальше
}//идет передача
else{//фантомное прерывание- мы ничего не должны передавать
USART1->CR1&=~USART_CR1_TCIE ;//сбросим разрешение этого прерывания
}//фантомное прерывание- мы ничего не должны передавать
}//данные переписались из буфера в сдвиговый регистр
USART1->SR=0;

}

InitGPIO();
Init_OSC_my();//инициализация и переключение синхронизации

USART1_INI(3,2,2);//1200







tx_buf1[0]=0x30;
tx_buf1[1]=0x31;
tx_buf1[2]=0x32;
tx_buf1[3]=0x33;
tx_buf1[4]=0x34;
tx_buf1[5]=0x35;
tx_buf1[6]=0x36;
tx_buf1[7]=0x37;
tx_buf1[8]=0x38;
tx_buf1[9]=0x39;
tx_buf1[10]=0x41;
tx_buf1[11]=0x42;
tx_buf1[12]=0x43;
tx_buf1[13]=0x44;
tx_buf1[14]=0x45;
tx_buf1[15]=0x46;
tx_buf1[16]=0x47;
tx_buf1[17]=0x48;
tx_buf1[18]=0x49;
tx_buf1[19]=0x4a;
tx_buf1[20]=0x4b;

tx_state1=1;
tx_last1=20;
tx_ptr1=0;


__NOP();



USART1->CR1|=USART_CR1_TCIE ;
GPIOC->ODR |= GPIO_ODR_ODR4;// между выставлением этой ножки и началом передачи на ножке - выдержка времени
USART1->DR=tx_buf1[tx_ptr1];

uint8_t UART4_TX_BUFFER[UART_TX_BUFFER_SIZE]; // Буфер передачи UART'
volatile uint16_t UART4_TX_POS, UART4_WR_POS; // Указатели буфера.

void DMA2_Channel5_IRQHandler(void) {
if (DMA2->ISR & DMA_ISR_TCIF5) {
DMA2->IFCR = DMA_IFCR_CTCIF5; // Сбрасываем бит прерывания.
DMA_STATE &= ~DMA_STATE_UART_ACTIVE;
UART4_ActivateDMA();
};
};
void init_DMA_uart(void) {
RCC->AHBENR |= RCC_AHBENR_DMA2EN;
UART4->CR3 |= USART_CR3_DMAT;
UART4->SR &= ~USART_SR_TC;
DMA2_Channel5->CCR = 0;
DMA2_Channel5->CPAR = (uint32_t)&(UART4->DR);
NVIC_EnableIRQ(DMA2_Channel5_IRQn);
NVIC_SetPriority(DMA2_Channel5_IRQn, 0x04);
};

void init_uart(void) {
SystemCoreClockUpdate(); // Обновляем рабочую частоту.
RCC->APB2ENR |= RCC_APB2ENR_IOPCEN; // Включаем тактирование порта с UART
GPIOC->ODR |= 0x00000C00; // Поднимаем пины.
GPIOC->CRH |= 0x0000FF00; // GPIOC[10:11] -> 50MHz, OpenDrain Alternate.
RCC->APB1ENR |= RCC_APB1ENR_UART4EN; // Включаем UART4
UART4->CR2 = 0; // Настройки. Сбрасываем.
UART4->CR3 = 0; // Продолжаем.
if (RCC->CFGR & RCC_CFGR_PPRE1_DIV2) {
UART4->BRR = (SystemCoreClock / 115200 / 2); // Ибо делим на 2
} else {
UART4->BRR = (SystemCoreClock / 115200); // Или не делим.
};
UART4->CR1 = (USART_CR1_TE | USART_CR1_RE | USART_CR1_UE); // Разрешаем работу UART.
init_DMA_uart();
};

void UART4_ActivateDMA(void) {
uint16_t CURR_WR_POS = UART4_WR_POS;
if (!(DMA_STATE & DMA_STATE_UART_ACTIVE)) {
DMA2_Channel5->CCR &= ~DMA_CCR_EN;
if (UART4_TX_POS == CURR_WR_POS) {
// Собственно, позиции начала и конца совпали.
} else {
// Есть разница между позициями буфера. Значит, нужно передавать данные.
// Начальная точка передачи - текущее значение указателя TX.
DMA2_Channel5->CMAR = (uint32_t)&(UART4_TX_BUFFER[(UART4_TX_POS)]); // Указатель на память
if (UART4_TX_POS < CURR_WR_POS) {
// Линия
DMA2_Channel5->CNDTR = (CURR_WR_POS - UART4_TX_POS); // Как раз нужная разница.
UART4_TX_POS = CURR_WR_POS;
} else {
// Кольцо
DMA2_Channel5->CNDTR = (UART_TX_BUFFER_SIZE - UART4_TX_POS);
UART4_TX_POS = 0;
};
DMA_STATE |= DMA_STATE_UART_ACTIVE;
DMA2_Channel5->CCR = (DMA_CCR_MINC | DMA_CCR_DIR | DMA_CCR_TCIE | DMA_CCR_EN);
};
};
};

void console_put(char *text) {
// Можно попытаться написать под реализацию на двух каналах DMA... Тогда будет ещё быстрее.
while(*text) {
// Пока не нуль-терминатор
UART4_TX_BUFFER[UART4_WR_POS] = *text; // Копируем данные в буфер
text++; // Сдвигаем указатель текста.
UART4_WR_POS++; // Сдвигаем указатель на 1 байт дальше.
UART4_WR_POS = UART4_WR_POS & UART_TX_MASK; // Указатель должен быть в пределах допустимых значений.
};
// Здесь всё хорошо, записываем от старой позиции до новой.
UART4_ActivateDMA();
};

//прием
    if((USART1->SR&USART_SR_RXNE)!=0) {//что то пришло
        USART1->SR&=~USART_SR_RXNE;//сбросим флаг
        rx_buf1[rx_ptr1]=USART1->DR;

acc = SR 0x01
interrupt!
SR=0x03 - появился дополнительный бит
acc = acc & 0xfe = 0x01 & 0xfe = 0x00

SR = 0x00 - сбрасывабтся все биты вообще

    USART3->SR&=~USART_SR_TC;
    USART3->DR=0xff;
    while((USART3->SR&USART_SR_TC)==0){
;
                                         }
    
    
    USART3->SR&=~USART_SR_TC;