Common.c File Reference

Common Support Functions: Implementation More...

#include "..\includes.h"

Macros
#define	INC_COMMON
#define	COMMON_PROGRAM_HALTED   CommonMessages[0]
#define	COMMON_EXIT   CommonMessages[1]
#define	COMMON_BUFFER_OVERFLOW   CommonMessages[1]

Functions
void	config_std_output (void *output)
	configure standard output stream More...
void	PrintExitCode (void)
	Show a descriptive error message on exit. More...
void	AppInit (uint32_t dsp_clock)
	Initialize application. More...
void	AppCleanup (void)
	Disable interrupts, DMA, timer etc. More...
uint32_t	progress (uint32_t done, uint32_t left, uint32_t bad)
char *	num2str (int32_t num, char *buffer, int32_t min, int hexmode)
	convert a 32bit integer to string More...
_CODE_ACCESS void	memmap (uint32_t heap_mem_size)
	show current dynamic memory allocation map More...
uint32_t	GetFreeHeapSize (void)
	determine free heap size More...

Variables
const char *	FRMessages []
uint32_t	exit_code = UINT32_C(0)
const char *	exit_string = NULL
char *	exit_file = NULL
uint32_t	exit_line = UINT32_C(0)
const char *	CommonMessages []
uint32_t	initial_heap_size = UINT32_C(0)
static tpOutputFunc	_out_stream =printf

Detailed Description

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

Author

D.SignT GmbH & Co. KG, Claus Hermbusche

Version

2.91

Date

2019-04-17

This module contains common support functions for application start-up, clean-up on exit, descriptive error and exit strings, LED signalling.

Macro Definition Documentation

#define INC_COMMON

#define COMMON_PROGRAM_HALTED   CommonMessages[0]

#define COMMON_EXIT   CommonMessages[1]

#define COMMON_BUFFER_OVERFLOW   CommonMessages[1]

Function Documentation

void config_std_output

(

void *

output

)

Parameters

output

- new output stream

Returns

nothing

{
    _out_stream = (tpOutputFunc)(uint32_t)output;
}

void PrintExitCode

(

void

)

Parameters

-

Returns

nothing

Print descriptive exit message. This function uses global pointer to exit string. Exit string is set by function prg_exit()

See also

exit_code, exit_string, prg_exit()

{
#ifdef _CPRINTF_H_
    CPrintfActivateOutput();
#endif

    /***************************************************************************
     in case of cprintf buffer overflow a printf is not possible
     set LEDs to signal exit status
    ***************************************************************************/
    if (exit_code != BUFFEROVERFLOW_ERROR)
    {
        /***********************************************************************
         print exit code
        ***********************************************************************/

        if (exit_string!=NULL)
            _out_stream (COMMON_EXIT,exit_file, exit_line, exit_string);

        _out_stream (COMMON_PROGRAM_HALTED);

        /***********************************************************************
         if necessary switch LED on to signal certain errors
        ***********************************************************************/
        // if ( (exit_code == OUT_OF_MEMORY_ERROR )
        // {
            // LED_on (1);
        // }

    }
    else
    {
        fputs (COMMON_BUFFER_OVERFLOW, stderr);

        /***********************************************************************
         switch all LEDs on if printing is impossible
        ***********************************************************************/
        LED_on (0);
        LED_on (1);
        LED_on (2);
        LED_on (3);
    }

    /***************************************************************************
     clean-up application, stop timers, DMA, close handles etc.
    ***************************************************************************/
    AppCleanup();

    return;
}

void AppInit

(

uint32_t

dsp_clock

)

Parameters

dsp_clock

[Hz]

Returns

nothing

Application Initialization Code
Put all your initialization code into this central function. To make the CPrintf() function work as well in your initialization code called from here CPrintf_select_output() should be moved here too.

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

    /***************************************************************************
     global disable interrupts
    ***************************************************************************/
    _disable_interrupts();

    /***************************************************************************
     calculate configured heap size
    ***************************************************************************/
#if (defined(USE_DSPBIOS) || defined(USE_SYSBIOS))
    initial_heap_size = GetFreeHeapSize();
#else
    initial_heap_size = ((uint32_t)&_SYSMEM_SIZE);
#endif

    /***************************************************************************
     basic initialisation
    ***************************************************************************/
    BoardAppInit (dsp_clock);

    /***************************************************************************
      install exit function
    ***************************************************************************/
    atexit (PrintExitCode );

    /***************************************************************************
      initialize board peripherals
    ***************************************************************************/
    BoardPeripheralInit();

    /***************************************************************************
      initialize LEDs
    ***************************************************************************/
    LED_init ();

    /***************************************************************************
      initialize KEYs
    ***************************************************************************/
    KEY_init ();

#ifdef INC_CPRINTF
    /***************************************************************************
     let the standard outputs go to our CPrintf device
    ***************************************************************************/
    config_std_output((void *)CPrintf);
#endif
}

void AppCleanup

(

void

)

Parameters

-

Returns

nothing

Application Cleanup Code at exit
This function is called on exit to cleanup running processes like interrupts and DMA, flush opened files, close handles

{

    /***************************************************************************
      close all peripherals
    ***************************************************************************/
    BoardPeripheralClose ();

    /***************************************************************************
      disable interrupt
    ***************************************************************************/
    _disable_interrupts();
}

uint32_t progress	(	uint32_t	done,
		uint32_t	left,
		uint32_t	bad
	)

{
    /***************************************************************************
      locals
    ***************************************************************************/
    static uint32_t old = UINT32_C(101);
    int32_t temp;
    int32_t total = (int32_t)done + (int32_t)left;

    if (total==INT32_C(0))
    {
        old = UINT32_C(101);
        return (UINT32_C(0)); // prevent division by zero
    }
    temp =  (int32_t)(done *100.0 / (float)(total));
    if ( old != temp )
    {
        old = temp;
        _out_stream ("\b\b\b\b\b\b %3d %%", old );
        if ( old == INT32_C(100) )
        {
            temp = (int32_t)bad;
            if ( temp > 0 ) _out_stream (" - %d bad blocks - ", bad);
            old = UINT32_C(101);
        } // if
    } // if

    return (UINT32_C(1));
}

char* num2str	(	int32_t	num,
		char *	buffer,
		int32_t	min,
		int	hexmode
	)

Parameters

num	- number to convert
*buffer	- pointer to string buffer
min	- reserved number of digits in string, 0 means automatic
hexmode	- 1: switch to hex mode

Returns

pointer to string buffer

{
    /***************************************************************************
      Locals
    ***************************************************************************/
    char* s = buffer;
    char const digit[] = "0123456789abcdef";
    uint32_t shifter;
    int base = hexmode?16:10;
    uint32_t i = (uint32_t)num;

    /***************************************************************************
      process sign and build absolute value, if not in hex mode
    ***************************************************************************/
    if ( ( !hexmode ) && ( num < INT32_C(0) ) )
    {
        s++;
        i = (uint32_t)(num * -1);
    } // if

    /***************************************************************************
      move to end
    ***************************************************************************/
    shifter = i;
    do
    {
        ++s;
    } while ( shifter /= base );

    /***************************************************************************
     check reserved number of digits if not zero
    ***************************************************************************/
    if ( min )
    {
        if ( (s-buffer) < min )
        {
            s = buffer + min;
        } // if
    } // if

    /***************************************************************************
      convert to string
    ***************************************************************************/
    *s = '\0';
    do
    {
        *--s = digit[i%base];
    } while ( i /= base );

    /***************************************************************************
      insert sign
    ***************************************************************************/
    if ( ( !hexmode ) && ( num < INT32_C(0) ) )
    {
        *--s = '-';
    } // if

    /***************************************************************************
      fill in leading blanks, if necessary
    ***************************************************************************/
    while ( s > buffer )
    {
        *--s = ' ';
    } // if


    return (buffer);
}

_CODE_ACCESS void memmap

(

uint32_t

heap_mem_size

)

This function is useful to show memory fragmentation and to detect memory leaks

Parameters

heap_mem_size

- configured heap size

Returns

-

Note

Taken from TI's RTS source

{
    /***************************************************************************
      Locals
    ***************************************************************************/
    PACKET *current;
    PACKET *heap_end;
    uint32_t free_block_num     = UINT32_C(0);
    uint32_t free_block_space   = UINT32_C(0);
    uint32_t free_block_max     = UINT32_C(0);
    uint32_t used_block_num     = UINT32_C(0);
    uint32_t used_block_space   = UINT32_C(0);
    uint32_t used_block_max     = UINT32_C(0);
    volatile uint32_t size;
    volatile int used;
    current = (PACKET *)&_sys_memory;
    heap_end = HEAP_END(current,heap_mem_size);

    /*-----------------------------------------------------------------------*/
    /* LOOP THROUGH ALL PACKETS                                              */
    /*-----------------------------------------------------------------------*/
    while (current < heap_end)
    {
        size = (uint32_t)(SIZE_ACTUAL(current->packet_size));
        used = (int)(SIZE_IS_USED(current->packet_size));

        _out_stream (">> Used:%d size:%"PRId32" addr:%"PRIx32"\r\n", used, size, (char*)current+ BLOCK_OVERHEAD);

        if (used)
        {
            used_block_num++;
            used_block_space += size;
            used_block_max   = MAX(used_block_max, size);
        }
        else
        {
            free_block_num++;
            free_block_space += size;
            free_block_max   = MAX(free_block_max, size);
        }
        current = (PACKET *)((char *)current + size + BLOCK_OFFSET);
    }

    _out_stream ("fr_nm:%"PRIx32" fr_sp:%"PRIx32" fr_mx:%"PRIx32" us_nm:%"PRIx32" us_sp:%"PRIx32" us_mx:%"PRIx32" ovr:%"PRIx32"\r\n",
       free_block_num, free_block_space, free_block_max,
       used_block_num, used_block_space, used_block_max,
       (free_block_num + used_block_num) * BLOCK_OVERHEAD);
}

uint32_t GetFreeHeapSize

(

void

)

This function determines the largest free heap block

Parameters

-

Returns

free heap size

{
    /***************************************************************************
     locals
    ***************************************************************************/
    uint32_t sz = UINT32_C(1);
    void* p;
    int m = 0, i;

    for (;;)
    {
        p = malloc (sz);
        if ( p == NULL )
            break;
        free (p);
        m++;
        sz <<= 1;
    }

    if ( !m )
        return (0);

    m--;
    sz = ((uint32_t)1) << m;

    for ( i=m-1; i>=0; i--)
    {
        uint32_t s = ((uint32_t)1) << i;
        p = malloc (sz | s);
        if ( p != NULL )
        {
            free (p);
            sz |= s;
        }
    }
    return (sz);
}

Variable Documentation

const char* FRMessages[]

Initial value:

= {
    VT100_GREEN" success\r\n"VT100_DEFAULT,
    
    VT100_BLUE" skipped\r\n"VT100_DEFAULT,
    VT100_RED" error\r\n"VT100_DEFAULT,
    VT100_BLUE" timed out\r\n"VT100_DEFAULT,
    ""
}

function return messages

uint32_t exit_code = UINT32_C(0)

exit codes => system error codes to signal fatal errors

See also

prg_exit(), exit_string, PrintExitCode()

const char* exit_string = NULL

exit string => global variable set in prg_exit() to the current exit message

See also

prg_exit(), exit_code, PrintExitCode()

char* exit_file = NULL

exit file => global variable set in prg_exit() to the current exit file

See also

prg_exit(), exit_code, PrintExitCode()

uint32_t exit_line = UINT32_C(0)

exit line => global variable set in prg_exit() to the current exit line

See also

prg_exit(), exit_code, PrintExitCode()

const char* CommonMessages[]

Initial value:

= {
    " Program halted!",
#define COMMON_PROGRAM_HALTED
    VT100_RED"\r\nEXIT: %s line %"PRId32": %s\r\n"VT100_DEFAULT,
#define COMMON_EXIT
    "CPrintf buffer overflow error, program halted\r\n"
#define COMMON_BUFFER_OVERFLOW
}

uint32_t initial_heap_size = UINT32_C(0)

configured heap size

tpOutputFunc _out_stream =printf

static