cprintf.c File Reference

Custom printf: Implementation More...

#include "..\includes.h"

Macros
#define	INC_CPRINTF
#define	CP_FLAG_CLS   1
#define	CP_FLAG_CLL   2
#define	CP_FLAG_STDERR   4
#define	CPRINTF_NO_ERROR   CPrintfMessages[0]
#define	CPRINTF_SUCCESS   CPrintfMessages[1]
#define	CPRINTF_ERROR   CPrintfMessages[2]
#define	CPRINTF_SKIPPED   CPrintfMessages[3]
#define	CPRINTF_NO_DEVICE   CPrintfMessages[4]
#define	CPRINTF_BUFFER_OVERFLOW   CPrintfMessages[5]

Functions
uint16_t	CPrintf_select_output (uint16_t device)
void	CPrintfActivateOutput (void)
	activate all initialized output devices More...
int	CPuts (const char *_ptr)
int	CPrintf (const char *_format,...)
	Custom printf function. More...
void	CPrintChar (const char symbol, size_t count)
	Custom print char function. More...
uint16_t	CPrintAnimatedSymbol (char *c, time_t period, size_t size)
int32_t	CPrintProgressBar (char c, time_t period, size_t length)
int32_t	CPrintProgressBarText (char c, time_t period, size_t length, char *text)

Variables
uint16_t	output_device = CPRINTF_NO_OUTPUT
	Select active output device. More...
static uint16_t	Initialized = 0
uint16_t	CPrintfFlags = 0
char	CPrintf_raw_buffer [CPRINTF_BUFFER_SIZE]
	static conversion buffer More...
char	CPrintf_cleared_buffer [CPRINTF_BUFFER_SIZE]
const char *	CPrintfMessages []

Detailed Description

                          _         _             _
                       __| |    ___(_) ____ _ __ | |_
                      / _` |   / __| |/ _` | '_ \| __|
                     | (_| | _ \__ \ | (_| | | | | |_
                      \__,_|(_) ___/_|\__, |_| |_|\__|
                     Signalprocessing |___/ Technology

Author

D.SignT GmbH & Co. KG, Claus Hermbusche

Version

2.91

Date

2019-04-17

This module contains the custom printf implementation. Depending on available peripheral a formatted print is possible over UART, USB or network

Additional information for using printf: http://processors.wiki.ti.com/index.php/Tips_for_using_printf

Macro Definition Documentation

#define INC_CPRINTF

#define CP_FLAG_CLS   1

#define CP_FLAG_CLL   2

#define CP_FLAG_STDERR   4

#define CPRINTF_NO_ERROR   CPrintfMessages[0]

#define CPRINTF_SUCCESS   CPrintfMessages[1]

#define CPRINTF_ERROR   CPrintfMessages[2]

#define CPRINTF_SKIPPED   CPrintfMessages[3]

#define CPRINTF_NO_DEVICE   CPrintfMessages[4]

#define CPRINTF_BUFFER_OVERFLOW   CPrintfMessages[5]

Function Documentation

uint16_t CPrintf_select_output

(

uint16_t

device

)

{
    /***************************************************************************
     locals
    ***************************************************************************/
    uint16_t old_device = output_device;

    if ( device == 0 )
    {
        /***********************************************************************
         output disabled
        ***********************************************************************/
        output_device = device;
        return (old_device);
    }

    if ( (device & CPRINTF_OUTPUT_MASK) == 0 )
    {
        /***********************************************************************
         device not available
        ***********************************************************************/
        prg_exit (CPRINTF_NO_DEVICE);
    }

    output_device = device & CPRINTF_OUTPUT_MASK;

#ifdef  CPRINTF_CCS_AVAILABLE
    if (output_device & CPRINTF_CCS_OUTPUT)
    {
        if (!(Initialized & CPRINTF_CCS_OUTPUT))
        {
            /*******************************************************************
              CCS output needs no initialization
            *******************************************************************/
            Initialized |= CPRINTF_CCS_OUTPUT;
        }
    }
#endif // CPRINTF_CCS_AVAILABLE

#ifdef  CPRINTF_UART_AVAILABLE
    if (output_device & CPRINTF_UART_OUTPUT)
    {
        if (!(Initialized & CPRINTF_UART_OUTPUT))
        {
            /*******************************************************************
              initialize UART
            *******************************************************************/
            if (UartInitialize())
            {
#ifndef FLASH_RUN
                puts ("couldn't get a UART handle!\r\nexiting program\r\n");
#endif
                prg_exit ("InitializeUART() failed");
            }
            else
            {
#ifndef FLASH_RUN
                puts (" UART successfully initialized!\r\n");
                puts (printf_uart_str);
#endif
            }
            Initialized |= CPRINTF_UART_OUTPUT;
        }
    }
#endif // CPRINTF_UART_AVAILABLE

#ifdef  CPRINTF_USB_AVAILABLE
    if (output_device & CPRINTF_USB_OUTPUT)
    {
        if (!(Initialized & CPRINTF_USB_OUTPUT))
        {
            /*******************************************************************
              USB connection must be initialized prior to this function
            *******************************************************************/
            // if ( UsbInitialize () )
            // {
                // prg_exit(CPRINTF_DEVICE_ERROR);
            // }
            Initialized |= CPRINTF_USB_OUTPUT;
        }
    }

#endif // CPRINTF_USB_AVAILABLE
#ifdef  CPRINTF_CDC_AVAILABLE
    if (output_device & CPRINTF_CDC_OUTPUT)
    {
        if (!(Initialized & CPRINTF_CDC_OUTPUT))
        {
            puts (" USB successfully initialized!\r\n");
            puts (printf_cdc_str);
            if ( BoardCdcInit () )
            {
                prg_exit("BoardCdcInit() failed");
            }
            Initialized |= CPRINTF_CDC_OUTPUT;
        }
    }

#endif // CPRINTF_USB_AVAILABLE

#ifdef  CPRINTF_NET_AVAILABLE
    if (output_device & CPRINTF_NET_OUTPUT)
    {
        if (!(Initialized & CPRINTF_NET_OUTPUT))
        {
            /*******************************************************************
              check if stack is initialized
            *******************************************************************/
            if (!net_initialized)
            {
                prg_exit(CPRINTF_NET_NOT_INITIALIZED);/* Stack not initialized*/
            }

            /*******************************************************************
              initialize Net connection
            *******************************************************************/
            if ( InitializeNetIO())
            {
                prg_exit (CPRINTF_NO_DEVICE);
            }
            else
            {
                puts (" NETPrintf successfully initialized!\r\n\n please connect a UDP terminal to see CPrintf outputs\r\n");
            }
            Initialized |= CPRINTF_NET_OUTPUT;
        }
    }
#endif // CPRINTF_NET_AVAILABLE

#ifdef  CPRINTF_TELNET_AVAILABLE
    if (output_device & CPRINTF_TELNET_OUTPUT)
    {
        if (!(Initialized & CPRINTF_TELNET_OUTPUT))
        {
            /*******************************************************************
              Telnet connection must be initialized prior to this function
            *******************************************************************/
            // if ( TelnetInitialize () )
            // {
                // prg_exit(CPRINTF_DEVICE_ERROR);
            // }
            Initialized |= CPRINTF_TELNET_OUTPUT;
        }
    }

#endif // CPRINTF_TELNET_AVAILABLE
#ifdef  CPRINTF_FILE_AVAILABLE
    if (output_device & CPRINTF_FILE_OUTPUT)
    {
        if (!(Initialized & CPRINTF_FILE_OUTPUT))
        {
            /*******************************************************************
              File must be initialized prior to this function
            *******************************************************************/
            // if ( FileInitialize () )
            // {
                // prg_exit(CPRINTF_DEVICE_ERROR);
            // }
            Initialized |= CPRINTF_FILE_OUTPUT;
        }
    }
    else
    {
        /***********************************************************************
         File output disabled
        ***********************************************************************/
        cprintf_file = NULL;
    }
#endif // CPRINTF_TELNET_AVAILABLE

    return (old_device);
}

void CPrintfActivateOutput

(

void

)

Parameters

-

Returns

-

{
    output_device |= Initialized;
}

int CPuts

(

const char *

_ptr

)

{
    /***************************************************************************
     locals
    ***************************************************************************/
    int cnt = 0;
    char *src;
    char *dest;
#if (defined(CPRINTF_CCS_AVAILABLE)||defined(CPRINTF_FILE_AVAILABLE))
    FILE *out=NULL;
#endif

    if ( output_device == 0 )
    {
        /***********************************************************************
         output disabled
        ***********************************************************************/
        return (cnt);
    }
    CPrintfFlags = 0;

    /***************************************************************************
     parse buffer for VT100 codes and create cleared buffer for non-VT100
     terminals
     note: not all VT100 commands are implemented!
    ***************************************************************************/
    src = (char *)_ptr;
    dest = CPrintf_cleared_buffer;
    cnt = strlen (_ptr);
    while ( *src )
    {
#ifdef VT100_TERMINAL
        /***********************************************************************
         escape sequence
        ***********************************************************************/
        if ( *src == '\x1B' )
        {
            src++;

            /*******************************************************************
             detect [
            *******************************************************************/
            if ( *src == '[' )
            {
                src++;

                /***************************************************************
                 detect 2
                ***************************************************************/
                if ( *src == '2' )
                {
                    src++;
                    if ( *src == 'K' )
                    {
                        src++;
                        continue;
                    } // if
                    if ( *src == 'J' )
                    {
                        src++;
                        CPrintfFlags |= CP_FLAG_CLS;     // clear screen detected
                        continue;
                    } // if
                    src++;
                    src++;
                    continue;
                } // if

                /***************************************************************
                 set cursor position code
                ***************************************************************/
                if ( *src == 'H' )
                {
                    src++;
                    continue;
                } // if
                if ( src[3] == 'H' )
                {
                    /***********************************************************
                     skip command
                    ***********************************************************/
                    src+=4;
                    continue;
                }
                if ( src[4] == 'H' )
                {
                    /***********************************************************
                     skip command
                    ***********************************************************/
                    src+=5;
                    continue;
                }
                if ( src[5] == 'H' )
                {
                    /***********************************************************
                     skip command
                    ***********************************************************/
                    src+=6;
                    continue;
                }

                if ( src[2] == 'D' )
                {
                    /***********************************************************
                     skip command
                    ***********************************************************/
                    src+=3;
                    CPrintfFlags |= CP_FLAG_CLL;      // clear line detected
                    continue;
                }

                /***************************************************************
                 detect 3 or 4, VT100 color codes
                ***************************************************************/
                if ( ( *src == '3' ) || ( *src == '4' ) )
                {
                    if (src[1] == '1')
                    {
                        /*******************************************************
                         red color requested, switch to stderr
                        *******************************************************/
                        CPrintfFlags |= CP_FLAG_STDERR;  // stderr detected

                    }

                    /***********************************************************
                     skip command
                    ***********************************************************/
                    src+=3;
                    continue;
                }

                continue;
            }
            continue;
        } // if

        /***********************************************************************
         back space
        ***********************************************************************/
        if ( *src == '\b' )
        {
            src++;
            continue;
        } // if
#endif
        *dest++ = *src++;
    } // if
    *dest=0;

    /***************************************************************************
     write string
    ***************************************************************************/
#ifdef  CPRINTF_CCS_AVAILABLE
    if (output_device & CPRINTF_CCS_OUTPUT)
    {
        /***********************************************************************
         output to CCS
        ***********************************************************************/
        if (CPrintfFlags & CP_FLAG_STDERR)  // stderr detected
        {
            out = stderr;
        }
        else
        {
            out = stdout;
        }
#ifndef FLASH_RUN
        if (CPrintfFlags & CP_FLAG_CLS)  // clear screen detected
        {
            /*******************************************************************
             clear screen command detected. use line feeds instead
            *******************************************************************/
            puts ("\r\n\n\n");
            fflush (out);
        }
        if (CPrintfFlags & CP_FLAG_CLL)  // clear line detected
        {
            /*******************************************************************
             clear line command detected. use line feed instead
            *******************************************************************/
            puts ("\r");
            fflush (out);
        }
        if (*CPrintf_cleared_buffer)
        {
            fprintf (out, CPrintf_cleared_buffer);
            fflush (out);
        }
#else
    (void)out;

#endif
    }
#endif // CPRINTF_CCS_AVAILABLE

#ifdef  CPRINTF_UART_AVAILABLE
    if (output_device & CPRINTF_UART_OUTPUT)
    {
        /***********************************************************************
         output to UART
        ***********************************************************************/
        UartWriteStr ((char *)_ptr);
    }
    // (void)cls_detect;
    // (void)stderr_detect;

#endif // CPRINTF_UART_AVAILABLE

#ifdef  CPRINTF_CDC_AVAILABLE
    if (output_device & CPRINTF_CDC_OUTPUT)
    {
        /***********************************************************************
         output to UART
        ***********************************************************************/
        BoardCdcWriteString ((char *)_ptr);
    }
    // (void)cls_detect;
    // (void)stderr_detect;

#endif // CPRINTF_UART_AVAILABLE

#ifdef  CPRINTF_USB_AVAILABLE
    if (output_device & CPRINTF_USB_OUTPUT)
    {
        /***********************************************************************
         output to USB
        ***********************************************************************/
        if (CPrintfFlags & CP_FLAG_CLS )  // clear screen detected
        {
            /*******************************************************************
             clear screen command detected. use line feeds instead
            *******************************************************************/
            UsbioWriteStr ( "\r\n\n\n");
        }
        UsbioWriteStr ( CPrintf_cleared_buffer);
    }
#endif // CPRINTF_USB_AVAILABLE

#ifdef  CPRINTF_NET_AVAILABLE
    if (output_device & CPRINTF_NET_OUTPUT)
    {
        /***********************************************************************
         output to network connection
        ***********************************************************************/
        if (_link )
        {
            NetWriteFormattedStr ();
        }
    }
#endif // CPRINTF_NET_AVAILABLE

#ifdef  CPRINTF_TELNET_AVAILABLE
    if (output_device & CPRINTF_TELNET_OUTPUT)
    {
        /***********************************************************************
         output to network connection
        ***********************************************************************/
        if (_link )
        {
            TelnetWriteStr ((char *)_ptr);
        }
    }
#endif // CPRINTF_TELNET_AVAILABLE

#ifdef  CPRINTF_FILE_AVAILABLE
    if (output_device & CPRINTF_FILE_OUTPUT)
    {
        /***********************************************************************
         output to file
        ***********************************************************************/
        out = cprintf_file;
        if (out )
        {
            if (CPrintfFlags & CP_FLAG_CLS)  // clear screen detected
            {
                /***************************************************************
                 clear screen command detected. use line feeds instead
                ***************************************************************/
                fprintf (out, "\r\n\n\n");
                fflush (out);
            }
            if (CPrintfFlags & CP_FLAG_CLL)  // clear line detected
            {
                /***************************************************************
                 clear line command detected. use line feed instead
                ***************************************************************/
                fprintf (out, CRLF);
                fflush (out);
            }
            if (*CPrintf_cleared_buffer)
            {
                fprintf ( out, CPrintf_cleared_buffer);
                fflush (out);
            }
        }
    }
#endif // CPRINTF_FILE_AVAILABLE

    return (cnt);
}

int CPrintf	(	const char *	_format,
			...
	)

Parameters

_format

- format string

Returns

amount of printed characters

{
    /***************************************************************************
     locals
    ***************************************************************************/
    va_list argptr;
    int cnt = 0;

    if ( output_device == 0 )
    {
        /***********************************************************************
         output disabled
        ***********************************************************************/
        return (cnt);
    }
    CPrintfFlags = 0;

    /***************************************************************************
     initializes variable argument list
    ***************************************************************************/
#pragma diag_suppress 238
    va_start (argptr, _format);
#pragma diag_default  238

    /***************************************************************************
     print to buffer
    ***************************************************************************/
    cnt = vsprintf (CPrintf_raw_buffer, _format, argptr);

    /***************************************************************************
     vsprintf returns the amount of printed characters. The user buffer size is
     limited to CPRINTF_BUFFER_SIZE. Check for buffer overflow and exit if
      necessary.
    ***************************************************************************/
    if (cnt > CPRINTF_BUFFER_SIZE)
    {
        exit_code = BUFFEROVERFLOW_ERROR;
        prg_exit (CPRINTF_BUFFER_OVERFLOW);
    }
    if ( cnt <= 0 )
    {
        /***********************************************************************
         nothing to print
        ***********************************************************************/
        va_end(argptr);
        return (cnt);
    }

    CPuts (CPrintf_raw_buffer);

    /***************************************************************************
     end variable argument list
    ***************************************************************************/
    va_end(argptr);

    return (cnt);
}

void CPrintChar	(	const char	symbol,
		size_t	count
	)

Parameters

symbol	- character to print
count	- repeat count

Returns

nothing

{
    /***************************************************************************
     locals
    ***************************************************************************/
    // size_t i;

    if ( output_device == 0 )
    {
        /***********************************************************************
         output disabled
        ***********************************************************************/
        return;
    }

    if (count >= CPRINTF_BUFFER_SIZE) prg_exit (CPRINTF_BUFFER_OVERFLOW);

    CPrintfFlags = 0;

    // i = count;
    memset(CPrintf_raw_buffer, (int)symbol, count);
    CPrintf_raw_buffer[count] = 0;

    // while ( i-- )
    // {
        // CPrintf_raw_buffer[i] = CPrintf_cleared_buffer[i] = symbol;
    // } // if

    CPuts (CPrintf_raw_buffer);
}

uint16_t CPrintAnimatedSymbol	(	char *	c,
		time_t	period,
		size_t	size
	)

Examples:

Chat.c, DHCPTest.c, DNSTest.c, Echo.c, FTPClient.c, FTPServer.c, HTTPdynamic.c, HTTPjava.c, HTTPsimple.c, Multicast.c, NetTest.c, Ping.c, PServer.c, Receive.c, Send.c, SMTP.c, and Telnet.c.

{
    /***************************************************************************
      locals
    ***************************************************************************/
    char str[3] = "\r*";
    uint16_t ret = 0;
    static timeval ProgressTime;      /* time stamp                           */
    static size_t i = (size_t)0;

    if ( tv_elapsed (&ProgressTime, (time_t)0, period, TRUE) )
    {
        if (++i>=size) i = 0;
        str[1] = c[i];
        CPuts (str);
        ret = 1;
    }
    return (ret);
}

int32_t CPrintProgressBar	(	char	c,
		time_t	period,
		size_t	length
	)

{
    /***************************************************************************
      locals
    ***************************************************************************/
    static timeval ProgressBarTime;   /* time stamp                           */
    static size_t ProgressBarLength = (size_t)0;
    static size_t len = (size_t)0;

    if ((len != length) // length changed
     || (!period) )     // if period is zero
    {
        /***********************************************************************
         reset locals
        ***********************************************************************/
        len = length;
        ProgressBarTime =  GetTimeStamp();
        ProgressBarLength = (size_t)0;
        CPuts (CLRLINE); // clear line
        return (TRUE);
    }

    // check elapsed time
    if ( tv_elapsed (&ProgressBarTime, (time_t)0, period, TRUE) )
    {
        CPrintChar (c, 1);
        if (ProgressBarLength++ >= length)
        {
            ProgressBarLength = (size_t)0;

            /*******************************************************************
             clear progress bar
            *******************************************************************/
            CPuts (CLRLINE);

            return (TRUE);
        }
    }
    return (FALSE);
}

int32_t CPrintProgressBarText	(	char	c,
		time_t	period,
		size_t	length,
		char *	text
	)

Examples:

Blocksend.c, DNSTest.c, and SMTP.c.

{
    /***************************************************************************
      locals
    ***************************************************************************/
    /* - */

    if (CPrintProgressBar(c, period, length))
    {
        if ((text != NULL) && (*text != 0)) // if text available, print text
        {
            CPuts (text);
            return (TRUE);
        }
    }

    return (FALSE);
}

Variable Documentation

uint16_t output_device = CPRINTF_NO_OUTPUT

Used to select the CPrintf() outputs. Use defines

CPRINTF_NO_OUTPUT          0
CPRINTF_CCS_OUTPUT         1
CPRINTF_UART_OUTPUT        2
CPRINTF_USB_OUTPUT         4
CPRINTF_NET_OUTPUT         8 

uint16_t Initialized = 0

static

uint16_t CPrintfFlags = 0

char CPrintf_raw_buffer[CPRINTF_BUFFER_SIZE]

Conversion buffer for CPrintf(). If you observe BUFFEROVERFLOW_ERROR errors try to increase CPRINTF_BUFFER_SIZE in cprintf.h or split your CPrintf() function call into several smaller calls.

char CPrintf_cleared_buffer[CPRINTF_BUFFER_SIZE]

const char* CPrintfMessages[]

Initial value:

= {
    "",
#define CPRINTF_NO_ERROR
    VT100_GREEN" success\r\n"VT100_DEFAULT,
#define CPRINTF_SUCCESS
    VT100_RED" error\r\n"VT100_DEFAULT,
#define CPRINTF_ERROR
    VT100_BLUE" skipped\r\n"VT100_DEFAULT,
#define CPRINTF_SKIPPED
    "Device not available!\r\nplease change output channel to CCS:\r\nCPrintf_select_output (CPRINTF_CCS_OUTPUT);\r\nexiting program...",
#define CPRINTF_NO_DEVICE
    "CPrintf() buffer overflow error",
#define CPRINTF_BUFFER_OVERFLOW




    ""

}