WikiImporter: Pushed from DSignT Issue Database.

2015-12-08T13:23:50Z

Pushed from DSignT Issue Database.

New page

=== Generate a Buffer with Test Data ===

To debug and test signal processing algorithms it is recommended to use a test data set
instead of "real world" data acquired by an ADC.
The following code shows an example to generate a buffer filled with a sine wave.
The data is truncated to the desired resolution and optionally dithered.

==== Includes ====
<syntaxhighlight lang="c">
#include <stdint.h>
#include <math.h>
</syntaxhighlight>

==== Defines ====
The following defines control the signal generation.
<syntaxhighlight lang="c">
#define PI 3.1415926535898 /**< pi */
#define FS_IN 44100 /**< input sampling frequency in Hz */
#define RES_IN 16 /**< input resolution in bits */
#define SIG_IN 1000 /**< input signal frequency in Hz */
#define AMPL_IN 0.995 /**< input signal amplitude (0.0 - 1.0) */
#define PHASE_IN (PI/2) /**< input signal phase (-pi to pi) */

#define INBUF_SIZE 32768

#define DITHER_NONE 0 /**< no dither */
#define DITHER_RECT 1 /**< flat spectrum 1/2 LSB dither */
#define DITHER_TRIANGLE 2 /**< high-pass filtered triangular dither*/
#define DITHER_SHAPED 3 /**< Lipschitz minimal audible dither */

#define DITHER_TYPE (DITHER_SHAPED)
#define DITHERSCALE (1.0/((double)RAND_MAX - 0.5))
</syntaxhighlight>

==== Buffer ====
Depending on the selected resolution the generated test data set is stored
in an int8_t, int16_t or int32_t buffer. Data is always stored left justified,
i.e. if RES_IN was set to 12, data is stored in a 16-bit buffer with D[15]=MSB,
D[4] = LSB, and D[3:0] = 0
<syntaxhighlight lang="c">
#if RES_IN <= 8
int8_t acqbuf[INBUF_SIZE];
#elif RES_IN <= 16
int16_t acqbuf[INBUF_SIZE];
#else
int32_t acqbuf[INBUF_SIZE];
#endif
</syntaxhighlight>

==== Functions ====
===== quantisize() =====
This function quantisizes a normalized double float (range -1.0 to 1.0) to
the desired integer size and optionally performs dithering
<syntaxhighlight lang="c">
/*******************************************************************//**
@brief quantisize a normalized double (-1 to +1) to
N-bit integer and store in buffer

@param data - double data
@param bits - resolution in bits
@param buffer_addr - storage location

@return next buffer address

@note requires the following defines:
@note - DITHER_TYPE (DITHER_NONE, DITHER_RECT,
DITHER_TRIANGLE, or DITHER_SHAPED)

***********************************************************************/
uint32_t quantisize (double data, uint32_t bits, uint32_t buffer_addr)
{
/*******************************************************************
locals
*******************************************************************/
double scale;
uint32_t addr = buffer_addr;

#if DITHER_TYPE != DITHER_NONE
double r;
#endif

#if DITHER_TYPE == DITHER_TRIANGLE
static double dither_last = 0.0;
#endif

#if DITHER_TYPE == DITHER_SHAPED
/* Lipshitz's minimally audible FIR */
static double dither_coeff[5] = {2.033, -2.165, 1.959, -1.590, 0.6149};
static double dither_buffer[8] = {0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0};
static uint32_t dither_phase = 0;
uint32_t idx;
double x;
#endif

/*******************************************************************
scale data
*******************************************************************/
scale = pow(2.0, (double)(bits-1)) - 2.0;
data = data * scale;

#if DITHER_TYPE == DITHER_NONE
/*******************************************************************
round to nearest integer
*******************************************************************/
data = floor (data + 0.5);
#endif

#if (DITHER_TYPE == DITHER_RECT)
/*******************************************************************
add dither and round to nearest integer
*******************************************************************/
r = (double)rand() * DITHERSCALE;
data = floor (data + r + 0.5);
#endif

#if (DITHER_TYPE == DITHER_TRIANGLE)
/*******************************************************************
add high-pass filtered dither and round to nearest integer
*******************************************************************/
r = (double)rand() * DITHERSCALE;
data = floor (data + r - dither_last + 0.5);
dither_last = r;
#endif

#if DITHER_TYPE == DITHER_SHAPED
/*******************************************************************
dither noise shaping in FIR filter
add noise shaped + triangular dither
store last error and roll buffer
*******************************************************************/
x = data;
for (idx = 0; idx < 5; idx++)
{
x = x + dither_buffer[(dither_phase - idx) & 7] * dither_coeff[idx];
}
r = (double)rand() * DITHERSCALE;
r += (double)rand() * DITHERSCALE;
data = x + r;

dither_phase++;
dither_phase &= 7;
data = floor (data + 0.5);
dither_buffer[dither_phase] = x - data;
#endif

/*******************************************************************
saturate
*******************************************************************/
if (data > scale) data = scale;
if (data < -scale) data = -scale;

/*******************************************************************
store in buffer
*******************************************************************/
if (bits <= 8)
{
*(int8_t *)addr = (int8_t)data << (8-bits);
addr += 1;
}
else if (bits <= 16)
{
*(int16_t *)addr = (int16_t)data << (16-bits);
addr +=2;
}
else
{
*(int32_t *)addr = (int32_t)data << (32-bits);
addr += 4;
}

/*******************************************************************
update address
*******************************************************************/
return addr;
}
</syntaxhighlight>

===== Sinewave Generator =====
generate a sinewave, calls quantisize
<syntaxhighlight lang="c">
/*******************************************************************//**
@brief generate a sinewave signal

@param fs - sampling frequency in Hz
@param fsig - signal frequency in Hz
@param asig - signal amplitude (0.0 to 1.0)
@param psig - signal phase (-pi to pi)
@param bits - signal resolution in bits
@param buffer - pointer to buffer memory
@param buffersize - size of buffer in samples

@note output array is left justified
@note calls quantisize()

***********************************************************************/
void sinegen ( uint32_t fs, double fsig, double asig, double psig, uint32_t bits, void* buffer, uint32_t buffersize)
{
/*******************************************************************
locals
*******************************************************************/
double arg;
double tmp;
uint32_t idx;
uint32_t addr = (uint32_t)buffer;

/*******************************************************************
calculate argument
*******************************************************************/
arg = 2.0 * PI * fsig / (double)fs;

/*******************************************************************
calculate sinewave
*******************************************************************/
for (idx = 0; idx < buffersize; idx++)
{
tmp = asig * sin (arg * (double)idx + psig);
addr = quantisize (tmp, bits, addr);
}
}
</syntaxhighlight>

===== Example =====
<syntaxhighlight lang="c">
/***********************************************************************

MAIN PROGRAM

***********************************************************************/
void main (void)
{
/*******************************************************************
generate acquisition sample buffer
*******************************************************************/
sinegen (FS_IN, SIG_IN, AMPL_IN, PHASE_IN, RES_IN, acqbuf, INBUF_SIZE);
}
</syntaxhighlight>

==== Dither Modes ====
The following spectrum plots show the effect of dithering:
[[File:16bit_no_dither.png]]
[[File:16bit_rectangular_dither.png]]
[[File:16bit_triangular_hp_dither.png]]
[[File:16bit_shaped_dither.png]]

{{pagetop}}

== Additional Tags ==
Sinewave Dither Noiseshaping

[[category:Software]][[category:DSP]]

Generate a Test Data Buffer - Revision history

WikiImporter: Pushed from DSignT Issue Database.