An interrupt driven UART Library for 8-bit AVR microcontrollers

AN10369 UART/SPI/I2C code examples Rev. 01 — 06 April 2005 Application note Document information Info Content Keywords UART, SPI, I2C Abstract Simple code examples are provided for UART0, SPI and I2C.

Maintained by Andy Gock

Derived from original library by Peter Fleury.

Interrupt driven UART library using the built-in UART with circular transmit and receive buffers.

An interrupt is generated when the UART has finished transmitting orreceiving a byte. The interrupt handling routines use circular buffersfor buffering received and transmitted data.

Setting up

The UART_RXn_BUFFER_SIZE and UART_TXn_BUFFER_SIZE symbols definethe size of the circular buffers in bytes. These values must be a power of 2.You may need to adapt this symbols to your target and your application by adding into your compiler options:

RXn and TXn refer to the UART number, for UART3 with 128 byte buffers, add:

UART0 is always enabled by default, to enable the other available UARTs, add the following to your compiler's symbol options for the relevant UART (also known as USART) number.

To enable large buffer support (over 256 bytes, up to 2^15 bytes) use:

Where n = USART number. The maximum buffer size is 32768.

This library supports AVR devices with up to 4 hardware USARTs.

Compiler flags

AVR/GNU C compiler requires the -std=gnu99 flag.

Below are some noticeable features which you’ll experience after SmartPlant 3D 2011 free download.

Documentation

Doxygen based documentation can be viwed at:

• HTML: https://andygock.github.io/avr-uart-documentation/html/index.html
• PDF: https://andygock.github.io/avr-uart-documentation/latex/refman.pdf
• RTF: https://andygock.github.io/avr-uart-documentation/rtf/refman.rtf

Notes

Buffer overflow behaviour

When the RX circular buffer is full, and it receives further data from the UART, a buffer overflow condition occurs. Any new data is dropped. The RX buffer must be read before any more incoming data from the UART is placed into the RX buffer.

If the TX buffer is full, and new data is sent to it using one of the uartN_put*() functions, this function will loop and wait until the buffer is not full any more. It is important to make sure you have not disabled your UART transmit interrupts (TXEN*) elsewhere in your application (e.g with cli()) before calling the uartN_put*() functions, as the application will lock up. The UART interrupts are automatically enabled when you use the uartN_init() functions. This is probably not the idea behaviour, I'll probably fix this some time.

For now, make sure TXEN* interrupts are enabled when calling uartN_put*() functions. This should not be an issue unless you have code elsewhere purposely turning it off.

This is a simple MAVLink to UART interface example for *nix systems that can allow communication between Pixhawk and an offboard computer.

This example will receive one MAVLink message and send one MAVLink message.

Connect the USB programming cable to your Pixhawk.

If you want to be able to interact with this example in Pixhawk's NuttX shell, you'll need a Telemetry Radio or an FTDI developer's cable. See the Exploration section below for more detail.

Also Note: Using a UART (serial) connection should be preferred over using the USB port for flying systems. The reason being that the driver for the USB port is much more complicated, so the UART is a much more trusted port for flight-critical functions. To learn how this works though the USB port will be fine and instructive.

You have to pick a port name, try searching for it with

Alternatively, plug in Pixhawk USB cable again and issue the command:

The device described at the bottom of dmesg's output will be the port on which the Pixhawk is mounted.

The Pixhawk USB port will show up on a ttyACM*, an FTDI cable will show up on a ttyUSB*.

Run the example executable on the host shell:

To stop the program, use the key sequence Ctrl-C.

Here's an example output:

There are a few things to explore past this example.

First you can connect via:

• a Telemetry Radio on TELEM1 or 2
• an FTDI cable on TELEM2 or Serial 4

Note

• Serial 5 can't be used to receive data without reconfiguration (its receive pin is occupied by a second NuttX shell).
• TELEM1 is typically dedicated to Telemetry Radio, but if you're using another port you will need to make sure it is not configured for use by another peripheral.
• If using FTDI with a TELEM port, connect all the pins to corresponding pins on port.
• If using FTDI with SERIAL4 connect the TX, RX GND and 5V pins (CTS, RTS need not be connected).

With this you'll be able to start a second port for communication, and leave the USB port available for viewing prints in the NuttX shell.

For steps 2 and 3 from the above tutorial, you'll use a different port. On the off-board computer side, the port might now be /dev/ttyUSB0. On the Pixhawk side, here the port mappings are in the table below.

Now add a print statement in the Pixhawk Firmware to see received messages. Build and upload this to Pixhawk.

Open the system terminal as described here: https://dev.px4.io/en/debug/system_console.html

On the off-board side, in another terminal run the c_uart_interface_example executable. You should see output in the NuttX shell similar to this:

Past this, you can:

• Modify the received message data type
• Modify the sent message data type