dbprint.h File Reference

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

#include <stdint.h>
#include <stdbool.h>
#include "em_usart.h"

Go to the source code of this file.

Macros
#define	DBPRINT_BUFFER_SIZE   80

Typedefs
typedef enum dbprint_colors	dbprint_color_t

Enumerations
enum	dbprint_colors {   RED, GREEN, BLUE, CYAN,   MAGENTA, YELLOW, DEFAULT_COLOR }

Functions
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	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...
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...
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...

Detailed Description

Homebrew println/printf replacement "DeBugPrint".

Version

6.2

Author

Brecht Van Eeckhoudt

---

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.

Definition in file dbprint.h.

Macro Definition Documentation

DBPRINT_BUFFER_SIZE

#define DBPRINT_BUFFER_SIZE   80

Public definition to configure the buffer size.

Definition at line 48 of file dbprint.h.

Typedef Documentation

dbprint_color_t

typedef enum dbprint_colors dbprint_color_t

Enum type for the color selection.

Enumeration Type Documentation

dbprint_colors

enum dbprint_colors

Enum type for the color selection.

Enumerator
RED
GREEN
BLUE
CYAN
MAGENTA
YELLOW
DEFAULT_COLOR

Definition at line 52 of file dbprint.h.

{
    RED,
    GREEN,
    BLUE,
    CYAN,
    MAGENTA,
    YELLOW,
    DEFAULT_COLOR
} dbprint_color_t;

Function Documentation

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);
}