Работа с com портом на скорости 921600

#include <stdio.h>
#include <fcntl.h>   /* File Control Definitions           */
#include <unistd.h>  /* UNIX Standard Definitions      */ 
#include <errno.h>   /* ERROR Number Definitions           */
#include <stdlib.h>
#include <time.h>
#include <sys/types.h> 
#include <sys/stat.h> 
#include <syslog.h>
#include <stdbool.h>
#include <wiringPi.h>
#include <pthread.h> 
#include <curses.h>
#include <string.h>
#include <sys/poll.h>
#include <linux/termios.h> 
#include <linux/serial.h>   
#include <linux/tty.h>  
// #include <termios.h> This must be removed! 
// Otherwise we'll get "redefinition of ‘struct termios’" errors #include <sys/ioctl.h> 
// Used for TCGETS2/TCSETS2, which is required for custom baud rates 
#define SUCCESS 0
#define IDLE  1
#define WRITE 2
#define WAIT_NPRES 100
#define BUFF_SIZE 4096
/***************************************************************/
void ButtonPressed(void);
void setup();
bool Debouncer_button();
void Uart_read(int fd_uart, int fd_log);
int Create_dir(int id_uart);
void Uart_init(int fd_uart);
int Create_fd_uart(int id_uart);
int ioctl(int fd_uart, int request, ...);
int tcflush (int filedes, int action);
/***************************************************************/
const int LEDPin = 30;
const int ButtonPin = 7;
const int PoweroffPin = 11;
/***************************************************************/
volatile int state = IDLE;
/***************************************************************/
int main ()
{   
    setup();
    bool prevState = false;
    bool button_pressed = false;
    int fdlog1;
    int fdlog2;
    int fdu1;
    int fdu2;
    int uart_1 = 1;//номер uart1
    int uart_2 = 2;//номер uart2
    fdu1 = Create_fd_uart(uart_1);
    fdu2 = Create_fd_uart(uart_2);
    digitalWrite(LEDPin,LOW);
 
    while (1) {
        button_pressed = Debouncer_button();
        if (state == IDLE) {
            if ((button_pressed != prevState) && (button_pressed == true)){
                state = WRITE;
                fdlog1 = Create_dir(uart_1);
                fdlog2 = Create_dir(uart_2);
            }
        } else {  // state == WRITE
                    tcflush(fdu1, TCOFLUSH);
                    tcflush(fdu2, TCOFLUSH);
                    digitalWrite(LEDPin,HIGH);
                    Uart_read(fdu1, fdlog1);//принимает fd fd_log 
                    Uart_read(fdu2, fdlog2);//принимает fd fd_log 
                     if ((button_pressed != prevState) && (button_pressed == true)){
 
                        if (close(fdlog1) != 0)
                        {
                            fprintf (stderr, "Cannot close file_log_uart1 (descriptor=%d)\n", fdlog1);
                            exit (1);
                        }
 
                        if (close(fdlog2) != 0)
                        {
                            fprintf (stderr, "Cannot close file_log_uart2 (descriptor=%d)\n", fdlog2);
                            exit (1);
                        }
                        //tcflush(fdu1, TCIOFLUSH);   /* Discards old data in the rx buffer*/
                        //tcflush(fdu2, TCIOFLUSH);   /* Discards old data in the rx buffer*/
                        digitalWrite(LEDPin,LOW);
                        state = IDLE;
                    }
        }
            prevState = button_pressed;
    }
}
/***************************************************************/
void setup()
{
    if(-1==wiringPiSetup())
    {
        exit(-1);
    }    
    pinMode(LEDPin,OUTPUT);    //Настройте контакт 30 для управления режимом вывода светодиода.
    digitalWrite(LEDPin,LOW);  //Инициализирован на низком уровне
    pinMode(ButtonPin,INPUT);            //Настройте контакт 1 как вход
    pullUpDnControl(ButtonPin,PUD_UP);  //Поднимите контакт 1 до 3,3 В
    pinMode(PoweroffPin,INPUT);            //Настройте контакт 1 как вход
    pullUpDnControl(PoweroffPin,PUD_UP);  //Поднимите контакт 1 до 3,3 В
    //Зарегистрировать обработчик прерывания
    if(0>wiringPiISR(PoweroffPin, INT_EDGE_FALLING, ButtonPressed))
    {
        exit(-1);
    }
}
/***************************************************************/
bool Debouncer_button()
{         
    static int counter = 0;         // сколько раз мы должны получить новое значение
    static int reading;             // текущее значение, прочитанное с входного вывода
    static int current_state = LOW; // входное значение, полученное после подавления дребезга
    int debounce_count = 50;        // количество миллисекунд/выборок для решения, что сигнал на входе принял устойчивое состояние
    reading = !digitalRead(ButtonPin);
    //устранение дребезга кнопки
    if(reading == current_state && counter > 0){
        counter--;
    }
    if(reading != current_state){
        counter++; 
    }
    // Если вход показывает одно значение достаточно долго, давайте переключим его
    if(counter >= debounce_count){
        counter = 0;
        current_state = reading;
    }  
    return current_state;
}
/***************************************************************/
int read_com(int fd, int len , int timeout, char * buff){
    int ret = 0;
    
    struct pollfd fds;
    fds.fd=fd;
    fds.events = POLLIN;
    poll(&fds, 1, timeout);
    if(fds.revents & POLLIN) {
            ret = read(fd, buff, len);
    }
    if(ret<0){
            ret = 0;
    }
    return ret; 
}
/***************************************************************/
int write_com(int fd, char * buf, size_t size, int timeout)
{
    int ret = 0;
 
    struct pollfd fds;
    fds.fd=fd;
    fds.events = POLLOUT;
    
    poll(&fds, 1, timeout);
    if(fds.revents & POLLOUT){
        ret = write(fd, (uint8_t*)buf, size);
    }
    if(ret!=size) return 0;
    return 1; 
}
/***************************************************************/
void Uart_init(int fd_uart) 
{   
    /*---------- Setting the Attributes of the serial port using termios structure --------- */
    struct termios2 SerialPortSettings;  /* Create the structure */
    ioctl(fd_uart,TCGETS2,&SerialPortSettings); 
 
    SerialPortSettings.c_cflag &= ~CBAUD;    //Remove current baud rate
    SerialPortSettings.c_cflag |= BOTHER;    //Allow custom baud rate using int input
    SerialPortSettings.c_ispeed = 921600;    //Set the input baud rate
    SerialPortSettings.c_ospeed = 921600;    //Set the output baud rate
    //tcgetattr(fd_uart, &SerialPortSettings); /* Get the current attributes of the Serial port */
    /* Setting the Baud rate */
    // cfsetispeed(&SerialPortSettings,921600); /* Set Read  Speed as 921600                       */
    // cfsetospeed(&SerialPortSettings,921600); /* Set Write Speed as 921600                       
 
    /* 8N1 Mode */
    SerialPortSettings.c_cflag &= ~PARENB;    //Disables the Parity Enable bit(PARENB),So No Parity   
    SerialPortSettings.c_cflag &= ~CSTOPB;   /* CSTOPB = 2 Stop bits,here it is cleared so 1 Stop bit */
    SerialPortSettings.c_cflag &= ~CSIZE;    /* Clears the mask for setting the data size             */
    SerialPortSettings.c_cflag |=  CS8;      /* Set the data bits = 8                                 */
 
 
    SerialPortSettings.c_cflag &= ~CRTSCTS;       /* No Hardware flow Control                         */
    SerialPortSettings.c_cflag |= CREAD | CLOCAL; /* Enable receiver,Ignore Modem Control lines       */ 
 
    SerialPortSettings.c_iflag &= ~(IXON | IXOFF | IXANY);          /* Disable XON/XOFF flow control both i/p and o/p */
    SerialPortSettings.c_iflag &= ~(ICANON | ECHO | ISIG | ECHOE| IGNCR);  /* Non Cannonical mode                            */
    
    SerialPortSettings.c_lflag = 0;
    SerialPortSettings.c_oflag &= ~OPOST;/*No Output Processing*/
 
 
    // /* Setting Time outs */
    SerialPortSettings.c_cc[VMIN] =  0; /* Read at least 10 characters */
    SerialPortSettings.c_cc[VTIME] = 0; /* Wait indefinetly   */
 
    tcflush(fd_uart, TCIOFLUSH);   /* Discards old data in the rx buffer*/
 
    //tcsetattr(fd_uart, TCSANOW, &SerialPortSettings);
    if((ioctl(fd_uart, TCSETS2, &SerialPortSettings)) != 0) /* Set the attributes to the termios structure*/
        printf("\n  ERROR ! in Setting attributes\n");
    else{
        printf("  BaudRate = 921600 \n  StopBits = 1 \n  Parity   = none \n");
    }
}  
/***************************************************************/
/// @brief Функция чтения буфера из UART
/// @param fd_uart file descriptor, дескиптор файла вывода UART
/// @param fd_log  file descriptor, декриптор на файл вывода, в котрый записывается текст из UART
/// @return none
void Uart_read(int fd_uart, int fd_log)
{      
    int status = 1; 
    int  bytes_read = 0;    /* Number of bytes read by the read() system call */
    int  bytes_write = 0;
 
    static char *read_buffer;   /* Buffer to store the data received              */
 
    if( read_buffer == NULL)
    {
        read_buffer = (char*)malloc(BUFF_SIZE);   /* Buffer to store the data received              */
        if( read_buffer == NULL)
        {
            exit(0);
            printf("error malloc");
 
        }
    }
 
 
 
    //ioctl(fd_uart, TIOCINQ, &read_buffer);
    //Переменная для сохранения текущего системного времени
    long int s_time;
    char str_t[30]="";
    char str[]="-->";
    int bytes;
    //Указатель, в который будет помещен адрес структуры с
    //преобразованным временем
    struct tm *m_time;
    //Считываем системное время
    s_time = time (NULL);
    //Преобразуем системное время в локальное
    m_time = localtime (&s_time);
    //Преобразуем локальное время в текстовую строку
    strftime (str_t, 55, "%x %X", m_time);
    
    ioctl(fd_uart, TIOCINQ, &bytes);
    
    // if (bytes>=BUFF_SIZE)
    // {
    //     printf("ERROR_COUNT %d\n",bytes);
    // }
 
    //printf("bytes %d\n", bytes);
    bytes_read = read_com(fd_uart, bytes>BUFF_SIZE?(BUFF_SIZE):(bytes) , 1, read_buffer); 
    if(bytes_read < 0)
        printf("ERROR_WRITE_READ");
    //char *string_log =strcat(str_t, str);
    //printf("bytes= %d\n",bytes);
 
    if(bytes_read>0){
        //write_com(fd_log,string_log,20,1);
        //write_com(fd_log, str,3,1);
 
        status = write_com(fd_log,read_buffer,bytes,1);
        if(status==0){
            printf("ERROR_WRITE\n");
            exit (0);
        } 
    }
 
    //free(read_buffer);  // TODO:!!!!
}
/***************************************************************/
int Create_fd_uart(int id_uart)
{
    char* pathname;
    if(id_uart == 1) 
        pathname = "/dev/ttyUSB0";
    else
        pathname = "/dev/ttyUSB1";
    printf("%s",pathname );
/*------------------------------- Opening the Serial Port -------------------------------*/
/* Change /dev/ttySx to the one corresponding to your system */
    int fd_uart = open(pathname,O_RDONLY | O_NOCTTY |  O_NDELAY| O_NONBLOCK);  
                    /* ttyUSB0 is the FT232 based USB2SERIAL Converter*/
                    /* O_RDWR   - Read/Write access to serial port       */
                    /* O_NOCTTY - No terminal will control the process   */
                    /* Open in blocking mode,read will wait              */
    if(fd_uart < 0) 
    {                /* Error Checking */
        printf("\n  Error! in Opening %s\n", pathname);
        exit(0);
    }
    fcntl(fd_uart, F_SETFL, FNDELAY);
    Uart_init(fd_uart);
    return fd_uart;/*File Descriptor for UART*/
}
/***************************************************************/
int Create_dir(int id_uart)
{
    int fd_log;
    mode_t mode = S_IRUSR | S_IWUSR;
    int flags = O_WRONLY | O_CREAT | O_TRUNC| O_NONBLOCK| O_EXCL; 
    //Переменная для сохранения текущего системного времени
    long int s_time;
    //Указатель, в который будет помещен адрес структуры с
    //преобразованным временем
    struct tm *m_time;
    char str_t[30]="";
    //Считываем текущее системное время
    s_time = time (NULL);
    //Преобразуем системное время в локальное
    m_time = localtime (&s_time);
    strftime (str_t, 64, "%Y-%m_%H-%M-%S", m_time);
 
    //printf("name_log=%s\n",string_log);
    if(id_uart == 1)
    {
        char string_first[36] ="/root/WiringOP/logs/log_uart1_";
        char *string_log = strcat(string_first, str_t);
        fd_log = open(string_log, flags, mode);
        if (fd_log < 0)
        {
            fprintf (stderr, "openclose: Cannot open file %s\n", string_log);
            exit (1);
        }
    }
    else
    {
        char string_first[36] ="/root/WiringOP/logs/log_uart2_";
        char *string_log = strcat(string_first, str_t);
        fd_log = open(string_log, flags, mode);
        if (fd_log < 0)
        {
            fprintf (stderr, "openclose: Cannot open file %s\n", string_log);
            exit (1);
        }
    }
 
    return fd_log;
}
/***************************************************************/ 
void ButtonPressed(void){
//Кнопка Shutdown, запуск сценария завершения работы системы
        //digitalWrite(LEDPin,HIGH);
        //system("shutdown -h now");
        //delay(WAIT_NPRES);
}
/***************************************************************/