Chapter 5

Program Design and Analysis

金仲達教授清華大學資訊工程學系

(Slides are taken from the textbook slides)

Program Design-2

Outline Program design Models of programs Assembly and linking Basic compilation techniques Analysis and optimization of programs Program validation and testing Design example: software modem

Program Design-3

Software components Need to break the design up into pieces to

be able to write the code. Some component designs come up often. A design pattern is a generic description of

a component that can be customized and used in different circumstances. Design pattern: generalized description of the

design of a certain type of program. Designer fills in details to customize the

pattern to a particular programming problem.

Program Design-4

Pattern: state machine style State machine keeps internal state as a

variable, changes state based on inputs. State machine is useful in many contexts:

parsing user input responding to complex stimuli controlling sequential outputs for control-dominated code, reactive systems

Program Design-5

State machine example

idle

buzzer seated

belted

no seat/-

seat/timer onno belt and no timer/-

no belt/timer on

belt/-belt/

buzzer off

Belt/buzzer on

no seat/-

no seat/buzzer off

State machine

state

output step(input)

design pattern

Program Design-6

C code structure Current state is kept in a variable. State table is implemented as a switch.

Cases define states. States can test inputs.

while (TRUE) {switch (state) {

case state1: …}

}

Switch is repeatedly evaluated in a while loop.

Program Design-7

C implementation#define IDLE 0#define SEATED 1#define BELTED 2#define BUZZER 3switch (state) {case IDLE: if (seat)

{ state = SEATED; timer_on = TRUE; }break;

case SEATED: if (belt) state = BELTED;else if (timer) state = BUZZER;

break;…

}

Program Design-8

Another example

A B

C D

in1=1/x=a

in1=0/x=b

r=0/out2=1

r=1/out1=0

s=1/out1=1

s=0/out1=0

Program Design-9

C state tableswitch (state) {case A: if (in1==1) { x = a; state = B; } else { x = b; state = D; }break;

case B: if (r==0) { out2 = 1; state = B; } else { out1 = 0; state = C; }break;

case C: if (s==0) { out1 = 0; state = C; } else { out1 = 1; state = D; }break;

Program Design-10

Pattern: data stream style Commonly used in signal processing:

new data constantly arrives; each datum has a limited lifetime.

Use a circular buffer to hold the data stream.

x1 x2 x3 x4 x5 x6

t1 t2 t3

Data stream

x1 x2 x3 x4

Circular buffer

x5 x6 x7

Program Design-11

Circular buffer pattern

Circular buffer

init()add(data)data head()data element(index)

Program Design-12

Circular buffers Indexes locate currently used data, current

input data:

d1

d2

d3

d4

time t1

use

input d5

d2

d3

d4

time t1+1

use

input

Program Design-13

Circular buffer implementation: FIR filterint circ_buffer[N], circ_buffer_head = 0;int c[N]; /* coefficients */…int ibuf, ic;for (f=0, ibuff=circ_buff_head, ic=0;ic<N; ibuff=(ibuff==N-1?0:ibuff++), ic++)

f = f + c[ic]*circ_buffer[ibuf];

Program Design-14

Outline Program design Models of programs Assembly and linking Basic compilation techniques Analysis and optimization of programs Program validation and testing Design example: software modem

Program Design-15

Models of programs Source code is not a good representation

for programs: clumsy; leaves much information implicit.

Compilers derive intermediate representations to manipulate and optimize the program.

Program Design-16

Data flow graph DFG: data flow graph. Does not represent control. Models basic block: code with one entry

and exit. Describes the minimal ordering

requirements on operations.

Program Design-17

Single assignment formx = a + b;y = c - d;z = x * y;y = b + d;

original basic block

x = a + b;y = c - d;z = x * y;y1 = b + d;

single assignment form

Program Design-18

Data flow graphx = a + b;y = c - d;z = x * y;y1 = b + d;

single assignment form

+ -

+*

DFG

a b c d

z

xy

y1

Program Design-19

DFGs and partial ordersPartial order: a+b, c-d; b+d, x*yCan do pairs of

operations in any order.+ -

+*

a b c d

z

xy

y1

Program Design-20

Control-data flow graph CDFG: represents control and data. Uses data flow graphs as components. Two types of nodes:

decision; data flow.

Program Design-21

Data flow nodeEncapsulates a data flow graph:

Write operations in basic block form for simplicity.

x = a + b;y = c + d

Program Design-22

Control

condT

F

Equivalent forms

valuev1

v2 v3

v4

Program Design-23

CDFG exampleif (cond1) bb1(); else bb2();bb3();switch (test1) {

case c1: bb4(); break;case c2: bb5(); break;case c3: bb6(); break;

}

cond1 bb1()

bb2()

bb3()

bb4()

test1

bb5() bb6()

T

F

c1

c2

c3

Program Design-24

for loopfor (i=0; i<N; i++)

loop_body();for loop

i=0;while (i<N) {

loop_body(); i++; }equivalent

i<N

loop_body()

T

F

i=0

Program Design-25

Outline Program design Models of programs Assembly and linking Basic compilation techniques Analysis and optimization of programs Program validation and testing Design example: software modem

Program Design-26

Assembly and linking Last steps in compilation:

HLL compile assembly assembleHLLHLL assemblyassembly

linkexecutableload

Program Design-27

Multiple-module programs Programs may be composed from several

files. Addresses become more specific during

processing: relative addresses are measured relative to the

start of a module; absolute addresses are measured relative to

the start of the CPU address space.

Program Design-28

Assemblers Major tasks:

generate binary for symbolic instructions; translate labels into addresses; handle pseudo-ops (data, etc.).

Generally one-to-one translation. Assembly labels:

ORG 100label1 ADR r4,c

Program Design-29

Symbol table generation Use program location counter (PLC) to

determine address of each location. Scan program, keeping count of PLC. Addresses are generated at assembly

time, not execution time.

Program Design-30

Symbol table example

ADD r0,r1,r2

xx ADD r3,r4,r5CMP r0,r3

yy SUB r5,r6,r7

assembly code

xx 0x8

yy 0xa

PLC=0x7

PLC=0x8

PLC=0x9

PLC=0xa

symbol table

Program Design-31

Two-pass assembly Pass 1:

generate symbol table Pass 2:

generate binary instructions

Program Design-32

Relative address generation Some label values may not be known at

assembly time. Labels within the module may be kept in

relative form. Must keep track of external labels---can’t

generate full binary for instructions that use external labels.

Program Design-33

Pseudo-operations Pseudo-ops do not generate instructions:

ORG sets program location. EQU generates symbol table entry without

advancing PLC. Data statements define data blocks.

Program Design-34

Linking Combines several object modules into a

single executable module. Jobs:

put modules in order; resolve labels across modules.

Program Design-35

external reference

entry point

Externals and entry points

a ADR r4,yyyADD r3,r4,r5xxx ADD r1,r2,r3

B ayyy %1

Program Design-36

Module ordering Code modules must be placed in absolute

positions in the memory space. Load map or linker flags control the order

of modules.

module1

module2

module3

Program Design-37

Dynamic linking Some operating systems link modules

dynamically at run time: shares one copy of library among all executing

programs; allows programs to be updated with new

versions of libraries.

Program Design-38

Outline Program design Models of programs Assembly and linking Basic compilation techniques Analysis and optimization of programs Program validation and testing Design example: software modem

Program Design-39

Compilation Compilation strategy (Wirth):

compilation = translation + optimization Compiler determines quality of code:

use of CPU resources; memory access scheduling; code size.

Program Design-40

Basic compilation phases

HLL

parsing, symbol table

machine-independentoptimizations

machine-dependentoptimizations

assembly

Program Design-41

Statement translation and optimization Source code is translated into

intermediate form such as CDFG. CDFG is transformed/optimized. CDFG is translated into instructions with

optimization decisions. Instructions are further optimized.

Program Design-42

Arithmetic expressionsa*b + 5*(c-d)

expression

DFG

* -

*

+

a b c d

5

Program Design-43

2

3

4

1

Arithmetic expressions, cont’d.

ADR r4,aMOV r1,[r4]ADR r4,bMOV r2,[r4]MUL r3,r1,r2

DFG

* -

*

+

a b c d

5ADR r4,cMOV r1,[r4]ADR r4,dMOV r5,[r4]SUB r6,r4,r5

MUL r7,r6,#5

ADD r8,r7,r3

code

Program Design-44

Control code generationif (a+b > 0)

x = 5;else

x = 7;a+b>0 x=5

x=7

Program Design-45

3

21

Control code generation, cont’d.

ADR r5,aLDR r1,[r5]ADR r5,bLDR r2,bADD r3,r1,r2BLE label3

a+b>0 x=5

x=7LDR r3,#5ADR r5,xSTR r3,[r5]B stmtent

label3 LDR r3,#7ADR r5,xSTR r3,[r5]

stmtent ...

Program Design-46

Procedure linkage Need code to:

call and return; pass parameters and results.

Parameters and returns are passed on stack. Procedures with few parameters may use

registers.

Program Design-47

Procedure stacks

proc1

growth

proc1(int a) {proc2(5);

}

proc2

SPstack pointer

FPframe pointer

5 accessed relative to SP

Program Design-48

ARM procedure linkage APCS (ARM Procedure Call Standard):

r0-r3 pass parameters into procedure. Extra parameters are put on stack frame.

r0 holds return value. r4-r7 hold register values. r11 is frame pointer, r13 is stack pointer. r10 holds limiting address on stack size to

check for stack overflows.

Program Design-49

Data structures Different types of data structures use

different data layouts. Some offsets into data structure can be

computed at compile time, others must be computed at run time.

Program Design-50

One-dimensional arrays C array name points to 0th element:

a[0]

a[1]

a[2]

a

= *(a + 1)

Program Design-51

Two-dimensional arrays Column-major layout:

a[0,0]

a[0,1]

a[1,0]

a[1,1] = a[i*M+j]

...

M

...

N

Program Design-52

Structures Fields within structures are static offsets:

field1

field2

aptrstruct { int field1; char field2;} mystruct;

struct mystruct a, *aptr = &a;

4 bytes

*(aptr+4)

Program Design-53

Expression simplification Constant folding:

8+1 = 9 Algebraic:

a*b + a*c = a*(b+c) Strength reduction:

a*2 = a<<1

Program Design-54

Dead code elimination Dead code:#define DEBUG 0if (DEBUG) dbg(p1);

Can be eliminated by analysisof control flow, constant folding

0

dbg(p1);

1

0

Program Design-55

Procedure inlining Eliminates procedure linkage overhead:

int foo(a,b,c) { return a + b - c;}z = foo(w,x,y);z = w + x + y;

May increase code size and extra cache activities

Program Design-56

Loop transformations Goals:

reduce loop overhead; increase opportunities for pipelining; improve memory system performance.

Program Design-57

Loop unrolling Reduces loop overhead, enables some

other optimizations.

for (i=0; i<4; i++)a[i] = b[i] * c[i];

for (i=0; i<2; i++) {a[i*2] = b[i*2] * c[i*2];a[i*2+1] = b[i*2+1] * c[i*2+1];

}

Program Design-58

Loop fusion and distribution Fusion combines two loops into 1:for (i=0; i<N; i++) a[i] = b[i] * 5;for (j=0; j<N; j++) w[j] = c[j] * d[j]; for (i=0; i<N; i++) {a[i] = b[i] * 5;

w[i] = c[i] * d[i];} Distribution breaks one loop into two. Changes optimizations within loop body.

Program Design-59

Loop tiling Changes order of accesses within array.

Changes cache behavior.

for (i=0; i<N; i++) for (j=0; j<N; j++)

c[i] = a[i,j]*b[i];

for (i=0; i<N; i+=2) for (j=0; j<N; j+=2) for (ii=0;ii<min(i+2,N);ii++) for (jj=0;jj<min(j+2,N);jj++)

c[ii] = a[ii,jj]*b[ii];

Program Design-60

Code motionfor (i=0; i<N*M; i++)z[i] = a[i] + b[i];

i<N*M

i=0;

z[i] = a[i] + b[i];

i = i+1;

N

Yi<X

i=0; X = N*M

Program Design-61

Induction variable elimination Induction variable: loop index. Consider loop:

for (i=0; i<N; i++)for (j=0; j<M; j++)

z[i][j] = b[i][j]; Rather than recompute i*M+j for each array in

each iteration, share induction variable between arrays, increment at end of loop body.

Program Design-62

Array conflicts in cache

a[0][0]

b[0][0]

main memory cache

1024 4099

...

1024

4099

Program Design-63

Array conflicts, cont’d. Array elements conflict because they are

in the same line, even if not mapped to same location.

Solutions: move one array; pad array.

a[0,0] a[0,1] a[0,2]

a[1,0] a[1,1] a[1,2]

before

a[0,0] a[0,1] a[0,2]

a[1,0] a[1,1] a[1,2]

after

a[0,2]

a[1,2]

Program Design-64

Register allocation Goals:

choose register to hold each variable; determine lifespan of variable in the register.

Basic case: within basic block.

Program Design-65

Register lifetime graphw = a + b;x = c + w;y = c + d;

a r0b r1c r2d r0w r3x r0y r3

time

a

b

cdwxy

1 2 3

t=1t=2t=3

c is livein interval

• spilling if not enough registers• graph coloring on conflict graph• operator rescheduling to improve

Program Design-66

Instruction scheduling Non-pipelined machines do not need instructi

on scheduling: any order of instructions that satisfies data dependencies runs equally fast.

In pipelined machines, execution time of one instruction depends on the nearby instructions: opcode, operands

Key: tracking resource utilization over time

Program Design-67

Reservation table A reservation table

relates instructions/timeto CPU resources

Time/instr A Binstr1 Xinstr2 X Xinstr3 Xinstr4 X

Program Design-68

Software pipelining Schedules instructions across loop

iterations. Reduces instruction latency in iteration i

by inserting instructions from iteration i-1. Example on SHARC:for (i=0; i<N; i++)

sum += a[i]*b[i]; Combine three iterations:

Fetch array elements a, b for iteration i. Multiply a, b for iteration i-1. Compute sum for iteration i-2.

Program Design-69

Software pipelining in SHARC/* first iteration performed outside loop */ai=a[0]; bi=b[0]; p=ai*bi;/* initiate loads used in second iteration; remainin

g loads will be performed inside loop */for (i=2; i<N-2; i++) {

ai=a[i]; bi=b[i]; /* fetch next cycle multiply */p = ai*bi; /* multiply for next iteration’s sum */sum += p; /* sum using p from last iteration */

}sum += p; p=ai*bi; sum +=p;

Program Design-70

Software pipelining timing

ai=a[i]; bi=b[i];

p = ai*bi;

sum += p;

ai=a[i]; bi=b[i];

p = ai*bi;

sum += p;

ai=a[i]; bi=b[i];

p = ai*bi;

sum += p;

time pipe

iteration i-2 iteration i-1 iteration i

Program Design-71

Instruction selection May be several ways to implement an

operation or sequence of operations. Template matching: represent operations

as graphs, match possible instruction sequences onto graph (e.g., using dynamic programming)

*

+

expression templates

* +

*

+

MULcost=1

ADDcost=1

MADDcost=1

Program Design-72

Using your compiler Understand various optimization levels (-

O1, -O2, etc.) Look at mixed compiler/assembler output. Modifying compiler output requires care:

correctness; loss of hand-tweaked code.

Program Design-73

Interpreters and JIT compilers Interpreter: translates and executes

program statements on-the-fly. JIT compiler: compiles small sections of

code into instructions during program execution. Eliminates some translation overhead. Often requires more memory.

Program Design-74

Outline Program design Models of programs Assembly and linking Basic compilation techniques Analysis and optimization of programs

for execution time, energy/power, program size Program validation and testing Design example: software modem

Program Design-75

Motivation Embedded systems must often meet

deadlines. Faster may not be fast enough.

Need to be able to analyze execution time. Worst-case, not typical.

Need techniques for reliably improving execution time.

Program Design-76

Run times will vary Program execution times depend on

several factors: Input data values. State of the instruction, data caches. Pipelining effects.

Program Design-77

Measuring program speed CPU simulator.

I/O may be hard. May not be totally accurate.

Hardware timer. Connected to microprocessor bus to measure

timing of code Requires board, instrumented program.

Logic analyzer. Limited logic analyzer memory depth.

Program Design-78

Program performance metrics Average-case:

For typical data values, whatever they are. Worst-case:

For any possible input set. Best-case:

For any possible input set. What values create worst/average/best

case? analysis; experimentation.

Concerns: operations; program paths.

Program Design-79

Performance analysis Elements of program performance (Shaw):

execution time = program path + instruction timing

Path depends on data values. Choose which case you are interested in.

Instruction timing depends on pipelining, cache behavior.

Program Design-80

Track program paths Consider for loop:for (i=0, f=0, i<N; i++)

f = f + c[i]*x[i]; Loop initiation block

executed once. Loop test executed

N+1 times. Loop body and

variable update executed N times.

For nest-if: need to enumerate all paths

i<N

i=0; f=0;

f = f + c[i]*x[i];

i = i+1;

N

Y

Program Design-81

Measure instruction timing Not all instructions take the same amount

of time. Hard to get execution time data for

instructions. Instruction execution times are not

independent. Execution time may depend on operand

values.

Program Design-82

Trace-driven performance analysis Trace: a record of the execution path of a

program. Trace gives execution path for

performance analysis. A useful trace:

requires proper input values; is large (gigabytes).

Program Design-83

Trace generation Hardware capture:

logic analyzer; hardware assist in CPU.

Software: PC sampling. Instrumentation instructions. Simulation.

Program Design-84

Performance optimization hints Use registers efficiently. Use page mode memory accesses. Analyze cache behavior:

instruction conflicts can be handled by rewriting code, rescheudling;

conflicting scalar data can easily be moved; conflicting array data can be moved, padded.

Program Design-85

Energy/power optimization Energy: ability to do work.

Most important in battery-powered systems. Power: energy per unit time.

Important even in wall-plug systems---power becomes heat.

Program Design-86

Measuring energy consumption Execute a small loop, measure current:

while (TRUE)a();

I

CPU

Program Design-87

Sources of energy consumption Relative energy per operation (Catthoor et al):

memory transfer: 33 external I/O: 10 SRAM write: 9 SRAM read: 4.4 multiply: 3.6 add: 1

Focus on memory for energy reduction

Program Design-88

Cache behavior is important Cache (SRAM) uses more power than

DRAM Energy consumption has a sweet spot as

cache size changes: cache too small: program thrashes, burning

energy on external memory accesses; cache too large: cache itself burns too much

power. Need to choose a proper size

Program Design-89

Optimizing programs for energy First-order optimization:

high performance = low energy. Optimize memory access patterns! Use registers efficiently. Identify and eliminate cache conflicts. Moderate loop unrolling eliminates some loop

overhead instructions. Eliminate pipeline stalls (e.g., software pipelin

e). Inlining procedures may help: reduces linkage,

but may increase cache thrashing.

Program Design-90

Optimizing for program size Goal:

reduce hardware cost of memory; reduce power consumption of memory units.

Reduce data size: Reuse constants, variables, data buffers in different

parts of code. Requires careful verification of correctness.

Generate data using instructions. Reduce code size:

Avoid function inlining. Choose CPU with compact instructions. Use specialized instructions where possible.

Program Design-91

Code compression Use statistical compression to reduce code

size, decompress on-the-fly:

CPUdeco

mpr

esso

r table

cache

mainmemory

0101101

0101101LDR r0,[r4]

Program Design-92

Outline Program design Models of programs Assembly and linking Basic compilation techniques Analysis and optimization of programs Program validation and testing Design example: software modem

Program Design-93

Goals Make sure software works as intended.

We will concentrate on functional testing---performance testing is harder.

What tests are required to adequately test the program? What is “adequate”?

Program Design-94

Testing basics Basic procedure:

Provide the program with inputs. Execute the program. Compare the outputs to expected results.

Types of software testing: Black-box: tests are generated without

knowledge of program internals. Clear-box (white-box): tests are generated

from the program structure.

Program Design-95

Clear-box testing Generate tests based on the structure of

the program. Is a given block of code executed when we

think it should be executed? Does a variable receive the value we think it

should get?

Program Design-96

Controllability and observability Controllability: must be able to cause a particu

lar internal condition to occur. Observability: must be able to see the effects o

f a state from the outside.

for (firout = 0.0, j =0; j < N; j++)firout += buff[j] * c[j];

if (firout > 100.0) firout = 100.0;if (firout < -100.0) firout = -100.0;

Controllability: to test range checks for firout, must first load circular buffer with suitable values

Observability: how to observe values of buff, firout?

Program Design-97

Choosing tests to performPath-based testing: Clear-box testing generally tests selected

program paths: control program to exercise a path; observe program to determine if path was

properly executed. May look at whether location on path was

reached (control), whether variable on path was set (data).

Several ways to look at control coverage, to discussed next ...

Program Design-98

Example: choosing paths Two possible criteria for selecting a set of

paths: Execute every statement at least once. Execute every direction of a branch at least

once.

Covers allstatements

+/+ Covers allbranches

Program Design-99

Find basis paths How many distinct paths are in a program? An undirected graph has a basis set of edges:

a linear combination of basis edges (xor together sets of edges) gives any possible subset of edges in the graph.

If we can cover all basis paths, the control flow is considered adequately covered

CDFG is directed, so basis set is approximation

Program Design-100

Basis set example

a b

c

ed

a b c d ea 0 0 1 0 0b 0 0 1 0 1c 1 1 0 1 0d 0 0 1 0 1e 0 1 0 1 0

incidence matrix

a 1 0 0 0 0b 0 1 0 0 0c 0 0 1 0 0d 0 0 0 1 0e 0 0 0 0 1

basis set

Program Design-101

Cyclomatic complexity Provides an upper bound on the control compl

exity of a program (size of basis set): e = # edges in control graph; n = # nodes in control graph; p = # graph components.

Cyclomatic complexity: M = e - n + 2p. Structured program: # binary decisions + 1.

Program Design-102

Branch testing strategy Exercise the elements of a conditional, not just

one true and one false case. Devise a test for every simple condition in a Bo

olean expression. Example: meant to write

if (a || (b >= c)) { printf(“OK\n”); } Actually wrote:

if (a && (b >= c)) { printf(“OK\n”); } Branch testing strategy:

One test for a=F, (b >= c) = T: a=0, b=3, c=2. Produces different answers.

Program Design-103

Domain testing Concentrates on linear inequalities. Example: j <= i + 1.

Test two cases on boundary, one outside boundary.

correct incorrect

j

i

i=3,j=5

i=4,j=5

i=1,j=2

Program Design-104

Data flow testing Def-use analysis: match variable definitions (a

ssignments) and uses. Example:

x = 5;…

if (x > 0) ... Does assignment get to the use?

Choose tests that exercise chosen def-use pairs Set value at def and observe use to check the path

(or flow)

def

p-use

Program Design-105

Loop testing Common, specialized structure---

specialized tests can help. Useful test cases:

skip loop entirely; one iteration; two iterations; mid-range of iterations; n-1, n, n+1 iterations.

Program Design-106

Black-box testing Black-box tests are made from the

specifications, not the code. Black-box testing complements clear-box.

May test unusual cases better. Types of tests:

Specified inputs/outputs: select inputs from spec, determine required outputs.

Random: generate random tests, determine appropriate output.

Regression: tests used in previous versions of system.

Program Design-107

Evaluating tests How good are your tests?

Keep track of bugs found, compare to historical trends.

Error injection: add bugs to copy of code, run tests on modified code.

Program Design-108

Outline Program design Models of programs Assembly and linking Basic compilation techniques Analysis and optimization of programs Program validation and testing Design example: software modem

Program Design-109

Theory of operation Frequency-shift keying:

separate frequencies for 0 and 1.

time

0 1

Program Design-110

FSK encoding Generate waveforms based on current bit:

bit-controlledwaveformgenerator

0110101

Program Design-111

FSK decoding

A/D

con

vert

er zero filter

one filter

detector 0 bit

detector 1 bit

Program Design-112

Transmission scheme Send data in 8-bit bytes. Arbitrary spacing

between bytes. Byte starts with 0 start bit. Receiver measures length of start bit to

synchronize itself to remaining 8 bits.

start (0) bit 1 bit 2 bit 3 bit 8...

Program Design-113

RequirementsInputs Analog sound input, reset button.

Outputs Analog sound output, LED bit display.

Functions Transmitter: Sends data from memoryin 8-bit bytes plus start bit.Receiver: Automatically detects bytesand reads bits. Displays current bit onLED.

Performance 1200 baud.

Manufacturing cost Dominated by microprocessor andanalog I/O

Power Powered by AC.

Physicalsize/weight

Small desktop object.

Program Design-114

Specification

Line-in*

input()

Receiver

sample-in()bit-out()

1 1

Transmitter

bit-in()sample-out()

Line-out*

output()

1 1

Program Design-115

System architecture Interrupt handlers for samples:

input and output. Transmitter. Receiver.

Program Design-116

Transmitter Waveform generation by table lookup.

float sine_wave[N_SAMP] = { 0.0, 0.5, 0.866, 1, 0.866, 0.5, 0.0, -0.5, -0.866, -1.0, -0.866, -0.5, 0};

time

Program Design-117

Receiver Filters (FIR for simplicity) use circular

buffers to hold data. Timer measures bit length. State machine recognizes start bits, data

bits.

Program Design-118

Hardware platform CPU. A/D converter. D/A converter. Timer.

Program Design-119

Component design and testing Easy to test transmitter and receiver on

host. Transmitter can be verified with speaker

outputs. Receiver verification tasks:

start bit recognition; data bit recognition.

Program Design-120

System integration and testing Use loopback mode to test components again

st each other. Loopback in software or by connecting D/A and A/D

converters.