UNIT 1:

PROGRAMMING

ENVIRONMENT

 

 

1.1       Introduction

 

            This unit introduces the programming environment for the Digital Signal Processing course.  It gives a brief description of the C++ classes available, and reviews support routines for signal access, complex arithmetic and graphics.

 

            When you have worked through this unit you should:

·                    understand the three basic C++ classes used in the course

·                    know how to use this document for reference information

·                    know how to manipulate complex numbers in your programs

·                    know how to create and manipulate signals, waveforms and complex waveforms

·                    know how to plot graphs

·                    know how to play and record signals

·                    have tried out a simple programming example

 

1.2       DSP Classes

 

            The DSP classes used for the course were developed to provide a simple and clean programming environment for the definition and demonstration of signal processing algorithms.  To a great extent the complexity of C++ is hidden by the classes provided, so that the implementation details of DSP concepts are not obscured by features of the language.  Through support for file I/O, replay, acquisition and graphics, the classes also make demonstration programs succinct and easy to understand.

 

            There are three main base classes:

 

·                    Complex       support for complex arithmetic

·                    Graph                        support for simple graphics

·                    Wave             support for waveform vectors

 

            The Complex and Graph classes are straightforward and described in more detail below.  The Wave class is an abstract base class from which a small hierarchy of classes has been developed:

           

            The implementation classes WaveShort, WaveDouble and WaveComplex provide an implementation of basic construction, assignment, element access, concatenation, partitioning and graph plotting of vectors of integers, floating-point numbers and complex numbers respectovely.  The lowest level of classes provide convenient objects for manipulation in DSP algorithms:

 

·                    Signal                                 Supports recording, replay, file I/O

·                    Waveform                            Supports amplitude-time graphs

·                    Spectrum                            Supports complex amplitude-frequency graphs

·                    ComplexWaveform                       Supports complex amplitude-time graphs

 

1.3       Complex Class

 

            Complex numbers consist of two double-precision floating-point numbers, representing the real part and the imaginary part of the complex number.  Complex numbers may be declared as:

 

     Complex c(1.0,2.0);

     Complex d = Complex(1.0,2.0);

     Complex e(1.0);

     Complex f = Complex(1.0);

     Complex g = 1.0;

 

            Here complex numbers c and d have real parts equal to 1.0, and imaginary parts set to 2.0.  Complex numbers e, f and g have real parts equal to 1.0 and imaginary parts set to 0.0.

 

            Arithmetic support is available for addition, subtraction, multiplication and division of complex numbers through overloading of the standard operators:

 

     Complex sum = c + d;

 

            There is also support for the +=, -=, *= and /= operators for updating complex numbers.

 

            The following global functions are also available:

 

            double mag(Complex c)   Magnitude of c

     double arg(Complex c)   Argument of c

     Complex sqrt(Complex c)   Square root of c

     Complex exp(Complex c)  Exponential of c

 

            Direct access to the real and imaginary parts of a complex number may be performed through the use of the member functions real() and imag().  Complex numbers may also be input and output using the iostream operators >> and <<.

 

1.4       Graph Class

 

            The Graph class supports the graphical display of simple X-Y graphs.  The class is implemented using a device-independent graphics library that supports PC Super-VGA screens, X-windows, postscript printers and GIF image files.

 

            Graph objects are constructed with a certain number of sub-graphs in the vertical and horizontal dimensions, and with an overall title.  Individual graphs are then positioned on this page by their index number (starting as graph number 1 for the top left graph, and incrementing left to right, to to bottom).  Each sub graph may have individual titles.

 

            The Graph constructor may be called as:

 

     Graph gr(2,3,”Example Graphs”);

 

            which would create a page with 2 rows and 3 columns of graphs with the overall title ‘Example Graphs’.

 

            The member functions wait() and close() may be used to pause for a keypress before continuing and to return the screen to its normal mode.  These operations are also performed automatically by the Graph class deconstructor,

 

            Although the Graph class has member functions for plotting arrays of numbers, these are normally called internally by objects of the various Wave classes.  The Wave objects are instructed through member functions to plot themselves as described below.  These member functions take the name of the Graph object and the number of the sub-graph as arguments.

 

1.5       Wave Class Hierarchy

 

            Conceptually the Wave classes support arrays of numerical values that also have an associated temporal or frequency parameter.  Thus a waveform is an array of sample values at a particular sample rate.  The classes allow the indexing of the elements of the array, concatenation of compatible arrays, and partitioning of arrays.  The arrays are created dynamically to a particular size, but they may also be ‘grown’ in size in  use.

 

            The Wave abstract base class provides the following interface through member functions:

 

            int  count()                   number of samples in array

            double rate()                sampling rate

            double period()                       sampling period

 

            The implementation classes WaveShort, WaveDouble and WaveComplex provide typed arrays with appropriate indexing operators:

 

            short WaveShort::operator[](int idx);

     double WaveDouble::operator[](int idx);

     Complex WaveComplex::operator[](int idx);

 

            These indexing operators are protected against range errors.  Attempts to index elements outside the current size of the arrays is guaranteed to return the value 0.  Attempts to set values of elements outside the current size of the array are safely ignored.  This characteristic of the Wave classes is used to simplify many of the signal processing algorithm implementations.

 

            Compatible wave objects may be concatenated using the + operator, for example:

 

     WaveShort owv = iwv1 + iwv2;

 

            Creates an output object owv that is the concatenation of objects iwv1 and iwv2 which must match in type and sampling rate.  Wave objects may also be grown one sample at a time by concatenation with a single numerical value:

 

     WaveShort owv = iwv1 + 2;

 

            The += operator may also be used for concatenation with arrays or single values.

 

            Every wave object also supports the selection of a sub-array through the member function

 

     cut(start_sample,number_of_samples)

 

            Signal Class

 

            The Signal class supports quantised (short integer) time series, a format that is used to import and export waveforms from/to disk or from/to analogue signals.

 

            The constructor looks like

 

     Signal sig(1000,20000);

 

            which constructs a signal of 1000 samples at a sampling rate of 20,000 samples/second. The samples are indexed from 0 to 999.

 

            Signals know how to play themselves, record themselves and load/save themselves from/to disk files through these member functions:

 

     record()                     record signal (PC only)

     replay()                     replay signal

     load(filename,itemstring)         load signal from file

     save(filename,history)       save signal to file

 

            The library uses the UCL signal format called SFS for disk files.  This format supports multiple signals in a single file.  The itemstring parameter is a character string that identifies which input signal should be loaded from the given file.  The history parameter is a character string that identifies the output signal in the given file.  SFS files need to be created with the hed program, before signals can be saved into them.

 

            Waveform Class

 

            The Waveform class is used a generic container for discrete time series used in DSP applications.  Unlike the Signal class, Waveform objects are indexed from 1 since this is the convention found in many DSP texts.  Thus the constructor

 

     Waveform wav(1000,20000);

 

            creates an array of 1000 floating point numbers from wav[1] to wav[1000] with an associated sample rate of 20,000 samples per second.  Knowledge of the sample rate is used to label graph axes correctly.

 

            ComplexWaveform Class

 

            The ComplexWaveform class is used to contain complex time series, such as that produced by the inverse Fourier transform.  Like Waveform objects, these are also indexed from 1.

 

            Interconversion between the types Signal, Waveform and ComplexWaveform is achieved by the following support functions

 

      Waveform          SignalToWaveform(Signal s);

      Signal                  WaveformToSignal(Waveform w);

      ComplexWaveform   WaveformToComplexWaveform(Waveform w);

      Waveform          ComplexWaveformMagToWaveform(ComplexWaveform c);

      Waveform          ComplexWaveformRealToWaveform(ComplexWaveform c);

 

            Note there are two ways of converting a ComplexWaveform to a normal Waveform.

 

            Objects of the Signal, Waveform and ComplexWaveform classes know how to plot themselves through member functions with the calling parameters:

 

      void plot(Graph gr,int graphno,char *title,char *xlabel,char *ylabel);

 

            The graphno value identifies into which sub-graph on the screen the waveform should be displayed (see 1.4).  The optional title parameter specifies an overall title.  The optional xlabel and ylabel parameters specify axis labels.

 

            ComplexWaveform objects may be plotted in a number of ways with the following member functions:

 

            plotMag()     plot magnitude of complex waveform

     plotLogMag()  plot log magnitude (in dB)

     plotPhase()   plot phase (in radians)

     plotReal()         plot real part

     plotImag()         plot imaginary part

 

            Spectrum Class

    

            The Spectrum class is a container for complex spectral information.  Like the ComplexWaveform class, it contains an array of complex numbers, but the associated time parameter is in samples per Hertz rather than samples per second.  Spectrum objects are also indexed from 0.  Thus the definition:

 

     Spectrum resp(1000,0.05);

 

            Represents a spectrum of 1000 samples extending from resp[0] at 0Hz, to resp[999] at 19,980Hz (each Hz is 0.05 of a sample).  To generate a suitable Spectrum object to plot the frequency characteristics of a linear system operating at an associated sample rate of SRATE samples/sec. choose enough samples to make a clear graph (say 1000) and for a frequency axis extending to SRATE/2, use a definition:

 

     Spectrum resp(1000,1000/(SRATE/2));

 

            Spectrum objects support the same varieties of the plot() member functions as ComplexWaveform objects.

 

1.6       Using DSP Classes

 

            Look at the Departmental Computing handout for general details about editing and compiling C++ programs.

 

            The definitions for the standard classes may be included in user programs through the use of the C++ 'include' file mechanism.  The line

 

     #include “tools.h”

 

            provides access to the Complex and Graph classes and the Wave hierarchy.  It also provides a set of useful constant definitions, including:

 

     const double PI=3.1459265359;     definition of p

     const int    MAXSHORT=32767; largest quantised sample

 

            As an example, here is a simple C++ program that calculates, replays and displays a sinusoid.  The output is displayed over the page.

 

// sinedemo.cpp - calculate, display and replay a sinusoid waveform

#include "tools.h"

const int    NUMSAMPLE=20000;                   // number of samples

const double SAMPRATE=20000.0;                  // sampling rate

const double SINEFREQ=500.0;                    // sine at 500Hz

const double SINEAMP=10000.0;                   // sine amplitude

int main()

{

Signal sinewave(NUMSAMPLE,SAMPRATE);     // create signal

for (int i=0;i<sinewave.count();i++)

sinewave[i] = (int)(SINEAMP*sin(2*PI*SINEFREQ*i/SAMPRATE));

sinewave.replay();                       // replay signal

Graph gr(1,1,"DSP Course");              // open graphics

Signal partwave=sinewave.cut(0,200);     // chop off first 200 samples

partwave.plot(gr,1,"Sinewave");          // display graph

}

            The algorithms presented in the DSP Units as pieces of C++ code need to be declared in your program before you may use them in your own programs.  To do this, include the corresponding ‘.h’ file in your source.  For example, to use the function for generating noise samples described in Unit 3 (noise.cpp), include at the top of your program source the line:  #include “noise.h”

 

           


 

 

Exercise

 

1.1       Type in, compile and run the example program above.