7.5 Race Conditions with printf

In certain situations, it is possible that using printf may trigger a race condition with the UART transmit complete flag. Hardware sets this flag but cannot clear the flag. This flag may be used to protect against entering sleep while UART is printing, but in given scenarios, it is possible to set this flag while transmitting. To understand this, see the following snippet from a code example.

else if (getResultFlag())
{
//Result Changed
clearResultFlag();
//Convert result to floating point
result = ADC0_GetConversionResult() * bitsPerVolt;
//Toggle LED
LED0_Toggle();
//Print Results
printf("Current Gain: %s\n\r", getCurrentGain());
printf("Measured: %1.3fV\n\r\n\r", result);
}
while (!USART0_IsTxDone()); //Wait for UART to finish
USART0.STATUS = USART_TXCIF_bm; //Clear empty Flag
//If the button was pressed while printing
if (getGainFlag())
continue;
//Go to Sleep
asm ("SLEEP");
asm ("NOP");
}}

This program periodically performs an ADC conversion, wakes up, converts the ADC value to a floating point value, transmits the results, and then returns to sleep. While this program performed as expected when released, trying to run this on more recent tools corrupts the text. The corruption is caused by a subtle error in the way printf is executed by the microcontroller. Take a closer look at the expected behavior (assume the result flag is set and the gain flag is clear):

1. (Not shown) The UART flag is clear.
2. The result flag (read ADC flag) is cleared, and the ADC value is read.
3. The ADC value is converted to a floating point number.
4. The LED on the Curiosity Nano is toggled.
5. The first printf statement transmits the current gain of the ADC. The %s operator prints a const char* in memory representing the current ADC gain.
6. The second printf statement transmits the current measured value of the ADC.
7. After exiting this printf, the UART completes the transmission of the last byte.
8. Wait until the empty flag is set by the UART hardware. (The flag is set when the transmit buffer is empty.)
9. Enter sleep until the next cycle.

As mentioned in the Printing in Interrupts chapter, printf is a slow and memory intensive function for embedded systems to execute; executing a float-to-string conversion with printf is even slower. The float-to-string conversion in the middle of the printf is sufficiently slow that the buffer runs out of data to transmit in the middle of the second printf statement, as seen in the logic analyzer capture in Figure 7-1. Note that the corrupted data at the start of the sequence is leftover data from the last cycle.

Since no data is present in the UART transmitter, the hardware flag is set, but printf continues to execute, allowing the code to jump through the blocking while loop (step 8) and straight into the sleep instruction (step 9).

The printf can be split in half, where the string to the left of the float is sent to fix this condition. After waiting for the hardware flag to set, clear the flag and execute the floating point printf operation. When the floating point conversion is complete, the UART will be transmiting. This way, the hardware can set the flag when the UART completes, rather than just momentarily. The following code excerpt is from the updated version.

else if (getResultFlag())
{
//Result Changed
clearResultFlag();
//Convert result to floating point
result = ADC0_GetConversionResult() * bitsPerVolt;
//Toggle LED
LED0_Toggle();
//Print Results
printf("Current Gain: %s\n\r", getCurrentGain());
printf("Measured: ");
waitForUART();
//Floats are slow
printf("%1.3fV\n\r\n\r", result);
}
//Wait for UART to finish
waitForUART();
//If the button was pressed while printing
if (getGainFlag())
continue;
//Go to Sleep
asm ("SLEEP");
asm ("NOP");

Another workaround is to use the function sprintf. Sprintf converts and copies a printf formatted string to a specified character buffer. Then, printf (or an equivalent function) can be called to print the converted string.