Common Embedded Systems Interview Preparation Guide

Download PDF

Obviously, it can work independantly. But to see the output
we need certain output devices like LED, Buzzer can be
connected to check its functionality. Without the help of
any o/p device connected we can check the functionality of
Microcontroller.

Avoid sleep , use GFP_ATOMIC instead of GFP_KERNEL in kmalloc

Verification is a front end process and testing is a post
silicon process.
verification is to verify the functionality of the design
during the design cycle.
Testing is find manufacturing faults.

Dirac delta is a continuous time function with unit area and
infinite amplitude at t=0.
the fourier transform of dirac delta is 1.
using dirac delta as an input to the system, we can get the
system respnose. it is used to study the behavior of the
circuit.
we can use this system behavior to find the output for any
input.

DMA deals with Physical addresses.

Only when CPU accesses addresses it refers to MMU(Memory
Management Unit) and MMU converts the Physical address to
Virtual address.

But, DMA controller is a device which directly drives the
data and address bus during data transfer. So, it is purely
Physical address. (It never needs to go through MMU &
Virtual addresses).

That is why when writing the device drivers, the physical
address of the data buffer has to be assigned to the DMA.

We cannot sleep in interrupt context so semaphores and mutex
can't be used.
Spinlocks can be used for locking in interrupt context.

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.

> Microprocessor is a manager of the resources(I/O, Memory)
which lie out-side of its architecture.
> Micro-controllers have I/O, Memory etc. built into it
and specially designed for Control applications

programming logical control system

Special function registers like accumulator,Program
controller(PC),data pointer(DPTR),TMOD and TCON (timing
registers),3 register banks with r0 to r7,Bit addressable
registers like B.

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.

its not a embedded system...bcoz it will be a part of a
embedded system and it does not work on any software..

A fourth order Butterworth filter can be made as cascade of
two seond order LP filters with zeta of 0.924 and 0.383.
One can use a bilinear transformation approach for
realising second order LP filters. Using this technique
described well in many texts, one can make two second order
LP filters and cascade them.

Anti aliasing filter reduces errors due to aliasing. If a
signal is sampled at 8 kS/S, the max frequency of the input
should be 4 kHz. Otherwise, aliasing errors will result.
Typically a 3.4kHz will have an image of 4.6 khz, and one
uses a sharp cut off filter with gain of about 1 at 3.4kHz
and gain of about 0.01 at 4.6 kHz to effectively guard
against aliasing. Thus one does not quite choose max
frequency as simply fs/2 where fs is sampling frequency.
One has to have a guard band of about 10% of this fmax, and
chooses max signal frequency as 0.9*fs/2

Before reading the data if you are giving the stop bit then
the communication is stopped.so after sending the data you
will give the stop bit.

%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');

"Normally you are at liberty to give functions whatever
names you like, but ``main'' is special - your program
begins executing at the beginning of main. This means that
every program must have a main somewhere." Kernighan &
Ritchie - The C Programming Language 2ed. p.6

Fifo(First In Last Out) is a memory sturcture where datas can be stored and retrived (in the order of its entery only). This is a queue,wheras Memory is a storage device which can hold datas dynamically or at any desired locations and can be retrived in any order.