Universitatea Tehnica "Gh.

Asachi" Iai,
Facultatea de Automatic i Calculatoare

Proiect
Comunicaii n sisteme de conducere
TEMA 1

Studenti:
Marius-Cosmin Tuluceanu
Andrei-Razvan Talaluta

0
 Cuprins

1. Tema proiectului..................................................................................................... 2

2. Protocolul Master-Slave......................................................................................... 3

3. Programul principal.............................................................................................. 4

4. Pregtirea mesajelor pentru transmisie.............................................................. 6

5. Transmisia mesajelor............................................................................................ 7

6. Recepia mesajelor descriere, schema logic i implementare........................ 10

1
 1. Tema proiectului

Folosind microsistemul MicroPac 515C s se implementeze un protocol de

comunicaie serial de tip master-slave, avnd urmtoarele caracteristici:
1 Port
2 Parametri comunicaie
3 Formatul mesajului
4 Codificare mesaj
COM0 (RS-232) - folosind modemul radio Satel
1870E
9600 Baud, 8 bii de date, paritate par, 1 bit de STOP
Adres HW nod destinaie
Cod funcie: 0 sau 1
Destinatia sau sursa mesajului, dup caz
Lungime date
Date
Cod detectare erori LRC ()
Ascii

Formatul mesajelor:
Adres HW Cod Surs (master) Lungime Date Suma de
destinaie funcie Destinaie (slave) control
1 octet 1 octet 1 octet 1 octet Lungime 1 octet
Obs.:
Cmpul adres destinaie va conine adresa nodului care va recepiona mesajul.
Cmpul cod funcie poate fi, dup caz:
o 0 mesaj de interogare (lungime date = 0) transmis de master ctre un nod
slave sau de slave ctre master, n lipsa altui mesaj util
o 1 mesaj de date mesaj care conine un text ASCII
Cmpul surs/destinaie va indica:
o pentru un mesaj de tip 1 transmis de nodul master sursa mesajului
o pentru un mesaj de tip 1 transmis de un nod slave destinaia final a mesajului
Cmpul lungime reprezint numrul de octei al cmpului de date;
Octetul din cmpul suma de control va fi calculat ca suma modulo 2 (XOR) a
tuturor octeilor din cmpurile anterioare.
Mesajul va fi transmis n format binar, octet cu octet, portului serial COM0.

2
 2. Protocolul Master-Slave

Pentru a forma o retea de comunicatie, este nevoie de o placa (nod) care sa

gestioneze fluxul de mesaje dintre restul placilor conectate. Astfel nodul master deine
controlul reelei i acord nodurilor slave, pe rnd, permisiunea de a transmite date
dealungul retealei. O legtur RS-485 intre placi, conecteaz emitorul masterului la
receptoarele nodurilor slave, iar o a doua legtur RS-485 conecteaz emitoarele
nodurilor slave la receptorul masterului. Nodurile slave au ca responsabilitate s citeasc
mesajele de la master pe prima legtur pentru a afla cnd au dreptul de a transmite date
pe cea de-a doua legtur. Avantajul acestei organizri este acela c nodurile slave pot
primi mesaje numai de la master i nu vor trebui s citeasc rspunsurile celorlalte noduri
slave. Dac toate nodurile ar partaja o singur legtur RS-485, atunci ar trebui s
citeasc mesajele tuturor celorlalte noduri n ateptarea unui mesaj de la master, ceea ce
va ingreuna si neeficientiza sistemul.
Tehnica master / slave este o tehnic de acces la mediu cu control centralizat, este
specificat atunci cand unul dintre noduri poate transmite date i, momentul cnd poate
face acest lucru. Dreptul de acces este acordat de ctre master pe rnd, n mod ciclic,
fiecrui nod slave, printr-un mesaj adresat acestuia. La primirea unui mesaj, un nod slave
tie c poate transmite la rndul lui un mesaj, dar numai ctre nodul master. Astfel,
dreptul de acces revine sistematic la nodul master, care trece la urmtorul nod
slave din lista circular.
Ca avantaje ale acestei metode putem enumera:
- fiecare nod primete dreptul de acces n reea ntr-un timp finit, indiferent de numrul de
mesaje pe care le au de transmis nodurile.
- pe termen lung, fiecare nod are aceleai anse de a transmite date n reea;
- determinism fiecare nod primete dreptul de acces ntr-un timp predictabil.
Ca Dezavantaje ale acestei metode putem enumera:
- textul programului executat de master este diferit de cel executat de nodurile slave;
- nodul master are o ncrcare mult mai mare dect nodurile slave cu sarcini de
comunicaie;
- un mesaj de la un nod slave pentru un alt nod slave apare n reea de dou ori;
- cderea nodului master determin blocarea comunicaiei.

3
 3. Programul principal

Dealungul acestui proiect vom invata sa intelegem comunicarea in retea printr-un

modem wireless, a placilor de dezvoltare. Pe fiecare placa, va fi incarcat acelasi program,
indiferent daca nodurile vor si catalogate ca master sau slave, diferentierea facandu-se in
cod de catre programator. Pentru aceast lucru, am avut la dispozitie un program deja
conceput, insa pentru a putea intelege, functia de pregatire a mesajului ce urmeaza sa fie
trimis sau receptionat, cea de transmisie si receptie a acestora, au fost sterse.
In schema bloc prezentata in Fig. 4, este prezentat modul de lucru al programului
principal, modul in care este facuta diferentierea intre noduri (master / slave) si corelatiile
dintre functii.
Programul principal va avea urmatoarele atributii:
informarea utilizatorului pe lcd, referitor la caracteristicile placii (numar nod),
afisarea meniului si a informatiilor primite prin intermediul functiilor de
transmisie / receptie;
pentru tipul de nod identificat:
master: - va trimite mesaje de interogare circulare catre nodurile din
retea folosindu-se de functiile de pregatire, transmisie si receptie a
mesajului;
slave: - va verifica prin intermediul aceloras functii, daca exista un
mesaj destinat nodului respectiv, apoi verificand bufferul de date, va
raspunde catre master in functie de starea acestuia. Nodul master, va fi
singurul din retea, care va da drept de transmisie a mesajelor prin retea.

4
 Reset

Initializari: LCD, coprocessor,

tastatura, port serial, timer T0
Variabile locale

receptie mesaj
Afisare meniu

Afisare mesaj si sursa (daca mesajPOLL)

nod=1(slave)

gol nod=0(master)
Verificam bufferul
plin gol
nod++; buffer(nod)
Pune mesaj de interogare (POLL)
in buffer(nod)
=
nod:ID
pregatire buffer(nod)
nu
nod++;
transmite mesaj(nod)
da nod=5?

receptie mesaj(nod) plin

nod=0
afisare mesaj (pentru master)

nod++; Punere in buffer(0) mesaj POOL

da alta

nu
nod=5? nod++;

nu pregatire mesaj(nod)

exista tasta apasata?

transmite mesaj(nod)
2 1
solicita destinatia

adresa buffer
preia destinatia

preia adresa buffer

solicita mesaj

afisarte stare buffer

preia mesaj

reface meniu

Fig. 4 - Schema logic a programului principal n varianta combinat Master-Slave

5
 4. Pregtirea mesajelor pentru transmisie

Dintre cele 3 functii ce trebuiesc completate pentru implementarea proiectului,

cea mai importanta este cea de pregatire a mesajului.
Aceasta are ca targhet alcatuirea mesajului ce va fi trimis prin retea de la un nod
la altul, si trebuie sa respecte anumite reguli pentru a putea fi interpretat si utilizat corect
de functiile de receptie si transmisie.
Conform schemei bloc de la Fig.5, ce pute in vedere atributiile ce trebuiesc
indeplinite, dealungul pregatirii mesajului trebuie tinut cont de:
- tipul mesajului ce trebuie pregatit:
o date
o interogare
- daca este de interogare, mesajul ce trebuie pregatit este suma de control a
nodului, ce va fi egala cu adresa nodului;
- daca este mesaj de date, se construieste suma de control, tinand seama de
adresa nodului, codul functiei, lungimea datelor si datele ce trebuie trimise.
Pe baza acestor reguli s-a implementat urmatoarea functie, pentru pregatirea
mesajului ce va urma sa fie trimis dealungul retelei.

void Pregatire_mesaj(int i){ // pregatire mesaj pentru transmisie catre nodul i

unsigned char sc; // suma de control
unsigned char *ptr; // pointer
int j,k; // contor
if(retea[i].bufbin.functie==POLL)
// Daca este un mesaj de interogare (POLL=0)
{
retea[i].bufbin.sc=retea[i].bufbin.adresa;
// atunci suma de control este egala cu adresa HW a nodului
destinatie
}
else // altfel...
{
sc=retea[i].bufbin.adresa; // initializeaza SC cu adresa HW a
nodului destinatie
sc+=retea[i].bufbin.functie; // ia in calcul codul functiei
sc+=retea[i].bufbin.destsrc; // ia in calcul adresa nodului destinatie
sau sursa a mesajului
sc+=retea[i].bufbin.lng; // ia in calcul lungimea datelor

6
 for(j=0;j<retea[i].bufbin.lng;j++)
{
sc+=retea[i].bufbin.date[j]; // ia in calcul datele
}
retea[i].bufbin.sc=sc; // stocheaza suma de control
}
ptr = retea[i].bufasc+1; // initializare pointer pe bufferul ASCII
// salt peste ':'
bin2ascii(retea[i].bufbin.adresa,ptr);// pune in bufasc adresa HW in ASCII
ptr+=2;
bin2ascii(retea[i].bufbin.functie,ptr);// pune in bufasc codul functiei
ptr+=2;
if(retea[i].bufbin.functie==MES) // daca este un mesaj de date (MES)
{
bin2ascii(retea[i].bufbin.destsrc,ptr); // pune in bufasc destsrc
ptr+=2;
bin2ascii(retea[i].bufbin.lng,ptr); // pune in bufasc lng date
ptr+=2;
for(k=0;k<retea[i].bufbin.lng;k++)
{
bin2ascii(retea[i].bufbin.date[k],ptr);// pune in bufasc datele
ptr+=2;
}
}
bin2ascii(retea[i].bufbin.sc,ptr);
ptr+=2;
*ptr++=0x0D;
*ptr=0x0A;
}

7
 Fig.5 - Schema bloc a functiei de pregatire a mesajului

5. Transmisia mesajelor

Cea de-a doua functie ce trebuie implementata, de transmisie a mesajului, va folosi

implicit cuvintele formate in functia de pregatire a acestuia. Informatiile preluate ne ajuta
pentru a stabili o comunicatie intre placi.
Pentru implementarea algoritmului, ne vom ghida dupa schema bloc din Fig.6 unde
puteam observa pe larg atributiile acestei functii. La fel ca in functia de pregatire a mesajului,
vom avea de controlat 2 tiputi de mesaje, ce vor fi diferentiate dupa codul functiei:
- un mesaj de date, ce trebuie trimis pas cu pas, tinand cont de urmatoarea ordine:
trimiterea adresei nodului ce va primi mesajul;
trimiterea lungimii mesajului;
trimiterea cuvantului propiu-zis;
trimitearea sumei de control.
- un mesaj de interogare, ce va avea ca scop verificarea bufferului de date al unui
nod oarecare din retea.
Respectand aceste regului, s-a implementat functia de transmitere a mesajului.

void TxMesaj(int i){ // transmite mesajul din bufferul i

unsigned char *ptr;
ptr = retea[i].bufasc; // pointer
ACC=*ptr; // initializare pointer
TB8=P; // calculeaza bitul de
paritate (paritate para - Even)
Ser_Send_Byte(COM0,*ptr,1); // transmite primul caracter al
mesajului (':')
do
{

8
 ptr++;
ACC=*ptr;
TB8=P; // transmite restul
caracterelor din bufferul ASCII
Ser_Send_Byte(COM0,*ptr,1);
} while(*ptr!=0x0A);
if(ADR_NOD!=MASTER)
{
retea[i].full=0; // slave-ul considera acum ca a
transmis mesajul
}
while(Ser_SND_Done(COM0)!=0);
return; // asteapta terminarea transmisiei
}

9
Fig. 6 Schema bloc a functiei de transmisie a unui mesaj

10
 6. Recepia mesajelor descriere, schema logic i implementare

Ultima functie ce a ramas de tratat, este cea de receptie a mesajelor. Ea este cea
mai complaxa dintre toate, deoarece are ca responsabilitati de a decodifica mesajul
primit, de a indentifica carui tip de nod (master / slave) ii este destinat si de a notifica
utilizatorul legat de datele primite in buffer.
Pentru a implementa aceasta functie, am urmarit cu atentie schema logica
prezentata in Fig.8. Pe scurt aceasta functie, tine mereu seama daca nodul care primeste
un mesaj este de tip master / slave, si va intra in asteptarea caracterelor corecte. Daca se
intampla ca datele receptionate sa fie eronate, va ignora acele date (informand
utilizatorul) si va astepta informatii corecte. Dupa identificarea nodului, functia va avea o
parte comuna, cea de recunoastere a mesajului primit, apoi va identifica iarasi daca nodul
este master / slave pentru a vedea ce trebuie facut cu mesajul primit.
Respectand schema bloc prezentata am alcatuit urmatorul cod, pentru a
implementa functia:
void RxMesaj(int i){ // receptie mesaj in bufferul i

unsigned char j, ch, sc, adresa, screc, destsrc, lng, functie, *ptr,*ptrbin;
if(ADR_NOD==MASTER){
// Daca nodul este master...
ch=Ser_Receive_TMO(COM0, 1000);
// M: asteapta cu timeout primul caracter al raspunsului
de la slave

//error("Receptie...");
if(timeout==1){
error("Timeout nod");
LCD_Putchar(i+'0');
return;
}
else{
retea[i].full=0;

11
if(ch!=':')
{
error("Eroare incadrare");
do{
ch=Ser_Receive_TMO(COM0, 5);
}while(timeout==0);
return;
}
else{
ptr=retea[i].bufasc + 1;
*ptr++=Ser_Receive_TMO(COM0,5);
if(timeout==1){
error("Timeout nod");
LCD_Putchar(i+'0');
return;
}
*ptr--=Ser_Receive_TMO(COM0,5);
if(timeout==1){
error("Timeout nod");
LCD_Putchar(i+'0');
return ;
}
adresa=ascii2bin(ptr);
if(adresa!=ADR_NOD)
{
error("Eroare adresa!");
do{
ch=Ser_Receive_TMO(COM0, 5);
}while(timeout==0);
return ;
}

12
 }

}
else{
do{
do{
//ignora mesaj
ch=Ser_Receive_TMO(COM0, 5);
}while(timeout==0);
do{
ch=Ser_Receive_Byte(COM0, 1);
}while(ch != ':');
ptr=retea[i].bufasc + 1;
*ptr++=Ser_Receive_TMO(COM0,5);
if(timeout==1){
error("Timeout nod");
LCD_Putchar(i+'0');
return;
}
*ptr--=Ser_Receive_TMO(COM0,5);
if(timeout==1){
error("Timeout nod");
LCD_Putchar(i+'0');
return;
}
adresa=ascii2bin(ptr);
}while(adresa != ADR_NOD);
}
ptr++;

13
do{
*(++ptr) = Ser_Receive_TMO(COM0,5);
if(timeout==1){
error("Timeout nod");
LCD_Putchar(i+'0');
return;
}
}while(*ptr != 0x0A);
ptr=retea[i].bufasc + 3;
screc=adresa;
functie=ascii2bin(ptr);
ptr+=2;
if(functie >= 2 ){
error("Eroare cod functie!");
return;
}
screc += functie;

if(functie==MES){
destsrc = ascii2bin(ptr);
ptr += 2;
screc += destsrc;
if(ADR_NOD==MASTER){
if(retea[destsrc].full == 1){
error("Eroare de suprapunere!");
return;
}
}
lng = ascii2bin(ptr);
ptr += 2;
screc += lng;

14
if(ADR_NOD==MASTER){
retea[destsrc].bufbin.functie = functie ;
retea[destsrc].bufbin.destsrc = i ;
retea[destsrc].bufbin.lng = lng ;
for (j=0;j<retea[destsrc].bufbin.lng;j++){
retea[destsrc].bufbin.date[j]=ascii2bin(ptr);
ptr += 2;
screc += retea[destsrc].bufbin.date[j];
}
sc = ascii2bin(ptr);
if(sc == screc){
retea[destsrc].full = 1 ;
return;
}
else{
error("Eroare SC!");
return;
}
}else{
retea[ADR_NOD].bufbin.functie = functie ;
retea[ADR_NOD].bufbin.destsrc = destsrc ;
retea[ADR_NOD].bufbin.lng = lng ;
for (j=0;j<retea[ADR_NOD].bufbin.lng;j++){
retea[ADR_NOD].bufbin.date[j]=ascii2bin(ptr);
ptr += 2;
screc += retea[ADR_NOD].bufbin.date[j];
}

sc = ascii2bin(ptr);
if(sc == screc){
retea[ADR_NOD].full = 1 ;

15
 return;
}
else{
error("Eroare SC!");
return;
}
}
}
else{

sc = ascii2bin(ptr);
if(sc == screc){
return;
}
else{
error("Eroare SC!");
return;
}

16
17
18
Fig. 8 - Schema bloc a fuctie de receptie

19