Lucrarea 2 - MC 10 decembrie 2019 (solutii propuse)

1.
Sa se realizeze din punct de vedere software blocul de comanda al unui lift cu 4 niveluri
(parter si 3 etaje) cu urmatoarele functii:

a. Inregistreaza comenzile pentru fiecare nivel (fiecare nivel are cite un

buton asociat)
b. Afiseaza aceste comenzi (pe cite un LED asociat fiecarui nivel)
c. Transmite comanda necesara de urcare, coborire sau oprire a liftului si
afiseaza modul de lucru al liftului (urcare, coborire, oprit)
d. Genereaza, la apasarea unui buton, pe o durata mai mare de 5 secunde, o
alarma care va fi semnlizata vizual
e. Resetarea alarmei se poate face la apasarea unui buton

Exista un senzor, pe 8 biti, care indica la ce etaj se afla liftul in orice moment de
timp. Nu se cer functiile necesare actionarii electromecanice a liftului (aceste
functii vor fi considerate ca fiind date).
Se cer:
- Graful procesului secvential care implementeza blocul de comanda
- Codul in limbaj C, asociat grafului
- Toate explicatile necesare pentru implementarea propusa

Graful propus:

Starile 1 si 2 realizeaza preluarea comenzii pentru nivelul 0 (parter), starile 3 si 4

realizeaza preluarea comenzii pentru nivelul 1, starile 5 si 6 realizeaza preluarea
comenzii pentru nivelul 2, iar starile 7 si 8 realizeaza preluarea comenzii pentru nivelul
3.
Comanda se inregistreaza in tabloul CDA : 1 – activ.
Butoanele pentru comenzile associate nivelurilor sint SW3, SW2, SW1 si SW0, iar
comanda e activata la apasarea si eliberarea butonului (buton apasat – 0 logic).
Starea 12 – afiseaza comenzile primite pe led-urile LED3, LED2, LED1 si LED0 (led
aprins – 0 logic).
Starea 0 este starea in care se comanda actionarea electromecanica a liftului si se
afiseaza modul de lucru (in urcare, in coborire, oprit) al liftului: daca exista comanda
activa, se citeste senzorul de etaj si se actioneaza in consecinta. Functiile UP , DOWN si
STOP realizeaza urcarea, coborirea sau oprirea liftului. In solutia propusa, aceste
functii efectueaza doar afisarile cerute (stop, urcare, coborire le LED7, LED6 si LED5).
Presupunem ca senzorul de etaj ia o valoare negativa (0xFF) intre etaje.
Starea 9 trateaza generarea alarmei, la apasarea butonului SW7. Se numara
intreruperile periodice intre apasarea lui SW7 si eliberarea lui, pentru a se determina
durata apasarii (valoarea NA = 5 sec / perioada intreruperilor periodice). Apasarea
SW6 conduce la resetarea alarmei.

Codul propus:

// se presupun date functiile portin si portout pentru citirea si

// scrierea intrarii si iesirii astfel:
// char portin(int adr); - intoarce ceea ce se citeste de la portul de
// intrare de adresa adr
// void portout(int adr, char val); - scrie valoarea val in portul de
// iesire de adresa adr

// adresele porturilor de intrare, senzor etaj si iesire

#define ADRIN 0x100

#define ADROUT 0x200
#define ADRSEN 0x300

// prototipurile functiilor utilizate

void STOP(void); // oprire lift
void UP(void); // urcare lift
void DOWN(void); // coborire lift
void afisare_CDA(void); // afisaree comenzi
void afisare_ALARMA(void); // afisare alarma
void reseteaza_ALARMA(void); // resetare alarma

char Q=0; // stare procesului secvential

char in; // intrarea (SW7...SW0)

char senet; // senzorul de etaj (0xFF intre etaje,
// 0, 1, 2 sau 3 – etajul la care s-a
// ajuns
char out; // iesirea (LED7 ... LED0)

char CDA[3]= {0,0,0,0}; // comenzile pentru etaje

char afis_CDA[3]={0xFE, 0xFD, 0xFB, 0xF7}; // afisarea comenzilor
char i =0; // index in CDA

// rutina de servire a intreruperii

void SCI(void)
{

in=portin(ADRIN); // citire intrare

senet=portin(ADRSEN); // citire senzor de etaj

switch (Q)
{
case 0:
{
// verificare daca s-a ajuns la un etaj (liftul nu se afla intre etaje)
// actionarea corespunzatoare a liftului in functie de comanda
// comenzile sint tratate la rind de la 0 la 3
if (senet>=0)
{
if (CDA[i]=1)
{
if ((i-senet) == 0) STOP();
if ((i-senet) > 0) UP();
if ((i-senet) < 0) DOWN();
CDA[i]=0;
out = (out | (~afis_CDA[i]); // CDA[i] in 1 logic
portout(ADROUT, out);
i=(i+1)%3;
}
}

// determinare comenzi noi

if ((in & 0x01) ==0 ) Q=1; // SW0

if ((in & 0x02) ==0 ) Q=3; // SW1
if ((in & 0x04) ==0 ) Q=5; // SW2
if ((in & 0x08) ==0 ) Q=7; // SW3

// determinare alarma

if ((in & 0x80) ==0 ) Q=9; // SW7

break;
}

// eliberare buton SW0

case 1:
{
if ((in & 0x01) !=0 ) Q=2;
break;
}

// inregistrare comanda 0
case 2:
{
CDA[0]=1;
Q=12;
break;
}
// eliberare buton SW1
case 3:
{
if ((in & 0x02) !=0 ) Q=4;
break;
}

// inregistrare comanda 1
case 4:
{
CDA[1]=1;
Q=12;
break;
}

// eliberare buton SW2

case 5:
{
if ((in & 0x04) !=0 ) Q=6;
break;
}

// inregistrare comanda 2
case 6:
{
CDA[2]=1;
Q=12;
break;
}

// eliberare buton SW3

case 7:
{
if ((in & 0x08) !=0 ) Q=8;
break;
}

// inregistrare comanda 3
case 8:
{
CDA[3]=1;
Q=12;
break;
}

// masurarea timp apasare buton alarma

case 9:
{
CNT_A++;
Q=10;
break;
}
// determinare eliberare buton alarma
// test durata apasare
case 10:
{
if ((in & 0x80) !=0 )
{
if (CNT_A>NA)
{
afiseaza_ALARMA();
Q=11;
}
else Q=0;
}
else Q=9;
break;
}

// test apasare SW6 si resetare alarma

case 11:
{
if ((in & 0x40) ==0 )
{
CNT_A=0;
reseteaza_ALARMA();
Q=0;
}
break;
}

// afisare CDA
case 12:
{
afiseaza_CDA();
Q=0;
break;
}

}
}

// Functile utilizate

// scrie 0 pe bitul 7 (STOP) al iesirii out

void STOP(void)
{
out = out & 0x7F;
out = out & (~0xBF); // UP stins
out = out & (~0xDF); // DOWN stins
portout(ADROUT, out);
}

// scrie 0 pe bitul 6 (UP) al iesirii out

void UP(void)
{
out = out & 0xBF;
out = out & (~0x7F); // STOP stins
out = out & (~0xDF); // DOWN stins
portout(ADROUT, out);
}

// scrie 0 pe bitul 5 (DOWN) al iesirii out

void DOWN(void)
{
out = out & 0xDF;
out = out & (~0xBF); // UP stins
out = out & (~0x7F); // STOP stins
portout(ADROUT, out);
}

// scrie in out CDA[i]

// afis_CDA - 0xFE, 0xFD, 0x FB, 0xF7 corespund bitilor 0, 1, 2 si 3
// in stare de 0 logic (aprindere led 0, 1 , 2 si 3)
void afisare_CDA(void)
{
char i, tmp;
for (i=0; i<3; i++)
{
if (CDA[i]==1) out = out & afis_CDA[i]; // led i in 0 logic
else out = (out | (~afis_CDA[i]); // led i in 1 logic
portout(ADROUT, out);
}
}

// scrie 0 pe bitul 4 (ALARMA) al iesirii out

void afisare_ALARMA(void)
{
out = out & 0xEF;
portout(ADROUT, out);
}

// scrie 1 pe bitul 4 (ALARMA) al iesirii out

void reseteaza_ALARMA(void)
{
out = (out & 0xEF) | 0x10;
portout(ADROUT, out);
}

2. Sa se scrie, in limbaj de asamblare ADSP2181, o secventa de cod care implementeaza

un generator de ecou sintetic dupa formula:

y (n)  x( n)  0.125.x( n  2400)0.0625.x( n  4000)

Daca ecoul devine sesizabil la o intirziere de peste 300ms, cit ar trebui sa fie frecventa de
esantionare?

Definirea constantelor:

// intirzierea maxima
#define N 4000

//0.125 in 1.15
#define a1 0x1000

//0.0625 in 1.15
#define a2 0x0800

// linia de intirziere circulara

.var/circ delay[N+1];

// portul de intrare si portul de iesire

.var input;
.var output;

Initializari

// linia de intirziere
i0=delay;
l0=N+1;

m0=1;
m1=1600; // 4000-2400
m2=-1600;

Secventa de prelucrare

// citeste x(n)
ay0=dm(input);

// actualizeaza linia de intirziere

dm(i0,m0)=ay0;

// I0 indica esantionul cel ai vechi x(n-4000), urmat de x(4000-1),

// x(4000-2) etc
// citeste x(n-4000)
mx0=dm(i0,m1);

// I0 va indica esantionul x(n-4000+1600) = x(n-2400)

// citeste x(n-2400)
mx1=dm(i0,m2);

// I0 va indica esantionul x(n-2400-1600)= x(n-4000)

my0=a2;
my1=a1;

// mx0 = x(n-4000), my0=a2= 0.0625 in 1.15

mr=mx0*my0 (ss);
// mr1=0.0625*x(n-4000)

// mx1 = x(n-2400), my1=a1= 0.125 in 1.15

mr=mr+mx1*my1 (ss);
// mr1=0.125*x(n-2400)+0.0625*x(n-4000)
ax0=mr1;
ar=ax0+ay0;
//ar = x(n)+0.125*x(n-2400)+0.0625*x(n-4000)

// scrie iesirea y(n)

dm(output)=ar;
x(n-N) repreezinta semnalul intirziat cu N esenatioane adica cu NTs= N/fs secunde.
(fs= 1/Ts – frecventa de esantionare).
Pentru o intirziere de minim 300 ms si N max 4000 rezulta N/fs=0.3 secunde adica
4000/fs=0.3.secunde , de unde fs= 4000/0.3 = 13.33 kHz
De exemplu pentru fs=13.3 KHz intirzierile din problema data sint 2400/13.33 kHz =
180 ms si 4000/13.33 kHz = 300 ms. Pentru frecventa uzuala de 8000 Hz aceste intirzieri
devin 2400/8000 = 300 ms si 4000/8000 = 500 ms.

3.
a) Precizati rolul predictorului de salt intr-un microprocessor cu pipe-line si evaluati
utilitatea acestui predictor daca adincimea pipe-line este 3 sau 20.
b) Explicati rolul paginarii intr-o schema de adresare cu segmente paginate. De ce nu se
utilizeaza doar segmentarea?

a) Predictorul de salt are rolul de a determina in avans daca saltul conditionat se va

efectua, astfel incit incarcarea instructiunilor in pipe-line sa se efectueze in
ordinea corecta. In cazul in care nu se cunoaste daca se va efectua sau nu saltul
conditionat structura pipe-line va astepta un numar de maxim k-1 tacte (k este
numarul de stagii sau adincimea pipe-line). Concluzia este ca pentru k mare
predictorul de salt este strict necesar. Pentru k mic timpul de asteptare este mic si
poate fi neglijat. Exemplu comparativ: pentru k=3 timpul maxim de asteptare este
2 tacte, dar pentru k=20 timpul maxim de asteptare este 19 tacte cu un ordin de
marime mai mare ca 2.
b) Segmentarea se foloseste pentru a asigura accesul protejat la memorie, iar
dimensiunea segmentului este stabilita de programe. Pentru a se evita incarcarea
intregului segment in memorie (de pe disc de exemplu), segmentul se imparte in
pagini si se incarca la nevoie doar un numar mic de pagini(doar paginile
necesare). Acest lucru este posibil datorita faptului ca programele utilizeaza, in
faza curenta de executie, doar o mica parte a memoriei in care isi stocheaza
variabilele. Avantajul este reducerea timpului necesar incarcarii de pe disc in
memorie si utilizarea mai eficienta a memoriei prin faptul ca mai multe programe
isi pot stoca pagini din segmentele proprii in memorie. Dezavantajul este
cresterea complexitatii mecanismului de segmentare paginare (trebuie citite 3
tabele (de descriptori de segment si director de pagini si de paginare) in loc de
una (de descriptori de segment), creste usor timpul de access la memorie.
Mecanismul de acces este implementat in hardware, prin urmare timpului de
acces este mic.