In your HAL_UART_RxCpltCallback() function, you can act differently depending upon the UART peripheral.

void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart) {
  if (huart->Instance == USART1) {
    // USART1
  } else if (huart->Instance == USART2) {
    // USART2
  } else if (huart->Instance == USART3) {
    // USART3
  } else if (huart->Instance == UART4) {
    // UART4
  }
}

Same is possible with HAL_UART_TxCpltCallback as well.

With a quick glance I see two potential issues. 1. You need to put the HAL_UART_Receive_ITinside the super loop. 2. The IRQ handler needs to be kept short. What you want to do is put the code in the HAL_UART_RxCpltCallback function which is going to be run after every RX.

It is a good idea to just try to use some the STM32 Cube examples.

Your code never asks to receive anything in the first place, so the receive callback is never executed.

And by looking at the way you use the callback, you seem to have an misunderstanding how the interrupt receiving works. HAL_USART_Receive_IT() is not used to read data that is previously received with interrupts. It is used to start reception of X bytes into memory buffer Y using interrupts.

The callback will be called only after X bytes have been received into the buffer and you can read the buffer in the callback.

The callback you are referring to is called when the amount of data specified in the receive functions (the third argument to HAL_UART_Receive_IT) is received on the UART. You are correct that the UART interrupt service routine (ISR) is called every time a character is received, but when using the HAL that happens internally to the library and doesn't need to be managed by you. Every time the ISR is called, the received character is moved into the array you provide via the second argument of HAL_UART_Receive_IT, and when the number of characters specified by the call is reached, the callback will be called in that ISR (so make sure not to do anything that will take too much time to complete - ISRs should be short, and the ISRs in the HAL library are already pretty lengthy to handle every possible use case).

Further, if you find that the callback is not being triggered even if you are sending enough data to the peripheral, make sure the interrupt is actually enabled - the HAL_UART_Receive_IT function doesn't actually enable the interrupt, that has to be done during initialization of the peripheral.