dbprint.c File Reference

Homebrew println/printf replacement "DeBugPrint". More...

#include "debug_dbprint.h"
#include <stdint.h>
#include <stdbool.h>
#include "em_cmu.h"
#include "em_gpio.h"
#include "em_usart.h"

Go to the source code of this file.

Macros
#define	TO_HEX(i)   (i <= 9 ? '0' + i : 'A' - 10 + i) /* "?:" = ternary operator (return ['0' + i] if [i <= 9] = true, ['A' - 10 + i] if false) */
#define	TO_DEC(i)   (i <= 9 ? '0' + i : '?') /* return "?" if out of range */
#define	COLOR_RED   "\x1b[31m"
#define	COLOR_GREEN   "\x1b[32m"
#define	COLOR_BLUE   "\x1b[34m"
#define	COLOR_CYAN   "\x1b[36m"
#define	COLOR_MAGENTA   "\x1b[35m"
#define	COLOR_YELLOW   "\x1b[33m"
#define	COLOR_RESET   "\x1b[0m"

Functions
static void	uint32_to_charHex (char *buf, uint32_t value, bool spacing)
	Convert a uint32_t value to a hexadecimal char array (string). More...
static void	uint32_to_charDec (char *buf, uint32_t value)
	Convert a uint32_t value to a decimal char array (string). More...
static uint32_t	charDec_to_uint32 (char *buf)
	Convert a string (char array) in decimal notation to a uint32_t value. More...
void	dbprint_INIT (USART_TypeDef *pointer, uint8_t location, bool vcom, bool interrupts)
	Initialize USARTx. More...
void	dbAlert (void)
	Sound an alert in the terminal. More...
void	dbClear (void)
	Clear the terminal. More...
void	dbprint (char *message)
	Print a string (char array) to USARTx. More...
void	dbprintln (char *message)
	Print a string (char array) to USARTx and go to the next line. More...
void	dbprint_color (char *message, dbprint_color_t color)
	Print a string (char array) to USARTx in a given color. More...
void	dbprintln_color (char *message, dbprint_color_t color)
	Print a string (char array) to USARTx in a given color and go to the next line. More...
void	dbinfo (char *message)
	Print an info string (char array) to USARTx and go to the next line. More...
void	dbwarn (char *message)
	Print a warning string (char array) in yellow to USARTx and go to the next line. More...
void	dbcrit (char *message)
	Print a critical error string (char array) in red to USARTx and go to the next line. More...
void	dbinfoInt (char *message1, int32_t value, char *message2)
	Print an info value surrounded by two strings (char array) to USARTx. More...
void	dbwarnInt (char *message1, int32_t value, char *message2)
	Print a warning value surrounded by two strings (char array) to USARTx. More...
void	dbcritInt (char *message1, int32_t value, char *message2)
	Print a critical value surrounded by two strings (char array) to USARTx. More...
void	dbinfoInt_hex (char *message1, int32_t value, char *message2)
	Print an info value surrounded by two strings (char array) to USARTx. More...
void	dbwarnInt_hex (char *message1, int32_t value, char *message2)
	Print a warning value surrounded by two strings (char array) to USARTx. More...
void	dbcritInt_hex (char *message1, int32_t value, char *message2)
	Print a critical value surrounded by two strings (char array) to USARTx. More...
void	dbprintInt (int32_t value)
	Print a number in decimal notation to USARTx. More...
void	dbprintlnInt (int32_t value)
	Print a number in decimal notation to USARTx and go to the next line. More...
void	dbprintInt_hex (int32_t value)
	Print a number in hexadecimal notation to USARTx. More...
void	dbprintlnInt_hex (int32_t value)
	Print a number in hexadecimal notation to USARTx and go to the next line. More...
char	dbReadChar (void)
	Read a character from USARTx. More...
uint8_t	dbReadInt (void)
	Read a decimal character from USARTx and convert it to a uint8_t value. More...
void	dbReadLine (char *buf)
	Read a string (char array) from USARTx. More...
bool	dbGet_RXstatus (void)
	Check if data was received using interrupts in the RX buffer. More...
void	dbGet_RXbuffer (char *buf)
	Get the value of the RX buffer and clear the dataReceived flag. More...
void	USART0_RX_IRQHandler (void)
	USART0 RX interrupt service routine. More...
void	USART0_TX_IRQHandler (void)
	USART0 TX interrupt service routine. More...
void	USART1_RX_IRQHandler (void)
	USART1 RX interrupt service routine. More...
void	USART1_TX_IRQHandler (void)
	USART1 TX interrupt service routine. More...

Variables
USART_TypeDef *	dbpointer
volatile bool	dataReceived = false
volatile char	rx_buffer [80]
volatile char	tx_buffer [80]

Detailed Description

Homebrew println/printf replacement "DeBugPrint".

Originally designed for use on the Silicion Labs Happy Gecko EFM32 board (EFM32HG322 – TQFP48).

Version

6.2

Author

Brecht Van Eeckhoudt

---

Versions

Please check https://github.com/Fescron/dbprint to find the latest version of dbprint!

• v1.0: "define" used to jump between VCOM or other mode, itoa (<stdlib.h>) used aswell as stdio.h
• v1.1: Separated printInt method in a separate function for printing "int32_t" and "uint32_t" values.
• v1.2: Added more options to the initialize method (location selection & boolean if VCOM is used).
• v2.0: Restructured files to be used in other projects, added a lot more documentation, added "dbAlert" and "dbClear" methods.
• v2.1: Added interrupt functionality.
• v2.2: Added parse functions, separated method for printing uint values in a separate one for DEC and HEX notation.
• v2.3: Updated documentation.
• v2.4: Fixed notes.
• v2.5: Separated method for printing int values in a separate one for DEC and HEX notation.
• v2.6: Stopped using itoa (<stdlib.h>) in all methods.
• v3.0: Simplified number printing, stopped using separate methods for uint and int values.
• v3.1: Removed useless if... check.
• v3.2: Added the ability to print text in a color.
• v3.3: Added info, warning and critical error printing methods.
• v3.4: Added printInt(_hex) methods that directly go to a new line.
• v3.5: Added USART0 IRQ handlers.
• v3.6: Added the ability to print (u)int values as INFO, WARN or CRIT lines.
• v3.7: Added separate "_hex" methods for dbinfo/warn/critInt instead of a boolean to select (hexa)decimal notation.
• v3.8: Added ReadChar-Int-Line methods.
• v3.9: Added "void" between argument brackets were before nothing was.
• v4.0: Added more documentation.
• v4.1: Added color reset before welcome message.
• v5.0: Made uint-char conversion methods static, moved color functionality to enum, started moving interrupt functionality to use getters and setters.
• v5.1: Fixed interrupt functionality with getters and setters.
• v6.0: Cleaned up interrupt functionality and added some documentation. (put some code in comments to maybe fix later if ever necessary)
• v6.1: Made dbpointer a local variable (removed extern). Removed extern from the documentation.
• v6.2: Removed static before the local variables (not necessary).

---

Todo:

Future improvements:

• Fix dbSet_TXbuffer and also add more functionality to print numbers, ...
• Separate back-end <-> MCU specific code

---

License

Copyright (C) 2019 - Brecht Van Eeckhoudt

This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.

A copy of the GNU General Public License can be found in the LICENSE file along with this source code.

Some methods also use code obtained from examples from Silicon Labs' GitHub. These sections are licensed under the Silabs License Agreement. See the file "Silabs_License_Agreement.txt" for details. Before using this software for any purpose, you must agree to the terms of that agreement.

---

Attention

See the file dbprint_documentation.h for a lot of useful documentation!

Definition in file dbprint.c.

Macro Definition Documentation

COLOR_BLUE

#define COLOR_BLUE   "\x1b[34m"

Definition at line 106 of file dbprint.c.

COLOR_CYAN

#define COLOR_CYAN   "\x1b[36m"

Definition at line 107 of file dbprint.c.

COLOR_GREEN

#define COLOR_GREEN   "\x1b[32m"

Definition at line 105 of file dbprint.c.

COLOR_MAGENTA

#define COLOR_MAGENTA   "\x1b[35m"

Definition at line 108 of file dbprint.c.

COLOR_RED

#define COLOR_RED   "\x1b[31m"

Definition at line 104 of file dbprint.c.

COLOR_RESET

#define COLOR_RESET   "\x1b[0m"

Definition at line 110 of file dbprint.c.

COLOR_YELLOW

#define COLOR_YELLOW   "\x1b[33m"

Definition at line 109 of file dbprint.c.

TO_DEC

#define TO_DEC

(

i

)

(i <= 9 ? '0' + i : '?') /* return "?" if out of range */

Definition at line 101 of file dbprint.c.

TO_HEX

#define TO_HEX

(

i

)

(i <= 9 ? '0' + i : 'A' - 10 + i) /* "?:" = ternary operator (return ['0' + i] if [i <= 9] = true, ['A' - 10 + i] if false) */

Definition at line 100 of file dbprint.c.

Function Documentation

charDec_to_uint32()

static uint32_t charDec_to_uint32 ( char *  buf )

static

Convert a string (char array) in decimal notation to a uint32_t value.

Note

If the input is not a string (ex.: "00BA0FA1") but a char array, the input buffer (array) needs to end with NULL ("\0")!

This is a static method because it's only internally used in this file and called by other methods if necessary.

Parameters

[in]

buf

The decimal string to convert to a uint32_t value.

Returns

The resulting uint32_t value.

Definition at line 1184 of file dbprint.c.

{
    /* Value to eventually return */
    uint32_t value = 0;

    /* Loop until buffer is empty */
    while (*buf)
    {
        /* Get current character, increment afterwards */
        uint8_t byte = *buf++;

        /* Check if the next value we need to add can fit in a uint32_t */
        if ( (value <= 0xFFFFFFF) && ((byte - '0') <= 0xF) )
        {
            /* Convert the ASCII (decimal) character to the representing decimal value
             * and add it to the value (which is multiplied by 10 for each position) */
            value = (value * 10) + (byte - '0');
        }
        else
        {
            /* Given buffer can't fit in uint32_t */
            return (0);
        }
    }

    return (value);
}

dbAlert()

void dbAlert

(

void

)

Sound an alert in the terminal.

Print the bell (alert) character to USARTx.

Definition at line 342 of file dbprint.c.

{
    USART_Tx(dbpointer, '\a');
}

dbClear()

void dbClear

(

void

)

Clear the terminal.

Print the form feed character to USARTx. Accessing old data is still possible by scrolling up in the serial port program.

Definition at line 356 of file dbprint.c.

{
    USART_Tx(dbpointer, '\f');
}

dbcrit()

void dbcrit

(

char *

message

)

Print a critical error string (char array) in red to USARTx and go to the next line.

Note

If the input is not a string (ex.: "Hello world!") but a char array, the input message (array) needs to end with NULL ("\0")!

Parameters

[in]

message

The string to print to USARTx.

Definition at line 539 of file dbprint.c.

{
    dbprint_color("CRIT: ", RED);
    dbprintln_color(message, RED);
}

dbcritInt()

void dbcritInt	(	char *	message1,
		int32_t	value,
		char *	message2
	)

Print a critical value surrounded by two strings (char array) to USARTx.

"CRIT: " gets added in front, the decimal notation is used and the function advances to the next line. The value is in the color white, the rest is red.

Note

If the input is not a string (ex.: "Hello world!") but a char array, the input message (array) needs to end with NULL ("\0")!

Parameters

[in]	message1	The first part of the string to print to USARTx.
[in]	value	The value to print between the two string parts.
[in]	message2	The second part of the string to print to USARTx.

Definition at line 629 of file dbprint.c.

{
    dbprint_color("CRIT: ", RED);
    dbprint_color(message1, RED);
    dbprintInt(value);
    dbprintln_color(message2, RED);
}

dbcritInt_hex()

void dbcritInt_hex	(	char *	message1,
		int32_t	value,
		char *	message2
	)

Print a critical value surrounded by two strings (char array) to USARTx.

"CRIT: " gets added in front, the hexadecimal notation is used and the function advances to the next line. The value is in the color white, the rest is red.

Note

If the input is not a string (ex.: "Hello world!") but a char array, the input message (array) needs to end with NULL ("\0")!

Parameters

[in]	message1	The first part of the string to print to USARTx.
[in]	value	The value to print between the two string parts.
[in]	message2	The second part of the string to print to USARTx.

Definition at line 721 of file dbprint.c.

{
    dbprint_color("CRIT: ", RED);
    dbprint_color(message1, RED);
    dbprintInt_hex(value);
    dbprintln_color(message2, RED);
}

dbGet_RXbuffer()

void dbGet_RXbuffer

(

char *

buf

)

Get the value of the RX buffer and clear the dataReceived flag.

Note

The index of the RX buffer gets reset in the RX handler when a CR character is received or the buffer is filled.

Attention

Interrupt functionality has to be enabled on initialization for this function to work correctly.

Parameters

[in]

buf

The buffer to put the resulting string in. This needs to have a length of DBPRINT_BUFFER_SIZE for the function to work properly: char buf[DBPRINT_BUFFER_SIZE];!

Definition at line 1017 of file dbprint.c.

{
    if (dataReceived)
    {
        uint32_t i;

        /* Copy data from the RX buffer to the given buffer */
        for (i = 0; rx_buffer[i] != 0 && i < DBPRINT_BUFFER_SIZE-1; i++)
        {
            buf[i] = rx_buffer[i];
        }

        /* Add NULL termination character */
        buf[i++] = '\0';

        /* Reset "notification" variable */
        dataReceived = false;
    }
    else
    {
        dbcrit("No received data available!");
    }
}

dbGet_RXstatus()

bool dbGet_RXstatus

(

void

)

Check if data was received using interrupts in the RX buffer.

Note

The index of the RX buffer gets reset in the RX handler when a CR character is received or the buffer is filled.

Attention

Interrupt functionality has to be enabled on initialization for this function to work correctly.

Returns

• true - Data is received in the RX buffer.
• false - No data is received.

Definition at line 909 of file dbprint.c.

{
    return (dataReceived);
}

dbinfo()

void dbinfo

(

char *

message

)

Print an info string (char array) to USARTx and go to the next line.

Note

If the input is not a string (ex.: "Hello world!") but a char array, the input message (array) needs to end with NULL ("\0")!

Parameters

[in]

message

The string to print to USARTx.

Definition at line 503 of file dbprint.c.

{
    dbprint("INFO: ");
    dbprintln(message);
}

dbinfoInt()

void dbinfoInt	(	char *	message1,
		int32_t	value,
		char *	message2
	)

Print an info value surrounded by two strings (char array) to USARTx.

"INFO: " gets added in front, the decimal notation is used and the function advances to the next line.

Note

If the input is not a string (ex.: "Hello world!") but a char array, the input message (array) needs to end with NULL ("\0")!

Parameters

[in]	message1	The first part of the string to print to USARTx.
[in]	value	The value to print between the two string parts.
[in]	message2	The second part of the string to print to USARTx.

Definition at line 567 of file dbprint.c.

{
    dbprint("INFO: ");
    dbprint(message1);
    dbprintInt(value);
    dbprintln(message2);
}

dbinfoInt_hex()

void dbinfoInt_hex	(	char *	message1,
		int32_t	value,
		char *	message2
	)

Print an info value surrounded by two strings (char array) to USARTx.

"INFO: " gets added in front, the hexadecimal notation is used and the function advances to the next line.

Note

If the input is not a string (ex.: "Hello world!") but a char array, the input message (array) needs to end with NULL ("\0")!

Parameters

[in]	message1	The first part of the string to print to USARTx.
[in]	value	The value to print between the two string parts.
[in]	message2	The second part of the string to print to USARTx.

Definition at line 659 of file dbprint.c.

{
    dbprint("INFO: ");
    dbprint(message1);
    dbprintInt_hex(value);
    dbprintln(message2);
}

dbprint()

void dbprint

(

char *

message

)

Print a string (char array) to USARTx.

Note

If the input is not a string (ex.: "Hello world!") but a char array, the input message (array) needs to end with NULL ("\0")!

Parameters

[in]

message

The string to print to USARTx.

Definition at line 373 of file dbprint.c.

{
    /* "message[i] != 0" makes "uint32_t length = strlen(message)"
     * not necessary (given string MUST be terminated by NULL for this to work) */
    for (uint32_t i = 0; message[i] != 0; i++)
    {
        USART_Tx(dbpointer, message[i]);
    }
}

dbprint_color()

void dbprint_color	(	char *	message,
		dbprint_color_t	color
	)

Print a string (char array) to USARTx in a given color.

Note

If the input is not a string (ex.: "Hello world!") but a char array, the input message (array) needs to end with NULL ("\0")!

Parameters

[in]	message	The string to print to USARTx.
[in]	color	The color to print the text in.

Definition at line 421 of file dbprint.c.

{
    switch (color)
    {
        case DEFAULT_COLOR:
            dbprint(COLOR_RESET);
            dbprint(message);
            break;
        case RED:
            dbprint(COLOR_RED);
            dbprint(message);
            dbprint(COLOR_RESET);
            break;
        case GREEN:
            dbprint(COLOR_GREEN);
            dbprint(message);
            dbprint(COLOR_RESET);
            break;
        case BLUE:
            dbprint(COLOR_BLUE);
            dbprint(message);
            dbprint(COLOR_RESET);
            break;
        case CYAN:
            dbprint(COLOR_CYAN);
            dbprint(message);
            dbprint(COLOR_RESET);
            break;
        case MAGENTA:
            dbprint(COLOR_MAGENTA);
            dbprint(message);
            dbprint(COLOR_RESET);
            break;
        case YELLOW:
            dbprint(COLOR_YELLOW);
            dbprint(message);
            dbprint(COLOR_RESET);
            break;
        default:
            dbprint(COLOR_RESET);
            dbprint(message);
    }
}

dbprint_INIT()

void dbprint_INIT	(	USART_TypeDef *	pointer,
		uint8_t	location,
		bool	vcom,
		bool	interrupts
	)

Initialize USARTx.

Parameters

[in]	pointer	Pointer to USARTx.
[in]	location	Location for pin routing.
[in]	vcom	true - Isolation switch enabled by setting PA9 high so the Virtual COM port (CDC) can be used. false - Isolation switch disabled on the Happy Gecko board.
[in]	interrupts	true - Enable interrupt functionality. false - No interrupt functionality is initialized.

Definition at line 148 of file dbprint.c.

{
    /* Store the pointer in the global variable */
    dbpointer = pointer;

    /*
     * USART_INITASYNC_DEFAULT:
     *   config.enable = usartEnable       // Specifies whether TX and/or RX is enabled when initialization is completed
     *                                     // (Enable RX/TX when initialization is complete).
     *   config.refFreq = 0                // USART/UART reference clock assumed when configuring baud rate setup
     *                                     // (0 = Use current configured reference clock for configuring baud rate).
     *   config.baudrate = 115200          // Desired baudrate (115200 bits/s).
     *   config.oversampling = usartOVS16  // Oversampling used (16x oversampling).
     *   config.databits = usartDatabits8  // Number of data bits in frame (8 data bits).
     *   config.parity = usartNoParity     // Parity mode to use (no parity).
     *   config.stopbits = usartStopbits1  // Number of stop bits to use (1 stop bit).
     *   config.mvdis = false              // Majority Vote Disable for 16x, 8x and 6x oversampling modes (Do not disable majority vote).
     *   config.prsRxEnable = false        // Enable USART Rx via PRS (Not USART PRS input mode).
     *   config.prsRxCh = 0                // Select PRS channel for USART Rx. (Only valid if prsRxEnable is true - PRS channel 0).
     *   config.autoCsEnable = false       // Auto CS enabling (Auto CS functionality enable/disable switch - disabled).
     */

    USART_InitAsync_TypeDef config = USART_INITASYNC_DEFAULT;

    /* Enable oscillator to GPIO*/
    CMU_ClockEnable(cmuClock_GPIO, true);


    /* Enable oscillator to USARTx modules */
    if (dbpointer == USART0)
    {
        CMU_ClockEnable(cmuClock_USART0, true);
    }
    else if (dbpointer == USART1)
    {
        CMU_ClockEnable(cmuClock_USART1, true);
    }


    /* Set PA9 (EFM_BC_EN) high if necessary to enable the isolation switch */
    if (vcom)
    {
        GPIO_PinModeSet(gpioPortA, 9, gpioModePushPull, 1);
        GPIO_PinOutSet(gpioPortA, 9);
    }


    /* Set pin modes for UART TX and RX pins */
    if (dbpointer == USART0)
    {
        switch (location)
        {
            case 0:
                GPIO_PinModeSet(gpioPortE, 11, gpioModeInput, 0);    /* RX */
                GPIO_PinModeSet(gpioPortE, 10, gpioModePushPull, 1); /* TX */
                break;
            case 2:
                GPIO_PinModeSet(gpioPortC, 10, gpioModeInput, 0);    /* RX */
                /* No TX pin in this mode */
                break;
            case 3:
                GPIO_PinModeSet(gpioPortE, 12, gpioModeInput, 0);    /* RX */
                GPIO_PinModeSet(gpioPortE, 13, gpioModePushPull, 1); /* TX */
                break;
            case 4:
                GPIO_PinModeSet(gpioPortB, 8, gpioModeInput, 0);     /* RX */
                GPIO_PinModeSet(gpioPortB, 7, gpioModePushPull, 1);  /* TX */
                break;
            case 5:
            case 6:
                GPIO_PinModeSet(gpioPortC, 1, gpioModeInput, 0);     /* RX */
                GPIO_PinModeSet(gpioPortC, 0, gpioModePushPull, 1);  /* TX */
                break;
            /* default: */
                /* No default */
        }
    }
    else if (dbpointer == USART1)
    {
        switch (location)
        {
            case 0:
                GPIO_PinModeSet(gpioPortC, 1, gpioModeInput, 0);     /* RX */
                GPIO_PinModeSet(gpioPortC, 0, gpioModePushPull, 1);  /* TX */
                break;
            case 2:
            case 3:
                GPIO_PinModeSet(gpioPortD, 6, gpioModeInput, 0);     /* RX */
                GPIO_PinModeSet(gpioPortD, 7, gpioModePushPull, 1);  /* TX */
                break;
            case 4:
                GPIO_PinModeSet(gpioPortA, 0, gpioModeInput, 0);     /* RX */
                GPIO_PinModeSet(gpioPortF, 2, gpioModePushPull, 1);  /* TX */
                break;
            case 5:
                GPIO_PinModeSet(gpioPortC, 2, gpioModeInput, 0);     /* RX */
                GPIO_PinModeSet(gpioPortC, 1, gpioModePushPull, 1);  /* TX */
                break;
            /* default: */
                /* No default */
        }
    }


    /* Initialize USART asynchronous mode */
    USART_InitAsync(dbpointer, &config);

    /* Route pins */
    switch (location)
    {
        case 0:
            dbpointer->ROUTE |= USART_ROUTE_TXPEN | USART_ROUTE_RXPEN | USART_ROUTE_LOCATION_LOC0;
            break;
        case 1:
            dbpointer->ROUTE |= USART_ROUTE_TXPEN | USART_ROUTE_RXPEN | USART_ROUTE_LOCATION_LOC1;
            break;
        case 2:
            dbpointer->ROUTE |= USART_ROUTE_TXPEN | USART_ROUTE_RXPEN | USART_ROUTE_LOCATION_LOC2;
            break;
        case 3:
            dbpointer->ROUTE |= USART_ROUTE_TXPEN | USART_ROUTE_RXPEN | USART_ROUTE_LOCATION_LOC3;
            break;
        case 4:
            dbpointer->ROUTE |= USART_ROUTE_TXPEN | USART_ROUTE_RXPEN | USART_ROUTE_LOCATION_LOC4;
            break;
        case 5:
            dbpointer->ROUTE |= USART_ROUTE_TXPEN | USART_ROUTE_RXPEN | USART_ROUTE_LOCATION_LOC5;
            break;
        case 6:
            dbpointer->ROUTE |= USART_ROUTE_TXPEN | USART_ROUTE_RXPEN | USART_ROUTE_LOCATION_LOC6;
            break;
        default:
            dbpointer->ROUTE |= USART_ROUTE_TXPEN | USART_ROUTE_RXPEN | USART_ROUTE_LOCATION_DEFAULT;
    }

    /* Enable interrupts if necessary and print welcome string (and make an alert sound in the console) */
    if (interrupts)
    {
        /* Initialize USART interrupts */

        /* RX Data Valid Interrupt Enable
         *   Set when data is available in the receive buffer. Cleared when the receive buffer is empty. */
        USART_IntEnable(dbpointer, USART_IEN_RXDATAV);

        /* TX Complete Interrupt Enable
         *   Set when a transmission has completed and no more data is available in the transmit buffer.
         *   Cleared when a new transmission starts. */
        USART_IntEnable(dbpointer, USART_IEN_TXC);

        if (dbpointer == USART0)
        {
            /* Enable USART interrupts */
            NVIC_EnableIRQ(USART0_RX_IRQn);
            NVIC_EnableIRQ(USART0_TX_IRQn);
        }
        else if (dbpointer == USART1)
        {
            /* Enable USART interrupts */
            NVIC_EnableIRQ(USART1_RX_IRQn);
            NVIC_EnableIRQ(USART1_TX_IRQn);
        }

        /* Print welcome string */
        dbprint(COLOR_RESET);
        dbprintln("\a\r\f### UART initialized (interrupt mode) ###");
        dbinfo("This is an info message.");
        dbwarn("This is a warning message.");
        dbcrit("This is a critical error message.");
        dbprintln("###  Start executing programmed code  ###\n");

        /* Set TX Complete Interrupt Flag (transmission has completed and no more data
        * is available in the transmit buffer) */
        USART_IntSet(dbpointer, USART_IFS_TXC);
    }
    /* Print welcome string (and make an alert sound in the console) if not in interrupt mode */
    else
    {
        dbprint(COLOR_RESET);
        dbprintln("\a\r\f### UART initialized (no interrupts) ###");
        dbinfo("This is an info message.");
        dbwarn("This is a warning message.");
        dbcrit("This is a critical error message.");
        dbprintln("### Start executing programmed code  ###\n");
    }
}

dbprintInt()

void dbprintInt

(

int32_t

value

)

Print a number in decimal notation to USARTx.

Parameters

[in]

value

The number to print to USARTx. This can be of type uint32_t or int32_t.

Definition at line 738 of file dbprint.c.

{
    /* Buffer to put the char array in (Needs to be 10) */
    char decchar[10];

    /* Convert a negative number to a positive one and print the "-" */
    if (value < 0)
    {
        /* Negative of value = flip all bits, +1
         *   bitwise logic: "~" = "NOT" */
        uint32_t negativeValue = (~value) + 1;

        dbprint("-");

        /* Convert the value */
        uint32_to_charDec(decchar, negativeValue);
    }
    else
    {
        /* Convert the value */
        uint32_to_charDec(decchar, value);
    }

    /* Print the buffer */
    dbprint(decchar);
}

dbprintInt_hex()

void dbprintInt_hex

(

int32_t

value

)

Print a number in hexadecimal notation to USARTx.

Parameters

[in]

value

The number to print to USARTx. This can be of type uint32_t or int32_t.

Definition at line 794 of file dbprint.c.

{
    char hexchar[9]; /* Needs to be 9 */
    uint32_to_charHex(hexchar, value, true); /* true: add spacing between eight HEX chars */
    dbprint("0x");
    dbprint(hexchar);
}

dbprintln()

void dbprintln

(

char *

message

)

Print a string (char array) to USARTx and go to the next line.

Note

If the input is not a string (ex.: "Hello world!") but a char array, the input message (array) needs to end with NULL ("\0")!

Parameters

[in]

message

The string to print to USARTx.

Definition at line 395 of file dbprint.c.

{
    dbprint(message);

    /* Carriage return */
    USART_Tx(dbpointer, '\r');

    /* Line feed (new line) */
    USART_Tx(dbpointer, '\n');
}

dbprintln_color()

void dbprintln_color	(	char *	message,
		dbprint_color_t	color
	)

Print a string (char array) to USARTx in a given color and go to the next line.

Note

If the input is not a string (ex.: "Hello world!") but a char array, the input message (array) needs to end with NULL ("\0")!

Parameters

[in]	message	The string to print to USARTx.
[in]	color	The color to print the text in.

Definition at line 480 of file dbprint.c.

{
    dbprint_color(message, color);

    /* Carriage return */
    USART_Tx(dbpointer, '\r');

    /* Line feed (new line) */
    USART_Tx(dbpointer, '\n');
}

dbprintlnInt()

void dbprintlnInt

(

int32_t

value

)

Print a number in decimal notation to USARTx and go to the next line.

Parameters

[in]

value

The number to print to USARTx. This can be of type uint32_t or int32_t.

Definition at line 774 of file dbprint.c.

{
    dbprintInt(value);

    /* Carriage return */
    USART_Tx(dbpointer, '\r');

    /* Line feed (new line) */
    USART_Tx(dbpointer, '\n');
}

dbprintlnInt_hex()

void dbprintlnInt_hex

(

int32_t

value

)

Print a number in hexadecimal notation to USARTx and go to the next line.

Parameters

[in]

value

The number to print to USARTx. This can be of type uint32_t or int32_t.

Definition at line 811 of file dbprint.c.

{
    dbprintInt_hex(value);

    /* Carriage return */
    USART_Tx(dbpointer, '\r');

    /* Line feed (new line) */
    USART_Tx(dbpointer, '\n');
}

dbReadChar()

char dbReadChar

(

void

)

Read a character from USARTx.

Returns

The character read from USARTx.

Definition at line 830 of file dbprint.c.

{
    return (USART_Rx(dbpointer));
}

dbReadInt()

uint8_t dbReadInt

(

void

)

Read a decimal character from USARTx and convert it to a uint8_t value.

Note

Specific methods exist to read uint16_t and uint32_t values:

• uint16_t USART_RxDouble(USART_TypeDef *usart);
• uint32_t USART_RxDoubleExt(USART_TypeDef *usart);

Returns

The converted uint8_t value.

Definition at line 848 of file dbprint.c.

{
    /* Method expects a char array ending with a null termination character */
    char value[2];
    value[0]= dbReadChar();
    value[1] = '\0';

    return (charDec_to_uint32(value));
}

dbReadLine()

void dbReadLine

(

char *

buf

)

Read a string (char array) from USARTx.

Note

The reading stops when a "CR" (Carriage Return, ENTER) character is received or the maximum length (DBPRINT_BUFFER_SIZE) is reached.

Parameters

[in]

buf

The buffer to put the resulting string in. This needs to have a length of DBPRINT_BUFFER_SIZE for the function to work properly: char buf[DBPRINT_BUFFER_SIZE];!

Definition at line 872 of file dbprint.c.

{
    for (uint32_t i = 0; i < DBPRINT_BUFFER_SIZE - 1 ; i++ )
    {
        char localBuffer = USART_Rx(dbpointer);

        /* Check if a CR character is received */
        if (localBuffer == '\r')
        {
            /* End with a null termination character, expected by the dbprintln method */
            buf[i] = '\0';
            break;
        }
        else
        {
            buf[i] = localBuffer;
        }
    }
}

dbwarn()

void dbwarn

(

char *

message

)

Print a warning string (char array) in yellow to USARTx and go to the next line.

Note

If the input is not a string (ex.: "Hello world!") but a char array, the input message (array) needs to end with NULL ("\0")!

Parameters

[in]

message

The string to print to USARTx.

Definition at line 521 of file dbprint.c.

{
    dbprint_color("WARN: ", YELLOW);
    dbprintln_color(message, YELLOW);
}

dbwarnInt()

void dbwarnInt	(	char *	message1,
		int32_t	value,
		char *	message2
	)

Print a warning value surrounded by two strings (char array) to USARTx.

"WARN: " gets added in front, the decimal notation is used and the function advances to the next line. The value is in the color white, the rest is yellow.

Note

If the input is not a string (ex.: "Hello world!") but a char array, the input message (array) needs to end with NULL ("\0")!

Parameters

[in]	message1	The first part of the string to print to USARTx.
[in]	value	The value to print between the two string parts.
[in]	message2	The second part of the string to print to USARTx.

Definition at line 598 of file dbprint.c.

{
    dbprint_color("WARN: ", YELLOW);
    dbprint_color(message1, YELLOW);
    dbprintInt(value);
    dbprintln_color(message2, YELLOW);
}

dbwarnInt_hex()

void dbwarnInt_hex	(	char *	message1,
		int32_t	value,
		char *	message2
	)

Print a warning value surrounded by two strings (char array) to USARTx.

"WARN: " gets added in front, the hexadecimal notation is used and the function advances to the next line. The value is in the color white, the rest is yellow.

Note

If the input is not a string (ex.: "Hello world!") but a char array, the input message (array) needs to end with NULL ("\0")!

Parameters

[in]	message1	The first part of the string to print to USARTx.
[in]	value	The value to print between the two string parts.
[in]	message2	The second part of the string to print to USARTx.

Definition at line 690 of file dbprint.c.

{
    dbprint_color("WARN: ", YELLOW);
    dbprint_color(message1, YELLOW);
    dbprintInt_hex(value);
    dbprintln_color(message2, YELLOW);
}

uint32_to_charDec()

static void uint32_to_charDec ( char *  buf, uint32_t  value  )

static

Convert a uint32_t value to a decimal char array (string).

Note

This is a static method because it's only internally used in this file and called by other methods if necessary.

Parameters

[out]	buf	The buffer to put the resulting string in. This needs to have a length of 10: char buf[10];!
[in]	value	The uint32_t value to convert to a string.

Definition at line 1122 of file dbprint.c.

{
    if (value == 0)
    {
        buf[0] = '0';
        buf[1] = '\0'; /* NULL termination character */
    }
    else
    {
        /* MAX uint32_t value = FFFFFFFFh = 4294967295d (10 decimal chars) */
        char backwardsBuf[10];

        uint32_t calcval = value;
        uint8_t length = 0;
        uint8_t lengthCounter = 0;


        /* Loop until the value is zero (separate characters 0-9) and calculate length */
        while (calcval)
        {
            uint32_t rem = calcval % 10;
            backwardsBuf[length] = TO_DEC(rem); /* Convert to ASCII character */
            length++;

            calcval = calcval - rem;
            calcval = calcval / 10;
        }

        /* Backwards counter */
        lengthCounter = length;

        /* Reverse the characters in the buffer for the final string */
        for (uint8_t i = 0; i < length; i++)
        {
            buf[i] = backwardsBuf[lengthCounter-1];
            lengthCounter--;
        }

        /* Add NULL termination character */
        buf[length] = '\0';
    }
}

uint32_to_charHex()

static void uint32_to_charHex ( char *  buf, uint32_t  value, bool  spacing  )

static

Convert a uint32_t value to a hexadecimal char array (string).

Note

This is a static method because it's only internally used in this file and called by other methods if necessary.

Parameters

[out]	buf	The buffer to put the resulting string in. This needs to have a length of 9: char buf[9];!
[in]	value	The uint32_t value to convert to a string.
[in]	spacing	true - Add spacing between the eight HEX chars to make two groups of four. false - Don't add spacing between the eight HEX chars.

Definition at line 1061 of file dbprint.c.

{
    /* 4 nibble HEX representation */
    if (value <= 0xFFFF)
    {
        /* Only get necessary nibble by ANDing with a mask and
         * shifting one nibble (4 bits) per position */
        buf[0] = TO_HEX(((value & 0xF000) >> 12));
        buf[1] = TO_HEX(((value & 0x0F00) >> 8 ));
        buf[2] = TO_HEX(((value & 0x00F0) >> 4 ));
        buf[3] = TO_HEX( (value & 0x000F)       );
        buf[4] = '\0'; /* NULL termination character */
    }

    /* 8 nibble HEX representation */
    else
    {
        /* Only get necessary nibble by ANDing with a mask and
         * shifting one nibble (4 bits) per position */
        buf[0] = TO_HEX(((value & 0xF0000000) >> 28));
        buf[1] = TO_HEX(((value & 0x0F000000) >> 24));
        buf[2] = TO_HEX(((value & 0x00F00000) >> 20));
        buf[3] = TO_HEX(((value & 0x000F0000) >> 16));

        /* Add spacing if necessary */
        if (spacing)
        {
            buf[4] = ' '; /* Spacing */
            buf[5] = TO_HEX(((value & 0x0000F000) >> 12));
            buf[6] = TO_HEX(((value & 0x00000F00) >> 8 ));
            buf[7] = TO_HEX(((value & 0x000000F0) >> 4 ));
            buf[8] = TO_HEX( (value & 0x0000000F)       );
            buf[9] = '\0'; /* NULL termination character */
        }
        else
        {
            buf[4] = TO_HEX(((value & 0x0000F000) >> 12));
            buf[5] = TO_HEX(((value & 0x00000F00) >> 8 ));
            buf[6] = TO_HEX(((value & 0x000000F0) >> 4 ));
            buf[7] = TO_HEX( (value & 0x0000000F)       );
            buf[8] = '\0'; /* NULL termination character */
        }
    }
}

USART0_RX_IRQHandler()

void USART0_RX_IRQHandler

(

void

)

USART0 RX interrupt service routine.

The index gets reset to zero when a special character (CR) is received or the buffer is filled.

Note

The weak definition for this method is located in system_efm32hg.h.

Definition at line 1279 of file dbprint.c.

{
    /* "static" so it keeps its value between invocations */
    static uint32_t i = 0;

    /* Get and clear the pending USART interrupt flags */
    uint32_t flags = USART_IntGet(dbpointer);
    USART_IntClear(dbpointer, flags);

    /* Store incoming data into dbprint_rx_buffer */
    rx_buffer[i++] = USART_Rx(dbpointer);

    /* Set dbprint_rxdata when a special character is received (~ full line received) */
    if ( (rx_buffer[i - 1] == '\r') || (rx_buffer[i - 1] == '\f') )
    {
        dataReceived = true;
        rx_buffer[i - 1] = '\0'; /* Overwrite CR or LF character */
        i = 0;
    }

    /* Set dbprint_rxdata when the buffer is full */
    if (i >= (DBPRINT_BUFFER_SIZE - 2))
    {
        dataReceived = true;
        rx_buffer[i] = '\0'; /* Do not overwrite last character */
        i = 0;
    }
}

USART0_TX_IRQHandler()

void USART0_TX_IRQHandler

(

void

)

USART0 TX interrupt service routine.

The index gets reset to zero when all the characters in the buffer are send.

Note

The weak definition for this method is located in system_efm32hg.h.

Definition at line 1319 of file dbprint.c.

{
    /* "static" so it keeps its value between invocations */
    static uint32_t i = 0;

    /* Get and clear the pending USART interrupt flags */
    uint32_t flags = USART_IntGet(dbpointer);
    USART_IntClear(dbpointer, flags);

    /* Mask flags AND "TX Complete Interrupt Flag" */
    if (flags & USART_IF_TXC)
    {
        /* Index is smaller than the maximum buffer size and
         * the current item to print is not "NULL" (\0) */
        if ( (i < DBPRINT_BUFFER_SIZE) && (tx_buffer[i] != '\0') )
        {
            /* Transmit byte at current index and increment index */
            USART_Tx(dbpointer, tx_buffer[i++]);
        }
        else
        {
            i = 0; /* No more data to send */
        }
    }
}

USART1_RX_IRQHandler()

void USART1_RX_IRQHandler

(

void

)

USART1 RX interrupt service routine.

Note

The weak definition for this method is located in system_efm32hg.h.

Definition at line 1353 of file dbprint.c.

{
    /* Call other handler */
    USART0_RX_IRQHandler();
}

USART1_TX_IRQHandler()

void USART1_TX_IRQHandler

(

void

)

USART1 TX interrupt service routine.

Note

The weak definition for this method is located in system_efm32hg.h.

Definition at line 1367 of file dbprint.c.

{
    /* Call other handler */
    USART0_TX_IRQHandler();
}

Variable Documentation

dataReceived

volatile bool dataReceived = false

Definition at line 118 of file dbprint.c.

dbpointer

USART_TypeDef* dbpointer

Local variable to store the settings (pointer).

Definition at line 114 of file dbprint.c.

rx_buffer

volatile char rx_buffer[80]

Definition at line 119 of file dbprint.c.

tx_buffer

volatile char tx_buffer[80]

Definition at line 120 of file dbprint.c.