Unitatea 12

Conectarea unui proces la sistemul de calcul.
Functii de operare cu semnale continue

Unitatea de învăţare nr. 12
Conectarea unui proces la sistemul de calcul. Functii de operare cu semnale continue.

Cuprins
Obiectivele unităţii de învăţare nr. 12
Conectarea semnalelor cu variatie continua la sistemul de calcul.
Citirea semnalelor cu variatie continua
Citirea semnalelor cu variatie continua prin pooling în sisteme multi‐
tasking
Citirea semnalelor cu variatie continua utilizând întreruperile în sisteme
multi‐tasking
Citirea semnalelor cu variatie continua utilizând transferul prin DMA
Citirea si procesarea semnalelor cu variatie continua utilizând procesoare de semnal (DSP-
uri)
Generarea semnalelor cu variatie continua
Răspunsuri şi comentarii la întrebările din testele de autoevaluare
OBIECTIVELE unităţii de învăţare nr. 12

Principalele obiective ale Unităţii de învăţare nr. 12 sunt:

 Familiarizarea cu principalele metode de achiziție a
semnalelor analogice
 Familiarizarea cu principalele metode de generare a
semnalelor analogice
Conectarea unui proces la sistemul de calcul. Functii de operare cu semnale continue

Conectarea semnalelor cu variatie continua la sistemul de calcul.

Sistemele numerice de calcul sunt
echipamente care operează cu semnale
numerice (cu 0 și 1) și grupuri de semnale
numerice (bit, octeți, cuvinte de 16 biți etc), în
timp ce semnalele continue (semnalele cu
variație continuă) sunt semnale analogice ce
pot lua orice valoare dintr‐un interval dat.
Pentru ca un semnal analogic să poată fi citit și
interpretat de un sistem de calcul, este necesar Fig. 1
ca acest semnal să fie conectat la o interfață specializată care transformă semnalul

analogic într‐un semnal numeric (care are o anumită valoare numerică pentru un
semnal electrice de o anumită valoare). Acestă interfață, care realizează conversia
unui semnal analogic într‐un semnal numeric, se numește interfață de conversie
analog‐numerică1 (notat cu interfață ADC).
O interfață de conversie analog‐
numerică este organizată în jurul
unui convertor analog/numeric
(ADC2) –vezi Fig. 2‐. Acest convertor
este elementul care realizează
conversia propriu‐zisă a
semnalului electric în semnal
numeric. Pentru a putea trasfera
date numerice către procesor,
interfața analogic/numerică este
prevăzută cu un registru de date
(BUFF. DE DATE). În acest registru
de date este stocată valoarea
Fig. 2 obținută în urma conversiei
analog‐numerice, realizată de
convertor. Intrările registrului de date sunt conectate la ieșirile de date ale
convertorului analog/numeric, iar ieșirile registrului de date sunt ieșiri TSL3, fiind
conectate la magistrala de date a sistemului numeric. Registrul se comportă ca un
port paralel de intrare (din punctul de vedere al procesorului). Pentru operare,
interfața analog/numerică dispune de un controler pentru secvențierea unității.

1
Interfață analog‐numeric = interfață de conversie analog/digital = analog/digital interface (ADC interface)
2
ADC = analog/digital convertor = convertor analog/digital = convertor analog/numeric
3
TSL = ieșiri three state logic = ieșiri cu trei stări logice.

Acest controler de secvențiere este comandat print‐un registru de stare și control
(REG DE CONTROL). Registrul de control este conectat la magistrala de date a
procesorului și din punct de vedere al procesorului el funcționează ca un port
paralel de intrare și ieșire. Prin acest port procesorul poate programa interfață și
de asemenea procesorul va comanda momentul de pornire a conversiei semnalului
analogice. Tot prin acest port, procesorul se poate informa despre starea unității
de conversie; acesta poate verifica starea convertorului (dacă este ocupat cu
conversia, dacă a pornit o conversie sau dacă conversia curentă s‐a terminat). Cele
două registre conectate la magistrala de date a procesorului sistemului sunt
selectate printr‐o logică de selecție; logica de selecție realizează generarea
semnalelor de selecție a celor două registre și de asemeni pentru generare
folosește semnale de adresă (din magistrala de adrese a procesorului), semnale de
selecție (selecția unui port) și semnale de sens de transfer a informației (semnale
de citire și semnale de scriere).
Pentru ca un sistem numeric să genereze un semnal cu variație continuă
(vezi Fig. 1) va trebui să dispună de o interfață de
conversie numeric‐analogică. Această interfață de
conversie numeric‐analogică are în centru un
convertor numeric‐analogic (DAC4). Convertorul
numeric‐analogic are o intrare numerică (de 8 biți sau
16 biți) și o ieșire analogică (vezi Fig. 3). La aplicarea
unei valori numerice pe intrarea numerică,
convertorul numeric‐analogic va genera un semnal
electric pe ieșirea analogică. Pentru a putea conecta
convertorul numeric‐analogic la procesor, acesta se va
conecta prin intermediul unui port de ieșire la

magistrala de date a procesorului. Intrarea portului
Fig. 3 este cuplată la magistrala de date a procesorului, iar
ieșirea portului este conectată la intrarea convertorului numeric‐analogic. Pentru
selecția portului se folosește o logică combinațională conectată la magistrala de
adrese a procesorului, la semnale de selecție (pentru selecția unui port) și
semnalul de citire a informației.
Interfețele analogice de intrare și de ieșire pot coexista împreună pe aceeași
placă (vezi Fig. 4). Aceste interfețe sunt prevăzute, pe intrare cu un multiplexor de
semnal analogic pe intrare, pentru a putea conecta mai multe semnale analogice pe
un canal de conversie analog‐numerică.

4
DAC = digital‐analog converter = convertor digital‐analogic = convertor numeric‐analogic

Fig. 4
Citirea semnalelor cu variatie continua

Pentru citirea semnalelor analogice cu variație continuă este necesar ca
sistemul numeric să fie prevăzut cu o interfață de conversie analog‐numerică de
intrare pentru semnale analogice (vezi Fig. 4).
În funcționarea procesului de conversie din semnal analogic în valoare
numerică, interfața de conversie analog‐numerică necesită execuția următoarelor
faze:
 Selecția unui canal de intrare analogica (multiplexare) pentru
conversie;
 Transformarea si adaptarea semnalului analogic in semnal analogic,
convertibil de catre convertorul analog numeric (prin amplificarea
nivelului sau prin reducerea nivelului semnalului analogic);
 Eșantionarea semnalului analogic și memorarea lui într‐o memorie
analogică5;
 Pornirea procesului de conversie analog‐numerică;
 Conversia propriu‐zisă a semnalului analogic în semnal numeric;
 Oprirea automată a procesului de conversie analog‐numerică (această
oprire este controlată de către controler‐ul de pe placa de achiziții) și

5
Memoria analogică poate fi constituită dintr‐un condensator cu pierderi mici și de clasă de precizie foarte bună

salvarea valorii numerice convertite din convertor în registrul de date
al interfeței;
 Citirea valorii convertite de către procesor;
 Prelucrarea numerică primară a valorii numerice citite.
Comanda operării acestui convertor este implementată în software printr‐un
algoritm ce execută următorii pași (vezi Fig. 5):
‐ Procesorul va selecta canalul analogic din
interfață pentru care se execută conversia, prin
înscrierea valorii canalului selectat în
multiplexor
‐ Pentru procesoare foarte rapide, se așteaptă
un timp (cât se poate de scurt) pentru ca
semnalul analogic de la intrarea
multiplexorului să se stabilizeze la intrarea
convertorului (timpii sunt de ordinul
microsecundelor)
‐ Activarea comenzii de eșantionare a
semnalului, concomitent cu pornirea
procesului de achiziție
‐ Se intră în așteptare, până când convertorul
analog‐numeric termină procesul de conversie;
‐ Cand procesul de conversie s‐a terminat,
procesorul va citii datele convertite din
registrul de date al convertorului.
Fig. 5
O evoluție în timp a procesului de conversie se poate analiza prin urmărirea pas cu

pas a execuției programului6 implementat în conformitate cu schema din Fig. 5:
‐ Pasul 1: selecția canalului de
conversie
…..
outportb(MUX_ADDR, CH)

6
In schemele de evolutie sunt marcați timpul de execuție al echipamentului electronic tHW și timpul execuție al
programului pe procesor tSW

În acest pas, procesorul execută instrucțiunea outportb(…), instrucțiune care
determină înscrierea în registrul de control al multiplexării (aflat la adresa
MUX_ADDR), din interfață, a canalului de multiplexare pentru care se realizează
conversia (CH). Se observă un timp ocupat de execuția instrucțiunii outportb și un
timp scurs pentru transferul datelor de la procesor până la selecția canalului.
‐ Pasul 2: Se așteaptă un timp până
când semnalul de la intrare se
stabilizează la intrarea în
convertorul ADC.
…..
outportb(MUX_ADDR, CH);
delay_us(2);
În acest pas, procesorul execută instrucțiunea delay_us(2)7, instrucțiune care

determină trecerea a 2 microsecunde. Se observă că sistemul .realizează o
așteptare pe axa timpului alocată programului. Această întârziere este validă
pentru procesoarele foarte rapidă.
‐ Pasul 3: Este pornit sistemul de
conversie prin înscrierea în
registrul de control al
convertorului a codului necesar
începerii conversiei (ADCSTART)
…..
delay_us(2);
outportb(CTR_ADDR, ADCSTART);

În acest pas, procesorul execută instrucțiunea outportb(…), care va înscrie în

registrul de control al convertorului (aflat la adresa CTR_ADDR) cuvântul
corescpunzător ADCSTART. Acest cuvânt activează la ieșirea registrului de control
al convertorului, semnalul SOC (semnal de început de conversie8). Acest semnal
determină la nivelul unității de control a convertorului, activarea circuitului de
eșantionare și memorare a semnalului analogic, de la intrarea în convertor și tot
odată pornirea procesului de conversie. Timpul scurs pe axa programelor este dat
de execuția instrucțiunii outportb(…), după execuția instrucțiunii durează un timp,

7
Pe sistemele de operare în timp real, în loc de delay_us(…) se poate utiliza funcția wait(…)
8
SOC = Start of Convertion = începutul conversiei

timp executat de echipamentele electronice, scurs din momentul execuției
instrucțiunii la nivel de procesor, până când din registrul de control se generează
semnalul de SOC.
‐ Pasul 4: Convertorul ADC a intrat
în regim de conversie AD, iar
programul execută codul care
testează sfârșitul conversiei
…..
delay_us(2);
while( ! inportb( STATUS_ADDR) \
& ADC_READY) ;

Ne aflăm la nivelul pasului în care procesorul citește registrul de stare al interfeței
ADC (aflat la adresa STATUS_ADDR), îl testează cu masca ADC_READY (mască
corespunzătoare bit‐ului din registru atașat semnalului de sfârșit de conversie).
Timpul scurs la nivel de procesor este dat de execuția acestui grup de instrucțiuni.
În tot acest timp interfața hardware execută procesul de conversie.
‐ Pasul 5: După sfârșitul conversiei
convertorul va transfera datele
convertite în registrul de date al
interfeței
…..
delay_us(2);
& ADC_READY) ;

In același timp, procesorul este blocat cu execuția aceleași bucăți de cod, interfața
încă raspunde cu semnal de convertor ocupat cu procesul de conversie.
‐ Pasul 6: După transferul de date,
controlerul unității de conversie
va genera semnalul EOC
…..
delay_us(2);
& ADC_READY) ;


Semnalul de EOC generat de controler, va ajunge la intrarea portului de stare al
interfeței. Procesorul se află în aceeși buclă de așteptare.
‐ Pasul 7: Procesorul citește starea
de sfârșit de conversie, ceea ce
determină ieșirea din bucla de
așteptare
…..
delay_us(2);
& ADC_READY) ;

În acest moment, după citirea semnalului activ de sfârșit de conversie, procesorul
va putea să iasă din bucla de așteptare și va trece la instrucțiunea următoare. Se
observă faptul că, în tot acest interval de timp alocat conversiei, programul a
consumat timp din resursele procesorului.
‐ Pasul 8: Procesorul datele
convertite de interfața ADC pentru
canalul de intrare selectat, din
registrul de stare al interfeței
…..
delay_us(2);
& ADC_READY) ;
v2 = inportw(DATA_ADDR)

Din acest moment se consideră procesul de conversie primară terminat pentru
canalul de intrare selectat. Mărimea continuă analogică este convertită și se află
stocată în variabila de stare v2. Se observă că, pe toată durata procesului de
conversie, procesorul a fost ocupat cu urmărirea stării interfeței de conversie.

În mod normal după achiziția primară a semnalului electric, de pe intrarea
selectată, se va trece la pasul de conversie a mărimii din unități de convertor în
unități inginerești de lucru sau în unități de lucru interne. Spre exemplu prin
apelarea procedurii P1(…) marimea primită ca parametru va fi convertită în unități
de lucru inginerești.

‐ Pasul 9: In acest pas marimea
achiziționată va fi transformată în
unitate de lucru sau în unități
inginerești
…..
delay_us(2);
& ADC_READY) ;
v2 = inportw(DATA_ADDR);
s2[k][i] = P1(v2);

După apelarea procedurii de conversie –P1(v2)‐ aplicată variabilei ce conține
mărimea convertită –v2‐, rezultatul va fi depus în memorie la locația destinată
acestui semnal –s2‐. Acest calcul implică utilizarea puterii procesorului pentru
operația matematică de conversie.
Pentru a putea realiza achiziția mai multor
eșantioane (de exemplul n eșantioane)
pentru mai multe canale de intrare (de
exemplu 4 canale de intrare, adică intrările
de la 0 la 3) putem folosi algoritmul
precedent ca bază a sistemului de conversie
și să‐l includem în două bucle (vezi Fig. 7). O
buclă (internă) realizează scanarea de la 0 la
3 a canalelor de intrare, având contorul i. Iar
a doua buclă, bucla externă, realizează
indexarea eșantioanelor de semnal
achizitionat după contorul k. Dacă avem
patru semnale, vezi figura de mai jos,

Fig. 7
Fig. 6

fiecare este conectat pe câte o intrare, atunci prin algoritmul prezentat în Fig. 7, dacă
ne aflăm la eșantionul j (k=j), algortimul va determina achiziția semnalului
conectat pe intrarea CH_0 (corespunzător lui i=0), după achiziție și prelucrare
primară semnalul se va depune în locația s2[k=j][i=0], urmează după un timp
(determinat de întârzierile date de timpii de execuție ai programului din procesor)
achiziția eșantionului j pentru următorul canal, canalul i=1, conectat la intrarea
CH_1. După achiziție și prelucrare primară acesta se va depune în locația
s2[k=j][i=1]. După un alt interval de timp se va trece la achiziția eșantionului j
pentru canalul i=2, conectat la intrarea CH_2. După achiziție și prelucrare primară
valoarea preluată se va depune în locația s2[k=j][i=2]. Urmează achiziția
eșantionului j pentru semnalului de pa CH_3, cu indexul i=3. După achiziție și
prelucrare va fi salvată valoarea în locația s2[k=j][i=3]. În acest moment s‐au
achiziționat și prelucrat câte un eșantion (cu indexul j) pentru fiecare canal de
semnal. Algoritmul se va relua pentru următorul eșantion j+1, realizând conversia
și prelucrarea primară pentru fiecare canal.
‐ Acest algorimt se prezintă
evolutiv ca în figura de alături
…..
for(k=0; k<n; ++k) {
for(i=0; i<4; ++i) {
outportb(MUX_ADDR, i);
delay_us(2);
outportb(CTR_ADDR, \
ADCSTART);
while( ! inportb( STATUS_ADDR)\
& ADC_READY) ;
s2[k][i] = P1(v2);
};
};
….

Acest proces se realizează pentru “n” eșantioane de semnal, pentru fiecare semnal
analogic de intrare. Este de remarcat, faptul că, pe perioada achiziției și prelucrării
primare aplicația necesită încărcarea totală a procesorului.

‐ După achiziția tuturor valorilor
se poate trece la analiza și
prelucrarea semnalelor
achzitionate pe baza algoritmilor
implementați.
…..
for(k=0; k<n; ++k) {
for(i=0; i<4; ++i) {
delay_us(2);
ADCSTART);

while( ! inportb( STATUS_ADDR) & ADC_READY) ;
s2[k][i] = P1(v2);
};
};
P2(s2);
….
Procesul P2 este consumator de resurse de procesor, pentru calcule matematice,
logice și pentru algoritmi de reglaj.
Acest sistem poate consta ca sistem de bază pentru un echipament de
achiziții care funcționează tot timpul. Astfel algoritmul prezentat poate fi pus intr‐o
buclă infinită.
while(1) {
for(k=0; k<n; ++k) {
for(i=0; i<4; ++i) {
delay_us(2);
ADCSTART);
while( ! inportb( STATUS_ADDR \
) & ADC_READY) ;
s2[k][i] = P1(v2);
};
};
P2(s2);
};
Algoritmul prezentat se numește mecanism de achiziție în pooling (în continuu).
Acest algoritm se remarcă prin simplitate, se preferă a fi utilizat la procese lent

evolutive în timp, și care nu necesită
convertoare de viteză mare. De asemeni,
are un mare dezavantaj, acela că sunt
introduși timpi morți, prin așteptarea
semnalului de sfârșit de conversie (EOC)
–semnal generat de convertorul ADC‐.
Se remarcă o încărcare nejudicioasă a
procesorului, dată de execuția
instrucțiunilor:
while( ! inportb( STATUS_ADDR ) & ADC_READY) ;
pentru așteptarea semnalului de EOC.
Un alt dezavantaj al acestui algoritm îl constituie posibilitatea de ca sisitemul sse
blocheze în bucla de așteptare a semnalului de sfârșit de conversie, în cazul în care
apare o problemă cu placa de interfață. Astfel se poate bloca tot sistemul de
achiziție și control.
Această metodă de achiziție în pooling, se recomandă a fi folosită la semnale lent
variabile în timp, în cadrul sistemelor ieftine de comandă și control și în sisteme cu
microcontrollere. Ea este utilizată în sisteme mono‐task‐ing9.
O îmbunătățire a sistemului s‐ar putea realiza prin utilizarea unui sistem de
operare multitasking (cu cel puțin două task‐uri active), un task va realiza funcția
de achizție, iar cel de‐al doilea task va realiza operațiile matematice și logice, de
calcul, procesare și comandă (realizată de funcțiile P1(v2) și P2 (s2)). Cele două
task‐uri functionând în paralel și realizând o încărcare uniformă a procesorului
sistemului.
Citirea semnalelor cu variatie continua prin pooling în sisteme multi-tasking

Mecanismul de achiziție în pooling poate fi folosit în sisteme multitasking.
Putem paraleliza procesul de achiziție cu procesul de calcul și control al sistemului
numeric. Astfel putem realiza trei task‐uri care vor încărca procesorul în mod egal,
fiecare având timpi de execuție egali în sistemul de operare. Se câștiga ceva din
timpul în care procesorul este folosit nejudicios pe perioada cât sistemul realizează
așteptările sfârșitului de achiziție, pe perioada conversiei. În acel timp procesorul
va putea executa calcule matematice. Având trei task‐uri, unul (task‐ul T1)
executând achiziția pentru mărimile în curs, iar cel de‐al doilea task (task‐ul T2)
execută calculelele cu privire la prelucrarea primară și cel de‐al treilea task (task‐
ul T3) care execută procedurile de control și comandă. Cele trei task‐uri T1, T2 și

9
Sisteme mono‐tasking sunt sistemele cu un singur task

T3 vor împărți timpul de execuție la procesor în mod egal. Astfel pe perioada cât
sistemul de calcul va aștepta sfârșitul conversiei 60% din timp va fi câștigat pentru
partea de calculele din procesele T2 și T3 (vezi Fig. 8).

Fig. 8
Cele trei task‐uri vor fi implementate după algoritmii din Fig. 9

Fig. 9
Task‐ul T1 va executa o buclă infinită, în care există două cicluri for. Primul
ciclu este un ciclu for care iterează indexul eșantionului convertit ( ),
cel de‐al doilea ciclul iterează indexul canalului de convertor ADC convertit

( 0, 3). Interiorul ciclurilor cuprinde procesul de achiziție (vezi Fig. 9). După
realizarea procesului de achiziție se așteaptă ca task‐ul T2 să fie disponibil pentru
preluarea unei noi date pentru procesare (waitmessage(T2)); dacă s‐a primit mesaj
de la task‐ul T2, atunci task‐ul T1 poate continua și preia datele din convertor, le
salvează în memorie (la variabila v2) și de asemeni salvează indexul eșantionului și
al canalului în două variabile de memorie comune cu task‐ul T2 (variabila k1 și
respectiv i1). După realizarea transferului de date se transmite un mesaj către
task‐ul T2, pentru inițializarea procesului de calcul primar (sendmessage(T2)) și se
continuă cu preluarea următorului eșantion.
// Task T1
//
// n = numarul de esantioane
#define n 1000
global unsigned int i1; // indexul canalului de conversie pentru calcule
global unsigned int k1; // indexul eșantionului pentru calcule
global unsigned int v2; // valoarea curenta convertita
global unsigned int s2[n][4]; // array‐ul în care sunt stocate datele convertite

void main_t1( void)
{
unsigned int i; // indexul canalului de conversie pentru achizie
unsigned int k; // indexul eșantionului pentru achizitie
while(1) {
for(k=0; k<n; ++k) {
for(i=0; i<4; ++i) {
delay_us(2);
while( ! inportb( STATUS_ADDR) & ADC_READY) ;
waitmessage( T2);
i1 = i; k1 = k;
sendmessage( T2);
};
};
};

Task‐ul T2 la inițializare va transmite un mesaj către task‐ul T1
(sendmessage(T1)) pentru a debloca task‐ul T1 la achiziția primului eșantion. În
continuare rulării lui, task‐ul T2 execută o buclă infinită. În corpul buclei acestui
task, se va aștepta în primul rând un mesaj de la task‐ul T1 (waitmessage(T1)),
mesaj ce indică faptul că un eșantion a fost achiziționat de către procesor de la

convertorul ADC, după deblocarea task‐ului T2, se intră în procedura de calcul
primar pentru valoarea achiziționată. După execuția funcției de calcul (funcția
P1(v2)) se va stoca valoarea obținută într‐o arie de valori (s2[k][i]). Urmează
transmiterea unui mesaj către T1 (sendmessage(T1)), prin care se anunță faptul că
task‐ul T2 este gata să proceseze un nou eșantion. Înaintea închiderii corpului
buclei task‐ului T2, se va face o validare, dacă s‐au procesat toate eșantioanele și
matricea de valori de ieșire s‐a umplut, se va transmite un mesaj către task‐ul T3
(sendmessage( T3)), task care procesează datele de intrare și controlează procesul,
mesaj ce indică achiziția unui număr “n” de eșantioane.

// Task T2
//
#define n 1000
external unsigned int i1; // indexul canalului de conversie pentru calcule
external unsigned int k1; // indexul eșantionului pentru calcule
external unsigned int v2; // valoarea curenta convertita
external unsigned int s2[n][4]; // array‐ul în care sunt stocate datele convertite

void main_t2( void)
{
// trimit un mesaj către T1, pentru a debloca primul waitmessage(T2)
// din task‐ul T1
sendmessage( T1);
while(1) {
// astept ca prima conversie pe T1 să se termine
waitmessage( T1);
s2[k1][i1] = P1( v2);
// am terminat calculul, anunț T1 că datele achiziției curente se pot
// transfera în memoria de date și poate începe o nouă achiziție
sendmessage( T1);
if(( i1 ==3) && (k1==n)) {
// dacă s‐au terminat de calculat toate eșantionale
// se poate activa un nou proces de comandă și control
sendmessage( T3);
}
}
}

Task‐ul T3 este task‐ul care se ocupa cu algoritmii de control și comandă.
Acest task are o buclă principală. În corpul acestei bucle se așteaptă un mesaj ce
indică faptul că s‐au preluat datele pentru control și au fost procesate primar
(waitmessage(T2)); după debloare (la primirea mesajului de la task‐ul T2), se

activează funcția de procesare a algortimului de control și comandă (funcția
P2(s2)).
// Task T3
//
#define n 1000

void main_t3( void)
{
while(1) {
// aștept mesaj de la T2, cu privire la primirea unui pachet de date
waitmessage( T2);
P2(s2);
}
}

Evoluția în timp a unui sistem de achiziție în pooling într‐un sistem de operare
multi‐tasking este prezentată mai jos:
‐ Pasul 1: inițializare celor două
cicluri
…..
for(k=0; k<n; ++k) {
for( i=0; i<3; ++i) {
În aces pas se inițializează cele două cicluri, unul pentru indexarea eșantionului
(k=0,n) și cel de‐al doilea pentru indexarea canalului de convertor (i=0,3).
Observăm un timp ocupat de execuția instrucțiunilor for.
conversie, în funcție de indexul
canalului (i)
…..
for(k=0; k<n; ++k) {
for( i=0; i<3; ++i) {

transferă înscrierea în registrul de control al multiplexării (aflat la adresa
conversia (i). Se observă un timp ocupat de execuția instrucțiunii outportb și un
stabilizează la intrarea în convertorul
ADC.
…..
for(k=0; k<n; ++k) {
for( i=0; i<3; ++i) {
delay_us(2);
În acest pas, procesorul execută instrucțiunea delay_us(2), instrucțiune care

determină întârzierea programului cu 2 microsecunde. Se observă că sistemul
realizează o așteptare pe axa timpului alocată programului. Această întârziere este
utilă pentru procesoarele foarte rapide. În acest timp se pot executa funcții ale
task‐urilor T2 și T3, task‐ul T1 fiind în stare de suspendat până ce trece timpul de
așteptare.
conversie prin înscrierea în registrul de
control al convertorului a codului
necesar începerii conversiei
(ADCSTART)
…..
for(k=0; k<n; ++k) {
for( i=0; i<3; ++i) {
delay_us(2);

corespunzător ADCSTART. Acest cuvânt activează la ieșirea registrului de control

10

semnalul de SOC.
‐ Pasul 5: Convertorul ADC a intrat în
regim de conversie AD, iar programul
execută codul care testează sfârșitul
conversiei
…..
for(k=0; k<n; ++k) {
for( i=0; i<3; ++i) {
delay_us(2);
& ADC_READY) ;

Ne aflăm la nivelul pasului în care procesorul citește registrul de stare al interfeței
ADC (aflat la adresa STATUS_ADDR), îl testează cu masca ADC_READY (mască
corespunzătoare bit‐ului din registru atașat semnalului de sfârșit de conversie).
Timpul scurs la nivel de procesor este dat de execuția acestui grup de instrucțiuni.
În tot acest timp interfața hardware execută procesul de conversie. Procesorul va
executa în comun cu task‐ul T1 în paralel task‐urile T2 și T3.
‐ Pasul 6: După sfârșitul conversiei
convertorul va transfera datele
convertite în registrul de date al
interfeței
…..
for(k=0; k<n; ++k) {
for( i=0; i<3; ++i) {
delay_us(2);
& ADC_READY) ;
In același timp, procesorul este blocat cu execuția aceleași bucăți de cod, interfața
încă raspunde cu semnal de convertor ocupat cu procesul de conversie.

‐ Pasul 7: După transferul de date,
controlerul unității de conversie va
genera semnalul EOC
…..
for(k=0; k<n; ++k) {
for( i=0; i<3; ++i) {
delay_us(2);
& ADC_READY) ;
Semnalul de EOC generat de controler, va ajunge la intrarea portului de stare al
interfeței. Procesorul se află în aceeși buclă de așteptare.
‐ Pasul 8: Procesorul citește starea de
sfârșit de conversie, ceea ce
determină ieșirea din bucla de
așteptare
…..
for(k=0; k<n; ++k) {
for( i=0; i<3; ++i) {
delay_us(2);
& ADC_READY) ;
În acest moment, după citirea semnalului activ de sfârșit de conversie, procesorul
va putea să iasă din bucla de așteptare și va trece la instrucțiunea următoare. Se
observă faptul că, în tot acest interval de timp alocat conversiei, programul a
consumat timp din resursele procesorului, dar acest timp a fost partajat cu
celelalte task‐uri din sistem, task‐urile T2 și T3.
‐ Pasul 9: Procesorul așteaptă o
semnalizare de la task‐ul T2, dacă
aceasta a terminat de procesat
datele de la pasul anterior.
…..
for(k=0; k<n; ++k) {
for( i=0; i<3; ++i) {
delay_us(2);
& ADC_READY) ;
waitmessage( T2);

Procesorul va testa (prin instrucțiunea sistemului de operare waitmessage( T2) )
dacă task‐ul T2 a terminat de calculat valoarea primară pentru eșantionul
precedent achiziționat; în cazul în care task‐ul T2 nu a terminat calculele, task‐ul
T1 se va suspenda până când T2 termină calculul propus. Dacă T2 a terminat
calculele, atunci, procesul T1 se continuă.
‐ Pasul 10: Procesorul preia datele
convertite de interfața ADC pentru
canalul de intrare selectat, din
registrul de stare al interfeței, și le
salvează pentru procesare, de
asemenea salvează și indexul
eșantionului și indexul canalului.
…..
for(k=0; k<n; ++k) {
for( i=0; i<3; ++i) {

delay_us(2);
& ADC_READY) ;
waitmessage( T2);
i1=i; k1=k;

Din acest moment se consideră procesul de conversie primară terminat pentru
canalul de intrare selectat. Mărimea continuă analogică este convertită și se
stochează în variabila de stare v2; de asemenea se salvează în i1 indexul canalului
de date salvat și se salvează și indexul eșantionului pentru care s‐a realizat
conversia. Se observă că, pe toată durata procesului de conversie procesorul a fost
ocupat cu urmărirea stării interfeței de conversie și în paralel cu execuția celorlalte
două task‐uri.
‐ Pasul 11: Procesorul transmite un
mesaj către task‐ul T2 și îl
informează că o achiziție s‐a
terminat iar datele sunt disponibile
pentru procesare
…..
for(k=0; k<n; ++k) {
for( i=0; i<3; ++i) {
delay_us(2);

& ADC_READY) ;
waitmessage( T2);
i1=i; k1=k;
sendmessage( T2);
Task‐ul T1 a terminat de realizat conversia și transmite un mesaj, către task‐ul T2,
mesaj prin care‐l informează ca un proces de conversie s‐a terminat, iar task‐ul T2
poate începe calculul primar.
‐ Pasul 12: Task‐ul T1, în execuția sa,
a încheiat conversia pentru acest
eșantion și va trece la următoarea
conversie.
…..
for(k=0; k<n; ++k) {
for( i=0; i<3; ++i) {
delay_us(2);

& ADC_READY) ;
waitmessage( T2);
i1=i; k1=k;
sendmessage( T2);
}
}
Task‐ul T1 a terminat cu actualul eșantion pentru un canal și trece la următorul
eșantion de date. Între timp s‐a activat task‐ul T2, care începe procesare. Task‐ul
T3 continuă în paralel cu T1 și T2, dacă are calcule de realizat.


În paralel cu task‐ul T1 se execută și task‐ul T2, care task realizează calculele
primare pentru fiecare eșantion de semnal achiziționat în parte. Task‐ul este
paralelizat cu task‐ul T1, astfel încât dacă task‐ul T1 achizionează eșantionul j,
pentru un canal c (c=1, 3), atunci T2 va executa calculele primare pentru
eșantionul j, pentru canalul c‐1; dacă task‐ul T1 achizionează eșantionul j, pentru
un canal 0, atunci T2 va executa calculele primare pentru eșantionul j‐1, pentru
canalul 3. Fazele execuției pentru task‐ul T2 sunt:
‐ Pasul 1: Task‐ul T2 așteaptă un
mesaj de la task‐ul T1, prin care este
anunțat că un eșantion a fost

achiziționat și transferat în memoria
de date (v2)
…..
waitmessage( T1);
Task‐ul T1 își execută algoritmul descris mai sus. La terminarea unei achiziții task‐
ul T1 va emite un mesaj către task‐ul T2. Când task‐ul T2 primește mesajul, acesta
este avertizat că task‐ul T1 a terminat o achiziție și poate începe calculele primare
pentru eșantionul achiziționat)
‐ Pasul 2: Task‐ul T2 realizează
calculele primare pentru eșantionul
achiziționat, după care salvează

rezultatul în memorie
…..
waitmessage( T1);
s2[i1][k1] = P1( v2);
Task‐ul T2 realizează calculul mărimii primare pentru eșantionul din v2, apelând
procedura P1(v2) și salvează valoarea în memorie în locația din matricea
s2[i1][k1], în paralel task‐ul T1 își continuă activitatea, iar task‐ul T3 rulează în
paralel cu T2 sau este în așteptare până când un nou pachet de date este pregătit
pentru prelucrare.
‐ Pasul 3: Task‐ul T2 transmite un
mesaj către task‐ul T1 pentru a‐l
anunța că, s‐a terminat prelucrarea

și stocarea rezultatului în memorie
pentru eșantionul prelucrat.
…..
waitmessage( T1);
s2[i1][k1] = P1( v2);
sendmessage( T1);
Task‐ul T2 anunță task‐ul T1 asupra faptului că s‐a realizat calculele primare
pentru ultimul eșantion convertit.

‐ Pasul 4: Dacă task‐ul T2 a ajuns la
ultimul eșantion, atunci task‐ul T2
va transmite un mesaj către task‐ul

T3, pe care‐l anunță că, s‐au
terminat calculele pentru toate
eșantionale.
…..
waitmessage( T1);
s2[i1][k1] = P1( v2);
sendmessage( T1);
if( i1==3 && k1==n)
sendmessage( T3);
La acest nivel, dacă s‐au procesat toate eșntioanele pentru toate canalele, va trebui
să pornim task‐ul de comandă și control. După transmiterea mesajului, task‐ul T3
se va debloca.
Task‐ul T2, va trece în așteptare până la venirea unei noi semnalizări de la task‐ul
T1.
Task‐ul T3 se execută în paralel cu taskurile T1 și T2. Execuția acestui task
determină controlul procesului. Fazele execuției task‐ului T3 sunt:
anunțat că un bloc de date a fost

achiziționat și prelucrat, datele se
regăsesc în matricea (s2)
…..
waitmessage( T2);
La primirea unui mesaj de la task‐ul T2, task‐ul T3 se va activa. Celelalte task‐uri
din sistem se vor executa în paralel.
‐ Pasul 2: Task‐ul T3 calculeaza(s2)
…..
waitmessage( T2);

P2(s2);
Acest task execută funcția P2 de execuție și control a procesului.
‐ Pasul 3: Task‐ul T3 trece în mod de
suspendare pentru a aștepta un nou
mesaj de la task‐ul T2.

…..
waitmessage( T2);
P2( s2);



Sistemul de control al procesului în pooling, utilizând un sistem de operare
multitask‐ing poate realiza o încărcare a procesorului asemănătoare cu cea din
figura

Fig. 10
Mecanismul prezentat este tot un mecanism de achiziție și control în pooling,

celelalte elemente de calcul și control sunt programate a încărca procesorul în mod
judicios. Cel mai mare avantaj al sistemului îl constituie simplitatea. Acest mod se
pretează la procesoare ie11Acest mecanism se pretează la procesele lent evolutive
în timp, aele nu necesită convertoare de viteză rapidă (la procedura de achiziție se
recuperează o parte din timpii de așteptaela procesor). În acest algoritm se
recuperează o parte din timpii pierduți în așteptarea convertorului AD. Programele
oferă o încărcare judicioasă a sistemului.
Dezavantajul principal îl constituie posibilitatea ca sistemul să se blocheze în
așteptarea semnalului de sfărșit de conversie.
Această metodă este utilizată în sisteme de achiziții la care variația semnalelor este
lentă, sistemele sunt ieftine. Astfel de sisteme sunt implementate pe
microcontrolere ieftine. Sistemul de operare folosește un sistem mult‐tasking.
O îmbunătățire a acestui sistem poate fi utilizat în cazul în care s‐ar putea conecta
semnalul terminare a conversiei direct la întrerupere procesorului.


Citirea semnalelor cu variatie continua utilizând întreruperile în sisteme multi-tasking

Mecanismul de achiziție în pooling în sistemele multitasking prezintă
principalul dezavantaj că ocupă timp la procesor pentru testarea semnalului de
sfârșit de conversie. Putem păstra structura organizatorică de multitasking cu un
proces de achiziție, cu un proces de calcul și un proces de control al sistemului
numeric.
Acest sistem presupune conectarea semnalului de sfârșit de conversie al
convertorului ADC la sistemul de întreruperi al calculatorului (operație realizată
prin cablarea internă a echipamentului). Astfel la generarea unui semnal de EOC

Fig. 11
de la interfața analog‐numerică, evenimentul este transmis controller‐ului de

întreruperi al sistemului numeric. Acesta la primirea unui eveniment de
întrerupere îl transmite procesorului. Procesorul își oprește activitatea curentă și
activează în sistemul de operare procedura atașată evenimentului de întreruperi
atașat. Prin aceasta sistemul de operare va activa toate task‐urile care erau
suspendate în așteptare la acest tip de eveniment. Astfel, dacă la acest eveniment
atașăm task‐ul T1, atunci task‐ul T1, în loc să monitorizeze apariția evenimentului
EOC (al convertorului ADC) va intra în așteptare la întreruperea atașata
evenimentului EOC. Prin această metodă task‐ul T1 va elibera timpul de execuție la
procesor pe perioada cât ar trebui să aștepte semnalul de sfârșit de conversie.
Cele trei task‐uri vor împărți în același mod timpul de execuție la procesor,
cu mențiunea că, task‐ul T1 va ocupa mai puțin timp de execuție la procesor.

Fig. 12
Cele trei task‐uri vor fi implementate după algoritmii din Fig. 13

Fig. 13
Tak‐ul T1, va inițializa cu o funcție prin care cere sistemului de operare,

dreptul de a atașa evenimentul de întrerupere EOC (sfârșit de conversie) la acest
task. După execuția inițializării task‐ul executa o buclă infinită, în care există două
cicluri for. Primul ciclu este un ciclu “for” este cel care iterează indexul
eșantionului convertit ( ), cel de‐al doilea ciclul iterează indexul
canalului de convertor ADC convertit ( ). Interiorul ciclurilor cuprinde
procesul de achiziție (vezi Fig. 13). După realizarea procesului de achiziție task‐ul T1
preia datele din convertor, le salvează în memorie (în variabila v2) și de asemeni
salvează indexul eșantionului și al canalului în două variabile de memorie comune
cu task‐ul T2 (variabila k1 și respectiv i1). După realizarea transferului de date se
transmite un mesaj către task‐ul T2, pentru inițializarea procesului de calcul
primar (sendmessage(T2)) și se continuă cu preluarea următorului eșantion.

// Task T1
//
#define n 1000
global unsigned int i1; // indexul canalului de conversie pentru calcule
global unsigned int k1; // indexul eșantionului pentru calcule
global unsigned int v2; // valoarea curenta convertita
global unsigned int s2[n][4]; // array‐ul în care sunt stocate datele convertite

void main_t1( void)
{
unsigned int i; // indexul canalului de conversie pentru achizie
unsigned int k; // indexul eșantionului pentru achizitie
attachinterrupt(EOC_INT, &main_t1);
while(1) {
for(k=0; k<n; ++k) {
for(i=0; i<4; ++i) {
delay_us(2);
waitinterrupt( EOC_INT);
i1 = i; k1 = k;
sendmessage( T2);
};
};
};

Task‐ul T2 execută o buclă infinită. În corpul buclei acestui task, se va aștepta
în primul rând un mesaj de la task‐ul T1 (waitmessage(T1)), mesaj ce indică faptul
că un eșantion a fost achiziționat de către procesor de la convertorul ADC, după
deblocarea task‐ului T2, se intră în procedura de calcul primar pentru valoarea
achiziționată. După execuția funcției de calcul (funcția P1(v2)) se va stoca valoarea
obținută într‐o arie de valori (s2[k][i]). Datorită faptului că în perioada achiziției
task‐ul T1 este suspendat, timpul acces la procesor al task‐ului T2 crește de la 30%
la 50% (task‐ul T2 va împărții timpul de procesor numai cu task‐ul T3), timpul va fi
suficient pentru prelucrarea primară a semnalului, nemiafiind necesară anunțarea
task‐ului T1 despre terminarea procesului de calcul. Înaintea închiderii corpului
buclei task‐ului T2, se va face o validare, dacă s‐au procesat toate eșantioanele și
matricea de valori de ieșire s‐a umplut, se va transmite un mesaj către task‐ul T3
(sendmessage( T3)), task care procesează datele de intrare și controlează procesul,
mesaj ce indică achiziția unui număr “n” de eșantioane.

// Task T2
//
#define n 1000
external unsigned int i1; // indexul canalului de conversie pentru calcule
external unsigned int k1; // indexul eșantionului pentru calcule
external unsigned int v2; // valoarea curenta convertita

void main_t2( void)
{
while(1) {
// astept ca prima conversie pe T1 să se termine
waitmessage( T1);
s2[k1][i1] = P1( v2);
if(( i1 ==3) && (k1==n)) {
// dacă s‐au terminat de calculat toate eșantionale
// se poate activa un nou proces de comandă și control
sendmessage( T3);
}
}
}

Task‐ul T3 este task‐ul care se ocupa cu algoritmii de control și comandă.
Acest task are o buclă principală. În corpul acestei bucle se așteaptă un mesaj ce
indică faptul că s‐au preluat datele pentru control și au fost procesate primar
(waitmessage(T2)); după debloare (la primirea mesajului de la task‐ul T2), se
activează funcția de procesare a algortimului de control și comandă (funcția
P2(s2)).
// Task T3
//
#define n 1000
void main_t3( void)
{
while(1) {
// aștept mesaj de la T2, cu privire la primirea unui pachet de date
waitmessage( T2);
P2(s2);
}
}


Evoluția în timp a unui sistem de achiziție în pooling într‐un sistem de operare
multi‐tasking este prezentată mai jos:
‐ Pasul 1: inițializare
…..
attachinterrupt( EOC_INT, T1);
….
În aces pas se inițializează task‐ul T1, prin execuția funcției de atașare a funcției
atașate task‐ului T1 (main_t1) la întreruperea EOC_INT din sistemul de operare.
‐ Pasul 2: inițializare celor două
cicluri
…..
…..
for(k=0; k<n; ++k) {
for( i=0; i<3; ++i) {
În aces pas se inițializează cele două cicluri, unul pentru indexarea eșantionului
(k=0, n) și cel de‐al doilea pentru indexarea canalului de convertor (i=0,3).
Observăm un timp ocupat de execuția instrucțiunilor for.
conversie, în funcție de indexul
canalului (i)
…..
…..
for(k=0; k<n; ++k) {
for( i=0; i<3; ++i) {

transferă înscrierea în registrul de control al multiplexării (aflat la adresa
conversia (i). Se observă un timp ocupat de execuția instrucțiunii outportb și un

stabilizează la intrarea în convertorul
ADC.
…..
…..
for(k=0; k<n; ++k) {
for( i=0; i<3; ++i) {
delay_us(2);
În acest pas, procesorul execută instrucțiunea delay_us(2), instrucțiune care
determină întârzierea programului cu 2 microsecunde. Se observă că sistemul
realizează o așteptare pe axa timpului alocată programului. Această întârziere este
utilă pentru procesoarele foarte rapide. În acest timp se pot executa funcții ale
task‐urilor T2 și T3, task‐ul T1 fiind în stare de suspendat până ce trece timpul de
așteptare.
conversie prin înscrierea în registrul de
control al convertorului a codului
necesar începerii conversiei
(ADCSTART)
…..
…..
for(k=0; k<n; ++k) {
for( i=0; i<3; ++i) {
delay_us(2);

corespunzător ADCSTART. Acest cuvânt activează la ieșirea registrului de control

12

semnalul de SOC.
‐ Pasul 6: Convertorul ADC a intrat în regim
de conversie AD, intră în stare de
suspendare până la apariția semnalului
de EOC
…..
…..
for(k=0; k<n; ++k) {
for( i=0; i<3; ++i) {
delay_us(2);
waitinterrupt(EOC_INT);

Ne aflăm la nivelul pasului în care task‐ul T1 își suspendă activitatea până când
apare evenimentul EOC_IN. Procesorul între timp va executa în comun cu task‐urile
T2 și T3.
‐ Pasul 7: Convertorul ADC a terminat
conversia AD, transferă datele în registrul
de date și emite un semnal EOC
…..
…..
for(k=0; k<n; ++k) {
for( i=0; i<3; ++i) {
delay_us(2);

În acest pas task‐ul T1 este încă în regim de suspendare până apare semnalizarea
de EOC_INT. Sistemul execută task‐urile T2 și T3, este posibil ca până în acest
moment task‐ul T2 să fi terminat calculele.

‐ Pasul 8: Semnalul EOC este generat de
interfața ADC către controllerul de
întreruperi, iar acesta (prin intermediul
procesorului) generează în sistemul de
operare semnalul EOC_INT.
…..
…..
for(k=0; k<n; ++k) {
for( i=0; i<3; ++i) {
delay_us(2);

Evenimentul EOC_INT ajunge la nivelul sistemului de operar, unde va fi gestionat
de către software.
‐ Pasul 9: Task‐ul T1 se deblochează și
intră‐n starea de execuție.
…..
…..
for(k=0; k<n; ++k) {
for( i=0; i<3; ++i) {
delay_us(2);

Task‐ul T1 se va debloca și intră în paralel în execuție cu task‐ul T3.
‐ Pasul 10: Se preiau datele din convertor
și sunt salvate în memorie.
…..
…..
for(k=0; k<n; ++k) {
for( i=0; i<3; ++i) {
delay_us(2);
v2 = inportw(ADC_DATA);
i1= i; k1=k;

Task‐ul T1 preia datele din convertor și le salvează în locația v2, de asemeni va
salva indexul canalului pentru care s‐au preluat datele în locația i1, iar în locatia k1
va salva indexul eșantionului preluat.
‐ Pasul 11: Se transmite o semnalizare
către task‐ul T2, prin care anunță
terminarea procesului de conversie.
…..
…..
for(k=0; k<n; ++k) {
for( i=0; i<3; ++i) {
delay_us(2);
i1= i; k1=k;
sendmessage( T2);
În acest punct task‐ul T1 a terminat achiziția și preluarea de date din convertorul
ADC și transmite un mesaj către task‐ul T2, deblocând acest task din starea de
așteptare.
‐ Pasul 12: Procesul task‐ului T1 se reia
pentru următorul eșantion
…..
…..
for(k=0; k<n; ++k) {
for( i=0; i<3; ++i) {
delay_us(2);
i1= i; k1=k;
sendmessage( T2);
}
}
Task‐ul T1 reia procesul de la început pentru următorul eșation. Pentru task‐urile
T2 și T3 execuția continuă.
În paralel cu task‐ul T1 se execută și task‐ul T2, care task realizează calculele
primare pentru fiecare eșantion de semnal achiziționat în parte. Task‐ul este
paralelizat cu task‐ul T1, astfel încât dacă task‐ul T1 achizionează eșantionul j,

pentru un canal c (c=1, 3), atunci T2 va executa calculele primare pentru
eșantionul j, pentru canalul c‐1; dacă task‐ul T1 achizionează eșantionul j, pentru
un canal 0, atunci T2 va executa calculele primare pentru eșantionul j‐1, pentru
canalul 3. Fazele execuției pentru task‐ul T2 sunt:
anunțat că un eșantion a fost

achiziționat și transferat în memoria
de date (v2)
…..
waitmessage( T1);
Task‐ul T1 își execută algoritmul descris mai sus. La terminarea unei achiziții task‐
ul T1 va emite un mesaj către task‐ul T2. Când task‐ul T2 primește mesajul, acesta
este avertizat că task‐ul T1 a terminat o achiziție și poate începe calculele primare
pentru eșantionul achiziționat)
‐ Pasul 2: Task‐ul T2 realizează
calculele primare pentru eșantionul
achiziționat, după care salvează

rezultatul în memorie
…..
waitmessage( T1);
s2[i1][k1] = P1( v2);
Task‐ul T2 realizează calculul mărimii primare pentru eșantionul din v2, apelând
procedura P1(v2) și salvează valoarea în memorie în locația din matricea
s2[i1][k1], în paralel task‐ul T1 își continuă activitatea, iar task‐ul T3 rulează în
paralel cu T2 sau este în așteptare până când un nou pachet de date este pregătit
pentru prelucrare.
‐ Pasul 3: Dacă task‐ul T2 a ajuns la
ultimul eșantion, atunci task‐ul T2
va transmite un mesaj către task‐ul

T3, pe care‐l anunță că, s‐au
terminat calculele pentru toate
eșantionale.
…..
waitmessage( T1);
s2[i1][k1] = P1( v2);
sendmessage( T1);
if( i1==3 && k1==n)
sendmessage( T3);

La acest nivel, dacă s‐au procesat toate eșantioanele pentru toate canalele, va
trebui să pornim task‐ul de comandă și control. După transmiterea mesajului, task‐
ul T3 se va debloca.
Task‐ul T2, va trece în așteptare până la venirea unei noi semnalizări de la task‐ul
T1.
Task‐ul T3 se execută în paralel cu taskurile T1 și T2. Execuția acestui task
determină controlul procesului. Fazele execuției task‐ului T3 sunt:
anunțat că un bloc de date a fost

achizționat și prelucrat, datele se
regăsesc în matricea (s2)
…..
waitmessage( T2);
La primirea unui mesaj de la task‐ul T2, task‐ul T3 se va activa. Celelalte task‐uri
din sistem se vor executa în paralel.
‐ Pasul 2: Task‐ul T3 trece la execuția
funcției de procesare și control
…..
waitmessage( T2);
P2( s2);
Acest task execută funcția P2 de execuție și control a procesului, în timp ce
celelalte task‐uri îsi continua starea lor de execuție.
‐ Pasul 3: Task‐ul T3 a terminat de
executat funcția P2 și revine la pasul
de așteptare a unui nou bloc de date
…..
waitmessage( T2);
P2( s2);
Acest task execută funcția P2 de execuție și control a procesului, în timp ce
celelalte task‐uri îsi continua starea lor de execuție.
Sistemul de control al procesului utilizând
întreruperile, pe un sistem de operare multitask‐ing
poate realiza o încărcare a procesorului asemănătoare
cu cea din figura Fig. 14

Fig. 14


Observăm că avantajul unui sistem de achiziție pe întreruperi constă în
faptul că, acest mod de programare aduce o folosire mai judicioasă a resurselor
procesorului.
Acest sistem de achiziție se pretează a fi folosit în procesele lent și mediu
evolutive în timp (timpii de răspuns sunt de la 1 sau câteva secunde, până la
intervale de ore sau zile). Prin acest mod de realizare a achiziției s‐au recuperat
timpii de așteptare la convertorul ADC și de asemeni se obține o încărcare mai
judicioasă a resurselor procesorului. În acest caz, modulele software ale task‐urilor
nu se mai blochează la așteptarea unui semnal de la un modul electronic (semnalul
de sfârșit de conversie). Principalul dezvantaj al acestui sistem, rămâne, faptul că
task‐ul de achiziție pierde timp cu gestionarea sistemului de achiziție.
Sistemul de achiziții utilizând întreruperile se recomandă în sistemele cu
costuri reduse, care utilizează microcontrolere și care utilizează multitasking‐ul cu
număr redus de task‐uri.
Acest sistem poate fi îmbunătățit prin utilizarea unui sistem mai complex,
care implică utilizarea unui echipament de transfer direc a informației din port în
memorie, anunțarea procesorului în momentul în care datele au fost preluate,
astfel toate funcțiile task‐ului de achiziție sunt preluata de hardware.


Citirea semnalelor cu variatie continua utilizând transferul prin DMA în sisteme multi-
tasking

Mecanismul de achiziție care utilizează transferul prin DMA, oferă marele
avantaj al degrevării modulului de software de sarcina controlului achiziției.
Sarcina controlului procesului de achiziție este transferat unității de control
DMAC13 (DMA14 Controller). După terminarea sarcinii, controller‐ul de DMA
(DMAC) transmite o întrerupere (DMA_INT) controller‐ului de întreruperi (CINT).
Această întrerupere va fi interceptată de software; pentru program ea are
semnificația sfârșitului achiziției pentru un bloc de date. După recepția acestei
întreruperi software‐ul poate realiza procesarea datelor, iar în paralel un nou bloc
de date poate fi programat pentru a fi preluat.
Acest sistem presupune conectarea semnalului de sfârșit de conversie al
convertorului ADC la sistemul inițializare a transferului de DMA (operație realizată
prin cablarea internă a echipamentului). Astfel la generarea unui semnal de EOC

Fig. 15
de la interfața analog‐numerică, evenimentul este transmis controller‐ului de DMA

al sistemului numeric. Acesta la primirea unui eveniment DMA penru canalul DMA
asociat canalului pentru interfața ADC va inițializa un transfer de tip IO între placa

13
DMAC = controler DMA, este un controler care realizează un control al transferului de date pe baza protocolului DMA,
între un port și o zonă de memorie sau între două zone de memorie. Transferul de date se realizează fără intervenția
microprocesorului.
14
DMA = Direct Memory Access = Un protocol de transfer automat a datelor în memoria sistemului (de la un port sau
dintr‐o altă zonă de memorie) fără interveția microprocesorului sistemului de calcul.

de interfață și memoria RAM (practic va controlerul DMA va citi din registrul de
date al interfeței valoarea convertită și o va scrie direct în memoria RAM). Numărul
de eșantionare convertit este programat în memoria controler‐ului DMA. Când se
atinge numărul de eșantioane, procesul de transfer este oprit, iar un eveniment de
întrerupere (DMA_INT) este generat către controler‐ul de întreruperi. Controler‐ul
de întreruperi va genera acest o întrerupere către microprocesor. Acesta o va
redirecta către sistemul de operare. Sistemul de operare va gestiona întreruperea
de timp DMA_INT și va activa task‐urile care sa află în așteptare la această
întrerupere.
Din punct de vedere logic, unitățile sunt
interconectate intern ca în figura Fig. 16.
Astfel controlerul plăcuii de achiziție va
genera semanalizare de început de
conversie către unitatea de conversie
(ADC) –semnalul SOC‐. La sfârșitul
conversiei, unitatea de conversie ADC va
genera un semnal de sfârșit de conversie Fig. 16
(EOC) către unitatea DMA, pentru a

anunța că semnalul electric a fost convertit iar datele sunt disponibile pentru
transfer. Unitatea de control DMA va transfera datele din convertor în memorie,
urmând ca după transfer controlerul DMA să inițializeze un nou ciclu de achizitie.
Controlerul DMA realizează un număr preprogramat de transferuri, dacă numărul
de transferuri a fost atins unitate de DMA generează un semnal de eveniment
(DMA_INT) către controlerul de întreruperi anunțând sfârșitul achiziției datelor.
Este de remarcat, faptul că această structură nu folosește intervenția procesorului
în procesul de achiziție. Pentru a putea realiza
schimbarea canalului de achiziție interfața de
conversie dispune de un controler specializat
care gestionează controlul procesului de
achiziție.
În acest context, programul de procesrare se
poate realiza monotasking. Task‐ul principal
va realiza programare interfețelor și calculul
matematic. Schema logică a task‐ului pricipal
este prezentată în Fig. 17.
In acest sistem este importantă proiectarea
datelor de comandă a achiziției. Astfel la
Fig. 17
nivelul interfeței de achiziție se vor specifica
canalul analogic de început și de sfărșit a conversiei. De asemeni, se specifică rata
de conversie (aceasta se calculează cu formula:

,
unde,
faq este frecvența de operare a plăcii de achiziție,
Nch reprezintă numărul de canale de achiziție, iar
fch este frecvența de achiziție a unui singur canal). La nivelul controlerului de
DMA se programează:
‐ numărul de date transferate (în conformitate cu formula:
_ ,
unde,
NDMA_DATA numărul de bytes transferați de controlerul DMA
Nch reprezintă numărul de canale de achiziție, iar
Nsamples este numărul de eșantioane pe un canal)
‐ adresa portului de la care se realizează transferul (de exemplu: 0x01Ac2);
‐ adresa de memorie15 la care se stochează datele
‐ dimensiunea unui cuvant de transfer (1 octet, 2 octeți sau 4 octeți).
‐ canalul de întrerupere DMA prin care se lucrează cu controler‐ul de
întreruperi.
Un factor important îl reprezintă alocarea de memorie pentru date, memoria
pentru date este alocată în zona “far heap”, adresa fizică a memoriei se va
transmite controlerului de DMA, iar adresa logică o va prelua programul pentru
operare.
Un algoritm evolutiv în timp se poate descrie:
 Programarea interfetei, a canalului DMA de transfer a datelor si a
controller‐ului de intreruperi
 Pornirea convertorului AD si a controller‐ului DMA (pentru a intializa
procesul)
 Controller‐ul plăcii de achiziție va initializa procesul de achizitie,
controland placa de achizitii
 Canalul de achizitie al placii, va fi controlat de catre un procesor aflat
pe placa de achzitii

15
Adresa memoriei la care se stochează datele se obține prin alocare din sistemul de operare. Este adresa fizică la care se
transfera datele.

 Dupa fiecare achizitie realizata, convertorul va transmite un DMA_RQ
catre DMAC
 DMAC va initia un transfer de date din convertor in memorie
 Dupa realizarea transferului DMAC va genera un semnal DMA_ACK
catre placa de achizitii
 Dupa un numar de transferuri/dupa ce memoria a fost umpluta, se va
genera un semnal de intrerupere catre controller‐ul de intreruperi
CINT
 CINT va genera o intrerupere, catre procesor. Anuntand sfarsitul
transferului de date
 Procesorul va activa task‐ul de procesare a datelor
 Acest task este responsabil cu:
 preluarea datelor din memorie,
 Restartarea procesului de achizitie
 Incerperea prelucrarii datelor
// Task T1
//
#define n 1000

void main_t1( void)
{
….
init_adc( …);
init_dma(…);
init_cint();
attachinterrupt( DMA_INT, T1) ;
while( 1) {
waitinterrupt( DMA_INT) ;
P3(s2);
}
}
Acest mecanism prezentat este denumit mecanism de achiziție prin DMA.
Avantajul principal al acestui mecanism este acela că se poate adapta la orice tip de
proces (atât la cele rapide, cât și la cele medii sau lente). Acest mecanism oferă o

încărcare judicioasă a sistemului de calcul; acesta fiind responsabil numai cu
partea de calcule. Dezavantajul este costul mai ridicat față de celelalte sisteme16.
Această metodă se recomandă în sisteme multitasking, cu încărcare mare a
volumului de calcule și în sisteme care procesează semnale cu variație rapidă în
timp.

Citirea si procesarea semnalelor cu variatie continua utilizând procesoare de semnal

(DSP-uri)

În cazul sistemelor complexe în care blocul de calcule matematice este foarte
complex, cu privire la analiza semnalului analogic, se pot utiliza procesoare
complexe de calcul, care realizează atât achiziția de semnal cât și partea de calcul
primară a semnalului. Aceste procesoare se numesc procesoare de semnal. Ele sunt
sisteme complexe de calcul realizate în echipamente electronice dedicate
(microcontrolere sau ASIC17‐uri).

Fig. 18
Aceste module realizează achiziția de semnal, prelucrarea lui primară, analiza

semnalui și pot stoca datele în memoria de bază a sistemului numeric. La sfârșitul
unei analize aceste module transmit o întrerupere către sistemul de bază prin care
anunță sfârșitul unei analize.

16
Un controler modern dispune de toate elementele transferului prin DMA încorporate la prețuri scăzute.
17
ASIC = Application Specific Integrated Circuit = Circuit electronic specializat.

Schema algoritmului de conversie utilizând
echipamente de tip DSP este prezentată în Fig.
19. Sistemul de calcul inițializează
comunicatia cu modulul DSP și cu controlerul
de întreruperi. Task‐ul principal se va
conecta la întreruperea gestionată de către
echipamentul DSP. După procesul de
inițializare se execută bucla principală. În
acestă buclă procesul așteaptă întreruperea
emisă de către modulul DSP. După deblocarea
task‐ului se execută codul de procesare a Fig. 19

datelor. Codul atașat poate fi structurat:
// Task T1
//

void main_t1( void)
{
….
init_dsp( …);
init_cint();
attachinterrupt( DSP_INT, T1) ;
while( 1) {
waitinterrupt( DSP_INT) ;
P3(s2);
}
}

Avantajul principal al acestui mecanism este acela că se poate adapta la orice tip de
proces (atât la cele rapide, cât și la cele medii sau lente). Acest mecanism oferă o
încărcare judicioasă a sistemului de calcul; acesta fiind responsabil numai cu
partea de calcule. Dezavantajul este costul ridicat față de celelalte sisteme.
Această metodă se recomandă în sisteme multitasking, cu încărcare mare a
volumului de calcule și în sisteme care procesează semnale cu variație rapidă în
timp, în sisteme care necesită o analiză complexă a semnalului.


Generarea semnalelor cu variatie continua
Procesul de conversie a unui semnal numeric într‐un semnal analogic se
realizează utilizând un convertor DAC18 și transferul direct al datelor către
convertor.

Schema unui sistem
numeric de comandă și
control care poate genera
semnale analogice este
prezentată în Fig. 20. Placa
de conversie este
interconectată în
magistrala sistemului.
Programul care reluează pe
sistem comandă transferul
de valori către convertorul
DAC. Convertorul
comandând pe ieșire
semnalele analogice. Fig. 20

Schema logică a algoritmului este prezentata în

Fig. 21. Task‐ul principal executa partea de calcul
prin funcția P(…). Rezultatul obținut fiind stocat
în variabila v. Valoarea v va fi transferată catre
portul DAC prin instrucțiunea
outportw(DAC_ADDR, v). Convertorul DAC
convertind valoare v din port în mărime

Fig. 21 analogică.
Schema programului este:
// Task T1
//
void main_t1( void)
{
….
while( 1) {
v = P();
outportw( DAC_ADDR, v);
}
}

18
DAC – Digital to Analog Convertor = Convertor numeric‐analogic.

Această metodă se recomandă pentru conversia mărimilor numerice în semnale
analogice.


De reţinut!
‐ Achizitia unui semnal analogic se realizeaza utilizând
un convertor analog/numeric
‐ Generarea unui semnal analogic se realizeaza utilizând
un convertor analog/numeric
‐ Metode de achiziție a unui semnal analogic
o Prin pooling
o Prin întreruperi
o Prin DMA
o Utilizând DSP‐uri
Test de autoevaluare
1. Care sunt elementele constituente ale unui sistem de achizitie
analog numeric în pooling
analog numeric pe întreruperi
analog numeric pe DMA
analog numeric utilizând DSP‐uri
numeric analogic
Răspunsuri la întrebările din testele de

autoevaluare
1. Un sistem de achiziție în pooling necesită un convertor
ADC și un procesor care să execute programul
2. Un sistem de achiziție pe întreruperi necesită un
convertor ADC, un controler de întreruperi și un procesor
care să execute programul
3. Un sistem de achiziție prin DMA necesită un convertor
ADC, un controler DMA, un controler de întreruperi și un
procesor care să execute programul
4. Un sistem de achiziție utilizând DSP necesită un controler
DSP și un procesor care să execute programul
5. Elementele unui sistem de generare analogic sunt un
convertor DAC și un procesor care să execute programul

Bibliografie
Morgan, D. “Numerical Methods – Real Time and Embedded Systems
Programming”, M&T Books, 1992
Walls, C., “Embedded Software: The Works”, O’Relly Ed., 2006
Walls, C., “Real Time Concepts for Embedded Systems”, R&D Books,
2000
Ledin, J., “Embedded Control Systems in C/C++; An Introduction on
Software Developers Using Matlab”, CMP Books, 2004

Unitatea 12

Încărcat de

Informații document

Drepturi de autor

Formate disponibile

Partajați acest document

Partajați sau inserați document

Opțiuni de partajare

Vi se pare util acest document?

Este necorespunzător acest conținut?

Drepturi de autor:

Formate disponibile

Unitatea 12

Încărcat de

Drepturi de autor:

Formate disponibile

Conectarea unui proces la sistemul de calcul.

Functii de operare cu semnale continue

Unitatea de învăţare nr. 12

Conectarea unui proces la sistemul de calcul. Functii de operare cu semnale continue.

OBIECTIVELE unităţii de învăţare nr. 12

Conectarea semnalelor cu variatie continua la sistemul de calcul.

ca acest semnal să fie conectat la o interfață specializată care transformă semnalul

Citirea semnalelor cu variatie continua

O evoluție în timp a procesului de conversie se poate analiza prin urmărirea pas cu

În acest pas, procesorul execută instrucțiunea delay_us(2)7, instrucțiune care

În acest pas, procesorul execută instrucțiunea outportb(…), care va înscrie în

Citirea semnalelor cu variatie continua prin pooling în sisteme multi-tasking

Cele trei task‐uri vor fi implementate după algoritmii din Fig. 9

În acest pas, procesorul execută instrucțiunea delay_us(2), instrucțiune care

Mecanismul prezentat este tot un mecanism de achiziție și control în pooling,

de la interfața analog‐numerică, evenimentul este transmis controller‐ului de

Cele trei task‐uri vor fi implementate după algoritmii din Fig. 13

Tak‐ul T1, va inițializa cu o funcție prin care cere sistemului de operare,

În acest pas, procesorul execută instrucțiunea outportb(…), instrucțiune care

de la interfața analog‐numerică, evenimentul este transmis controller‐ului de DMA

(EOC) către unitatea DMA, pentru a

Citirea si procesarea semnalelor cu variatie continua utilizând procesoare de semnal

Aceste module realizează achiziția de semnal, prelucrarea lui primară, analiza

datelor. Codul atașat poate fi structurat:

Schema logică a algoritmului este prezentata în

Răspunsuri la întrebările din testele de

S-ar putea să vă placă și