AVR Freaks

You picked one of the most complex UART drivers to examine. Can I suggest something like Peter Fleury's UART lib as an easier starting point?

code: http://www.peterfleury.epizy.com...

docs: http://www.peterfleury.epizy.com...

The journey out in the Fleury code starts with:

void uart_putc(unsigned char data)
{
    unsigned char tmphead;

    
    tmphead  = (UART_TxHead + 1) & UART_TX_BUFFER_MASK;
    
    while ( tmphead == UART_TxTail ){
        ;/* wait for free space in buffer */
    }
    
    UART_TxBuf[tmphead] = data;
    UART_TxHead = tmphead;

    /* enable UDRE interrupt */
    UART0_CONTROL    |= _BV(UART0_UDRIE);

}/* uart_putc */

That just puts a character into the output buffer but then, as a last act it set UDRIE in the UART control register. That in itself is a synonym that depends on which AVR is being used:

D:\fleury_uart>grep -w UART0_CONTROL uart.c
 #define UART0_CONTROL     UCR
 #define UART0_CONTROL     UCSRB
 #define UART0_CONTROL     UCSRB
 #define UART0_CONTROL     UCSRB
 #define UART0_CONTROL     UCSRB
 #define UART0_CONTROL     UCSRB
 #define UART0_CONTROL     UCSR0B
 #define UART0_CONTROL     UCSRB
 #define UART0_CONTROL     UCSR0B
 #define UART0_CONTROL     UCSRB
 #define UART0_CONTROL     UCSR0B
 #define UART0_CONTROL     UCSR0B
 #define UART0_CONTROL     UCSR1B

If the UDR is already empty that will immediately raise the flag to trigger an interrupt but if there was a character just written and it's waiting for the transmit shift register to clear a previous one it may be some time before the interrupt flag is raised. When it is raised it will trigger the ISR() handler:

ISR (UART0_TRANSMIT_INTERRUPT)
/*************************************************************************
Function: UART Data Register Empty interrupt
Purpose:  called when the UART is ready to transmit the next byte
**************************************************************************/
{
    unsigned char tmptail;

    
    if ( UART_TxHead != UART_TxTail) {
        /* calculate and store new buffer index */
        tmptail = (UART_TxTail + 1) & UART_TX_BUFFER_MASK;
        UART_TxTail = tmptail;
        /* get one byte from buffer and write it to UART */
        UART0_DATA = UART_TxBuf[tmptail];  /* start transmission */
    }else{
        /* tx buffer empty, disable UDRE interrupt */
        UART0_CONTROL &= ~_BV(UART0_UDRIE);
    }
}

That then plucks the oldest character in the holding buffer out and writes it to the UDR register (again covered by synonym to support multiple devices) but if the buffer is now empty it disables the UDRIE so that this ISR will not continually be called (until later writes enable it again).

That is the "simple" version.

The Arduino version you were looking at is doing pretty much the same but it's complicated by the fact that it is C++ code and a potentially multi instance C++ class has some difficulty connecting to a single instance ISR which is what then complicates the Arduino C++ stuff further.

Physically, a UART is "just" a shift register. The shift register usually has a predetermined location in RAM memory space though it may not be physically part of the cells thought of as RAM - it may be somewhere else on the chip. This is called "mapping"; it is something that is wired up to behave like RAM even though it is (or may be) somewhere else.

While the UART is just a shift register, it is a somewhat special shift register. Some of the locations in the shift register, such as the first bit, are hard wired to always send the same logic level, e,g, the "start bit". Other locations in the register carry the "message", which is often called a character; this is the part that is loaded when you write a character to the data registers. A few other bits are controlled by other configuration registers that are part of the UART block. These include the parity bit and the stop bit(s).

The UART includes a bunch of other bits and pieces. There is a clock scaler that converts the MCU clock into a signal that controls the timing of shifting bits in or out. There are other configuration or control registers that manage the main shift register. And, there is a second shift register that handles incoming bits. Further, there is logic that controls lots of things, like detecting when a character has been received or the end of a character is reached on the way out. This logic is also capable, under certain circumstances, of detecting some kinds of errors on incoming characters. 

So, there are lots of little wheels (virtually) spinning around in there, all working to send and receive characters, When everything works right, it is a marvel to behold, When it does NOT work right, it can be a vexing puzzle. The most common instance of "not working right" is to not have the same baud (bit) shift rate at both ends of the link. And, the most common cause of that is that the MCU clock frequency is not what you think it is.

Jim

Yes - you do need to read the accompanying text for that.

EDIT

https://ww1.microchip.com/downlo...

via https://www.microchip.com/wwwproducts/en/ATmega328p