UART to UART Bridge STM32

Question

Is there a simple way to bridge 2 U(S)ART Lines (USART1 & UART5 on STM32F107) in software?

I need to forward the data incoming on USART1 to UART5 and back.

Current MCU is STM32F107VCT7.

The main reason I want to do that is to update a device over UART, which is connected to my MCU. The MCU is connected to a PC.

PC --- STM32 --- Other Device

If both I/O lines of each UART are connected to the other, where is the data coming from? — Lee Daniel Crocker, Jun 20 '19 at 21:29
No both uart lines connected to ST32, the ST32 have to handle the Data forwarding. The Connection is Like: PC - ST32 - other Device — guenthernagel, Jun 20 '19 at 21:47
Yes they have both 115200 and the Rest of the uart config ist same too — guenthernagel, Jun 21 '19 at 09:33
What you are trying to do besides passing the data? If you want to implement just a sniffer, Why not just to connect two devices by a direct wires and connect RX pin of two USARTs to them? — AterLux, Jun 21 '19 at 13:46
I need to update a UART Device, but my STM32 is between pc and the other device. PC --- STM -- Other Device A direct connection is not possible — guenthernagel, Jun 21 '19 at 13:51
It still smells very strongly like an XY problem. What kind of weird design is this, using a 100 pin MCU to connect two pairs of traces on a PCB? — followed Monica to Codidact, Jun 22 '19 at 08:19
@berendi Haha, dont worry that's not the only task of the MCU. But the environment do not allow a direct connection from the other device and the PC. — guenthernagel, Jun 22 '19 at 10:09

followed Monica to Codidact · Answer 1 · 2019-06-22T11:27:44.907

2

Simply copying bytes from one UART to the other will not work.

If the sending side (PC serial adapter) is just by 0.1% faster than the MCU, it will start dropping bytes after the 1000th byte. The frequency accuracy of the STM32F107 internal clock is given as -1.1% to +1.8% at room temperature in the datasheet, so it might as well happen earlier, and the other two participants might not be perfectly accurate either.

Dropping bytes in the middle of a firmware update to an otherwise inaccessible part is not going to be funny.

You need circular (FIFO) buffers both ways

The size of the buffer is determined by the size of the data packets, and the sum of the frequency inaccuracies in the participating devices. E.g. if there is 64 kB data in one block, and both devices have +/- 2% frequency accuracy, then you'd need at least 65536*0.04 ~ 2622 bytes buffer.

Do this in an endless loop,

check for RXNE in USART1->SR
if set, read the data from USART1->DR and put it at the head of the buffer (complain loudly if the buffer is full)
check for TXE in UART5->SR`
if set, AND the buffer is not empty, write the byte at the tail of the buffer into UART5->DR
do the same for the other direction

edited Jun 22 '19 at 11:27

answered Jun 22 '19 at 09:03

followed Monica to Codidact

7,779
1
23
39

Thanks. I feared that the simple copy dont work at all. Will check with the circular buffer, i read about it before. – guenthernagel Jun 22 '19 at 10:11
@berendi No if there are gaps (more than 1 char) between those 1000 bytes. Then the counter starts from the begining – 0___________ Jun 22 '19 at 12:36
@P__J__ With +/- 2% HSI accuracy at both ends, it could break down at the 25th byte – followed Monica to Codidact Jun 22 '19 at 14:45
Depending on the stm32 model and even for some silicon version. Some of the uarts compensate the clock deviations. For example f303 on internal clock just tested 1M speed DMA circular random data from flash. No errors after 4 hours – 0___________ Jun 22 '19 at 14:51
@P__J__ That's exactly the problem here. The receiving UART would tolerate speed deviations up to 5%, but the other one won't transmit the data any faster than the programmed baudrate. Buffers would be filled up, fast. – followed Monica to Codidact Jun 22 '19 at 19:19
1

@guenthernagel If you can have either hardware or XON/XOFF flow control, a simple copy will work. – tonypdmtr Jun 22 '19 at 23:05

Matthew Robinson · Answer 2 · 2019-06-21T00:08:51.533

1

Could you just write the data the data to the appropriate usart registers? That is, if you have a byte come through on the usart1 line and it is stored in the usart1 data register, read it and write it to the usart5 data register and set the bit to let the chip know it is ready transfer the byte. Do the same for the usart5 to usart1 bridge.

If you are concerned about reading/writing multiple bytes consider adding transmit and receive buffers to handle this.

If we were to do a polling method, the code would look something like (note: I mainly deal with AVR so I may be off with my register names but the method should be along these lines):



// Check to see if data has been written to usart1 and transfer it usart5.
if(USART1_CR1&(1 << USART1_SR_RXNE))
{
    // May want to avoid race conditions, so disable interrupts.
    // Write the data in usart1 to usart5
    USART5_DR = USART1_DR;

    // Set the data ready bit on the usart5 control register.
    USART5_CR1 |= (1 << USART_SR_RXNE);
    // Enable interrupts.
}

I used this tutorial for STM32 language. Not the point about disabling interrupts. You may also want to write to a buffer.

edited Jun 21 '19 at 00:08

answered Jun 20 '19 at 22:53

Matthew Robinson

65
2
10

@guenthernagel I added a snippet of what I would expect it to be like. – Matthew Robinson Jun 21 '19 at 00:09
Tried but the registers dont match. In the tutorial you refered they use the same. I use HAL_Libray for communicate with USART. Any Ideas how to adopt? – guenthernagel Jun 21 '19 at 14:11
To learn how to communicate from the PC to the STM and back, simply write a test program for the STM and check it with some terminal emulator on the PC side. If you have done this, you know how to use your library, and you can implement the other channel. The main part of your "transport" is then quite simple. – the busybee Jun 21 '19 at 16:31
@MatthewRobinson do not use this tutorial. What is `USART5_DR` ? Use modern CMSIS definitions, BTW article is very very poor. – 0___________ Jun 22 '19 at 12:38

score 0 · Answer 3 · edited Jun 22 '23 at 21:59

0

Here's a simple two-way communication method, assuming the same speed of both UARTs.

volatile uint8_t data[2];

void USART1_IRQHandler(void)
{
    if(USART1 -> SR & USART_SR_RXNE)
    {
        data[0] = USART1 -> DR;
        USART5 -> CR1 |= USART_CR1_TXEIE;
    }

    if( (USART1 -> CR1 & USART_CR_TXEIE) && (USART1 -> SR & USART_SR_TXE))
    {
        USART1 -> CR1 &= ~USART_CR1_TXEIE;
        USART1 -> DR = data[1];
    }
}

void USART5_IRQHandler(void)
{
    if(USART5 -> SR & USART_SR_RXNE)
    {
        data[1] = USART5 -> DR;
        USART1 -> CR1 |= USART_CR1_TXEIE;
    }

    if( (USART5 -> CR1 & USART_CR_TXEIE) && (USART5 -> SR & USART_SR_TXE))
    {
        USART5 -> CR1 &= ~USART_CR1_TXEIE;
        USART5 -> DR = data[0];
    }
}

edited Jun 22 '23 at 21:59

dda

6,030
2
25
34

answered Jun 22 '19 at 12:34

0___________

60,014
4
34
74

Thanks. Tried with small changes (see my Question-Answer with code) but it's not working. – guenthernagel Jun 22 '19 at 15:01
@guenthernagel Of course it will not. Did you see anywhere in my code HAL function calls? – 0___________ Jun 22 '19 at 15:30
No but the interrups are generated by Cube IDE. – guenthernagel Jun 22 '19 at 16:04
Haha. Cube generates the Interrupt Functions and `HAL_UART_IRQHandler(&huart1);` the rest is without HAL Library. Why it should not work? – guenthernagel Jun 22 '19 at 16:29

UART to UART Bridge STM32

3 Answers3