//
// Created by cfif on 15.11.22.
//
#include "SerialPorts.h"
#include "at32f435_437.h"

tSerialPorts SERIAL_PORTS;


//начало------------------------------------GONEC2 связь с модемом ГОНЕЦ (запасной)-------------------------------------
//начало------------------------------------GONEC2 связь с модемом ГОНЕЦ (запасной)-------------------------------------
//начало------------------------------------GONEC2 связь с модемом ГОНЕЦ (запасной)-------------------------------------

// GONEC2
//void UART8_IRQHandler() {
//    vSerialPortIrqProcessing(&SERIAL_PORTS.GONEC2);
//}

uint8_t buf_UART8_DMA[1024];

// GONEC2
void UART8_IRQHandler() {
    SerialPort_IrqProcessing_UartIdle(&SERIAL_PORTS.GONEC2);
    // Смотрим idle прерывание
//    if (usart_flag_get(SERIAL_PORTS.GONEC2.uart, USART_IDLEF_FLAG)) {
//        // Сброс прерывания
//        usart_data_receive(SERIAL_PORTS.GONEC2.uart);
//        vSerialPortIrqProcessingDMAloop(&SERIAL_PORTS.GONEC2, SERIAL_PORTS.GONEC2.dma_rx_init_struct.buffer_size -
//                                                              SERIAL_PORTS.GONEC2.dma_channel->dtcnt);
//    }
}

// RX
void DMA1_Channel1_IRQHandler(void) {
    SerialPort_IrqProcessing_DmaRxLoop(&SERIAL_PORTS.GONEC2);
    //    if (dma_flag_get(DMA1_FDT1_FLAG)) {
//
//        vSerialPortIrqProcessingDMAloop(&SERIAL_PORTS.GONEC2,
//                                        SERIAL_PORTS.GONEC2.dma_rx_init_struct.buffer_size);
//        SERIAL_PORTS.GONEC2.offset = 0;
//        dma_flag_clear(DMA1_FDT1_FLAG);
//    }
}


// TX
void DMA1_Channel2_IRQHandler(void) {
    SerialPort_IrqProcessing_DmaTx(&SERIAL_PORTS.GONEC2);
    //    if (dma_flag_get(DMA1_FDT2_FLAG)) {
//        dma_flag_clear(DMA1_FDT2_FLAG);
//        osMutexRelease(SERIAL_PORTS.GONEC2.dmaAccess);
//    }
}


// Настройка порта мезонин ГОНЕЦ UART2
static void vSerialPort_InitUART8(tSerialPortArtery *env) {
    gpio_init_type GPIO_InitStruct;

    gpio_default_para_init(&GPIO_InitStruct);

    GPIO_InitStruct.gpio_drive_strength = GPIO_DRIVE_STRENGTH_STRONGER;
    GPIO_InitStruct.gpio_out_type = GPIO_OUTPUT_PUSH_PULL;
    GPIO_InitStruct.gpio_mode = GPIO_MODE_MUX;
    GPIO_InitStruct.gpio_pins = GPIO_PINS_0 | GPIO_PINS_1;
    GPIO_InitStruct.gpio_pull = GPIO_PULL_NONE;
    gpio_init(GPIOE, &GPIO_InitStruct);

    gpio_pin_mux_config(GPIOE, GPIO_PINS_SOURCE0, GPIO_MUX_8);
    gpio_pin_mux_config(GPIOE, GPIO_PINS_SOURCE1, GPIO_MUX_8);

//    vSerialPortInitName(env, UART8, false, 115200, 0xFF, 256);
//    vSerialPortInitNameWithSniffer(env, UART8, 921600, 0xFF, 1024, 1024);

//    vSerialPortInitDMAName(env, UART8, DMA1,
//                                      DMA1_CHANNEL1, DMA1MUX_CHANNEL1, DMAMUX_DMAREQ_ID_UART8_RX, DMA1_Channel1_IRQn,
//                                      DMA1_FDT1_FLAG,
//                                      buf_UART8_DMA, sizeof(buf_UART8_DMA),
//                                      DMA1_CHANNEL2, DMA1MUX_CHANNEL2, DMAMUX_DMAREQ_ID_UART8_TX, DMA1_Channel2_IRQn,
//                                      DMA1_FDT2_FLAG,
//                                      true, 921600, 0xFF, 512);

    vSerialPortInitDmaWithNameAndSniffer(
            env, UART8, 921600,
            1, 1, 1, 2,
            true, 0xFF,
            buf_UART8_DMA, sizeof(buf_UART8_DMA),
            4096, 0
    );


}
//конец-------------------------------------GONEC2 связь с модемом ГОНЕЦ (запасной)-------------------------------------
//конец-------------------------------------GONEC2 связь с модемом ГОНЕЦ (запасной)-------------------------------------
//конец-------------------------------------GONEC2 связь с модемом ГОНЕЦ (запасной)-------------------------------------

//начало------------------------------------GONEC1 связь с модемом ГОНЕЦ------------------------------------------------
//начало------------------------------------GONEC1 связь с модемом ГОНЕЦ------------------------------------------------
//начало------------------------------------GONEC1 связь с модемом ГОНЕЦ------------------------------------------------

// GONEC1
//void UART7_IRQHandler() {
//    vSerialPortIrqProcessing(&SERIAL_PORTS.GONEC1);
//}

uint8_t buf_UART7_DMA[3200];

volatile uint32_t timeModemStuckGetMs = 0;

// IDLE прерывание
void UART7_IRQHandler() {

    timeModemStuckGetMs = SystemGetMs();

    SerialPort_IrqProcessing_UartIdle(&SERIAL_PORTS.GONEC1);
    // Смотрим idle прерывание
//    if (usart_flag_get(SERIAL_PORTS.GONEC1.uart, USART_IDLEF_FLAG)) {
//        // Сброс прерывания
//        usart_data_receive(SERIAL_PORTS.GONEC1.uart);
//
//        vSerialPortIrqProcessingDMAloop(&SERIAL_PORTS.GONEC1, SERIAL_PORTS.GONEC1.dma_rx_init_struct.buffer_size -
//                                                              SERIAL_PORTS.GONEC1.dma_channel->dtcnt);
//
//    }
}

// RX
void DMA1_Channel3_IRQHandler(void) {

    SerialPort_IrqProcessing_DmaRxLoop(&SERIAL_PORTS.GONEC1);

//    if (dma_flag_get(DMA1_FDT3_FLAG)) {
//
//        timeModemStuckGetMs = SystemGetMs();
//
//        vSerialPortIrqProcessingDMAloop(&SERIAL_PORTS.GONEC1,
//                                        SERIAL_PORTS.GONEC1.dma_rx_init_struct.buffer_size);
//        SERIAL_PORTS.GONEC1.offset = 0;
//        dma_flag_clear(DMA1_FDT3_FLAG);
//    }
}

// TX
void DMA1_Channel4_IRQHandler(void) {

    SerialPort_IrqProcessing_DmaTx(&SERIAL_PORTS.GONEC1);

//    if (dma_flag_get(DMA1_FDT4_FLAG)) {
//        dma_flag_clear(DMA1_FDT4_FLAG);
//        osMutexRelease(SERIAL_PORTS.GONEC1.dmaAccess);
//    }
}

// Настройка порта мезонин ГОНЕЦ UART1
static void vSerialPort_InitUART7(tSerialPortArtery *env) {
    gpio_init_type GPIO_InitStruct;

    gpio_default_para_init(&GPIO_InitStruct);

    GPIO_InitStruct.gpio_drive_strength = GPIO_DRIVE_STRENGTH_STRONGER;
    GPIO_InitStruct.gpio_out_type = GPIO_OUTPUT_PUSH_PULL;
    GPIO_InitStruct.gpio_mode = GPIO_MODE_MUX;
    GPIO_InitStruct.gpio_pins = GPIO_PINS_6 | GPIO_PINS_7;
    GPIO_InitStruct.gpio_pull = GPIO_PULL_NONE;
    gpio_init(GPIOF, &GPIO_InitStruct);

    gpio_pin_mux_config(GPIOF, GPIO_PINS_SOURCE6, GPIO_MUX_8);
    gpio_pin_mux_config(GPIOF, GPIO_PINS_SOURCE7, GPIO_MUX_8);

//    vSerialPortInitNameWithSniffer(env, UART7, true, 115200, 0x55, 1024, 1024);


//    vSerialPortInitDMANameWithSniffer(env, UART7, DMA1,
//                                      DMA1_CHANNEL3, DMA1MUX_CHANNEL3, DMAMUX_DMAREQ_ID_UART7_RX, DMA1_Channel3_IRQn,
//                                      DMA1_FDT3_FLAG,
//                                      buf_UART7_DMA, sizeof(buf_UART7_DMA),
//                                      DMA1_CHANNEL4, DMA1MUX_CHANNEL4, DMAMUX_DMAREQ_ID_UART7_TX, DMA1_Channel4_IRQn,
//                                      DMA1_FDT4_FLAG,
//                                      true, 921600, 0xFF, 3200, 3200);
//
//    vSerialPortInitDMAName(env, UART7, DMA1,
//                                      DMA1_CHANNEL3, DMA1MUX_CHANNEL3, DMAMUX_DMAREQ_ID_UART7_RX, DMA1_Channel3_IRQn,
//                                      DMA1_FDT3_FLAG,
//                                      buf_UART7_DMA, sizeof(buf_UART7_DMA),
//                                      DMA1_CHANNEL4, DMA1MUX_CHANNEL4, DMAMUX_DMAREQ_ID_UART7_TX, DMA1_Channel4_IRQn,
//                                      DMA1_FDT4_FLAG,
//                                      true, 921600, 0xFF, 3200);

    vSerialPortInitDmaWithNameAndSniffer(
            env, UART7, 921600,
            1, 3, 1, 4,
            true, 0xFF,
            buf_UART7_DMA, sizeof(buf_UART7_DMA),
            3200, 3200
    );

}

//конец-------------------------------------GONEC1 связь с модемом ГОНЕЦ------------------------------------------------
//конец-------------------------------------GONEC1 связь с модемом ГОНЕЦ------------------------------------------------
//конец-------------------------------------GONEC1 связь с модемом ГОНЕЦ------------------------------------------------

//начало-------------------------------------Модем SIM800---------------------------------------------------------------
//начало-------------------------------------Модем SIM800---------------------------------------------------------------
//начало-------------------------------------Модем SIM800---------------------------------------------------------------

// SIM800F
//void USART3_IRQHandler() {
//    vSerialPortIrqProcessing(&SERIAL_PORTS.SIM800F);
//}

uint8_t buf_USART3_DMA[100];

// IDLE прерывание
void USART3_IRQHandler() {

    SerialPort_IrqProcessing_UartIdle(&SERIAL_PORTS.SIM800F);
    // Смотрим idle прерывание
//    if (usart_flag_get(SERIAL_PORTS.SIM800F.uart, USART_IDLEF_FLAG)) {
//        // Сброс прерывания
//        usart_data_receive(SERIAL_PORTS.SIM800F.uart);
//
//        vSerialPortIrqProcessingDMAloop(&SERIAL_PORTS.SIM800F, SERIAL_PORTS.SIM800F.dma_rx_init_struct.buffer_size -
//                                                               SERIAL_PORTS.SIM800F.dma_channel->dtcnt);
//
//    }
}

// RX
void DMA2_Channel3_IRQHandler(void) {
    SerialPort_IrqProcessing_DmaRxLoop(&SERIAL_PORTS.SIM800F);
//    if (dma_flag_get(DMA2_FDT3_FLAG)) {
//
//        vSerialPortIrqProcessingDMAloop(&SERIAL_PORTS.SIM800F,
//                                        SERIAL_PORTS.SIM800F.dma_rx_init_struct.buffer_size);
//        SERIAL_PORTS.SIM800F.offset = 0;
//        dma_flag_clear(DMA2_FDT3_FLAG);
//    }
}

// TX
void DMA2_Channel5_IRQHandler(void) {
    SerialPort_IrqProcessing_DmaTx(&SERIAL_PORTS.SIM800F);

//    if (dma_flag_get(DMA2_FDT5_FLAG)) {
//        dma_flag_clear(DMA2_FDT5_FLAG);
//        osMutexRelease(SERIAL_PORTS.SIM800F.dmaAccess);
//    }
}

// Настройка порта SIM800F
static void vSerialPort_InitUSART3(tSerialPortArtery *env) {
    gpio_init_type GPIO_InitStruct;

    gpio_default_para_init(&GPIO_InitStruct);

    GPIO_InitStruct.gpio_drive_strength = GPIO_DRIVE_STRENGTH_STRONGER;
    GPIO_InitStruct.gpio_out_type = GPIO_OUTPUT_PUSH_PULL;


    GPIO_InitStruct.gpio_mode = GPIO_MODE_MUX;
    GPIO_InitStruct.gpio_pins = GPIO_PINS_8 | GPIO_PINS_9;

    GPIO_InitStruct.gpio_pull = GPIO_PULL_NONE;
    gpio_init(GPIOD, &GPIO_InitStruct);

    gpio_pin_mux_config(GPIOD, GPIO_PINS_SOURCE8, GPIO_MUX_7);
    gpio_pin_mux_config(GPIOD, GPIO_PINS_SOURCE9, GPIO_MUX_7);

//    vSerialPortInitName(env, USART3, false, 115200, 0xFF, 256);

    vSerialPortInitDmaWithNameAndSniffer(
            env, USART3, 115200,
            2, 3, 2, 5,
            false, 0xFF,
            buf_USART3_DMA, sizeof(buf_USART3_DMA),
            100, 100
    );

//    vSerialPortInitDMAName(env, USART3, DMA2,
//                           DMA2_CHANNEL3, DMA2MUX_CHANNEL3, DMAMUX_DMAREQ_ID_USART3_RX, DMA2_Channel3_IRQn,
//                           DMA2_FDT3_FLAG,
//                           buf_USART3_DMA, sizeof(buf_USART3_DMA),
//                           DMA2_CHANNEL5, DMA2MUX_CHANNEL5, DMAMUX_DMAREQ_ID_USART3_TX, DMA2_Channel5_IRQn,
//                           DMA2_FDT5_FLAG,
//                           false, 115200, 0xFF, 100);
//
//    vSerialPortInitDMANameWithSniffer(env, USART3, DMA2,
//                           DMA2_CHANNEL3, DMA2MUX_CHANNEL3, DMAMUX_DMAREQ_ID_USART3_RX, DMA2_Channel3_IRQn,
//                           DMA2_FDT3_FLAG,
//                           buf_USART3_DMA, sizeof(buf_USART3_DMA),
//                           DMA2_CHANNEL5, DMA2MUX_CHANNEL5, DMAMUX_DMAREQ_ID_USART3_TX, DMA2_Channel5_IRQn,
//                           DMA2_FDT5_FLAG,
//                           false, 115200, 0xFF, 3200, 3200);

 }
//начало-------------------------------------Модем SIM800---------------------------------------------------------------
//начало-------------------------------------Модем SIM800---------------------------------------------------------------
//начало-------------------------------------Модем SIM800---------------------------------------------------------------


//начало-------------------------------------ГНСС-----------------------------------------------------------------------
//начало-------------------------------------ГНСС-----------------------------------------------------------------------
//начало-------------------------------------ГНСС-----------------------------------------------------------------------

//void UART5_IRQHandler() {
//    vSerialPortIrqProcessing(&SERIAL_PORTS.PRO04);
//}

uint8_t buf_UART5_DMA[100];

// IDLE прерывание
void UART5_IRQHandler() {
    SerialPort_IrqProcessing_UartIdle(&SERIAL_PORTS.PRO04);

    // Смотрим idle прерывание
//    if (usart_flag_get(SERIAL_PORTS.PRO04.uart, USART_IDLEF_FLAG)) {
//        // Сброс прерывания
//        usart_data_receive(SERIAL_PORTS.PRO04.uart);
//
//        vSerialPortIrqProcessingDMAloop(&SERIAL_PORTS.PRO04, SERIAL_PORTS.PRO04.dma_rx_init_struct.buffer_size -
//                                                             SERIAL_PORTS.PRO04.dma_channel->dtcnt);
//
//    }
}

// RX
void DMA1_Channel6_IRQHandler(void) {

    SerialPort_IrqProcessing_DmaRxLoop(&SERIAL_PORTS.PRO04);

//    if (dma_flag_get(DMA1_FDT6_FLAG)) {
//
//        vSerialPortIrqProcessingDMAloop(&SERIAL_PORTS.PRO04,
//                                        SERIAL_PORTS.PRO04.dma_rx_init_struct.buffer_size);
//        SERIAL_PORTS.PRO04.offset = 0;
//        dma_flag_clear(DMA1_FDT6_FLAG);
//    }
}

// TX
void DMA1_Channel7_IRQHandler(void) {
    SerialPort_IrqProcessing_DmaTx(&SERIAL_PORTS.PRO04);
//    if (dma_flag_get(DMA1_FDT7_FLAG)) {
//        dma_flag_clear(DMA1_FDT7_FLAG);
//        osMutexRelease(SERIAL_PORTS.PRO04.dmaAccess);
//    }
}

// Настройка порта PRO04
static void vSerialPort_InitUART5(tSerialPortArtery *env) {
    gpio_init_type GPIO_InitStruct;

    gpio_default_para_init(&GPIO_InitStruct);

    GPIO_InitStruct.gpio_drive_strength = GPIO_DRIVE_STRENGTH_STRONGER;
    GPIO_InitStruct.gpio_out_type = GPIO_OUTPUT_PUSH_PULL;
    GPIO_InitStruct.gpio_mode = GPIO_MODE_MUX;
    GPIO_InitStruct.gpio_pins = GPIO_PINS_2;
    GPIO_InitStruct.gpio_pull = GPIO_PULL_NONE;
    gpio_init(GPIOD, &GPIO_InitStruct);

    GPIO_InitStruct.gpio_pins = GPIO_PINS_12;
    gpio_init(GPIOC, &GPIO_InitStruct);

    gpio_pin_mux_config(GPIOD, GPIO_PINS_SOURCE2, GPIO_MUX_8);
    gpio_pin_mux_config(GPIOC, GPIO_PINS_SOURCE12, GPIO_MUX_8);

    vSerialPortInitDmaWithNameAndSniffer(
            env, UART5, 115200,
            1, 6, 1, 7,

            false, 0xFF,
            buf_UART5_DMA, sizeof(buf_UART5_DMA),
            256, 0
    );

//    vSerialPortInitName(env, UART5, false, 115200, 0xFF, 256);

//    vSerialPortInitDMAName(env, UART5, DMA1,
//                           DMA1_CHANNEL6, DMA1MUX_CHANNEL6, DMAMUX_DMAREQ_ID_UART5_RX, DMA1_Channel6_IRQn,
//                           DMA1_FDT6_FLAG,
//                           buf_UART5_DMA, sizeof(buf_UART5_DMA),
//                           DMA1_CHANNEL7, DMA1MUX_CHANNEL7, DMAMUX_DMAREQ_ID_UART5_TX, DMA1_Channel7_IRQn,
//                           DMA1_FDT7_FLAG,
//                           false, 115200, 0xFF, 256);
}
//конец--------------------------------------ГНСС-----------------------------------------------------------------------
//конец--------------------------------------ГНСС-----------------------------------------------------------------------
//конец--------------------------------------ГНСС-----------------------------------------------------------------------


//начало-------------------------------------Трассировка----------------------------------------------------------------
//начало-------------------------------------Трассировка----------------------------------------------------------------
//начало-------------------------------------Трассировка----------------------------------------------------------------


//void USART2_IRQHandler() {
//    vSerialPortIrqProcessing(&SERIAL_PORTS.ComInt485);
//}

uint8_t buf_USART2_DMA[100];

// IDLE прерывание
void USART2_IRQHandler() {
    SerialPort_IrqProcessing_UartIdle(&SERIAL_PORTS.ComInt485);
    // Смотрим idle прерывание
//    if (usart_flag_get(SERIAL_PORTS.ComInt485.uart, USART_IDLEF_FLAG)) {
//        // Сброс прерывания
//        usart_data_receive(SERIAL_PORTS.ComInt485.uart);
//
//        vSerialPortIrqProcessingDMAloop(&SERIAL_PORTS.ComInt485, SERIAL_PORTS.ComInt485.dma_rx_init_struct.buffer_size -
//                                                                 SERIAL_PORTS.ComInt485.dma_channel->dtcnt);
//
//    }
}

// RX
void DMA2_Channel1_IRQHandler(void) {
    SerialPort_IrqProcessing_DmaRxLoop(&SERIAL_PORTS.ComInt485);
//    if (dma_flag_get(DMA2_FDT1_FLAG)) {
//
//        vSerialPortIrqProcessingDMAloop(&SERIAL_PORTS.ComInt485,
//                                        SERIAL_PORTS.ComInt485.dma_rx_init_struct.buffer_size);
//        SERIAL_PORTS.ComInt485.offset = 0;
//        dma_flag_clear(DMA2_FDT1_FLAG);
//    }
}

// TX
void DMA2_Channel2_IRQHandler(void) {
    SerialPort_IrqProcessing_DmaTx(&SERIAL_PORTS.ComInt485);
//    if (dma_flag_get(DMA2_FDT2_FLAG)) {
//        dma_flag_clear(DMA2_FDT2_FLAG);
//        osMutexRelease(SERIAL_PORTS.ComInt485.dmaAccess);
//    }
}


// Настройка порта ComInt485
static void vSerialPort_InitUSART2(tSerialPortArtery *env) {
    gpio_init_type GPIO_InitStruct;

    gpio_default_para_init(&GPIO_InitStruct);

    GPIO_InitStruct.gpio_drive_strength = GPIO_DRIVE_STRENGTH_STRONGER;
    GPIO_InitStruct.gpio_out_type = GPIO_OUTPUT_PUSH_PULL;


    GPIO_InitStruct.gpio_mode = GPIO_MODE_MUX;
    GPIO_InitStruct.gpio_pins = GPIO_PINS_5 | GPIO_PINS_6;

    GPIO_InitStruct.gpio_pull = GPIO_PULL_NONE;
    gpio_init(GPIOD, &GPIO_InitStruct);

    gpio_pin_mux_config(GPIOD, GPIO_PINS_SOURCE5, GPIO_MUX_7);
    gpio_pin_mux_config(GPIOD, GPIO_PINS_SOURCE6, GPIO_MUX_7);

//    vSerialPortInitName(env, USART2, false, 115200, 0xFF, 256);

    vSerialPortInitDmaWithNameAndSniffer(
            env, USART2, 115200,
            2, 1, 2, 2,
            false, 0xFF,
            buf_USART2_DMA, sizeof(buf_USART2_DMA),
            256, 0
    );

//    vSerialPortInitDMAName(env, USART2, DMA2,
//                           DMA2_CHANNEL1, DMA2MUX_CHANNEL1, DMAMUX_DMAREQ_ID_USART2_RX, DMA2_Channel1_IRQn,
//                           DMA2_FDT1_FLAG,
//                           buf_USART2_DMA, sizeof(buf_USART2_DMA),
//                           DMA2_CHANNEL2, DMA2MUX_CHANNEL2, DMAMUX_DMAREQ_ID_USART2_TX, DMA2_Channel2_IRQn,
//                           DMA2_FDT2_FLAG,
//                           false, 115200, 0xFF, 256);

}

// Перенастройка порта ComInt485
void vSerialPort_ReInitUSART2(uint32_t BoundRate) {
//    vSerialPortInitName(&SERIAL_PORTS.ComInt485, USART2, false, BoundRate, 0xFF, 256);

    vSerialPortInitDmaWithNameAndSniffer(
            &SERIAL_PORTS.ComInt485, USART2, BoundRate,
            2, 1, 2, 2,
            false, 0xFF,
            buf_USART2_DMA, sizeof(buf_USART2_DMA),
            256, 0
    );

//    vSerialPortInitDMAName(&SERIAL_PORTS.ComInt485, USART2, DMA2,
//                           DMA2_CHANNEL1, DMA2MUX_CHANNEL1, DMAMUX_DMAREQ_ID_USART2_RX, DMA2_Channel1_IRQn,
//                           DMA2_FDT1_FLAG,
//                           buf_USART2_DMA, sizeof(buf_USART2_DMA),
//                           DMA2_CHANNEL2, DMA2MUX_CHANNEL2, DMAMUX_DMAREQ_ID_USART2_TX, DMA2_Channel2_IRQn,
//                           DMA2_FDT2_FLAG,
//                           false, BoundRate, 0xFF, 256);
}

//конец-------------------------------------Трассировка-----------------------------------------------------------------
//конец-------------------------------------Трассировка-----------------------------------------------------------------
//конец-------------------------------------Трассировка-----------------------------------------------------------------

//начало------------------------------------Внешний протокол------------------------------------------------------------
//начало------------------------------------Внешний протокол------------------------------------------------------------
//начало------------------------------------Внешний протокол------------------------------------------------------------

//void USART6_IRQHandler() {
//    vSerialPortIrqProcessing(&SERIAL_PORTS.ComInt232);
//}


uint8_t buf_USART6_DMA[100];


// IDLE прерывание
void USART6_IRQHandler() {
    SerialPort_IrqProcessing_UartIdle(&SERIAL_PORTS.ComInt232);
    // Смотрим idle прерывание
//    if (usart_flag_get(SERIAL_PORTS.ComInt232.uart, USART_IDLEF_FLAG)) {
//        // Сброс прерывания
//        usart_data_receive(SERIAL_PORTS.ComInt232.uart);
//
//        vSerialPortIrqProcessingDMAloop(&SERIAL_PORTS.ComInt232, SERIAL_PORTS.ComInt232.dma_rx_init_struct.buffer_size -
//                                                                 SERIAL_PORTS.ComInt232.dma_channel->dtcnt);
//
//    }
}

// RX
void DMA2_Channel6_IRQHandler(void) {
    SerialPort_IrqProcessing_DmaRxLoop(&SERIAL_PORTS.ComInt232);
    //    if (dma_flag_get(DMA2_FDT6_FLAG)) {
//
//        vSerialPortIrqProcessingDMAloop(&SERIAL_PORTS.ComInt232,
//                                        SERIAL_PORTS.ComInt232.dma_rx_init_struct.buffer_size);
//        SERIAL_PORTS.ComInt232.offset = 0;
//        dma_flag_clear(DMA2_FDT6_FLAG);
//    }
}


// TX
void DMA2_Channel7_IRQHandler(void) {
    SerialPort_IrqProcessing_DmaTx(&SERIAL_PORTS.ComInt232);
//    if (dma_flag_get(DMA2_FDT7_FLAG)) {
//        dma_flag_clear(DMA2_FDT7_FLAG);
//        osMutexRelease(SERIAL_PORTS.ComInt232.dmaAccess);
//    }
}

// Настройка порта ComInt232
static void vSerialPort_InitUSART6(tSerialPortArtery *env) {
    gpio_init_type GPIO_InitStruct;

    gpio_default_para_init(&GPIO_InitStruct);

    GPIO_InitStruct.gpio_drive_strength = GPIO_DRIVE_STRENGTH_STRONGER;
    GPIO_InitStruct.gpio_out_type = GPIO_OUTPUT_PUSH_PULL;
    GPIO_InitStruct.gpio_mode = GPIO_MODE_MUX;
    GPIO_InitStruct.gpio_pins = GPIO_PINS_11;
    GPIO_InitStruct.gpio_pull = GPIO_PULL_NONE;
    gpio_init(GPIOA, &GPIO_InitStruct);

    GPIO_InitStruct.gpio_pins = GPIO_PINS_7;
    gpio_init(GPIOC, &GPIO_InitStruct);


    gpio_pin_mux_config(GPIOA, GPIO_PINS_SOURCE11, GPIO_MUX_8);
    gpio_pin_mux_config(GPIOC, GPIO_PINS_SOURCE7, GPIO_MUX_8);

//    vSerialPortInitName(env, USART6, false, 115200, 0xFF, 256);

    vSerialPortInitDmaWithNameAndSniffer(
            env, USART6, 115200,
            2, 6, 2, 7,
            false, 0xFF,
            buf_USART6_DMA, sizeof(buf_USART6_DMA),
            8000, 0
    );

//    vSerialPortInitDMAName(env, USART6, DMA2,
//                           DMA2_CHANNEL6, DMA2MUX_CHANNEL6, DMAMUX_DMAREQ_ID_USART6_RX, DMA2_Channel6_IRQn,
//                           DMA2_FDT6_FLAG,
//                           buf_USART6_DMA, sizeof(buf_USART6_DMA),
//                           DMA2_CHANNEL7, DMA2MUX_CHANNEL7, DMAMUX_DMAREQ_ID_USART6_TX, DMA2_Channel7_IRQn,
//                           DMA2_FDT7_FLAG,
//                           false, 115200, 0xFF, 256);
}

//конец-------------------------------------Внешний протокол------------------------------------------------------------
//конец-------------------------------------Внешний протокол------------------------------------------------------------
//конец-------------------------------------Внешний протокол------------------------------------------------------------


void SerialPorts_Init(tRs485DirectionPins *env485) {
    tSerialPorts *env = &SERIAL_PORTS;

    vSerialPort_InitUART5(&env->PRO04);
    SERIAL_PORTS.PRO04IO = vSerialPortGetIo(&SERIAL_PORTS.PRO04);

    vSerialPort_InitUART7(&env->GONEC1);
    SERIAL_PORTS.GONEC1IO = vSerialPortGetIo(&SERIAL_PORTS.GONEC1);
    SERIAL_PORTS.GONEC1IOSniffer = vSerialPortGetSnifferIo(&SERIAL_PORTS.GONEC1);

    vSerialPort_InitUART8(&env->GONEC2);
    SERIAL_PORTS.GONEC2IO = vSerialPortGetIo(&SERIAL_PORTS.GONEC2);


    vSerialPort_InitUSART3(&env->SIM800F);
    SERIAL_PORTS.SIM800FIO = vSerialPortGetIo(&SERIAL_PORTS.SIM800F);
    SERIAL_PORTS.SIM800FIOSniffer = vSerialPortGetSnifferIo(&SERIAL_PORTS.SIM800F);


    vSerialPort_InitUSART2(&env->ComInt485);
    SERIAL_PORTS.ComInt485IO = vSerialPortGetIo(&SERIAL_PORTS.ComInt485);

    vSerialPort_InitUSART6(&env->ComInt232);
    SERIAL_PORTS.ComInt232IO = vSerialPortGetIo(&SERIAL_PORTS.ComInt232);

    SERIAL_PORTS.ComIntHalfDuplex = vSerialPortHalfDuplexInit(&SERIAL_PORTS.ComInt485IO,
                                                              &env485->transmit,
                                                              &env485->receive);

    SERIAL_PORTS.ComIntHalfDuplexIo = vSerialPortHalfDuplexGetIo(&SERIAL_PORTS.ComIntHalfDuplex);


    SerialPortP2p_Init(&env->cliVirtualPort, 1 * 2048, 512);
    env->cliVirtualInIo = SerialPortP2p_GetIoFirst(&env->cliVirtualPort);
    env->cliVirtualOutIo = SerialPortP2p_GetIoSecond(&env->cliVirtualPort);

 }