ece 491-153 fall 05 undergraduate research

ECE 491 6/5/2007

DSP & Quantization 1 Tanim Taher

ECE 491-153

Fall 05

Undergraduate Research:

Digital Signal Processing &

Quantization Effects

Done By: Tanim Taher SID# 10370800

Date: December 19, 2005

ECE 491 6/5/2007


ACKNOWLEDGEMENTS

I would like to express my gratitude towards Dr. Erdal Oruklu and Dr. Jafar Saniiee for

their strong support in making this project successful and a good learning experience for

me. A special thanks to Dr. Saniiee for realizing my potential and suggesting that I

should take up this research course. Thank you professors so much!

Tanim Taher

ECE 491 6/5/2007


Table Of Contents

1 Abstract……………………………………………………………….4 2 Introduction…………………………………………………...............5 3 Types of Processing……..…………………………………................7 4 DSP Processor Complexity Factors…..……………………................8 5 Processor Architecture……………..…………………………………9 6 Quantization Issues…………..……...……………………..………..10 7 Signal Flow Graphs....……………...………………………………..11 8 Direct Form Transpose Filters………………………………………13 9 Lattice Filters………………………………………….…………….14 10 Results:

a. Simulation Program Overview……………………………….17 b. Software Performance………………………………………..19 c. Software’s Algorithm Description……………………………25 d. Software Applicability………………………………………..27 e. Simulations.…………………………...……………………...28

11 Interpretation………………………………………………………...32 12 Conclusion & Future Work……………………………………...…..33 13 Appendix – Program Listings……………………………………….34

ECE 491 6/5/2007


1. ABSTRACT

Digital Signal Processing (DSP) is one of the most powerful areas in the electrical

engineering field, that lies at the root of the most exciting technologies today –

communications (wireless and all other kinds), image recognition and processing, and

many others. DSP is so exciting because due to its digital nature, it allows the integration

of computer technology with fields of science and engineering. Many DSP applications

use their own specialized techniques and algorithms, but some basic methods are

common to all and lie really at the core of the subject.

Digital signal processing involves using digital signal processors, which can be

programmed to act as filters to the digitized signals. Quantization is the process of

representing numbers in a digital binary format. The objective of this research project

was to learn how digital quantization parameters affect the performance of different kinds

of digital filters.

ECE 491 6/5/2007


2. INTRODUCTION

Digital Signal Processing is distinguished from the rest of the digital computer field by

the unique type of data it uses: signals. In most cases, these signals originate as sensory

data from the real world, for example, sound signals being picked up by a microphone.

Digital filters are a very important part of DSP. In fact, their extraordinary performance is

one of the key reasons that DSP has become so popular. Filters have two uses: signal

separation and signal restoration:

1) Signal Separation is the separation of signals that have been combined. Signal

separation is needed when a signal has been contaminated with interference,

noise, or other signals undesired. For example, when talking in a telephone’s

speakerphone, in addition to the person’s voice at this end of the line, the

microphone picks up the sound being produced by the loudspeaker. This would

normally cause the person at the other end of the line to hear echoes of his or her

own voice. Thus a filter is used that separates the sounds and eliminates the echo.

2) Signal restoration is used when a signal has been distorted in some way. For

example, an audio recording made with poor equipment may be filtered to better

represent the sound as it actually occurred.

Filtering can be done with analog filters, but digital filters achieve much better results.

This is because fine tuning analog filters can be difficult, as the analog components have

tolerance issues with their stated property values and the actual ones. On the other hand,

digital filters can be designed with precise characteristics.

However, digital filters have their own limitations. The major limit is due to a finite word

length. This limits the degree of precision with which the signal can be represented.

Digital filtering is carried out by arithmetic operations (processing) that involve ‘filter

ECE 491 6/5/2007


coefficients’. The finite word length also means that the results of the processing are not

100% accurate, but only an approximation depending on the word length and

representation format.

There are two main kinds of digital filters – infinite impulse response (IIR) filters, and

finite impulse response (FIR) filters. IIR filters have feedback, while FIR filters do not.

Any digital filter can be represented as a polynomial transfer function. The coefficients of

the polynomial represent the digital filter’s coefficients mentioned before. The transfer

function is usually represented as follows:

H(z) = (b0 + b1z-1 + b2z-2 + … bMz-M) / (1 + a1z-1 + a2z-2 + … aNz-N)

Here z-1 is called a unit delay operator. It represents a digital component whouse output

value is the same as the input value of the previous bus cycle.

An FIR filter has the denominator (a) coefficients as all zero, while IIR filters have at

least one non-zero ‘a’ coefficients. The values of the ‘a’ and ‘b’ coefficients are

determined based on the filtering characteristics that are required. Now these coefficients

must also be represented in the computer in a digital format with finite precision, and

hence the response of the filter can vary depending on how precisely these numbers are

represented in the digital signal processor.

In summary, quantization of the signal data, the coefficients and the finite precision

possible in arithmetic processing affect the performance of digital filters. The purpose of

my research was to look at the quantization effects more closely. An important objective

of my work was also to learn more about the field of digital signal processing and digital

signal processors. Hence a large portion of this report has been dedicated to summarizing

what I have learnt.

ECE 491 6/5/2007


3. TYPES OF PROCESSING

There are two main types of processing in computer science – real-time processing and

off-line processing. Off-line processing is where data has been obtained before, but the

processing is done later. Real-time processing is where the data is processed immediately

after input. Off-line processing is used in situations where the results of the operations on

the data collected are not immediately required. However, in real-time processing, the

results need to be obtained immediately. For example, in speech to text computer

systems, the spoken voice (input signal) must be processed in real-time to generate the

text (result) when preparing a document in a word processing software.

Time is a very crucial factor in real-time systems. Since the results are required

immediately, digital filters in real-time applications need to be very fast. Hence,

sometimes shortcuts may need to be made during processing, in order to produce results

faster. If a computer system is being used in an application as a real time digital filter,

this may mean that single precision word format is used instead of double precision, as

single precision processing is faster.

On the other-hand, time is not so crucial a factor in off-line processing. Hence, if we use

the same computer in an off-line application that needs to use a digital filter, we can now

use double precision arithmetic. Thus we can use higher precision in the digital filter

which makes quantization effects minimal.

Thus depending on the type of processing required – real-time or off-line, the

quantization effects on digital filters can vary. Off course we can use the same amount of

higher precision in real-time digital filters, but this may make the design of the digital

processor more complex, and hence more expensive.

ECE 491 6/5/2007


4. DSP PROCESSOR COMPLEXITY FACTORS

There are several factors which determine the design complexity and hence the cost of

digital signal processors. Ideally, we want maximum performance at lowest cost. Since

this is not always possible, we can hope to achieve optimum performance that meets the

application requirements, at a reasonably low cost.

The following are the main factors involved in determining this complexity:

Processing Frequency

Precision

The type of filter used

The number of coefficients in the filter

1) Obtaining higher processing frequency affects the processor complexity as follows.

Processor uses more power

Complex algorithms may need to be used to make the processing faster and more

efficient. The algorithm complexity and the processor complexity are correlated.

Processor may require more memory.

Processor may need more adders, multipliers, etc to increase the amount of

calculations possible per bus cycle.

Hence more cost and more complexity.

2) Higher precision in a digital filter involves using longer word lengths. For high

precision work, we would prefer a 32-bit processor over a 16-bit. Hence, the cost and

complexity of the processor is more.

3) Type of filter Used:

IIR filters usually have far fewer coefficients than FIR. Hence they are faster in

processing, or require fewer arithmetic components in the processor.

Lattice filters require a lot of multiplication and addition stages, and this means

added processor complexity.

ECE 491 6/5/2007


4) More the number of coefficients in a digital filter, the more calculations that need to be

performed. Hence complexity and cost increases as does the number of coefficients. If

we are to use the same processor for two filters – one with more coefficients than

another one, the former would require more processing time and hence will be slower.

5. PROCESSOR ARCHITECTURE

DSP processors in the market commonly use the Super Harvard Architecture. This

architecture lets the processor achieve more per bus cycle. The key features of this type

of architecture are support for separate data and program buses, instruction cache and

support for independent data management in memory. The following figure shows this

architecture:

As can be seen the processor (CPU) uses separate buses for instructions and data. Also

there is an instruction cache that stores the common instruction sequences required for

signal processing. And finally, we can see data in the memory being written or read by an

I/O controller independent of the processor. This architecture, as is obvious, allows for

faster processing.

Reference: The Scientist and Engineer's Guide to Digital Signal Processing (2nd Edition)

ECE 491 6/5/2007


6. QUANTIZATION ISSUES

No digital system in the world can give us infinite precision while representing all

numbers. There is always a size limit for a digital word.

Rounding is the term used to describe the process of approximating a number in the

digital domain. This is done by rounding the least significant bit such that the value of the

digital number is closest to the actual value of the number. We are loosing some degree

of precision by this approximation, and generating what is called a ‘roundoff error’. On

average, this error amount is equal to a quarter of the least significant bit value. During

analog to digital sampling, the roundoff error can be quite significant if the amount of

noise inherent in the original signal is close to the average error amount.

Another type of error is truncation error which occurs when the results of arithmetic

operations like division are truncated after the word length has been reached.

In recursive filtering operations, the quantization errors simply keep adding up each time

with the digitally filtered data. Furthermore, roundoff error can cause stability issues

when it comes to IIR filters. Rounding, as it causes loss in precision, changes the filter

coefficients such that they no longer are the ideal values. If the pole (denominator in the

transfer function) coefficients are close to 1, and rounding produces a coefficient equal to

1 or more, then the digital filter is unstable.

There are three binary number formats that are in common use. The type of format used

changes the impact of quantization effects in digital filters. The following are the formats:

1) Single Precision floating point – this uses a 32 bit word. The format for storing

the number is standard number format (e.g +1.234 X 103 is a standard format

number).

2) Double Precision floating point – 64 bit, standard number format.

3) Fixed Point – varying word lengths are in use (common 16, 32, 64 bits), where the

decimal point is fixed and does not vary.

ECE 491 6/5/2007


7. SIGNAL FLOW GRAPHS

Previously, the transfer function for any digital filer was shown. The transfer function can

be used to draw the direct form system diagrams. The system diagram simply represents

the flow of data within a digital filter, and shows the operations carried out at each stage,

like multiplication by the coefficients, and summation of the results. The direct form

diagrams are very common, and I was introduced to them while taking the course, Digital

Signal Processing (ECE 437). Since my focus in this report is on material that I learnt

afterwards, we will not get into the details of the direct form diagrams. However, we shall

look into signal flow graphs, which are another way of representing the digital filter

pictorially.

Signal flow graphs use nodes to represent the adders and as signal sources. If an arrow is

pointing towards a node, it means that that node is adding that signal, or performing a

process on the signal (like multiplication). If the signal arrow is pointing away, then it

simply means that the result of the node’s operation is taken out in that data path.

Multiplication coefficients are represented simply as numbers on the data flow lines, and

the unit delay as z-1on the line. The following diagram makes this clear:

ECE 491 6/5/2007


Based on this principle, an N order FIR filter would look like the following if shown in

the form of a signal flow graph:

Reference: http://www.onesmartclick.com/engineering/digital-signal-processing.html

ECE 491 6/5/2007


8. DIRECT FORM TRANSPOSE FILTERS

Direct form filters are filters that realize the filter structure by using the same coefficients

directly from the transfer function into the filter. I learned about direct form 1 and direct

form 2 filters from ECE 437. However, during the course of my research, I came across

Direct Form Transpose filter structures. These structures are generated from the signal

flow graphs of their direct form counterparts. The procedure for converting from direct

form to direct form transpose is as follows:

1) Draw the signal flow graph for the original direct form structure.

2) Redraw the signal flow graph, but reverse the arrow directions of the data

flow paths. Physically this amounts to changing the nodes into adders and the

adders into nodes.

3) Now interchange the input and the output. Thus the new signal flow graph

represents the direct form transpose structure.

The next two system diagrams shows the difference between direct form II and direct

form II transpose filters. The small triangles are the coefficient multipliers. Source:

http://ccrma.stanford.edu/~jos/filters/Direct_Form_II.html

Direct Form II

Direct Form II Transposed

ECE 491 6/5/2007


9. LATTICE FILTERS

Lattice filters are very different from the direct form structures. They use entirely new

coefficients called K coefficients. The following diagram shows how a lattice IIR filter

would look like.

Source: http://www.mathworks.com/access/helpdesk/help/toolbox/signal/basics27.html

The K and V coefficients are a new set of coefficients that are generated from the IIR

transfer function. The K coefficients are generated from the denominator (pole)

coefficients, and they form the lattice structure. The V coefficients are generated from the

numerator (zero) coefficients and form part of the ladder structure.

The following example shows how to determine the K and V coefficients and also shows

the equations employed. In order to find the coefficients, an FIR filter A(z) is first created

by simply copying the denominator coefficients of the IIR filter. In the following

notations, sub-script m denotes the order of the filter:

αm(n) is the impulse response an ‘m’ order FIR filter at time nT. i.e. hm(n)=αm(n)

βm(n) = αm(m - n)

ECE 491 6/5/2007


Example: if A2(z) = 1 + 0.2z-1 + 0.3z-2

then B2(z) = 0.3 + 0.2z-1 + 1z-2

so α2(2) = β 2(0) = 0.3

And α2(1) = β 2(1) = 0.2

And α2(0) = β 2(2) = 1

First Step: Km = αm(m)

Since A2(z) = 1 + 0.2z-1 + 0.3z-2

Km = K2 = αm(m) = α2(2) = 0.3

Second: αm-1(n) = [αm(n) - Km βm(n)] / (1 – K2m)

α1(0) = α2(0) – K2 β2(0)] / (1 – K22)

= [1 – (.3 X .3)] / [1 - .32] = 1

α1(1) = α2(1) – K2 β2(1)] / (1 – K22)

= [.2 – (.3 X .2)] / [1 - .32] = .1538

So K1 = α1(1) = 0.1538

All the Am(n), for n = 0 to m, need to be determined so that the Bm(n) can be found for all

required filter orders. Bm(z) is also required later on to find the V coefficients.

Now that Bm(z) is known for all m orders, we can find the V coefficients. To do this, we

first create an FIR filter by copying the numerator of the transfer function of the original

IIR. Let us call this filter Cm(z). Then:

Let cm(n) be the numerator coefficients. It is the response of an ‘m’ order FIR

filter at time nT. i.e. hm(n)=cm(n)

First Step: vm = cm(m)

Second: Cm-1(n) = Cm(n) - vm βm(n)

Thus both the V and K coefficients can be found in this way.

ECE 491 6/5/2007


Now the question is why use lattice filters. It is indeed quite a lot of work to determine

the K and V coefficients initially. However, during processing, a bigger problem occurs

as is evident from the system diagram shown earlier. The problem is that a large number

of extra multiplication and summation operations need to be carried out in lattice filters in

comparison to their direct form counterparts. So there needs to be a good reason for

choosing lattice filters. The answer is that the output of a lattice filter is less sensitive to

the parameterization of the filter coefficients. This is specially relevant to stability, as

otherwise slight changes in the coefficients during parameterization can make the entire

filter system unstable. The following two diagrams explain this concept. Source of

diagrams: homes.esat.kuleuven.ac.be/~moonen/

This figure shows all the possible

pole locations for any IIR filter

where the coefficient numbers are

represented in 5 bits. Note due to

areas of concentration, generally,

slight changes in coefficients equal

a significant change in the filter’s

characteristics.

This figure shows all the possible

pole locations for any IIR lattice

filter where the K coefficient

numbers are represented in 5 bits.

Note due to uniform concentration,

slight changes in coefficients here

do not affect much the filter’s

characteristics.

-1.5 -1 -0.5 0 0.5 1 1.5-1.5

-1

-0.5

0

0.5

1

1.5

-1.5 -1 -0.5 0 0.5 1 1.5-1.5

-1

-0.5

0

0.5

1

1.5

ECE 491 6/5/2007


10a. RESULTS: Simulation Program Overview

In an effort to explore the quantization effects in digital filters and to obtain a first-hand

experience in programming digital filters in a computer, I developed a Digital Filter

Simulator and Analysis Tool. I used Matlab to develop the software, and used Matlab’s

Graphics User Interface Design Environment (GUIDE) to make the user interface. Most

of my research time was spent on this software development, and in my opinion the

investment was worthwhile. The software lets the user easily change the quantization

parameters, and at the click of a button change the structure of a digital filter. The output

graphs are very useful in analyzing the performance of the filters in response to

quantization parameter changes.

The software has to GUIDE forms/menus. The first form is called the “Waveform

Generator” and it is used to generate sample data to be fed into the digital filter. The

advantage of this form is that virtually any periodic waveform can be used as input

provided the fourier series coefficients are known. This is also very helpful to the

electrical engineering student for two reasons:

a) He/she can observe firsthand how the fourier series can be used to generate any

waveform of choice, and hence understand the power of Fourier series.

b) He/she can also observe the effect of aliasing which occurs significantly if the

sampling rate is below the Nyquist frequency.

The other form is the “Digital Filter” form. The user inputs the coefficients of a digital

filter (FIR or IIR) from the transfer function coefficients. The user also chooses the filter

structure to be used. The quantization parameters like word length, fixed-point/floating

point can be changed at will. Then at the click of a button, the software simulates the

digital filter. There are two outputs that can be produced by the program:

a) Data output: Using the data-set of the waveform generated by the “Waveform

Generator”, an output data-set is created and displayed by digitally filtering the

ECE 491 6/5/2007


data input. Thus this represents the output of the digital filter. This means that the

user can know how the output from the filter would be distorted or changed as the

word length or other quantization parameters are changed. This is sometimes

more useful than the frequency response, as it shows how easily the output can

saturate even though the system may be stable.

b) Frequency Response: The user can see the magnitude and phase responses of the

digital filter.

ECE 491 6/5/2007


10b. RESULTS: Software Performance

In the following, all the waveforms were compared to their Matlab DSP tool

counterparts. The results in each case match with each other. As per the discussion in the

previous section, the following screenshot shows the “Waveform Generator”.

The entry fields on the left let the user input the fourier series fundamental frequency (1st

harmonic frequency) and the coefficients (amplitudes) for various harmonics. The

sampling frequency is important as it determines the aliasing effects. To demonstrate the

aliasing effect, the sampling frequency was lowered. The resulted distorted input

waveform is shown in the next screenshot.

ECE 491 6/5/2007


The entry fields on the right side let the user determine the length of the data-set by

specifying the start and stop times for the input waveform. The “Total Window Points”

field is used to zoom in or zoom out, and it refers to the number of data points to be

plotted on screen.

This screenshot

is that of the

“Digital Filter”

form.

ECE 491 6/5/2007


The quantization options lets the user to select the word type (fixed point, single or

double floating points), and the word length for the fixed point type. The output shown is

that produced by the digital filter with input being the waveform shown in the

“Waveform Generator” shown before. The digital filter is specified by the ‘a’ and ‘b’

coefficients that the user can input. The filter structure is chosen by selecting any bullet

from the “Implementation Type” box area. The most important thing to note is that as

the quantization options are changed, the actual filter coefficients used by the digital

filter changes, and these are displayed in the two list boxes at the bottom of the form (A

Coefficients, B coefficients).

The following screenshot shows the magnitude phase response which is the other output.

ECE 491 6/5/2007


Note, the aliasing effect can be observed here also, by lowering the ‘Fs(Hz)’ entry-field

value. This is shown in the next screenshot:

The third output waveform is for the phase response:

ECE 491 6/5/2007


Also the lattice coefficients generated by the software are displayed if the implementation

type is Lattice.

Finally, the poles of any filter system can be plotted by clicking “Plot system poles”

button. For a filter, the poles are shown in the next figure. Red color indicates instability.

ECE 491 6/5/2007


So we see that the user is given many options to play around with the digital filter and the

input waveform. The results are good at experimentally demonstrating many principles of

digital signal processing and quantization effects to the user.

ECE 491 6/5/2007


10c. RESULTS: Software Algorithm Description

1) The Waveform Generator uses the following algorithm to generate the input

waveform:

Time Period, T = 1 / Sampling Frequency

a. For sample n, input x(n) = 0

b. T0 = Start time

c. Start with harmonic number h = 1

d. For harmonic number h,

x(n) = [h’th fourier Coeff] * Sin (h * fundamental frequency * n * T + T0) + x(n)

e. Increment h by 1

f. If h <= highest harmonic number, repeat steps c to f.

g. Increment n

h. If n not last sample, then repeat steps c to h. The last sample count is

determined from the start and stop times, and the time period T.

2) Once the quantization options are chosen, the program creates a fixed point data object

type is created. Then the program uses this object type for all arithmetic, if the word type

is fixed point. Otherwise, it uses single or double floating point objects (as specified by

the user) for all calculations. Hence during filtering, the simulated digital filter is fully

exposed to quantization effects.

3) Direct Form 1 Filter Implementation: The software uses two separate loops to perform

the two separate summation operations of the IIR direct form 1 implementation equation

shown below:

ECE 491 6/5/2007


4) Direct Form 2 Filter Implementation: The software uses two separate loops to perform

this filter function. Each of the loops perform one of the summation functions as

specified by the IIR direct form 2 implementation equations shown below:

5) Generating Lattice Filter Coefficients: The software uses several loops to generate the

lattice coefficients recursively using the equations given before in the Lattice Filters

sections. While I was able to successfully generate the lattice coefficients, I faced

constant difficulty recreating the filter model for the lattice structure, and never was able

to successfully implement it. Hence, I used the lattice coefficient vectors generated by my

algorithm, with Matlab’s built in lattice filter function (keyword latcfilt()) for the

filtering.

6) In order to generate the magnitude response, the software uses complex arithmetic.

This algorithm uses the quantized coefficients, and replaces ‘z’ within the filter’s transfer

function (given before) by

z = e-jwt

where, w is the sweep frequency being used. Then the value of H(z) , i.e. H(e-jwt) is

calculated. This complex value’s magnitude represents the magnitude response, and its

phase represents the phase response.

ECE 491 6/5/2007


10d. RESULTS: Software Applicability

This was briefly mentioned before. Basically, the software is a powerful learning tool. I

certainly learned a lot as the programmer. By simulating a lot of filters using the

software, I was also able to learn and see the quantization effects, and to classify how

different filter structures hold up to quantization effects.

For an electrical engineering student, the software can help for the following:

Learning tools for digital signal processing – aliasing, fourier series, filter

structures, stability, magnitude and phase response, etc.

Students can use and modify this code to learn about:

MATLAB

Simulation

Filter structure

Students can test Quantization effects First Hand. By examining code, then can

appreciate how Quantization errors build up.

I would like to allow the source to be used as freeware, that can be modified by students

and users. The condition is that the comments with my ID information are not modified.

ECE 491 6/5/2007


10e. RESULTS: Simulation Results

From my software, I was able to see how drastic changes occur when the word length is

increased by even a few bits. The effects of moving from small word fixed point to single

floating point, and then to double floating point were visible. From the simulations, it

seems clear that as long as the word length is adequate to hold the maximum and

minimum input and output values, word format did not matter. By playing around with

the program, I was able to learn more about the general quantization effects.

Anyways, I also carried out several simulations in MATLAB’s DSP tools. Some output

waveforms are shown as follows. LP is low pass, HP is high pass. The conditions and

constraints used are mentioned too:

1100kkHHzz LLoowwppaassss,, OOrrddeerr 2255 FFIIRR,, DDoouubbllee,, FFllooaattiinngg PPooiinntt

8 Bit, Fixed Point

ECE 491 6/5/2007


1100kkHHzz LLoowwppaassss,, OOrrddeerr 1100 FFIIRR,, DDoouubbllee,, FFllooaattiinngg PPooiinntt

8 Bit, Fixed Point

ECE 491 6/5/2007


1100kkHHzz LLPP,, OOrrddeerr 44 CChheebbyysshheevv IIIIRR,, DDoouubbllee,, FFllooaattiinngg PPooiinntt,, DDiirreecctt FFoorrmm11

8 Bit, Fixed Point, DF1

ECE 491 6/5/2007


1100kkHHzz HHPP,,OOrrddeerr 1133 CChheebbyysshheevv IIIIRR,,66 BBiitt,, FFiixxeedd PPooiinntt,, LLaattttiiccee

8 Bit, Fixed Point, Lattice

ECE 491 6/5/2007


11. INTERPRETATION:

A lot was learned about quantization effects from the simulations. Listed below are the

interpretation of the simulation results:

Lattice Structure is most stable.

Direct Form 1 and Direct Form 2 can give issue with stability.

Direct Form 1 and Direct Form2 sensitive to slight parameterization changes.

Cascade and Parallel structures (done in MATLAB) more stable than Direct Form

1 and Direct Form 2. This is due to the fact that the lower order structural units

used in the cascade and parallel forms have lesser feedback continuation (only

one level of feedback for second order units).

The total number of coefficients in the IIR and FIR filter is the main factor that

determines the filter performance. That is the order is a very important factor

affecting filter performance.

As long as the word length is adequate to hold the maximum and minimum input

and output values, word format has little effect on performance. However, for

input and output values with large ranges, the floating point data formats were

decidedly better than the fixed point ones. The fixed point outputs often saturated.

Even though lattice structure is more stable, the extra processing required (more

multiplication and addition) cannot be really justified. This is because today,

having large word lengths an inexpensive feat, and with large words, the direct

form filters give performance close to that of lattice filters when parameterization

effects are considered.

ECE 491 6/5/2007


12. COCNCLUSION AND FUTURE WORK

I must repeat again how valuable a learning experience this project was to me. On the one

hand, I learnt how to use MATLAB, GUIDE, improved my simulation program

development skills – skills which will come in handy even in fields outside DSP. In the

other, I learned a lot more about digital signal processing and processors. I feel confident

now of my knowledge in this field, and many of the concepts that were not very clear to

me before are now at the back of my head! I also gained experience in independent study.

As a person, I feel much more confident – something which came due to the multiple

presentations that I had to give during the course. For all this, I would again like to give

special thanks to Dr. Oruklu and Dr. Saniiee.

However much I learned and worked, there is always a lot of learning that can always be

done. Directly related to this project, I believe that this project has the following future

scope:

Further development of Software

Cascade Realization

Parallel Realization

Lattice Filter implementation

Transpose direct forms: although it was my goal to add this functionality, I

did not get any time to work on this.

Generating the coefficients automatically using Chebyshev’s/Butterworth

analog filter coefficients, followed by Bilinear transformation.

Examine quantization effects on Multi-rate and adaptive filters.

ECE 491 6/5/2007


GENERAL REFERENCES: The Scientist and Engineer's Guide to Digital Signal Processing (2nd Edition)

DSP (Proakis, Manolakis)

http://www.onesmartclick.com/engineering/digital-signal-processing.html

(Excellent Resources here)

Other interesting finds:

DSP Lab manual detailing chip programming and algorithms: Rutgers

University, ADSP-2181 Experiments, Sophocles J. Orfanidis

ECE 491 6/5/2007


13. APPENDIX: Program Listing

The following is the listing for the “Waveform Generator” form. %Programmer Name: Tanim Taher %e-mail: [email protected] %Done as coursework for ECE 491, undergraduate research work %Fall 2005 function varargout = wavegen(varargin) % WAVEGEN M-file for wavegen.fig % WAVEGEN, by itself, creates a new WAVEGEN or raises the existing % singleton*. % % H = WAVEGEN returns the handle to a new WAVEGEN or the handle to % the existing singleton*. % % WAVEGEN('CALLBACK',hObject,eventData,handles,...) calls the local % function named CALLBACK in WAVEGEN.M with the given input arguments. % % WAVEGEN('Property','Value',...) creates a new WAVEGEN or raises the % existing singleton*. Starting from the left, property value pairs are % applied to the GUI before wavegen_OpeningFunction gets called. An % unrecognized property name or invalid value makes property application % stop. All inputs are passed to wavegen_OpeningFcn via varargin. % % *See GUI Options on GUIDE's Tools menu. Choose "GUI allows only one % instance to run (singleton)". % % See also: GUIDE, GUIDATA, GUIHANDLES % Copyright 2002-2003 The MathWorks, Inc. % Edit the above text to modify the response to help wavegen % Last Modified by GUIDE v2.5 07-Dec-2005 16:00:42 % Begin initialization code - DO NOT EDIT gui_Singleton = 1; gui_State = struct('gui_Name', mfilename, ... 'gui_Singleton', gui_Singleton, ... 'gui_OpeningFcn', @wavegen_OpeningFcn, ... 'gui_OutputFcn', @wavegen_OutputFcn, ... 'gui_LayoutFcn', [] , ... 'gui_Callback', []); if nargin && ischar(varargin{1})

ECE 491 6/5/2007


gui_State.gui_Callback = str2func(varargin{1}); end if nargout [varargout{1:nargout}] = gui_mainfcn(gui_State, varargin{:}); else gui_mainfcn(gui_State, varargin{:}); end % End initialization code - DO NOT EDIT % --- Executes just before wavegen is made visible. function wavegen_OpeningFcn(hObject, eventdata, handles, varargin) global h_max ampl h_no Amp %intialize harmonic values h_max = 1; ampl = 1; Amp(1) = 1 h_no = 1; % Choose default command line output for wavegen handles.output = hObject; % Update handles structure guidata(hObject, handles); % UIWAIT makes wavegen wait for user response (see UIRESUME) % uiwait(handles.figure1); % --- Outputs from this function are returned to the command line. function varargout = wavegen_OutputFcn(hObject, eventdata, handles) % Get default command line output from handles structure varargout{1} = handles.output; function edit4_Callback(hObject, eventdata, handles) % --- Executes during object creation, after setting all properties. function edit4_CreateFcn(hObject, eventdata, handles) % Hint: edit controls usually have a white background on Windows. % See ISPC and COMPUTER. if ispc && isequal(get(hObject,'BackgroundColor'), get(0,'defaultUicontrolBackgroundColor')) set(hObject,'BackgroundColor','white'); end function edit5_Callback(hObject, eventdata, handles) global h_max ampl h_no Amp h_no = str2double(get(handles.edit5,'String')); % Get entered harmonic no value

ECE 491 6/5/2007


if h_no <= h_max set(handles.edit6,'String',Amp(h_no)); else set(handles.edit6,'String',0); end % --- Executes during object creation, after setting all properties. function edit5_CreateFcn(hObject, eventdata, handles) % Hint: edit controls usually have a white background on Windows. % See ISPC and COMPUTER. if ispc && isequal(get(hObject,'BackgroundColor'), get(0,'defaultUicontrolBackgroundColor')) set(hObject,'BackgroundColor','white'); end function edit6_Callback(hObject, eventdata, handles) global h_max ampl h_no Amp %redundant % --- Executes during object creation, after setting all properties. function edit6_CreateFcn(hObject, eventdata, handles) % Hint: edit controls usually have a white background on Windows. % See ISPC and COMPUTER. if ispc && isequal(get(hObject,'BackgroundColor'), get(0,'defaultUicontrolBackgroundColor')) set(hObject,'BackgroundColor','white'); end % --- Executes on button press in pushbutton3. function pushbutton3_Callback(hObject, eventdata, handles) global h_max ampl h_no Amp ampl = str2double(get(handles.edit6,'String')); % Get entered amplitude value h_no = str2double(get(handles.edit5,'String')); % Get entered harmonic no value Amp(h_no)=ampl; set(handles.edit5,'string',h_no+1); set(handles.edit6,'string',0); if h_no > h_max h_max = h_no set(handles.maxH,'string',h_max) end; %Find Nyquist frequency and set it as default value min_samp = (2 * h_max * str2double(get(handles.edit4,'String'))) / (2 * pi); w = str2double(get(handles.edit7,'String')); if w < min_samp set(handles.edit7,'string',min_samp); end

ECE 491 6/5/2007


% --- Executes on button press in pushbutton4. function pushbutton4_Callback(hObject, eventdata, handles) global h_max ampl h_no Amp %Global makes these variables accessible throughout the MATLAB workspace clear dpts xs global st_time end_time pts tot_pts xs dpts T% for slider T = 1 / str2double(get(handles.edit7,'String')); %Calculate the period w = str2double(get(handles.edit4,'String')); %fundamental frequency st_time = str2double(get(handles.edit9,'String')); %Get start and stop times end_time = str2double(get(handles.edit10,'String')); tot_pts = ((end_time - st_time) / (T * 1000)) %Calculate total number of points for m = 0:tot_pts n = int16(m+1); dpts(n)=0; xs(n) = m * T + (st_time / 1000); %nT sample for i = 1:h_max dpts(n) = dpts(n) + Amp(i)*sin(w*i*xs(n)); %Generate the waveform end; end; pts = str2num(get(handles.edit8,'String')); % Adjust Slider so that the plot is displayed properly if (tot_pts > pts) frac = pts / (tot_pts - pts) else frac = 500 end Min = st_time; Max = st_time + T * 1000 * (tot_pts-pts); pcnt = (pts/tot_pts) * .05; set(handles.slider1,'Min',Min); %Set values and limits for the axes set(handles.slider1,'Max',Max); set(handles.slider1,'value',st_time); set(handles.slider1,'SliderStep',[pcnt frac]); xst = (get(handles.slider1,'value')) / 1000; xend = xst + pts * T %determine density of pts in plot plot(xs(1:tot_pts),dpts(1:tot_pts),'--.b') axis ([xst xend 0 10]) axis 'auto_y' function edit7_Callback(hObject, eventdata, handles) % --- Executes during object creation, after setting all properties. function edit7_CreateFcn(hObject, eventdata, handles) % Hint: edit controls usually have a white background on Windows.

ECE 491 6/5/2007


% See ISPC and COMPUTER. if ispc && isequal(get(hObject,'BackgroundColor'), get(0,'defaultUicontrolBackgroundColor')) set(hObject,'BackgroundColor','white'); end % --- Executes on slider movement. function slider1_Callback(hObject, eventdata, handles) global st_time end_time pts tot_pts xstp dpts T xst = (get(handles.slider1,'value')) / 1000; xend = xst + T * pts %determine density of pts in plot axis ([xst xend 0 10]) %Redraw waveform as specified by slider position axis 'auto_y' % --- Executes during object creation, after setting all properties. function slider1_CreateFcn(hObject, eventdata, handles) % Hint: slider controls usually have a light gray background. if isequal(get(hObject,'BackgroundColor'), get(0,'defaultUicontrolBackgroundColor')) set(hObject,'BackgroundColor',[.9 .9 .9]); end function edit8_Callback(hObject, eventdata, handles) % --- Executes during object creation, after setting all properties. function edit8_CreateFcn(hObject, eventdata, handles) % Hint: edit controls usually have a white background on Windows. % See ISPC and COMPUTER. if ispc && isequal(get(hObject,'BackgroundColor'), get(0,'defaultUicontrolBackgroundColor')) set(hObject,'BackgroundColor','white'); end function edit9_Callback(hObject, eventdata, handles) % --- Executes during object creation, after setting all properties. function edit9_CreateFcn(hObject, eventdata, handles) if ispc && isequal(get(hObject,'BackgroundColor'), get(0,'defaultUicontrolBackgroundColor')) set(hObject,'BackgroundColor','white'); end function edit10_Callback(hObject, eventdata, handles) % --- Executes during object creation, after setting all properties. function edit10_CreateFcn(hObject, eventdata, handles) % Hint: edit controls usually have a white background on Windows. % See ISPC and COMPUTER.

ECE 491 6/5/2007


if ispc && isequal(get(hObject,'BackgroundColor'), get(0,'defaultUicontrolBackgroundColor')) set(hObject,'BackgroundColor','white'); end % --- Executes on button press in clearH. function clearH_Callback(hObject, eventdata, handles) global h_max ampl h_no Amp global st_time end_time pts tot_pts xs dpts T% for slider pts = 0; %Make all the fourier coefficients = 0, clear the plot tot_pts = 0; clear dpts; clear xs; h_max = 1; clear Amp; h_no = 1; set(handles.edit5,'string',1); set(handles.edit6,'string',1); set(handles.maxH,'string',1); Amp(1) = 1; plot(0,0); THE FOLLOWING IS THE CODE FOR THE DIGITAL FILTER SIMULATOR %Programmer Name: Tanim Taher %e-mail: [email protected] %Done as coursework for ECE 491, undergraduate research work %Fall 2005 function varargout = Filter_Coefficients_Parameterization(varargin) % FILTER_COEFFICIENTS_PARAMETERIZATION M-file for Filter_Coefficients_Parameterization.fig % FILTER_COEFFICIENTS_PARAMETERIZATION, by itself, creates a new FILTER_COEFFICIENTS_PARAMETERIZATION or raises the existing % singleton*. % % H = FILTER_COEFFICIENTS_PARAMETERIZATION returns the handle to a new FILTER_COEFFICIENTS_PARAMETERIZATION or the handle to % the existing singleton*. % % FILTER_COEFFICIENTS_PARAMETERIZATION('CALLBACK',hObject,eventData,handles,...) calls the local % function named CALLBACK in FILTER_COEFFICIENTS_PARAMETERIZATION.M with the given input arguments. % % FILTER_COEFFICIENTS_PARAMETERIZATION('Property','Value',...) creates a new FILTER_COEFFICIENTS_PARAMETERIZATION or raises the % existing singleton*. Starting from the left, property value pairs are % applied to the GUI before Filter_Coefficients_Parameterization_OpeningFunction gets called. An % unrecognized property name or invalid value makes property application

ECE 491 6/5/2007


% stop. All inputs are passed to Filter_Coefficients_Parameterization_OpeningFcn via varargin. % % *See GUI Options on GUIDE's Tools menu. Choose "GUI allows only one % instance to run (singleton)". % % See also: GUIDE, GUIDATA, GUIHANDLES % Copyright 2002-2003 The MathWorks, Inc. % Edit the above text to modify the response to help Filter_Coefficients_Parameterization % Last Modified by GUIDE v2.5 14-Dec-2005 19:24:45 % Begin initialization code - DO NOT EDIT gui_Singleton = 1; gui_State = struct('gui_Name', mfilename, ... 'gui_Singleton', gui_Singleton, ... 'gui_OpeningFcn', @Filter_Coefficients_Parameterization_OpeningFcn, ... 'gui_OutputFcn', @Filter_Coefficients_Parameterization_OutputFcn, ... 'gui_LayoutFcn', [] , ... 'gui_Callback', []); if nargin && ischar(varargin{1}) gui_State.gui_Callback = str2func(varargin{1}); end if nargout [varargout{1:nargout}] = gui_mainfcn(gui_State, varargin{:}); else gui_mainfcn(gui_State, varargin{:}); end % End initialization code - DO NOT EDIT % --- Executes just before Filter_Coefficients_Parameterization is made visible. function update_listbox(handles) %This functions displays the A and B coefficients global a_no a_max b_no b_max c_A c_B a_string b_string oCA oCB oCK oCV clear a_string b_string a2_string b2_string k_string v_string b2_string(1)={' '}; a2_string(1) = {'A0 = 1'}; for n=1:a_max %Show the a coeff tmp = {strcat('A',num2str(n),' = ',num2str(c_A(n)))}; a_string(n) = tmp; end for n=1:b_max %Show the b coeffs tmp = {strcat('B',num2str(n-1),' = ',num2str(c_B(n)))}; b_string(n) = tmp;

ECE 491 6/5/2007


end if get(handles.Latt, 'Value') == 0 set(handles.paramAK, 'Title','A Coefficients'); set(handles.paramBV, 'Title','B Coefficients'); for n=1:numel(oCA) tmp = {strcat('A',num2str(n),' = ',num2str(oCA(n)))}; a2_string(n+1) = tmp; end for n=1:numel(oCB) tmp = {strcat('B',num2str(n-1),' = ',num2str(oCB(n)))}; b2_string(n) = tmp; end set(handles.listAK,'String',a2_string); set(handles.listBV,'String',b2_string); else %Show the K and V coeffs if filter type is lattice set(handles.paramAK, 'Title','K Coefficients'); set(handles.paramBV, 'Title','V Coefficients'); for n=1:numel(oCK) tmp = {strcat('K',num2str(n),' = ',num2str(oCK(n)))}; k_string(n) = tmp; end for n=1:numel(oCV) tmp = {strcat('V',num2str(n-1),' = ',num2str(oCV(n)))}; v_string(n) = tmp; end set(handles.listAK,'String',k_string); set(handles.listBV,'String',v_string); end set(handles.a_list,'String',a_string); set(handles.b_list,'String',b_string); function Filter_Coefficients_Parameterization_OpeningFcn(hObject, eventdata, handles, varargin) % This function has no output args, see OutputFcn. % hObject handle to figure % varargin command line arguments to Filter_Coefficients_Parameterization (see VARARGIN) global a_no a_max b_no b_max c_A c_B PT WL FL oCA oCB %Initialize oCA=[]; oCB=[]; PT = 1; b_no = 1; b_max = 2; a_no = 1; a_max = 2; WL = 8; FL = 4; %c_B = [0.028 0.053 0.071 0.053 0.028] % c_A = [-2.026 2.148 -1.159 0.279] c_B = [0.5 .8125] %Initialize the A and B coefficients to any desired value c_A = [0.5 .3125] pushbutton4_Callback(0, 0, handles)

ECE 491 6/5/2007


% Choose default command line output for Filter_Coefficients_Parameterization handles.output = hObject; % Update handles structure guidata(hObject, handles); axes(handles.axes3); % UIWAIT makes Filter_Coefficients_Parameterization wait for user response (see UIRESUME) % uiwait(handles.figure1); % --- Outputs from this function are returned to the command line. function varargout = Filter_Coefficients_Parameterization_OutputFcn(hObject, eventdata, handles) % varargout cell array for returning output args (see VARARGOUT); % hObject handle to figure % Get default command line output from handles structure varargout{1} = handles.output; % -------------------------------------------------------------------- function FileMenu_Callback(hObject, eventdata, handles) % hObject handle to FileMenu (see GCBO) % eventdata reserved - to be defined in a future version of MATLAB % handles structure with handles and user data (see GUIDATA) % -------------------------------------------------------------------- function OpenMenuItem_Callback(hObject, eventdata, handles) % hObject handle to OpenMenuItem (see GCBO) file = uigetfile('*.fig'); if ~isequal(file, 0) open(file); end % -------------------------------------------------------------------- function PrintMenuItem_Callback(hObject, eventdata, handles) % hObject handle to PrintMenuItem (see GCBO) printdlg(handles.figure1) % -------------------------------------------------------------------- function CloseMenuItem_Callback(hObject, eventdata, handles) % hObject handle to CloseMenuItem (see GCBO) selection = questdlg(['Close ' get(handles.figure1,'Name') '?'],... ['Close ' get(handles.figure1,'Name') '...'],... 'Yes','No','Yes'); if strcmp(selection,'No')

ECE 491 6/5/2007


return; end delete(handles.figure1) % --- Executes on selection change in popupmenu1. function popupmenu1_Callback(hObject, eventdata, handles) % hObject handle to popupmenu1 (see GCBO) % Hints: contents = get(hObject,'String') returns popupmenu1 contents as cell array % contents{get(hObject,'Value')} returns selected item from popupmenu1 % --- Executes during object creation, after setting all properties. function popupmenu1_CreateFcn(hObject, eventdata, handles) % hObject handle to popupmenu1 (see GCBO) % Hint: popupmenu controls usually have a white background on Windows. % See ISPC and COMPUTER. if ispc set(hObject,'BackgroundColor','white'); else set(hObject,'BackgroundColor',get(0,'defaultUicontrolBackgroundColor')); end set(hObject, 'String', {'plot(rand(5))', 'plot(sin(1:0.01:25))', 'bar(1:.5:10)', 'plot(membrane)', 'surf(peaks)'}); % --- Executes during object creation, after setting all properties. function edit1_CreateFcn(hObject, eventdata, handles) % hObject handle to edit1 (see GCBO) if ispc && isequal(get(hObject,'BackgroundColor'), get(0,'defaultUicontrolBackgroundColor')) set(hObject,'BackgroundColor','white'); end % --- Executes during object creation, after setting all properties. function edit2_CreateFcn(hObject, eventdata, handles) % hObject handle to edit2 (see GCBO) if ispc && isequal(get(hObject,'BackgroundColor'), get(0,'defaultUicontrolBackgroundColor')) set(hObject,'BackgroundColor','white'); end % --- Executes during object creation, after setting all properties. function listbox1_CreateFcn(hObject, eventdata, handles)

ECE 491 6/5/2007


% hObject handle to listbox1 (see GCBO) if ispc && isequal(get(hObject,'BackgroundColor'), get(0,'defaultUicontrolBackgroundColor')) set(hObject,'BackgroundColor','white'); end % --- Executes during object creation, after setting all properties. function edit3_CreateFcn(hObject, eventdata, handles) % hObject handle to edit3 (see GCBO) if ispc && isequal(get(hObject,'BackgroundColor'), get(0,'defaultUicontrolBackgroundColor')) set(hObject,'BackgroundColor','white'); end % --- Executes during object creation, after setting all properties. function edit4_CreateFcn(hObject, eventdata, handles) % hObject handle to edit4 (see GCBO) if ispc && isequal(get(hObject,'BackgroundColor'), get(0,'defaultUicontrolBackgroundColor')) set(hObject,'BackgroundColor','white'); end % --- Executes during object creation, after setting all properties. function listbox2_CreateFcn(hObject, eventdata, handles) % hObject handle to listbox2 (see GCBO) if ispc && isequal(get(hObject,'BackgroundColor'), get(0,'defaultUicontrolBackgroundColor')) set(hObject,'BackgroundColor','white'); end function wordlength_Callback(hObject, eventdata, handles) % hObject handle to wordlength (see GCBO) global WL FL WL = str2num(get(hObject,'String')) FL = str2num(get(handles.frac,'String')) if WL <= FL WL = FL + 2; set(hObject,'String',WL) end % --- Executes during object creation, after setting all properties. function wordlength_CreateFcn(hObject, eventdata, handles) % hObject handle to wordlength (see GCBO) if ispc && isequal(get(hObject,'BackgroundColor'), get(0,'defaultUicontrolBackgroundColor')) set(hObject,'BackgroundColor','white'); end

ECE 491 6/5/2007


function frac_Callback(hObject, eventdata, handles) % hObject handle to frac (see GCBO) global WL FL WL = str2num(get(handles.wordlength,'String')) FL = str2num(get(handles.frac,'String')) if WL <= FL WL = FL + 2; set(handles.wordlength,'String',WL) end % --- Executes during object creation, after setting all properties. function frac_CreateFcn(hObject, eventdata, handles) % hObject handle to frac (see GCBO) if ispc && isequal(get(hObject,'BackgroundColor'), get(0,'defaultUicontrolBackgroundColor')) set(hObject,'BackgroundColor','white'); end % --- Executes on button press in togglebutton1. function togglebutton1_Callback(hObject, eventdata, handles) % Hint: get(hObject,'Value') returns toggle state of togglebutton1 global PT %Change the word type used for processing PT = PT + 1 % Sets the Float or fixed Point data types if PT > 3 PT = 1 end if PT == 1 set(handles.togglebutton1,'String','Fixed Point'); elseif PT == 2 set(handles.togglebutton1,'String','Single, Floating Point'); elseif PT == 3 set(handles.togglebutton1,'String','Double, Floating Point'); end if PT == 1 set(handles.frac,'Enable','on'); set(handles.wordlength,'Enable','on'); else set(handles.frac,'Enable','off'); set(handles.wordlength,'Enable','off'); end function f_start_Callback(hObject, eventdata, handles) % hObject handle to f_start (see GCBO) % --- Executes during object creation, after setting all properties. function f_start_CreateFcn(hObject, eventdata, handles) % hObject handle to f_start (see GCBO) if ispc && isequal(get(hObject,'BackgroundColor'), get(0,'defaultUicontrolBackgroundColor'))

ECE 491 6/5/2007


set(hObject,'BackgroundColor','white'); end function f_end_Callback(hObject, eventdata, handles) % hObject handle to f_end (see GCBO) % --- Executes during object creation, after setting all properties. function f_end_CreateFcn(hObject, eventdata, handles) % hObject handle to f_end (see GCBO) if ispc && isequal(get(hObject,'BackgroundColor'), get(0,'defaultUicontrolBackgroundColor')) set(hObject,'BackgroundColor','white'); end % --- Executes on button press in pushbutton6. function pushbutton6_Callback(hObject, eventdata, handles) sweep_freq(handles,'magnitude'); % hObject handle to pushbutton6 (see GCBO) % --- Executes on button press in pushbutton7. function pushbutton7_Callback(hObject, eventdata, handles) sweep_freq(handles,'phase'); % hObject handle to pushbutton7 (see GCBO) %Calculates the lattice coefficients function calc_latt(handles) global oCK oCV a_max b_max c_A c_B K_C V_C Km Am K_C = []; V_C = []; oCK = []; oCV = []; % X_C are the ones used for calculations, oCX are used for printing Km=[]; Am=[]; Bm=[]; %My Code for determining K and V Am(a_max,1) = 1; for i=1:a_max Am(a_max,i+1) = c_A(i); end for m=a_max:-1:1 %From m'th order to 1st order Am(m,1) = 1; %Am(0)=1 Km(m) = Am(m,m+1); %Km=Am(m) if m>1 %If there is any lower order coefficients to find for n=1:(m-1) %for Am-1(1) to Am-1(m-1) Am(m-1,n+1)=(Am(m,n+1)-Km(m)*Am(m,m-n+1))/(1-(Km(m)^2)); %The Equation for finding lower order A coeff's end end end %This finds all values of Bm(k):

ECE 491 6/5/2007


mx_len = 1; for mm = 1:a_max mx_len=mx_len+1; for mmi = 1:mx_len Bm(mm,mmi) = Am(mm,mx_len-mmi+1); end end Cm=[]; %Create a square matrix and copy the numerator coefficents to last row. for j=1:(a_max+1) %Calculate the ladder (V) coefficients if j>b_max Cm(a_max+1,j)=0; else Cm(a_max+1,j) = c_B(j); %Cm_max(z) end end if b_max>a_max for j=1:(b_max) if j>a_max Km(j)=0; end Cm(b_max+1,j) = c_B(j); %Cm_max(z) end end for m=(a_max+1):-1:1 %From N'th order to 1st order y Vm(m) = Cm(m,m); %Vm=Cm(m) if m>1 %Check if there is any lower order C(z) coefficients to find for n=1:(m-1) %for calculating Cm-1(1) to Cm-1(m-1) Cm(m-1,n)=Cm(m,n) - Vm(m)*Bm(m-1,n); %The Equation for finding lower order C coeff's end end end oCK = []; oCK = Km; oCV = []; oCV = Vm; % --- Executes on button press in pushbutton4. function pushbutton4_Callback(hObject, eventdata, handles) %This parameterizes all the coefficients global a_no a_max b_no b_max c_A c_B PT WL FL A_C B_C F T1 A_CF B_CF oCA oCB oCV oCK K_C V_C oCB = []; oCA = []; A_C = []; B_C = []; t=0; for i = a_max:-1:1 %get vectors for the coefficients if c_A(i) == 0 && t==0 a_max = a_max-1; else

ECE 491 6/5/2007


t=1; end end t=0; for i = b_max:-1:1 if c_B(i) == 0 && t==0 b_max = b_max-1; else t=1; end end c_A = c_A(1:a_max) c_B = c_B(1:b_max) global pts tot_pts xs dpts T calc_latt(handles); %Find K and V coefficients if PT == 1 %If chosen data format is Fixed Point F = fimath('OverflowMode','saturate','RoundMode','convergent') T1 = numerictype('WordLength',WL,'FractionLength',FL) for i = 1:a_max A_C(i) = fi(c_A(i),T1,F); oCA(i) = double(A_C(i)); end for i = 1:b_max B_C(i) = fi(c_B(i),T1,F); oCB(i) = double(B_C(i)); end for i = 1:numel(oCK) K_C(i) = fi(oCK(i),T1,F); oCK(i) = double(K_C(i)); end for i = 1:numel(oCV) V_C(i) = fi(oCV(i),T1,F); oCV(i) = double(V_C(i)); end elseif PT == 2 %If chosen data format is Single Floating Point for i = 1:a_max A_C(i) = single(c_A(i)); oCA(i) = double(A_C(i)); end for i = 1:b_max B_C(i) = single(c_B(i)); oCB(i) = double(B_C(i)); end for i = 1:numel(oCK) K_C(i) = single(oCK(i)); oCK(i) = double(K_C(i)); end for i = 1:numel(oCV) V_C(i) = single(oCV(i)); oCV(i) = double(V_C(i)); end elseif PT == 3 for i = 1:a_max A_C(i) = double(c_A(i)); oCA(i) = A_C(i); end

ECE 491 6/5/2007


for i = 1:b_max B_C(i) = double(c_B(i)); oCB(i) = B_C(i); end for i = 1:numel(oCK) K_C(i) = oCK(i); end for i = 1:numel(oCV) V_C(i) = oCV(i); end end update_listbox(handles) % hObject handle to pushbutton4 (see GCBO) % --- Executes on button press in del_coeff. function del_coeff_Callback(hObject, eventdata, handles) clear c_A c_B global a_no b_no a_max b_max c_A c_B b_no = 1; b_max = 1; a_no = 1; a_max = 1; c_A(1) = 0; c_B(1) = 0; set(handles.ac_no,'String',1) %set(handles.ac,'String',0) set(handles.bc_no,'String',0) %set(handles.bc,'String',0) update_listbox(handles); % plot(xs(1:tot_pts),dpts(1:tot_pts)) function ac_no_Callback(hObject, eventdata, handles) function ac_Callback(hObject, eventdata, handles) %Store a coefficient values global a_no a_max b_no b_max c_A c_B if a_no > 0 c_A(a_no) = str2double(get(hObject,'String')); a_no = a_no + 1; set(handles.ac_no,'String',a_no); if a_no <= a_max set(handles.ac,'String',c_A(a_no)); else set(handles.ac,'String',0); a_max = a_no; c_A(a_no) = 0; end end update_listbox(handles) % hObject handle to ac (see GCBO)

ECE 491 6/5/2007


function bc_no_Callback(hObject, eventdata, handles) % hObject handle to bc_no (see GCBO) function bc_Callback(hObject, eventdata, handles) %Store B coefficient values from guide global a_no a_max b_no b_max c_A c_B if b_no > 0 c_B(b_no) = str2double(get(hObject,'String')); b_no = b_no + 1; if b_no < b_max set(handles.bc_no,'String',b_no-1); set(handles.bc,'String',c_B(b_no)); else set(handles.bc,'String',0); b_max = b_no; c_B(b_no) = 0; end end update_listbox(handles) % --- Executes on selection change in a_list. function a_list_Callback(hObject, eventdata, handles) global a_max a_no c_A; a_no = get(hObject,'Value'); set(handles.ac_no,'String',a_no); set(handles.ac,'String',c_A(a_no)); % --- Executes on selection change in b_list. function b_list_Callback(hObject, eventdata, handles) global b_max b_no c_B; b_no = get(hObject,'Value'); set(handles.bc_no,'String',b_no-1); set(handles.bc,'String',c_B(b_no)); function param_obj(handles) global PT FL if strcmp(get(handles.togglebutton1,'String'),'Fixed Point') PT = 1; else PT = 2; end function find_lattice_op(handles) %Failed function that tried to implement lattice structure %Calculate the lattice output global oCK oCV PT FL T1 dpts tot_pts F otpt xs oCK oCV [oCK,oCV]=tf2latc(c_B,[1, c_A]); %Fm(n)=Fo(n), G(1,n)=Go(1,n)

ECE 491 6/5/2007


if PT == 1 otpt = fi([],T1,F); inpt = fi([],T1,F); elseif PT==2 otpt = single([]); inpt = single([]); w = single([]) elseif PT==3 otpt = double([]) inpt = double([]) w = double([]) end for i = 1:tot_pts if PT == 1 xn = fi(dpts(i),T1,F); elseif PT==2 xn = single(dpts(i)); elseif PT==3 xn = double(dpts(i)); end Fm(numel(oCK)+1)=xn; for jj=1:numel(oCK) if i < 2 G(jj,2)=0; else G(jj,2)=G(jj,1); end end for j=(numel(oCK)+1):-1:2 Fm(j-1) = Fm(j) - oCK(j-1) * G(j-1,2); G(j,1)=oCK(j-1) * Fm(j-1) + G(j-1,2); end G(1,1)=Fm(1); for n=1:numel(oCV) otpt(i)=0; otpt(i) = otpt(i) + G(n,1) * oCV(n); end end otpt = latc plot(xs(1:tot_pts), otpt(1:tot_pts)); function find_FP_output(handles) %Calculate the output waveform global a_no a_max b_no b_max c_A c_B PT WL FL A_C B_C F T1 global pts tot_pts xs dpts T % for slider otpt = []; inpt = []; % Set the data types if PT == 1 %Quantize the input values otpt = fi([],T1,F); inpt = fi([],T1,F); w = fi([],T1,F); elseif PT==2 otpt = single([]) inpt = single([])

ECE 491 6/5/2007


w = single([]) elseif PT==3 otpt = double([]) inpt = double([]) w = double([]) end %F = fimath('OverflowMode','saturate','RoundMode','convergent') %T1 = numerictype('WordLength',WL,'FractionLength',FL) if get(handles.Latt,'Value')==0 for i = 1:tot_pts if get(handles.DF1,'Value')==1 % Direct Form1 structure if PT == 1 % Fixed Point Processing inpt(i)= fi(dpts(i),T1,F); otpt(i) = fi(0,T1,F); elseif PT == 2 % Single Floating Point Processing inpt(i)= single(dpts(i)); otpt(i) = single(0); elseif PT == 3 %Double Floating Point Processing inpt(i)= double(dpts(i)); otpt(i) = double(0); end otpt(i) = inpt(i) * B_C(1); for bi = 2:b_max if i > (bi-1) if PT == 1 % Fixed Point Processing otpt(i) = fi(otpt(i) + B_C(bi) * inpt(i-bi+1),T1,F); elseif PT == 2 % Single Floating Point Processing otpt(i) = single(otpt(i) + B_C(bi) * inpt(i-bi+1)); elseif PT == 3 %Double Floating Point Processing otpt(i) = double(otpt(i) + B_C(bi) * inpt(i-bi+1)); end %otpt(i) = otpt(i) + B_C(bi) * inpt(i-bi+1); end end for ai = 1:a_max if i > (ai) if PT == 1 % Fixed Point Processing otpt(i) = fi(otpt(i) - A_C(ai) * otpt(i-ai),T1,F); elseif PT == 2 % Single Floating Point Processing otpt(i) = single(otpt(i) - A_C(ai) * otpt(i-ai)); elseif PT == 3 %Double Floating Point Processing otpt(i) = double(otpt(i) - A_C(ai) * otpt(i-ai)); end %otpt(i) = otpt(i) - A_C(ai) * otpt(i-ai); end end elseif get(handles.DF2,'Value')==1 % Direct Form2 Structure if PT == 1 % Fixed Point Processing w(i) = fi(dpts(i),T1,F); otpt(i) = fi(0,T1,F); elseif PT == 2 % Single Floating Point Processing

ECE 491 6/5/2007


w(i) = single(dpts(i)); otpt(i) = single(0); elseif PT == 3 %Double Floating Point Processing w(i) = double(dpts(i)); otpt(i) = double(0); end otpt(i) = 0; for ki = 1:a_max if i > ki if PT == 1 % Fixed Point Processing w(i) = fi(w(i) - A_C(ki) * w(i-ki),T1,F); elseif PT == 2 % Single Floating Point Processing w(i) = single(w(i) - A_C(ki) * w(i-ki)); elseif PT == 3 %Double Floating Point Processing w(i) = double(w(i) - A_C(ki) * w(i-ki)); end end end for ki = 1:b_max if i >= ki if PT == 1 % Fixed Point Processing otpt(i) = fi(otpt(i) + B_C(ki) * w(i-ki + 1),T1,F); elseif PT == 2 % Single Floating Point Processing otpt(i) = single(otpt(i) + B_C(ki) * w(i-ki + 1)); elseif PT == 3 %Double Floating Point Processing otpt(i) = double(otpt(i) + B_C(ki) * w(i-ki + 1)); end end end end fin_OP(i) = double(otpt(i)); end plot(xs(1:tot_pts), fin_OP(1:tot_pts)) else % Use lattice coefficients if get(handles.latttype,'Value')==0 global k v % Lattice coefficient vector tmpA = [1]; for aaai = 1: a_max tmpA(aaai+1) = A_C(aaai); end for i = 1: tot_pts if PT == 1 inpt(i) = fi(dpts(i),T1,F); elseif PT == 2 inpt(i) = single(dpts(i)); elseif PT == 3 inpt(i) = double(dpts(i)); end inpt2(i)=double(inpt(i)); end

ECE 491 6/5/2007


[k,v] = tf2latc(B_C,tmpA); [otpt,tmp_g] = latcfilt(k,v,inpt2); otpt = filter(B_C,tmpA, inpt2); for i = 1: tot_pts if PT == 1 otpt2(i) = fi(otpt(i),T1,F); elseif PT == 2 otpt2(i) = single(otpt(i)); else otpt2(i) = double(otpt(i)); end otpt2(i)=double(otpt(i)); end plot(xs(1:tot_pts), otpt2(1:tot_pts)) else find_lattice_op(handles); end end otpt = []; inpt = []; w = []; tmp_g = []; % --- Executes on button press in show_Output. function show_Output_Callback(hObject, eventdata, handles) pushbutton4_Callback(0, 0, handles) find_FP_output(handles) function sweep_freq(handles, plot_type) %This calculates the frequency response pushbutton4_Callback(0, 0, handles) global a_no a_max b_no b_max oCA oCB PT WL FL A_C B_C F T1 c_A = oCA; c_B = oCB; %only in this function due to later change T = 1 / str2num(get(handles.samplerate,'String')); freq = str2num(get(handles.f_start,'String')); fend = str2num(get(handles.f_end,'String')); f_step = (fend - freq) / 60; fn = 0; for fn = 1:60 frequ(fn) = freq; comp_sum_n = complex(0,0); w = 2 * pi * freq; %Vary the frequency for bk = 1:b_max %Calculate the complex value of numerator of transfer function with z=e^jw comp_sum_n = comp_sum_n + c_B(bk) * exp(complex(0,-(bk-1) * w * T));

ECE 491 6/5/2007


end comp_sum_d = complex(1,0); for ak = 1:a_max %Calculate the complex value of denominator of transfer function with z=e^jw comp_sum_d = comp_sum_d + c_A(ak) * exp(complex(0,-ak * w * T)); end mag(fn) = abs(comp_sum_n / comp_sum_d); %Find the magnitude phs(fn) = angle(comp_sum_n / comp_sum_d) * (180 / pi); %Find the phase freq = freq + f_step; end %Plot the frequency response if strcmp(plot_type, 'magnitude') && get(handles.dBplot,'Value') == 0 plot(frequ(1:fn),mag(1:fn),'--.b'); elseif strcmp(plot_type, 'magnitude') && get(handles.dBplot,'Value') == 1 plot(frequ(1:fn),20 * log(mag(1:fn)),'--.b'); else plot(frequ(1:fn),phs(1:fn),'--*r'); end % --- Executes when user attempts to close figure1. function figure1_CloseRequestFcn(hObject, eventdata, handles) delete(hObject) % Hint: delete(hObject) closes the figure % --- Executes on button press in dBplot. function dBplot_Callback(hObject, eventdata, handles) % Hint: get(hObject,'Value') returns toggle state of dBplot function samplerate_Callback(hObject, eventdata, handles) % hObject handle to samplerate (see GCBO) % --- Executes during object creation, after setting all properties. function samplerate_CreateFcn(hObject, eventdata, handles) % hObject handle to samplerate (see GCBO) if ispc && isequal(get(hObject,'BackgroundColor'), get(0,'defaultUicontrolBackgroundColor')) set(hObject,'BackgroundColor','white'); end % --- Executes during object creation, after setting all properties. function axes3_CreateFcn(hObject, eventdata, handles) % hObject handle to axes3 (see GCBO) % Hint: place code in OpeningFcn to populate axes3 % --- Executes on selection change in listAK. function listAK_Callback(hObject, eventdata, handles)

ECE 491 6/5/2007


% hObject handle to listAK (see GCBO) % --- Executes during object creation, after setting all properties. function listAK_CreateFcn(hObject, eventdata, handles) % hObject handle to listAK (see GCBO) if ispc && isequal(get(hObject,'BackgroundColor'), get(0,'defaultUicontrolBackgroundColor')) set(hObject,'BackgroundColor','white'); end % --- Executes on selection change in listBV. function listBV_Callback(hObject, eventdata, handles) % hObject handle to listBV (see GCBO) % --- Executes during object creation, after setting all properties. function listBV_CreateFcn(hObject, eventdata, handles) % hObject handle to listBV (see GCBO) if ispc && isequal(get(hObject,'BackgroundColor'), get(0,'defaultUicontrolBackgroundColor')) set(hObject,'BackgroundColor','white'); end % --- Executes on button press in poles. function poles_Callback(hObject, eventdata, handles) %This plots the poles of the system pushbutton4_Callback(0, 0, handles) global oCA oCB a_max A = [1 oCA]'; % random polynomial poles = roots(A); % system poles for i = 1:(a_max) if abs(poles(i))>=1 %For unstable pole use red color plot(poles(i),'*r'); else plot(poles,'+b'); %For stable pole use blue color end hold on; end axis ([-5 5 -2 2]); grid on; hold off; % --- Executes on button press in latttype. function latttype_Callback(hObject, eventdata, handles)

ece 491-153 fall 05 undergraduate research

Documents