HAL_UART_Transmit_IT sending data twice

Question

I am trying to establish UART communication between a PC and a STM32f407-DISC1 board using an arduino nano as a middle man. The PC sends 'r' to the arduino to indicate a request. The request is then communicated to the stm32 with a GPIO interrupt, which then should be transmitting 480 bytes of data using HAL_UART_Transmit_IT. It however sends the data twice, with only a single request made.

The code on the STM32 is generated by STM32CubeMX

Data request made by the arduino

void loop() {
    digitalWrite(4, 0); // Clear EXTI11 line.

    if (mySerial.available() && received < 480) {   // STM32 sending data and is not done.
        buff[received] = mySerial.read();           // Append received data to the buffer.
        received++;
    }
    if (received >= 480) {                          // If the buffer is full
        received = 0;                               // transmit it to PC.
        Serial.println(buff);
    }


    if (Serial.available()) {
        if (Serial.read() == 'r') {     // PC requests data from the STM32
            digitalWrite(4, 1);         // Triggers STM32 EXTI11 line.
            while (Serial.available())  // Empty the buffer.
                Serial.read();
        }
    }
}

data transmission on the STM32

void EXTI15_10_IRQHandler(void)
{
    // Make sure that the interrupt is the good one.
    if (HAL_GPIO_ReadPin(data_req_IRQ_GPIO_Port, data_req_IRQ_Pin)) {
        if (is_sending_data == FALSE)   // If no transmission is happening
            should_send_data = TRUE;    // raise transmission flag.
    }

    // IRQ handling stuff...
}

void HAL_UART_TxCpltCallback(UART_HandleTypeDef * huart) {
    is_sending_data = FALSE;    // Transmition is completed, unblock requests.
}

void main(void){
    // Init and other stuff...

    while (1) {
        if (should_send_data == TRUE) { // If data was requested
            HAL_GPIO_WritePin(LD5_GPIO_Port, LD5_Pin, GPIO_PIN_RESET);
            HAL_UART_Transmit_IT(&huart3, matrice, 480);    // Start transmission by interrupt.
            is_sending_data = TRUE;                         // Block requests.
            should_send_data = FALSE;                       // Clear flag.
        }
    // matrice acquisition stuff here
    }
}

Answer 1

Alright so I found a solution, but it involved just rethinking my approach, so sorry for those looking for an answer to this problem.

I removed the arduino middle man by replacing it with a USB to RS232 converter and made UART reception work by interrupt. The STM detects the 'r' character which triggers the data communication. Here is the interrupt part:

void USART3_IRQHandler(void)
{
    if (USART3->SR & UART_IT_RXNE) {    // If a byte is received
        rxBuff[0] = (uint8_t) (huart3.Instance->DR & (uint8_t) 0xFF);   // Read it.
        __HAL_UART_FLUSH_DRREGISTER(&huart3);   // Clear the buffer to avoid errors.
        rx_new_char_flag = TRUE;    // Raise the new_char flag.
        return; // Stops the IRQHandler from disabling interrupts.
    }
}

and the gestion of that in the main

while (1) {
    if (rx_new_char_flag == TRUE) {
        rx_new_char_flag = FALSE;
        if (rxBuff[0] == 'r') {
            rxBuff[0] = 0;
            HAL_UART_Transmit_IT(&huart3, matrice, 480); // Start transmission by interrupt.
            }
        }

On the PC side, to optimize performance, instead of waiting for the full 480 bytes, I wait for only one character, if one is received I keep reading the serial port, as shown in the code bellow

int i = 0;
do {
    ReadFile(m_hSerial, &temp_rx[i], 1, &dwBytesRead, NULL);
    i++;
} while (dwBytesRead > 0 && i < 480);
for (int j = i; j < 480; j++)  // If the transmission is incomplete, fill the buffer with 0s to avoid garbage data.
    temp_rx[j] = 0;

if(i>=480)  // If all the bytes has been received, copy the data in the working buffer.
    std::copy(std::begin(temp_rx), std::end(temp_rx), std::begin(m_touch_state));

This works well with pretty decent performance, so that may be a permanent solution to my problem.