Edge of New Technologies Forum

In the last article we got acquainted with such an interesting block in STM32 as UART. In this article we will not deal with simple examples (but that's for now), but we will immediately get acquainted with the library that allows you to conveniently interact with any UART in STM32F103xx microcontrollers.

Brief description

This library was created as a result of professional activities aimed at developing software for another project on a microcontroller It consists of 2 header files and 2 C files:

• uart.h

• uart.c

• RingFIFO.h

• RingFIFO.c

Main features:

1. Runs on stm32f103xx microcontrollers;

• Allows data exchange via UART1, 2, 3, 4. Data exchange through UART5 is not yet implemented (was not necessary, but this will be corrected );

• Ability to reinitialize UART directly during code execution;

• The ability to engage and customize the length of the FIFO-buffer on the receiver and transmitter;

• Code sections not used in this project will not be compiled into the project (implemented via #ifdef);

• Uses only CMSIS for operation;

• Not overloaded with unnecessary code (if possible) and requires not very many resources (reasonable price for usability).

Let's look at the contents of uart.h. At the very beginning there is this:
With the help of these defines we connect the pieces of code that are responsible for working with the corresponding UART module. Here you should pay attention to the fact that if the selected MC does not have this UART, you must comment out the corresponding define, otherwise the code will not compile.

Next comes the following:
There's a bunch of define-ons that are responsible for fine-tuning the functionality of the library.

If we want to use the ring buffer, we need to uncomment #define UARTn_USE_RING_BUFF, n is the number of UART-a. Further, you can configure the length of the ring buffer for the receiver and transmitter through #define UARTn_TXBUFF_LENGHT and #define UARTn_RXBUFF_LENGHT, in this example, the lengths of the buffers are 16 bytes.

Then comes the initialization structure:
and prototypes of library functions:
UART_Init() is used for initialization, it should be called before you start working with UART. UART_PutC() - send byte to UART, UART_GetC() - read.

Next are the functions of working with ring buffers.

UART_BytesToRead() - returns the number of bytes in the receiver buffer, which can be read by the function UART_GetC().

UART_BytesToWrite() - with this function you can get the number of bytes in the UART transmitter buffer.

UART_ReadBuffClear() and UART_WriteBuffClear() - clear the buffer of the receiver and transmitter respectively.

Internal device

Full description of the library I will not spend a full description of the library, I will stop only on the function of UART initialization. It is organized as follows:
For an example, let's look at the initialization process of UART1:
The first instruction in the condition if(id == 1) { ... } is to enable clocking of the UART1 module:
After that we proceed to initialize the pins to which the RX and TX lines are connected:
Using the TxPinInit() function we initialize the TX pin and RxPinInit() the RX pin. These functions are not very convenient, but I have some ideas how to improve it. By default, non-remap pins are used, if there is a need to use remap pins, all the configuration should be done in this code block. Of course, it's not very convenient, but for now it's just the way it is.

Next is the initialization of the UART:
The first thing we do is to reset the UART module through the RCC registers. This is done for "clean" reinitialization of the UART module. A bunch of asm("nop") just in case, that the periphery to keep up with the rapid execution of the program in the CPU. We do not use different HALs, we have a program is executed quickly?

After that we call the _uart_init() function, and in case of failure we exit with the return code -1.

Then we initialize the ring buffer, if it is used for this UART:
And the final touch: enable the UART and exit with return code 0:
Example of working with the library

Initially this library was written to work on stm32f103c8 microcontroller, then it was finalized on stm32f103ve, and for writing this article the project for stm32f103c8 was created again, and it didn't cause any problems. Most likely, there will be no problems when porting this library to any stm32f103 microcontroller.

So, let's move on to the code. Here is main.c: The first thing we declare the structure, which contains information for the initialization of UART-a, and I declared it as const, so that it was placed in flash memory and did not take up space in the RAM of the microcontroller. The value of the parameters of the structure is as follows:

• bus_freq - the frequency of the bus, which is connected to the module UART, in this case 36MHz

• baud - data transfer rate

• data_bits - the number of data bits, 8 or 9

• stop_bits - number of stop bits, 1 or 2

• parity - parity control, 0 - none, 1 - even, 2 - odd.

There is a small nuance here. If parity control is used (even or odd), and the number of transmitted bits is 8, then data_bits should be set to 9 (8 data bits + 1 parity bit, total 9). Either this is a peculiarity of STM32, or so it is customary for all, I did not bother to look, however, this point is described in the Referens Manual, although I managed to find it only after I knew what to look for ?

Let's go to main(). First initialize the clock generator with ClockInit() to the maximum frequency of operation. After that initialize UART1:

UART_Init(1, &UARTInitStr);

As arguments we pass the number of the UART and the initialization structure.

After that, we clear the buffers of the receiver and transmitter (it is not necessary), and in an infinite loop poll the receiver UART with the function UART_GetC(). If any character arrives, the function will return a value other than -1, which we immediately send back using UART_PutC(). Here is the whole example.