Embedded Systems

%program for FIR filters

disp('choose the window from the list');

ch=menu('types of

windows','bartlett','blackman','hamming','hanning','kaiser',

'rectangular');

rp=input('enter the passband ripple in db');

rs=input('enter the stopband ripple in db');

wsample=input('enter sampling frequency in hertz');

wp=input('enter the passband frequency in hertz');

ws=input('enter the stopband frequency in hertz');

wp=2*wp/wsample; ws=2*ws/wsample;

p=20*log10(sqrt(rp*rs))-13;

q=14.6*(ws-wp)/wsample;

N=1+floor(p/q);

N1=N;

if(rem(N,2)==0)

N1=N+1;

else

N=N-1;

end

switch ch

case 1

y=bartlett(N1);

case 2

y=blackman(N1);

case 3

y=hamming(N1);

case 4

y=hanning(N1);

case 5

beta=input('enter beta for kaiser window');

y=kaiser(N1,beta);

case 6

y=boxcar(N1);

otherwise

disp('enter proper window number');

end

disp('select the type of filter from the list');

type=menu('types of

filters','lowpass','highpass','bandpass','bandstop');

switch type

case 1

b=fir1(N,wp,'low',y);

case 2

b=fir1(N,wp,'high',y);

case 3

b=fir1(N,[wp ws],'bandpass',y);

case 4

b=fir1(N,[wp ws],'stop',y);

otherwise

disp('enter type number properly');

end

[h,w]=freqz(b,1,512);

magn=20*log10(abs(h));

phase=(180/pi)*unwrap(angle(h));

w=(w*wsample)/(2*pi);

subplot(2,1,1); plot(w,magn),grid on;title('magnitude

plot'); subplot(2,1,2); plot(w,phase),grid on;title('phase

plot');

In the x86 processor architecture, memory addresses are

specified in two parts called the segment and the offset.

One usually thinks of the segment as specifying the

beginning of a block of memory allocated by the system and

the offset as an index into it. Segment values are stored

in the segment registers. There are four or more segment

registers: CS contains the segment of the current

instruction (IP is the offset), SS contains the stack

segment (SP is the offset), DS is the segment used by

default for most data operations, ES (and, in more recent

processors, FS and GS) is an extra segment register. Most

memory operations accept a segment override prefix that

allows use of a segment register other than the default

one.

Some operating systems (such as UNIX or Windows in enhanced

mode) use virtual memory. Virtual memory is a technique for

making a machine behave as if it had more memory than it

really has, by using disk space to simulate RAM (random-

access memory). In the 80386 and higher Intel CPU chips,

and in most other modern microprocessors (such as the

Motorola 68030, Sparc, and Power PC), exists a piece of

hardware called the Memory Management Unit, or MMU.

The MMU treats memory as if it were composed of a series

of “pages.” A page of memory is a block of

contiguous bytes of a certain size, usually 4096 or 8192

bytes. The operating system sets up and maintains a table

for each running program called the Process Memory Map, or

PMM. This is a table of all the pages of memory that

program can access and where each is really located.

Every time your program accesses any portion of memory, the

address (called a “virtual address”) is processed by the

MMU. The MMU looks in the PMM to find out where the memory

is really located (called the “physical address”). The

physical address can be any location in memory or on disk

that the operating system has assigned for it. If the

location the program wants to access is on disk, the page

containing it must be read from disk into memory, and the

PMM must be updated to reflect this action (this is called

a “page fault”).

Because accessing the disk is so much slower than

accessing RAM, the operating system tries to keep as much

of the virtual memory as possible in RAM. If you’re running

a large enough program (or several small programs at once),

there might not be enough RAM to hold all the memory used

by the programs, so some of it must be moved out of RAM and

onto disk (this action is called “paging out”).

The operating system tries to guess which areas of memory

aren’t likely to be used for a while (usually based on how

the memory has been used in the past). If it guesses wrong,

or if your programs are accessing lots of memory in lots of

places, many page faults will occur in order to read in the

pages that were paged out. Because all of RAM is being

used, for each page read in to be accessed, another page

must be paged out. This can lead to more page faults,

because now a different page of memory has been moved to

disk.

The problem of many page faults occurring in a short time,

called “page thrashing,” can drastically cut the

performance of a system. Programs that frequently access

many widely separated locations in memory are more likely

to cause page thrashing on a system. So is running many

small programs that all continue to run even when you are

not actively using them. To reduce page thrashing, you can

run fewer programs simultaneously. Or you can try changing

the way a large program works to maximize the capability of

the operating system to guess which pages won’t be needed.

You can achieve this effect by caching values or changing

lookup algorithms in large data structures, or sometimes by

changing to a memory allocation library which provides an

implementation of malloc() that allocates memory more

efficiently. Finally, you might consider adding more RAM to

the system to reduce the need to page out.

Page thrashing causes performance degradation. You can

increase the ram disk size to reduce page thrashing.