tutorial c iulie2004

8/19/2019 Tutorial C Iulie2004

1/167

Programarea în Limbajul C Aplicaţii Automotive Iulie 2004 Pagina : 1Siemens VDOSiemens VDO

Programarea în limbajul C

Programarea C pentru aplicaţii dincategoria automotive

Iulie 2!


2/167


Cuprins

Introducere în limbajul C

Introducere în limbajul de asamblare (C16x)

Programarea în limbaj C la nivel scăzut pentru aplicaţiiautomotive

Programarea C de nivel înalt pentru aplicaţii automotive

eguli algoritmice

C"#$


3/167


"% Introducere în limbajul C

"% Introducere în limbajul C


4/167


Caracteristicile limbajului C

!imbaj pentru aplicaţii de uz general" Conceput de către programatori# pentru programatori" !imbaj universal" $ste e%icient în comparaţie cu alte limbaje de a treia generaţie

(Pascal)" $ste dependent# ca putere# de biblioteci"

A doua generatie A treia generaţie A patra generaţie

C&&' Ada' (avaAsamblor C PASCAL


5/167


C ) limbaj de nivel înalt sau sc*+ut ,

$ste considerat limbaj de nivel înalt doar prin comparaţie cu

asamblorul" &intre limbajele de nivel înalt# are nivelul cel mai scăzut" 'pre deosebire de alte limbaje# programatorul trebuie să cunoască

comportamentul compilatorului"

-n Pascal . i/ 0cond" A1D cond2

-n C i/ 0cond" 33 cond2

Cond" se evaluea+* prima


6/167


Comparaţie C 4 Assembler

Ce este comun ambelor limbaje odularizarea programelor *i a datelor Constante# variabile *i etic+ete de program simbolice 'tructuri de programare de tip macro

Ce există în C# dar nu *i în ,ssembler 'tructuri de date elaborate

- *iruri# tablouri# structuri- pointeri- enumeraţii

'tructuri de control elaborate- I% else

- .ucle- Case /uncţii cu parametri# recursivitate"


7/167


Comparaţie C 4 Assembler

!imite ale limbajului C cînd se programează la nivelscăzut !imbajul în sine este independent de ma*ină# dar o implementare

anume este dependentă de biblioteci" ,par di%icultăţi sau elemente nestandard atunci cînd este necesar

accesul nemijlocit la resursele +ard0are"- egistre- ,drese %izice- ntreruperi


8/167


Comparaţie C 4 C&&

Ce există în C22# dar nu *i în C

Programare orientată către obiecte- Clase# încapsulare (privat# public)- o*tenire- Polimor%ism

,lte mecanisme- 3ipizare puternică- Conversii avansate- $xcepţii- 4abloane de proiectare

&ezavantaje ale C în programarea la nivel înalt &i%icultăţi în reutilizarea programelor (lipsa mo*tenirii) &i%icultăţi în programarea generică (lipsa *abloanelor)


9/167


Conte$tul aplicaţiilor automotive

ulte obiective 5biective de mentenabilitate 5biective de reutilizabilitate

ulte constrîngeri

Constrîngeri de e%icienţă Constrîngeri de robusteţe *i %iabilitate


10/167


Impactul conte$tului automotive

/olosirea programării la nivel scăzut pentru a atinge obiectivele dee%icienţă

/olosirea unor elemente de nivel înalt pentru a îmbunătăţi mentenabilitatea robusteţea reutilizabilitatea

&e ce se %olose*te limbajul C C este singurul limbaj care are medii de dezvoltare a aplicaţiilor pentru

microcontrolerele %olosite în aplicaţiile automotive $xistă *i unele extensii C22"


11/167


Versiuni ale limbajului C

'tandardele 78 # ,9'I" Programare la nivel scăzut" !imitări %oarte mari în ceea ce prive*te accesul direct la resursele +ard0are"

:ersiunile native C" 'e caracterizează prin aceea că compilatorul rulează pe acela*i procesor pe

care va rula *i programul compilat" :ersiunile C cross;compilate"

Compilatorul rulează pe alt procesor decît cel pentru care compilează" $xistă multe produse de calitate inegală" &epind de %urnizor# de numărul de licenţe ac+iziţionate etc"

3endinţe curente" C nativ C este înlocuit de C22#


12/167


2% Introducere în limbajulde asamblare

al microcontrolelelor dinseria C"#$

2% Introducere în limbajulde asamblare

al microcontrolelelor dinseria C"#$

C"#$


13/167


Structura C"#$

1ucleul CP56O7intern

6A7intern

C"#$

6A7e$tern

6O7e$tern


14/167


Structura CP5

6egistre de stiv*

6egistre pipeline

6egistre de paginare 8i segmentare

7D9 4 7DL

6egistre de u+ general de "# biţi

6A7Intern

6egistre de conte$t

C"#$

AL5


15/167


Caracteristici ale seriei de microcontrolere

5rganizare pe principiul I'C" Principii de adresare

>tilizarea pre%erenţială a registrelor pentru operaţiile aritmetico?logice Pentru instrucţiile 5: un operand este în memorie iar altul într;un

registru ,dresare pe cîmpuri de biţi" /azele execuţiei unei instrucţii

Pre;%etc+ $xecuţia propriu;zisă

,dresare segmentată *i paginată"

C"#$


16/167


Instrucţiile limbajului de asamblare Instrucţii ,! standard

aritmetice

- ,& '>.# ,'@ - :ariante de lungime ,&&.- ,lte variante ,&&C

logice- ,9#'@!

combinate

- 5:.A# 5:.' Instrucţii ,! nestandard

5peraţii pe bit- .5:# .5:9# .'$3# .C!

nmulţire *i împărţire- >!# &I:# >!># &I:>

Instrucţii de salt"

C"#$


17/167


7odurile de adresare

&irectă (pe 16 biţi)5: Bu#

Imediată (pentru operanzi sau adrese)5: 1#D65: E#DBa

Indirectă5: Bu#FEG

elativă5: H#(B'2)

Indexată5: FH2DBCG#!5: FJ2G#!5: F;JG#!

C"#$


18/167


:impul de e$ecutie(Minim)

Instrucţia Cicluri de tact Durata (ns) la 20!"

C#$$I% C#$$# 2 100C#$$&% C#$$' 4 200% C% *** 2 100P& 4 200P#% PI 2 100

+$ 10 500DI, 20 1000-, 'n% .'/ 4 200' 4 200'#P 4 200

#ltele 2 100

C"#$


19/167


:ipuri de date speci/ice microcontrolerului

&e%inite ca variabile# în %i*iere +eader >tilizabile în cod sursă C 'e re%eră la registre care au %uncţii speciale în microcontroler

Kspecial %unction registersL s%r

Kspecial %unction registers bitsL s%rbit

C"#$


20/167


;estiunea tas


21/167


@% Programarea în limbaj C lanivel sc*+ut pentru aplicaţii

automotive

@% Programarea în limbaj C lanivel sc*+ut pentru aplicaţii

automotive

C t î li b j C l i l * t


22/167


Ce este programarea în limbaj C la nivel sc*+utpentru aplicaţii automotive ,

3e+nicile de programare sînt alese pentru o cît mai maree%icienţă" 'e %olose*te limbajul C" 'e ţine cont de comportamentul compilatorului"

'e %olosesc resurse +ard0are ale microcontrolerului# prinintermediul variabilelor speci%ice" ,cest capitol se bazează pe compilatorul .'5 pentru

microcontrolere din seria C16x" Principiile sînt portabile *i pentru alte compilatoare# dacă acestea

răspund acelora*i constrîngeri"

C"#$


23/167


Structura unui program C

uncţii apelate

Date locale

Declaraţii de dateuncţia main

DeclaraţiiInstrucţii?locuri

uncţii apelateDeclaraţiiInstrucţii?locuri

i8ierulprincipal

i8ieresecundare


24/167


Declaraţii simpleDeclaraţii simple


25/167


Declaraţii de variabile 0"

/iecare variabilă are un nume" /iecare variabilă are un tip" Principalele tipuri

întreg (int) este tipul implicit- pe acest microcontroler este =5& (16 biţi)

Caracter# sau octet (c+ar) 9umăr real (%loat) (nu se %olose*te în programarea de nivel scăzut)

,lte tipuri (nestandard) .it Cîmp de biţi

3ipul de bază al unei variabile poate %i modi%icat în mod explicit" odi%icatori de lungime

s+ort

long ,tenţie pe procesoare de 16 biţi# int *i s+ort int sînt ec+ivalente" &oar tipul

c+ar are are lungimea de un octet (bMte)"

C"#$


26/167


Declaraţii de variabile 02

odi%icatori de semn unsigned signed

odi%icator de volatilitate" volatile o dată se nume*te volatilă dacă poate %i modi%icată în mod asincron

de către mai multe procese" odi%icatori de vizibilitate

Implicit# orice variabilă este locală# adică vizibilă doar în interiorul %uncţieisau blocului în care a %ost declarată"

static o variabilă statică este locală# dar î*i păstrează valoarea la părăsireadomeniului de vizibilitate"

extern o dată declarată în alt %i*ier sau modul"


27/167


Declaraţii de variabile 0@

'intaxaNtipO NnumeO

sauNmodi%icatorO NtipO NnumeO

sau NtipO N9ume1O# N9umeO# """

$xempleint x

bit bs+ort int xstatic c+ar xunsigned c+ar x

volatile int x#M ,tenţie la utilizarea tipului implicit în declaraţii combinate

unsigned x# M ?Q M este signed Q?


28/167


Domeniul de repre+entare al tipurilor simple

intdimensiune octeţi (dependent de +ard0are)

alte nume signed# signed intdomeniu ;E#R6S pînă la E#R6R (pentru octeţi)

unsigned intdimensiune octeţi (dependent de +ard0are)alte nume unsigneddomeniu J pînă la E#R6R (pentru octeţi)

c+ar dimensiune 1 octetalte nume signed c+ar domeniu ;1S pînă la 1R

unsigned c+ar

dimensiune 1 octetalte nume ;;;domeniu J pînă la


29/167


Domeniul de repre+entare al tipurilor simple 02 s+ort

dimensiune octeţi (independent de +ard0are)

alte nume s+ort int# signed s+ort intdomeniu ;E#R6S pînă la E#R6R

unsigned s+ortdimensiune octeţi (independent de +ard0are)alte nume unsigned s+ort intdomeniu J pînă la E#R6R

long dimensiune H octeţi alte nume long int# signed long int domeniu ;#1HR#HSE#6HS pînă la #1HR#HSE#6HR


30/167

D l ţii d t t 0"


31/167


Declaraţii de constante 0"

/iecare constantă are un nume"

/iecare constantă are un tip" /iecare constantă are o valoare" :aloarea unei constante este dată printr;un KliteralL (nu se

acceptă expresii pentru iniţializare)"

&eclaraţia unei constante poate conţine modi%icatori" 5 constantă este alocată în memorie (se rezervă memorie

în zona de 5)" 3ipul unui literal

3ipul implicit este întreg" Poate %i modi%icat la unsigned (>) sau long (!)"

D l ţii d t t 02


32/167


Declaraţii de constante 02

'intaxa const NtipO NnumeO T NvaloareO

$xemple corecte const unsigned int t T 1U> const unsigned int j T JJ1 ?Q octal Q? const unsigned int V T Jx// ?Q @exa Q? const long e T 1! const c+ar c T WcW const c+ar d T WXJJRW ?Q 5ctal Q?

$xemple incorecte 9everi%icate de către compilator

- const unsigned int t T ;1JJ- const c+ar a T JJ

:eri%icat de către compilator - const c+ar b T a21

Alt mod de a de/ini valori constante.


33/167


Alt mod de a de/ini valori constante.de/inirea de simboluri

5rice simbol are un nume" 5rice simbol are o valoare" :aloarea trebuie să %ie un literal# ca *i la constante" >n simbol nu este alocat (nu se rezervă spaţiu în 5)" &e%iniţia simbolurilor va %i detaliată mai tîrziu în curs

(capitolul despre preprocesare)" 'intaxa

Dde%ine 9CBCY!B9 H

Alt d d d /i i l i t t


34/167


Alt mod de a de/ini valori constante.de/inirea de valori enumerate

3ipul KenumeraţieL este un tip de%init de utilizator *i constă într;un set de valori constante#numite enumeratori" Implicit# primul enumerator are valoarea zero# iar următorii se obţin prin incrementare# dacă nu se speci%ică explicit alte valori"

/iecare enumerator este tratat ca o constantă *i trebuie să aibă o denumire unică în cadruldomeniului de de%iniţie"

$xempluenum Aile Z ?Q&eclaratie de tip AileQ? 'imbata# ?Q 'imbata T J# implicitQ?

&uminica T J# ?Q &uminica T J (la %el ca 'imbata)Q? !uni# ?Q !uni T 1Q? arti# ?Q arti T Q? iercuri# ?Q etc"" Q?


35/167


:ipul enumeraţie

3ipul enumeraţie este ec+ivalent cu tipul întreg" >n enumerator poate %i atribuit unei

variabile întregi" 3otu*i# conversia inversă necesită un cast explicit iar valoarea obţinutănu este întotdeauna de%inită" $xemplu

int ieri T


36/167


enum EEPSTATE {EEP_IDLE, EEP_BEF_PROG,EEP_PROG,EEP_AFT_PROG1,EEP_AFT_PROG2};

.../* State = I!e */ "u#_Ee$P%mState = EEP_IDLE;...

&'(t) +"u#_Ee$P%mState { e-au!t #-&&e""_"&t+E_E2P; #"ea0; )a&e EEP_IDLE #ee$mana_(!e+; #"ea0; )a&e EEP_BEF_PROG #ee$mana_#e-$"%+; #"ea0;

)a&e EEP_PROG #ee$mana_$"%+; #"ea0; )a&e EEP_AFT_PROG1 #ee$mana_a-t$"%1+; #"ea0; )a&e EEP_AFT_PROG2 #ee$mana_a-t$"%2+; #"ea0; }

...(- + "u#_Ee$P%mState == EEP_IDLE { "u#_IneB!)0 = "u'_3umB!)0; #ee$mana_!a_(ma%e+; "etu"n+TR4E; }

Iniţiali+area unei variabile


37/167


Iniţiali+area unei variabile

$ste posibil să iniţializăm o variabilă la de%inirea sa" 'intaxa

NtipO NnumeO T NexpresieO

$xempluint iT1

$%ect compilatorul va genera o secvenţă speci%ică de

cod pentru a iniţializa variabila" 9u se recomandă %olosirea" ,tenţie nu con%undaţi o constantă cu o variabilă

iniţializată"

Detalii privind alocarea datelor


38/167


Detalii privind alocarea datelor

n programarea C pentru microcontrolere datele trebuie alocate precis" &e%iniţi secţiuni di%erite pentru di%erite tipuri %izice de

memorie" &e%iniţi secţiuni în %uncţie de persistenţa datelor"

/olosiţi directiva C!,'' pentru a de%ini *i selecta o anumesecţiune pentru un anume set de date" 9estandard C %olosiţi directive KpragmaL"

C"#$

C"#$

Conceptul de secţiune


39/167


Conceptul de secţiune

5rganizarea logică a datelor"

i8ier "Secţiunea Aint a"int a2Secţiunea ?int a@

i8ier 2Secţiunea Aint b"Secţiunea Cint b2

i8ier @Secţiunea Cint c"Secţiunea ?int c2

Secţiunea Aa"a2b"

Secţiunea ?a@c2

Secţiunea Cb2c"

Conceptul de secţiune în ?SO


40/167


Conceptul de secţiune în ?SO

'ecţiunea :ariabile" class biT.I3B'$C3I59B$\,P!$

class baT.I3=5&B'$C3I59B$\,P!$ class nbT9$,B&,3,B'$C3I59B$\,P!$ class %bT/,B&,3,B'$C3I59B$\,P!$ class +bT@>]$B&,3,B'$C3I59B$\,P!$

'ecţiunea Constante" class ncT9$,BC59'3,93B'$C3I59B$\,P!$ class %cT/,BC59'3,93B'$C3I59B$\,P!$ class +cT@>]$BC59'3,93B'$C3I59B$\,P!$

'ecţiunea Cod" class prTC5&$B'$C3I59B$\,P!$

,ltele în %uncţie de aplicaţie" Partiţionarea %izică a memoriei anagementul logic al memoriei

C"#$

B$emple de declaraţii


41/167


B$emple de declaraţii5(n)!ue 6e-"am#.6 /* Ste$ - te (a%n&t() &te$ ma)(ne */PRI7ATE_DATA T_4B8TE "u#_9'$:ana%eSte$;

ETER3 T_BIT "#(_D(a%Runn(n%;

5(n)!ue 6e-"am#.6ETER3 T_4B8TE "u#_Se"e u&(n% Su")e Statement


42/167


Expresii Expresii

B$presii aritmetice 8i logice


43/167


B$presii aritmetice 8i logice 5peratori *i operanzi

x2Mx 8 1

5peranzi variabile constante simboluri literale

5peratori

5peratorii clasici binari *i unari2#;#Q#?#^# etc""88#__#`# etc""

5peratori speci%ici- &e acces la date (structuri# tablouri# pointeri)- Pentru apelul %uncţiilor

$xpresiile pot %i des%ăcute în expresii mai simple# %olosind parantezele dacă estenecesar" $xemplu

(x2M) Q g

Bvaluarea e$presiilor


44/167


Bvaluarea e$presiilor

'e %ace respectînd anumite

priorităţi"

5rdinea evaluării termenilor ai întîi termenul din stînga pentru

operatori binari" ai întîi termenul din dreapta pentru

operatori unari sau atribuiri" Prioritatea operatorilor

ai întîi înmulţirea *i împărţirea ,poi adunarea *i scăderea

,poi operatorii logici ,poi operatorii de comparaţie ,poi atribuirea

$xemplu a 2 bQc 2 d

întîi a apoi b apoi c

apoi bQc apoi a 2 bQc apoi d n %inalîntreagaexpresie

:ipuri de e$presii


45/167


p p

/iecare parte a unei expresii are untip"

3ipul unei expresii este calculat dintipul operanzilor (*i doar aloperanzilor)" $xemplu

c+ar x#M

const int g T

long int p (x 2 M) Q g 2 p

x2 M e de tip c+ar (S biţi# cu semn)

(x2M)Qg e de tip int (16 biţi# cusemn) (casting implicit)

(x2M)Qg2p e de tip long int (E biţi#cu semn) (casting implicit)

&i%erenţe %aţă de assembler

3ipul unei expresii este de%init detipul operatorilor >! xQM# tipul este in%luenţat deoperandul >!

3ipul unei expresii poate %i modi%icat princasting

'intaxa (NtipO) NexpresieO $xemple de casting

((long) (x2M))Qg 2p(E biţi pentru x2M)

((long)x 2M)Qg2p(E biţi pentru întreaga

expresie)

Atribuirea 0"


46/167


0

$ste un operator de tip particular" ,tribuie rezultatul expresiei unei variabile

'intaxa T $xemplu

r T (x2M) Qg 2p

3ipul destinaţiei trebuie să %ie compatibil cu tipul expresiei" $xemple

c+ar x#M

const int g T long int p

r T (x 2 M) Q g 2 p

Corect- &acă r a %ost declarat de tip long int (E biţi)

Incorect (*i neveri%icat de către compilator)- &acă r a %ost declarat de tip c+ar sau int- &acă r a %ost declarat unsigned

Atribuirea 02


47/167


0

,tribuirea presupune un casting implicit"

$xemplu r codat pe E biţi x2M codaţi pe 16 biţi- n expresia rTx2M doar partea lo0 a lui r (16 biţi) este a%ectată deatribuire" Partea +ig+ este setată prin extensie la 1 sau la J %uncţie desemnul lui x2M"

>n casting explicit se poate %ace înaintea atribuirii"

$xemplu r codat pe E biţi x2M codaţi pe 16 biţi- r T (long) x 2 (long) M expresie evaluată pe E biţi

- r T (long) (x 2 M) expresie evaluată pe 16 biţi (dummM casting)

,tribuirea este un operator care poate %i %olosit în cadrul uneiexpresii" ezultatul atribuirii este valoarea atribuită însă*i" $xemplu

- tT (r T (x2M) Qg)

:ipul boolean implicit


48/167


9u este cu adevărat un tip deoarece nu există o declaraţie explicită" 5rice dată poate %i evaluată ca booleană dacă se poate de%ini pentru ea o

valoare în care toţi biţii sînt zero" $ste un tip implicit %olosit pentru operaţii logice *i condiţionale

J (întreg 16 biţi) este %als Caracterul KnullL (XJ) este %als pointerul 9>!! este %als

9umărul real (%loat) J este %als 5rice altă valoare este adevărat

1 este adevărat ;1 este adevărat caracterul WsW este adevărat >n pointer care a %ost iniţializat cu orice adresă este adevărat

,cest tip este ec+ivalent cu tipul bool din C22"

Operatori booleeni


49/167


/olosesc tipul boolean implicit" 5peratori logici

88 (4I)# __ (',>) # ` (9$],$) 5peratori de comparare

TT ($],!)# ̀ T(I9$],!) N# NT# O# OT

Cînd o dată prime*te valoarea KadevăratL# valoarea ei e%ectivă depinde deimplementarea compilatorului"

$xempleint a#b#r

r T (aTTb) ?Q r este 3>$ dacă a este egal cu bQ?r T (aN1) 88 (bO) ?Q corect Q?r T (a`Tb) 2 E ?Q posibil dar """ Q?

Operatori pe bit


50/167


!ucrează asupra codului datei la nivel de bit" 'înt dependenţi de declaraţia datei *i de implementarea ei prin intermediul

compilatorului pe +ard0are" 'înt operatori logici

8 (4I)# _ (',>)# (',> exclusiv)# (complement %aţă de 1) $xemple

int a#b#r aT1 bT r T a 8 b ?Q r este zero Q?

aT1 bT E rT a 8 b ?Q r este 1 Q?

B$emple de operatori


51/167


,ritmetici2 ,dunare

; 'cădere

Q nmulţire

? mpărţire

^ odulo Incrementare *i decrementare

22 incrementare (pre sau post)

;; decrementare (pre sau post)

5peratori compu*i2T ,dunare;T 'cădere

QT nmulţire?T mpărţire^TodulNNT deplasare la stîngaOOT deplasare la dreapta8T4I pe bitT ',> exclusiv pe bit_T ',> pe bit

Signed Addition and Subtraction

;; C Declarations :

Signed Addition and Subtraction /01

;; C Source Statement :

C"#$


52/167


;; C Declarations :char x,y,z,t ;

;; C Source Statement : z = x+y ;;; Generated Assembler :

!"# $%&,'xADD# $%&,'y!"# 'z,$%&

;; C Source Statement : z = x + ( ;;; Generated Assembler :

!"# $%),'x!"# 'z,$%)

;; C Source Statement : z = x * y ;;; Generated Assembler :

!"# $%),'xS## $%),'y!"# 'z,$%)

;; C Source Statement : z = y * y ;;; Generated Assembler = -on o.timized

!"# $%&,'yS## $%&,'y!"# 'z,$%&

;; C Source Statement : t = z + x ;;; Generated Assembler :

ADD# $%&,'x

!"# 't,$%&

;; C Source Statement : t += x ;;; Generated Assembler = Same Code

ADD# $%&,'x!"# 't,$%&

;; C Source Statement : x ++ ;;; Generated Assembler = se o2 ones register

S## 'x,!-3S

;; C Source Statement : ++ x ;;; Generated Assembler :

S## 'x,!-3S

;; C Source Statement : x = x ++ ;;; Generated Assembler = 4riority 4roblem

!"# $%),'xS## 'x,!-3S!"# 'x,$%)

;; C Source Statement : z = *x ;;; Generated Assembler = !.timized usage o2 -eg

-3G# $%)!"# 'z,$%)

;; C Source Statement : z = *506 ; z = *z ;;; Generated Assembler = Correct

!"# $%7,8(95h!"# 'z,$%7!"# $%),8(6h!"# 'z,$%)

;; C Source Statement : z = *509 ; z = *z ;

;; Generated Assembler = S.eci2ic treatment o2 (9(h!"# $%7,8(9(h!"# 'z,$%7!"# $%),8(9(h!"# 'z,$%)

C"#$


53/167


Signed ord Addition and Subtraction

;; C Declarations :int x,y,z,t ;


z = x+y ;;; Generated Assembler = Same .rinci.les as #ytes

!" $&,'xADD $&,'y!" 'z,$&

nsigned ord Addition and Subtraction

;; C Declarations :unsigned int x,y,z,t ;

;; C Source Statement : z = *5 ;;; Generated Assembler = Same .rinci.les as #ytes

!" 'z,!-3S

;; C Source Statement : z = x+y ;;; Generated Assembler =


54/167


;; Generated Assembler = ?uite !.timized @ith neg!"#S $0,'x!" $7,$0-3G $7!"# 'z,$%7


z >= *5 ;;; Generated Assembler = non !.timized in this case

!" $0,8(h!"#S $&,'z% $&,$0!" $&,D%!"# 'z,$%&

;; C Source Statement : z = z > 7 ;;; Generated Assembler = !.timized

!"#S $&,'z!" $),$&

S% $),8(0hS# $),$&!"# 'z,$%)

;; C Source Statement : z >= 7 ;;; Generated Assembler = -on !.timized

!" $&,8(7h!"#S $),'z% $),$&!" $),D%!"# 'z,$%)

,y,

;; C Source Statement : z = x > y;;; Generated Assembler :

!"#S $&,'x!"#S $),'y% $&,$)

!" $&,D%!"# 'z,$%&

;; C Source Statement : z = x > (;;; Generated Assembler = ?uite !.timized

!"# $%&,'x!"# $%&,8((h!"# 'z,$%&

;; C Source Statement : z = x > 5;;; Generated Assembler = !.timized

!"# $%&,'x!"# 'z,$%&


!"#S $&,'xS% $&,8(5h!"# 'z,$%&


!"#S $&,'x!" $),$&S% $),8(7hADD $),$&S% $),8(5h!"# 'z,$%)

Signed #yte Diide

;; C Declarations :

Signed ord ulti.lication

;; C Declarations :

C"#$


55/167


olatile char x,y,z ;char nx ;

;; C Source Statement : z = x B y;;; Generated Assembler :

!"#S $&,'x!"#S $),'y!" D%,$&D


56/167


olatile int x,y,z ;

;; C Source Statement : z = x B y;;; Generated Assembler :

!" $&,'x!" $),'y

!" D%,$&D


57/167


;; C Source Statement :x = 5 ;

;; Generated Assembler :!" $&,8(5h!" 'x,$&

;; C Source Statement :y = 5 ;

;; Generated Assembler :!" $),8(5h!" 'y,$)

;; C Source Statement : x = y = 5;; Generated Assembler :

!" $&,8(5h!" 'x,$&!" 'y,$&

char sb5;char sb0 ;unsigned char ub5 ;unsigned char ub0 ;int s@5;int s@0 ;unsigned int u@5 ;

unsigned int u@0 ;

;; C Source Statement : sb0 = sb5 5 ;;; Generated Assembler = !.timized

!"#S $&,'sb5AS$ $&,8(5h!"# 'sb0,$%&

;; C Source Statement : sb0 = sb5 HH 5 ;;; Generated Assembler = !.timized

!"#S $&,'sb5

S% $&,8(5h!"# 'sb0,$%&

;; C Source Statement : ub0 = ub5 5 ;;; Generated Assembler =


58/167


Funcţii Funcţii

1oţiunea de /uncţie în C


59/167


'e implementează prin instrucţia Call (din assembler)"

5 %uncţie este de%inită de un +eader (nume# tip# parametri %ormali)

>n corp

5 %uncţie are tipul scalar (c+ar# int# long sau pointer) %uncţie propriu;zisă

void asimilabilă unei proceduri din P,'C,!

/uncţiile non void returnează un rezultat de tipul respectiv" $xemplu

- add (x#M) returnează x 2 M

/uncţiile de tip void nu returnează nici un rezultat"

9eaderul /uncţiei 0"


60/167


'intaxa

NvizibilitateO

Nmodul de pasare a parametrilorONtipO

NnumeO

(Nlista parametrilorO) :izibilitatea

odi%icatorul KstaticLpoate %i %olosit pentru a %ace ca %uncţia să %ie vizibilă doar în interiorul

%i*ierului în care a %ost declarată"

odul de pasare a parametrilor

Implicit# parametrii sînt pasaţi prin registre# în limita registrelor disponibile# apoi prin stivă"

5pţiunea KstacVparmL %orţează pasarea tuturor parametrilor prin stivă"

3ipul

void pentru proceduri

scalar (implict int)

C"#$

9eaderul /uncţiei 02


61/167


!ista parametrilor Poate %i vidă K()L sau K(void)L dacă nu se transmite nici un parametru"

Prezenţa parantezelor este obligatorie" !ista parametrilor este o listă de declaraţii de date"

,ce*ti parametri# numiţi parametri %ormali# sînt consideraţi variabile locale# vizibile doar îninteriorul corpului %uncţiei"

'înt disponibile două tipuri de parametri

- 3ransmi*i prin valoare (de intrare)" !a apel# programul apelant trimite %uncţiei o copie

a valorii parametrului actual"- 3ransmi*i prin adresă (de intrare?ie*ire) " !a apel# programul apelant trimite %uncţieiadresa parametrului actual (un pointer)# %apt marcat prin operatorul Q"

$xemple de +eadere 5 %uncţie % care are un parametru întreg x *i returnează un întreg

- int % (int x)

5 procedură g care are un parametru de intrare x *i un parametru de intrare?ie*ire z"- void g(int x# int QM)

Corpul /uncţiei


62/167


$ste delimitat de acolade# Z [# ca *i orice alt bloc de program C"

Permite declaraţii de variabile locale

Implicit de tip automatic# alocate dinamic în registre sau stivă" odi%icatorul static %orţează alocarea în zona de date statice"

odi%icatorul register sugerează alocarea în registru"

&acă tipul %uncţiei nu este void# ea include cel puţin o instrucţie return. Instrucţia return %orţează părăsirea %uncţiei"

:aloarea returnată este cea care rezultă din evaluarea expresiei din instrucţia return" $xemplu

return x 2 1

Parametrii transmi*i prin valoare sînt %olosiţi ca atare"

Parametrii transmi*i prin adresă pot %i modi%icaţi# prin efect lateral # de către%uncţie"

Apelul de /uncţie


63/167


,pelul unei %uncţii se %ace prin numele %uncţiei# urmat de lista parametrilor actuali "

Prezenţa parantezelor este obligatorie" eguli pentru parametrii actuali

Parametrii transmi*i prin valoare pot %i substituiţi cu expresii de acela*i tip" Parametrii transmi*i prin adresă necesită existenţa unei variabile declarate# a

cărei adresă (pointer) se extrage cu operatorul 8" /uncţii inline

Cre*te viteza de execuţie în dauna spaţiului de memorie" Corpul %uncţiei (în cod ma*ină) este copiat la %iecare apel din cod sursă" 'e evită procedura de apel?retur care consumă timp"

&oar pentru %uncţii statice"

uncţii. B$emplul "


64/167


/uncţie cu parametru transmis prin valoare"int % (int x)

Z return x21

[ ,pelul

int a

const b T 1H

int r

aTE

r T % (a) ?Q r devine H Q?

r T %(b2r;1) ?Q r devine 1S Q?

uncţii. B$emplul 2


65/167


/uncţie cu parametru transmis prin adresă"void g (int QM# int x)

Z

QM T x21

[ ,pelul

int a

const b T 1H

int r

aTE

g(8r#a) ?Q r devine H Q?

g(8r#b2r;1) ?Q r devine 1SQ?

g(r#a) ?Q incorect Q?

uncţii. B$emplul @


66/167


/olosirea eronată a unui parametru transmis prin valoare# pentru areturna rezultate prin e%ect lateral"

void g (int M# const int x) Z M T x21 [

,pelul

int aconst b T 1H int rrTJaTE

g(r#a) ?Q r nu va %i a%ectat Q?g(8r#a) ?Q deasemenea %ără e%ectul scontat Q?

Detalii de implementare Parametrii !a C16x primii patru parametri se trimit prin 1 1E 1H 1

C"#$


67/167


!a C16x primii patru parametri se trimit prin 1# 1E# 1H# 1" Pentru %uncţii cu mai mult de patru parametri se %olose*te stiva" 1# 1E# 1H *i 1 nu sînt adresabile la nivel de octet"

n cazul %uncţiilor terminale (lea% %unctions)# ordinea parametrilor poate %ioptimizată" $xemplu

void % ( long a# int b #long c # c+ar Qd)- a 1;1E- b 1H

- c stiva- d stiva void g ( long a# int b #c+ar Qd# long c)

- a 1;1E- b 1H- d 1- c stiva

n cazul %uncţiilor neterminale ese necesară o analiză interprocedurală a codului pentru a putea %ace o optimizare" &e obicei se %olose*te stiva"

Detalii de implementare ) Variabilele locale

C"#$


68/167


!a C16x se %olosesc 6# R# S# U pentru primele patru variabile

locale" n continuare se %olose*te stiva" S *i U nu sînt adresabile la nivel de octet" U este %olosit de obicei pentru variabile de tip bit" 1# 1E# 1H *i 1 pot %i %olosite dacă sînt disponibile"

n cazul %uncţiilor terminale# datele locale pot %i optimizate" n cazul %uncţiilor neterminale ese necesară o analiză

interprocedurală a codului pentru a putea %ace o optimizare" &eobicei se %olose*te stiva"


69/167


VizibilitateVizibilitate

Vi+ibilitatea datelor 0"

3 i l li ă i ibil t d t


70/167


3rei localizări posibile pentru date

7odul7odul

7odul

uncţie

uncţie

?loc

Vi+ibilitatea datelor 02


71/167


5 dată este vizibilă în interiorul %i*ierului (dată de nivel global)# %uncţieisau blocului în care a %ost declarată"

5 dată de nivel global poate %i %ăcută vizibilă *i pentru alte %i*iere (module)" odi%icatorul extern:

$ste %olosit într;un %i*ier# pentru a %ace posibil accesul la o dată care a %ostdeclarată în alt %i*ier pe nivel global"

'intaxaextern Ndeclaraţie de datăO

$xempluextern int r

odi%icatorul static: $ste %olosit pentru a ascunde o dată globală %aţă de alte module (%i*iere)" 'intaxa

static Ndeclaraţie de datăO

$xemplustatic int r

Vi+ibilitatea /uncţiilor 0"

$ i tă d ă ti i d i ibilit t


72/167


$xistă două tipuri de vizibilitate

i8ier ?

uncţia local* /

uncţia e$portat* b

i8ier A

uncţia a

Vi+ibilitatea /uncţiilor 02 odi%icatorul extern.

$ t % l it î t %i i t % ibil l l % ţi % t d %i ită î lt


73/167


$ste %olosit într;un %i*ier# pentru a %ace posibil accesul la o %uncţie care a %ost de%inită în alt%i*ier"

'intaxa

- extern N+eader de %uncţieO $xempluextern int % (int x)

,tenţie- &eclaraţia extern este obligatorie dacă tipul %uncţiei este altul decît int# alt%el este opţională"- &eclaraţia extern este recomadabilă deoarece %orţează compilatorul să veri%ice tipul %uncţiilor"

odi%icatorul static. $ste %olosit într;un %i*ier pentru a ascunde o %uncţie %aţă de alte %i*iere" 'intaxa

- static N +eader de %uncţie O $xemplu

- static int % (int x) Z ?Qcorpul %unctieiQ? [ Prototipuri"

>n prototip este un +eader de %uncţie %olosit pentru a declara o %uncţie externă" ntr;un prototip# numele parametrilor %ormali pot %i omise"

$xempluextern int % (int) Protipurile %uncţiilor externe de uz larg sînt stocate în %i*iere +eader ("+)"

Vi+ibilitatea la nivel de tas<

C"#$


74/167


odi%icatorul public. $ste %olosit pentru a declara o dată care poate %i accesată în mod concurent de către mai multe

tasVuri"

AS= :as< 07ain

Sistemde operare

:as


75/167


Structuri de control Structuri de control

?locuri instrucţie 'intaxa


76/167


Z

NdeclaraţiiO

Ninstrucţiune 1O """ Ninstrucţiune nO [

'înt utile pentru a declara date locale *i pentru a încapsula un anume procedeu" Compilatorul de C16x nu asigură optimizarea alocării datelor" $xemplu

int i#j

Z

int i

jTi ?Q i este data locală Q?

[

C"#$

I 8i I BLSB

'intaxa


77/167


'intaxa

i% NexpresieO NinstrucţiuneO

i% NexpresieO Ninstrucţiune 1O else Ninstrucţiune O

unde Nexpresie O este /,!'$ dacă expresia evaluată este zero (tipul este booleanimplicit)"

$xemplei% (iN1) iTi21 else iT1

i% (iN1) Z

jTV

VTi

iTi21 [

Structura CASB 'intaxa


78/167


'0itc+ (Nexpresie întreagăO) Z

case Nvaloare 1O

NinstrucţiuneON instrucţiuneO

breaV

case Nvaloare O

N instrucţiuneO

breaV

de%ault

N instrucţiuneO

[ $xpresia evaluată trebuie să %ie de tip întreg sau enumerare" Cazul default este opţional"

break este optional dar lipsa sa sc+imbă modul de execuţie" Instrucţia switch poate %i înlocuită cu o tabelă de salturi sau cu o listă imbricată deinstrucţii i%;else"


79/167


S


80/167


p ţ p

eturnează un rezultat"

'intaxaNcondiţieO Nexpresie I/(condiţie este 3>$)O Nexpresie $!'$O

$xemplu /uncţia ax (x#M)

xNMMx

>tilitatea Codul generat este optimizat în unele cazuri# %aţă de implementarea cu instrucţii i% (depinde de

compilator)"

5peratorul este acceptat de toate compilatoarele compilatoarele"

,tenţie $xprimarea este concisă dar greu de citit"

Pot apărea e%ecte laterale"

C"#$


81/167


Com.arison bet@een i2 and Q

;; C Source Statement : i2 /xy1 z=y ; else z=x ;;; Generated Assembler = -ot !.timized

!" $&,'xC4 $&,'yK4$ cc'S%3,'R!" $&,'y!" 'z,$&K4$ cc'C,'6

'R:!" $&,'x!" 'z,$&

'6:

Com.arison bet@een i2 and Q

;; C Source Statement : z=xyQy:x ;;; Generated Assembler = !.timized

!" $&,'xC4 $&,'yK4$ cc'S%3,'9

'L:!" $&,'y

K4$ cc'C,'5('9:

!" $&,'x'5(:

!" 'z,$&

Structuri iterative 0"

3rei tipuri de bucle


82/167


=+ile- &e%iniţie

Instrucţiunea se execută iterativ cît timp expresia evaluată este non;zero" $xpresia seevaluează înainte de execuţie"

- 'intaxa

0+ile (NexpresieO) NinstrucţiuneO

&o;=+ile- &e%iniţie

Instrucţiunea se execută iterativ cît timp expresia evaluată este non;zero" $xpresia seevaluează după de execuţie"

- 'intaxa

do NinstrucţiuneO 0+ile (NexpresieO)

Structuri iterative 02

/or


83/167


- &e%iniţie

ai întîi# se evaluează expresia Nexpr1O" ,poi# atîta timp cît expr este non;zero# se execută

acţiunea" &upă %iecare iteraţie se evaluează exprE"- 'intaxa

%or (Nexpr1ONexprONexprEO)

NinstrucţiuneO

ceea ce se poate pune *i sub %orma

Nexpr1O

0+ile (NexprO) Z NinstrucţiuneO

NexprEO [

- $%icienţă

&e%inirea indexului de buclă ca întreg"

Alte structuri de control

.reaV *i continue


84/167


Z ?Q Inceput de bucla Q?

""" ? """

breaV """ ? """

continue

""" ? """

?Q '%irsit de bucla Q?

[ Instrucţia breaV are ca e%ect părăsirea celei mai interioare bucle 0+ile# do # %or sau s0itc+" Instrucţiunea continue are ca e%ect trecerea controlului la s%îr*itul celei mai interioare bucle 0+ile# do sau %or#

moment în care condiţia de buclare este reevaluată"

]oto 'intaxa

goto Netic+etăO

""" ?

Netic+etăO$ste o structură de control speci%ică limbajelor de asamblare" Paradigma de proiectare strucrurată recomandăevitarea ei"

hile statement


85/167


@hile /ru@'!ctet1 I i2 /ru@'!ctet F (x(51

I B> Change .arity >B ru@'4arity = ru@'4arity; }

ru@'!ctet = 5; }

or statement @ith additional increment and init

.ub'4tr#u2Dyn= .ub'DynData;

.ub'4trDiag=A-S3$'4$;>/.ub'4trDiag1+=(x&(;

2or /ru@'/.ub'4trDiag1 = >/>/.ub'4tr#u2Dyn11; .ub'4tr#u2Dyn++; }

3xam.les o2 Do hile structure @ith a breaO statement

do I

B> B


86/167


B -e@ last is the .ointed >B raub'-extimSrMrub'%ocal4trimSrN =

rub'%ocal4trimSr; } else I B> Adding to the next o2 the timer to sto., the

reload o2 the timer to sto. >B ras@'$eloadimSrMraub'-extimSrMrub'-umSrNN+=

ras@'$eloadimSrMrub'-umSrN;

B> Changing the next >B raub'-extimSrMrub'%ocal4trimSrN =

raub'-extimSrMrub'-umSrN; } breaO; } else I

rub'%ocal4trimSr =raub'-extimSrMrub'%ocal4trimSrN; } } @hile/51;


87/167


Tablouri şi pointeri Tablouri şi pointeri

:ablouri simple >n tablou este un set de date care au acela*i tip" &atele sînt alocate contiguu în memorie


88/167


&atele sînt alocate contiguu în memorie" &eclararea tablourlorO

NtipO NnumeO FNdimensiuneOG tMpe poate %i oarecare ,tributul dimensiune este obligatoriu *i reprezintă dimensiunea maximă

$ste posibilă iniţializarea o dată cu declarareaNtipO NnumeO ZFNdimensiune OG[ T Z Nlistă de valoriO [

tipul trebuie să %ie compatibil cu valorile precizarea dimensiunii este opţională întrucît ea se poate deduce din lista de valori

$xempleint t FHG

- int j FG T Z1# # E [ ?Q dimensiunea este E Q?

- int V FG T Z1#[ ?Q celelalte elemente se iniţializează cu J Q?

- int l FG T Z1# # E [ ?Q Incorect Q?

Accesul la elementele unui tablou

,ccesul se %ace cu ajutorul operatorului FG" ntre parantezele drepte


89/167


se plasează indexul"

$xemplur T a FiG 2 b FjG

Primul element al unui tablou are indexul J"

9umele unui tablou reprezintă adresa primului element din tablou *i

poate %i parametru actual la apelul unei %uncţii"

$ste posibilă declararea de tablouri cu mai multe dimensiuni

Array code

;; C Declarations :char C M5(N;int M5(N;


Array handling

rub'Serice


90/167


;; C Sou ce State e t : CMxN = (;;; Generated Assembler =


91/167


date" &eclaraţie

NtipO Q NnumeO >tilizare

Q Nnumele datei indicate de pointerO 3ipul pointerului trebuie să %ie compatibil cu cel al datei indicate"

$xemple

- c+ar Q p de%ine*te un pointer compatibil cu orice adresă de octet (a*adar# cu orice adresă)"- int Q p de%ine*te un pointer compatibil cu orice dată aliniată la adresă pară

>n pointer este întotdeauna alocat în ,"

Atribuirea pointerilor

>nui pointer i se poate atribui valoarea altui pointer# adresa unuiobiect (prin intermediul operatorului de extragere a adresei 8) sau


92/167


obiect (prin intermediul operatorului de extragere a adresei 8)# sauvaloarea unei expresii de tip pointer" $xemple

c+ar Qp

int Q

c+ar a

int b

p T 8a

p T 8b ?Q corect Q?

T 8a ?Q incorect Q?

T 8b ?Q corect Q?

p T 8 ?Qcorect# adresa unui alt pointer Q?

Pointeri 8i constante

Cuvîntul c+eie const poate %i %olosit în declaraţii de pointeri" &e exemplu


93/167


int a

int Qpint Qconst ptr T 8a ?? Pointer constant

Qptr T 1 ?? !egal# Qptr se poate modi%ica

ptr Tp ?? $roare# ptr nu se poate modi%ica &esemenea se poate declara un pointer ca indicînd către o variabilă care este de

tip constant"const int a

int Qp

const int Q ?? Pointer catre o variabila de tip constant

const int Qptr T 8a ?? !egal

Qptr T 1 ?? $roare

ptr Tp ?? $roare ptr T ?? !egal

B$presii cu pointeri

>n pointer poate %i %olosit în expresii aritmetice de tip întreg pentru a e%ectuacalcule de adresă# în mod similar celui în care un registru de adresă este %olosit în


94/167


# gassembler"

3ipul pointerului de%ine*te pasul de incrementare" $xemple

- c+ar Qp p21 este adresa următorului octet (adresa %izică 2 1)

- int Q p p21 este adresa următorului 0ord (adresa %izică 2 ) 3ipul pointer nu este compatibil cu tipul întreg"

$xempleint i

c+ar Qp

p T EH ?Q corect dar nerecomandat Q?

p T 8i ?Q corect Q?

p T p 2 1 ?Q corect Q?

p T p Q H ?Q incorect Q?

p T i ?Q incorect Q?

:ablouri 8i pointeri

3ablourile *i pointerii sînt tipuri de date compatibile unul cu celălalt"

5 declaraţie de tablou alocă un număr de octeţi în memorie *i de%ine*te un mod


95/167


5 declaraţie de tablou alocă un număr de octeţi în memorie *i de%ine*te un modde a avea acces la oricare dintre ei"

9umele unui tablou poate %i considerat ca un pointer constant la primul elemental tabloului"

,vem ec+ivalenţaint tab FEG ?Q tab FiG NTTO Q (tab 2i) Q?

$ste deasemenea posibil să de%inim un pointer pentru a avea acces la elementeleunui tablou"int tab FEG

int Qp

p T 8 tab FJG ?Q initializarea lui p cu primul element al tabloului Q?

p 22 ?Q p adreseaza al doilea element Q?

Qp T ?Q al doilea element este modi%icat Q?

Code 2or .ointers

int x,y,z;char c;char > .C ;int > .< ;

;; C Source Statement : .C = /char >15(;;; Generated Assembler :

se o2 .ointers to bro@se data area

ru@'ChO = (;2or /r.'4tr$amCtl=FS$A'#T3'#!!;

r.'4tr$amCtlHFS$A'#T3'!4 ;r.'4tr$amCtl++ 1

Iru@'ChO += >r.'4tr$amCtl;

}2or /r. 4tr$amCtl=FS$A !$D #!!;

C"#$


96/167


;; Generated Assembler :!" $&,8(Ah!" '.C,$&

;; C Source Statement : .C = Fx ;;; Generated Assembler :

!" $),8'x!" '.C,$)

;; C Source Statement : .< = /int >1 Fc ;;; Generated Assembler = Could generated a 2ault

!" $0,8'c!" '.r.'4tr$amCtl;}2or /r.'4tr$amCtl=/'!$D>1Fru'$amOey;

r.'4tr$amCtlH=/'!$D>1Fru'ChecOsumcr@o ;r.'4tr$amCtl++ 1

Iru@'ChO += >r.'4tr$amCtl;

}


97/167


Structuri şi uniuniStructuri şi uniuni

Structuri

'înt agregate contigue de variabile de tipuri oarecare" /iecare variabilă din interiorul unei structuri poartă numele de cîmp"


98/167


p p &eclaraţie

struct Z Nlistă de variabileO [ NnumeO Iniţializare

struct Z Nlistă de variabileO [NnumeO T Z Nlistă de valoriO [

,tenţie Pe procesoare de 16 biţi# structurile se aliniază la multipli de octeţi" 3rebuie evitate

KgolurileL în interiorul structurilor"

$xemplestruct Z

int c1

int c [ x ?Q structura neinitializata Q?struct Z int c1

int c [ M T Z1#1[ ?Q structura initializata Q?

5tili+area structurilor

5 structură este accesată prin numele ei"


99/167


/iecare cîmp este accesat %olosind numele cîmpului *i

operatorul K"L" $xemplu

x"c1 T M"c1

$ste posibilă modi%icarea unei structuri în întregul său prin

atribuire"

5peratorul ;O $ste %olosit pentru a combina lucrul cu structuri *i cel cu pointeri"

(Qx)"a NTTO x;Oa

5niuni 5 uniune este un tip de date de%init de utilizator# care poate stoca valori de tipuri

di%erite la momente di%erite" $ste similară unei structuri# cu di%erenţa că tuturormembrilor li se alocă acelea*i locaţii de memorie


100/167


membrilor li se alocă acelea*i locaţii de memorie" 5 variabilă de tip uniune poate conţine la un moment dat doar unul dintre membrii

săi" 'paţiul alocat uniunii este spaţiul necesar pentru cel mai mare membru" 'intaxa

union Z Nlista de cîmpuriO [ NnumeO $xemple

,ceastă dată poate %i adresată %ie ca tabel (arraM) %ie ca structură union Z

int cMlBtabFHGstruct Z

int cMl1int cMlint cMlEint cMlH[ cMlBid

[ advanceBtable advanceBtable"cMlBtabF1G NTO advanceBtable"cMlBid"cMl

Code 2or unions

;; C Declarations :int x,y,z ;char c;union I unsigned int !$D ;struct I

Code 2or structures

;; C Declarations :int x,y,z ;struct I char c ; int i,J ;} S ;

C"#$


101/167


struct I unsigned char %S#, S# ; } #T3 ;

} ;

;; C Source Statement : !$D = x;;; Generated Assembler = !.timized

!" $&,'x!" ',$&

;; C Source Statement : #T3%S# = c ;;; Generated Assembler = !.timized

!"# $%&,'c

!"# ',$%&

;; C Source Statement : #T3S# = ( ;;; Generated Assembler = !.timized

!"# /'+51,E3$!S

} S ;

;; C Source Statement : Sc=(;;; Generated Assembler :

!"# 'S,E3$!S

;; C Source Statement : SJ=Si;;; Generated Assembler :

!" $&,/'S+01!" /'S+&1,$&


102/167

Cîmpul de biţi Permite lucrul cu date de tip bit" $ste bazat pe conceptul de structură" 'i t


103/167


'intaxa

struct Z unsigned NcîmpO NlăţimeO

""" [ NnumeO

Codul produs nu este întotdeauna optimizat" $xemplu

struct 3$\3BC$!! ?? &eclara 3$\3BC$!! ca un cimp de biti

Z

unsigned c+aracter S ?? JJJJJJJJ

unsigned %oreground E ?? JJJJJ JJJJJJJJ

unsigned intensitM 1 ?? JJJJJJJ JJJJJJJJ

unsigned bacVground E ?? JJJJJ JJJJJJJJ

unsigned blinV 1 ?? JJJJJJJ JJJJJJJJ

[ screenFGFSJG ?? atrice de cimpuri de biti

Date de tip ?it

'înt speci%ice secţiunii adresabile la nivel de bit din memoria internă a C16x" Permit declaraţii la nivel de bit"

C"#$


104/167


ţ 'intaxa

.I3 a#b#c

aT b 8 c Produce un cod optimizat" &atele de tip bit nu pot %i combinate cu date de alte tipuri (tablouri# structuri#

pointeri)"

#oolean ex.resssions using integers data

;; C Source Statement : bi7 = bi5 F bi0 ;;; Generated Assembler = ?uite !.timized

!" $&,'bi5A-D $&,'bi0!" 'bi7,$&

;; C Source Statement : bi7 = bi5 FF bi0 ;;; Generated Assembler = -on !.timized

!" $&,'bi5K4$ cc E, 50

#oolean ex.resssions using #it data

;; C Source Statement : b7 = b5 F b0 ;;; Generated Assembler = !.timized

#C4 'b5,'b0#!" 'b7,C

;; C Source Statement : b7 = b5 FF b0 ;;; Generated Assembler = -ot !.timized

K-# b5 &

C"#$


105/167


K4$ cc'E,'50'5&:

!" $&,'bi0K4$ cc'E,'50

'55:!" $&,8(5hK4$ cc'C,'57

'50:!" $&,8((h

'57:!" 'bi7,$&

;; C Source Statement : bi7 = bi5 U bi0 ;;; Generated Assembler = !.timized

!" $&,'bi5!$ $&,'bi0!" 'bi7,$&

;; C Source Statement : bi7 = bi5 ;;; Generated Assembler = -ot !.timized

!" $&,'bi5K4$ cc'-E,'0(

'5L:!" $&,8(5hK4$ cc'C,'05

'0(:!" $&,8((h

'05:!" 'bi7,$&

;; C Source Statement : bi7 = Vbi5 ;;; Generated Assembler = !.timized

!" $&,'bi5C4% $&!" 'bi7,$&

K-# 'b5,'&'R:

K-# 'b0,'&

'7:#S3 S$(K4$ cc'C,')

'&:#C%$ S$(

'):#!" 'b7,S$(

;; C Source Statement : b7 = b5 U b0 ;;; Generated Assembler = !.timized

#C4 'b5,'b0#!" 'b7,-

;; C Source Statement : b7 = b5 ;;; Generated Assembler = !.timized

#!"- 'b7,'b5

;; C Source Statement : b7 = Vb5 ;;; Generated Assembler = !.timized

#!"- 'b7,'b5

#oolean ex.resssions using #it ields

;; C Declarations :olatile struct I unsigned bc5 : 5 ;

unsigned bc0 : 5 ;

C"#$


106/167


unsigned bc0 : 5 ; unsigned bc7 : 5 ;

} bit2ield;

;; C Source Statement : bit2ieldbc7 = bit2ieldbc5 F bit2ieldbc0 ;;; Generated Assembler = Should be aoided

!" $&,'bit2ieldA-D $&,8(5h

!" $),'bit2ieldS$ $),8(5hA-D $),8(5hA-D $&,$)A-D $&,8(5hS% $&,8(0h!" $),'bit2ieldA-D $),8(#h!$ $),$&

!" 'bit2ield,$)


107/167


Organizarea memoriei Organizarea memoriei

7odele de memorie

n general# prin model de memorie înţelegem modelul deorganizare a resurselor disponibile de memorie# pentru cod *i


108/167


pentru date# din punctul de vedere al compilatorului" Problema este speci%ică procesoarelor cu memorie segmentată" 'copul este de a găsi un compromis între modurile de adresare

cele mai simple *i mai e%iciente cu necesarul real de memorie pentru cod *i date"

Compilatorul pentru C16x admite patru modele de memorie 3inM cod N 6H7 &ate N HQ16 T6H7 'mall cod O 6H7 &ate N HQ16 T6H7 edium cod N 6H7 &ate O HQ16T6H7 !arge cod O 6H7 &ate OHQ16T6H7

C"#$

Accesul la date% Segment% Pagin*%

!a seria C16x memoria de cod

Pagin &eg/ent

C"#$


109/167


!a seria C16x memoria de cod

(programe) este organizată în segmente de 6H7" emoria de date (operanzi)

este organizată în pagini de167"


110/167


$xistă H registre pointer de pagini de date &&PJ""E (&&P T &ataPage Pointer)"

Principiul de adresare orice adresă internă de date de 16 biţi se

%ormează din .iţii 1E""J care speci%ică un o%%set în pagină

.iţii 1 *i 1H care speci%ică un registru &&P

n cazul cel mai simplu# registrele &&P se înscriu o singură dată# la

reset"

Accesul la date din limbajul C 5 dată este plasată în mod implicit a*a %el încît adresa ei să %ie

de tipul near# ceea ce nu implică modi%icarea registrelor &&P"$xemple

C"#$


111/167


p- c+ar aBn - c+ar near aBn

5 dată poate %i alocată dincolo de limita de 6H7 %olosind adresede H biţi# caz în care adresa va %i declarată de tip %ar *i accesulla dată va implica modi%icarea registrelor &&P" $xemplu

c+ar %ar aB% &acă data este un tablou al cărui dimensiune depă*e*te 6H7

atunci adresa va %i declarată de tip +uge# iar indexul în tablouva trebui să %ie un întreg de tip long"

c+ar +uge aB+F1JJJJJG

Accesul la /uncţiile C 5 %uncţie poate %i localizată în orice segment" Pentru a de%ini o %uncţie care este localizată în acela*i segment ca *i

i l ii i % l i di%i l

C"#$


112/167


toţi apelanţii ei# se poate %olosi modi%icatorul near. $xemplu

void near % ()

,cesta ar trebui să %ie# în particular# cazul %uncţiilor statice" ,pelul în acela*i segment este mai rapid"

Impactul asupra pointerilor

Pointeri %ar >n pointer %ar este o adresă de E de biţi care permite accesul în orice segment"

C"#$


113/167


$xemplec+ar Qp c+ar %ar Q%p

p T 8 aBn ?Q corect Q?

p T 8 aB% ?Q incorect Q?

%p T 8 aB% ?Q corect Q?%p T 8 aBn ?Q corect Q?

,tenţie >n pointer poate %i el însu*i o dată de tip %ar" $xemplu

c+ar Q %ar p ?Q a nu se con%unda cu c+ar %ar Q p Q?

7odelul Small

ajoritatea aplicaţiilor din domeniul automotive %olosesc modelulsmall

C"#$


114/167


small" Ca o caracteristică generală a aplicaţiilor din domeniul automaticii#

acestea %olosesc relativ puţine resurse de memorie ," n modelul small# %iecare &&P indică după reset o pagină de ,"

,ceastă setare nu se mai modi%ică" Codul (programele) poate depă*i 6H7 dacă este necesar"

ar and uge data

;; C Declarations :2ar char M5(N;huge char M5(((((N;

;; C Source Statement : MxN = (;;; Generated Assembler = 2ar data acces

ar .ointers and .ointers to 2ar data

;; C Declarations :olatile int x;olatile int y;int z ;char c;char > .C ;int > .< ;

C"#$


115/167


;;!" $),'x

!" D44(,84AG '!"# $%&,8((h!"# M$)+84! 'N,$%&!" D44(,84AG Q#AS3'D44(

;; C Source Statement : MxN = (;;; Generated Assembler = uge data acces

!" $5(,8S! '!" $55,8S3G '!" $0,'x!" $7,$0AS$ $7,8(h

ADD $5(,$0ADDC $55,$7!" M*$(N,$5(S$ $5(,8(3hS% $55,8(0h!$ $55,$5(!" $5(,M$(+N!" D44(,$55A-D $5(,8(7h!"# M$5(N,$%&!" D44(,84AG Q#AS3'D44(

. ;char 2ar > 2.C ;

char > 2ar .2C ;

;; C Source Statement : 2.C = Fc ;;; Generated Assembler = 4ointer to 2ar data

!" $&,84! 'c!" $),84AG 'c!" '2.C,$&!" /'2.C+01,$)

;; C Source Statement : .2C = Fc ;;; Generated Assembler = ar .ointer

!" D44(,84AG '.2C!" $7,8'c!" 4! '.2C,$7!" D44(,84AG Q#AS3'D44(


116/167


ointeri la !uncţii ointeri la !uncţii

Pointeri la /uncţii 'înt pointeri speci%ici al căror rol este de a memora adresa unei

%uncţii 'înt utili pentru


117/167


'înt utili pentru Programarea generică &eclararea tabelelor de salturi

&eclaraţieNtipul %uncţieiO (Q NnumeO) ()

>tilizare(Q NnumeO) ( NargumenteO) $xemplu

int (Q%) () ?Qdeclarare Q?extern int g () ?Q prototipul %uncţiei gQ?

% T g ?Q atribuire (operatorul 8 nu este obligatoriu aici) Q?(Q%) () ?Q apelul %uncţiei prin pointer Q?

-C

;; C Declarations :olatile int x,y,z ;extern int 2( /int1;extern int 25 /int1;extern int 20 /int1;extern int 27 /int1;int />MN1 /int1 = I2(,25,20,27} ;

C"#$


118/167


int / MN1 /int1 I2(,25,20,27} ;

;; C Source Statement : int i;;; Generated Assembler :

;; C Source Statement : 2or /i=(;iH&;i++1;; Generated Assembler :

!" $L,8((h'7:

;; C Source Statement : i2 //>MiN1/x1y1 breaO ;;; Generated Assembler :

!" $50,'x!" $&,$LS% $&,8(0h!" $5(,$&!" $&,M$5(+8'N!" $),M$5(+8/'+01NCA%%S S3G ''icall,''icall = S.eci2ic mechanismC4 $&,'yK4$ cc'SG,'&C4


119/167


reprocesorul " reprocesorul "

Comportarea compilatorului C

Compilarea se %ace în trei %aze Prima %ază preprocesarea

- includerea %i*ierelor +eader (directive Dinclude)


120/167


includerea %i*ierelor +eader (directive Dinclude)

- &e%inirea *i substituirea simbolurilor preprocesor (directive Dde%ine)- de%inirea *i substituirea macrode%iniţiilor

- eliminarea comentariilor

- analiza directivelor Dpragma

, doua %ază analiza codului (programului) sursă- analiza codului

- %ormarea *abloanelor de compilare

, treia %ază generarea codului obiect- optimizarea *abloanelor de compilare

- generarea %i*ierului cu cod obiect

Caracteristici ale preprocesorului0CppC PreProcesssor

&irectivele Cpp încep cu caracterul D"


121/167


pp p

&irectivele Cpp se termină la s%îr*itul liniei sursă" $ste posibilă

prelungirea pe mai multe linii %olosind caracterul de continuare

a liniei X"

Preprocesorul nu este recursiv"

$ste posibilă lansarea în execuţie a preprocesorului ca %ază de

sine stătătoare"

Includerea /i8ierelor 'intaxa

Dinclude Nnume de %i*ierO


122/167


&ouă modalităţi de a preciza locaţia %i*ierului- numele este delimitat de N *i O %i*ierul este localizat pe caleamemorată în variabila de mediu speci%ică (I9C!>&$)"

- numele este delimitat de N *i O %i*ierul este localizat în directorulcurent"

&irectiva este %olosită pentru a include %i*iere +eader#macrode%iniţii# variabile prede%inite speci%ice +ard0are"

$xempleDinclude Nmet+od"eO

Dinclude flocal"+f

Simboluri 8i macrode/iniţii &e%inirea simbolurilor

Dde%ine NnumeO NvaloareO

acrode%iniţii


123/167


Dde%ine NnumeO(Nlista de parametriO) Ncorpul de%iniţieiO $xemple

Dde%ine 3>$ 1

Dde%ine val1 1J

Dde%ine val Qval

Dde%ine max (x#M) (x)N(M)(M)(x) &in cauza priorităţilor operatorilor# parametrii trebuie %olosiţi împreună cu paranteze

$xempluDde%ine mul(x#M) (x)Q(M)mul (a21#b21) este translatat de către preprocesor în (a21)Q(b21)

$xemplu eronat

Dde%ine mul(x#M) xQMmul (a21#b21) este translatat de către preprocesor în a21Qb21

Compilarea condiţionat* $xistă două %orme de utilizare

Compilare condiţionată bazată pe expresii cu simboluriDi% NexpresieODelseDendi%


124/167


Dendi% Compilare condiţionată bazată existenţa unor simboluri

Di%(n)de% Nnume de simbolODelseDendi%

amura else este optională" Compilarea condiţionată poate %i %olosită încuibat"

$xempleDi% (9CBCY!B9O)

?Q Cod speci%ic pentru motoare cu mai mult de cilindri Q?Dendi%

Di%de% .55'3

?Q se compilează doar dacă simbolul .55'3 este de%init Q?Dendi%

Directiva Epragma

$ste o directivă speci%ică# %olosită pentru a de%ini medii de lucru nonstandard" 3ipuri de pragma


125/167


p p g &e%inirea modelului de memorie &e%inirea tipurilor de optimizări la compilare &e%inirea secţiunilor de memorie relocabile &e%inirea opţiunilor de listare &e%inirea nivelului de veri%icare la compilare

B$emple de pragmaDpragma global 5biectele C sînt globale pentru toate tasVurileDpragma public 5biectele C sînt publiceDpragma nomacro mpiedică expandarea macrode%iniţiilor Dpragma asm &eclară o secţiune de cod assembler inline

C"#$


126/167


Dpragma asm &eclară o secţiune de cod assembler inlineDpragma static %orţează toate variabilele la tipul staticDpragma automatic %orţează toate variabilele la tipul automaticDpragma clear 4terge conţinutul variabilelor statice la lansarea programuluiDpragma noclear Păstrează conţinutul variabilelor statice la lansarea programuluiDpragma cse size 'tabile*te dimensiunea stivei utilizator

Dpragma align xx 'tabile*te modul de aliniere a variabilelor în memorieDpragma class odi%ică numele clasei

Pragma asm $ste %olosită pentru a insera secvenţe de cod sursă în assembler

în interiorul programului sursă C" 'intaxa

C"#$


127/167


Dpragma asm (sau asmBno%lus+)

Ninstrucţiiîn assemblerO

Dpragma endasm

'e %olose*te în situaţii punctuale" 9ecesită o %oarte bună cunoa*tere a limbajului de asamblare" Portabilitatea depinde de

microcontroler compilator versiunea compilatorului

4$AGA AS

;; C Declarations :olatile int a,b,W,r ;int x;


C"#$


128/167


W = aBb ;;; Generated Assembler :!" $&,'a!" $),'b!" D%,$&D


129/167


p 'elecţia caracteristicilor procesorului ţintă anagementul secţiunilor de cod &irective de generare a codului (date statice# registre %olosite

etc)

Inserarea codului sursă C în %i*ierul sursă assembler (src) &e%inirea simbolurilor coprocesorului Includerea %i*ierelor &e%inirea căilor pentru %i*ierele de includere

9ivelul de veri%icare a codului sursă C


130/167


!% Programarea C de nivel înaltpentru aplicaţii automotive

!% Programarea C de nivel înaltpentru aplicaţii automotive

Ce este programarea C de nivel înalt pentruaplicaţii automotive ,

$xtinde te+nicile de programare pentru ]enericitate


131/167


obusteţe entenabilitate

Programarea de nivel înalt utilizează *i unele extensii C22 Programarea de nivel scăzut *i cea de nivel înalt nu sînt concepte

opuse


132/167


MetaprogramareaMetaprogramarea

Conceptul de metaprogramare

Constă în %olosirea unor limbaje de nivel înalt sau %oarteînalt# altele decît C# pentru a genera cod sursă în limbajul C


133/167


etaprogramarea se bazează pe Preprocesorul Cpp ,lte unelte de preprocesare

$ste asemănătoare cu %olosirea *abloanelor de programare

în C22

Conte$tul standard de de+voltare /olose*te diverse unelte de programare" Proiectantul aplicaţiei C trebuie să supervizeze întregul proces de dezvoltare"


134/167


Compilator

Assembler

Lin


135/167


Cpp nu este recursiv" >neori sînt necesare mai multe %aze de preprocesare# deexemplu atunci cînd un macro este de%init în cadrul altui macro"

n a%ară de directivele Cpp admite construcţii precum I/ =@I!$

'$3 $ste un macrolimbaj complet

B$amplu de 7acro Instrucţii s0itc+ (ctrBVnV0) Z '$3(C3#J) =@I!$ (C3 ̀ T 9CBCY!B9) '$3(C3#C321) case C3 Z I&I9&=\(idBVnVB0bB C3 BBn#n) VnV0bFsegBo%sG T I&B1&.(idBVnVB0bB C3 BBn)

C"#$


136/167


breaV [ $9&= [ which is translated as :

s0itc+ (ctrBVnV0) Z case J Z I&I9&=\(idBVnVB0bBJBBn#n) VnV0bFsegBo%sG T I&B1&.(idBVnVB0bBJBBn) breaV [ case 1 Z

I&I9&=\(idBVnVB0bB1BBn#n) VnV0bFsegBo%sG T I&B1&.(idBVnVB0bB1BBn) breaV [ case Z I&I9&=\(idBVnVB0bBBBn#n) VnV0bFsegBo%sG T I&B1&.(idBVnVB0bBBBn) breaV [ case E Z I&I9&=\(idBVnVB0bBEBBn#n) VnV0bFsegBo%sG T I&B1&.(idBVnVB0bBEBBn)

breaV [ [

-mpacFetarea datelor

n aplicaţiile ,utomotive se lucrează cu multe


137/167


tipuri de date" Principiile împac+etării" gruparea datelor în scopul de a limita %luxul de date gruparea datelor în scopul de a limita cuplarea între date

3e+nici de împac+etare" eguli de denumire a variabilelor ]ruparea datelor în %i*iere# %olosind atributul KstaticL ]ruparea datelor în structuri de%inirea de %uncţii inline pentru accesul la date


138/167


G% 6eguli algoritmiceG% 6eguli algoritmice


139/167


#eguli generale#eguli generale

Constrîngeri

,lgoritmii %olosii în %aza de concepere a codului sursă sînt legaţi deurmătorii %actori de calitate

%i i


140/167


e%icienţa mentenabilitatea (portabilitatea# capabilitatea de evoluţie) robusteţea

Principalele obiective sînt Portabilitatea

$%icienţa

Cre8terea e/icienţei 0" $vitaţi apelurile inutile de %uncţii" /olosiţi

%uncţii inline macrode%iniţii

d li d l i ă


141/167


duplicarea codului sursă $vitaţi excesul de parametri la apelul %uncţiilor

&e regulă# mai puţin de H" /olosiţi variabile globale dacă sînt disponibile"

5rganizaţi expresiile condiţionale"

$ste necesară cunoa*terea modului de comportare a compilatorului" 5rdinea de testare a condiţiilor (în cea mai probabilă secvenţă)" 9umărul condiţiilor (evitarea evaluarii redundante a unor termeni)" 5rdinea cazurilor în instrucţiile s0itc+ (uneori# evitarea acestora)" /olosirea instrucţiilor goto# breaV# continue *i return (mai multe în

aceea*i %uncţie dacă este necesar"

/olosirea expresiei condiţionale dacă este mai e%icientă"

Cre8terea e/icienţei 02

$vitaţi datele de tip bMte" pre%erabil int (cu excepţia tablourilor mari)

i î t di i d l i i d t l


142/167


compromis între dimensiunea codului *i cea a datelor nlocuiţi tablourile de mici dimensiuni cu structuri" /olosiţi union pentru a selecta cel mai potrivit mod de acces la date" /olosiţi adresarea pe 16 biţi" $vitaţi pe cît posibil adresele %ar sau +uge" &eclaraţi date volatile doar atunci cînd este realmente necesar"

$vitaţi %olosirea stivei în %avoarea registrelor pentru datele locale"

Cre8terea e/icienţei 0@ /olosiţi accesul direct la registrele dedicate ale microcontrolerului

biţi de stare

&!# &@

$ it ţi % l i Kbl il L C (KZ[L) i d t l l l l i l d

C"#$


143/167


$vitaţi %olosirea KblocurilorL C (KZ[L) *i a datelor locale la nivel de bloc"

]rupaţi %uncţiile în segmente de cod *i %olosiţi apeluri de tip near emoraţi valoarea expresiilor în variabile locale înainte de a le pasa

ca parametri către macrode%iniţii# sau asiguraţi;vă că parametrul nu

este duplicat în macro" 5ptimizaţi secvenţele de cod assembler inline" '@!# '@# ,'@ în loc de >!#&I:#>!>#&I:>" $vitaţi trans%erurile între registre" /avorizaţi secvenţe liniare lungi de cod (se execută e%icient pe structuri

+ard0are de tip pipeline)"

C"#$

C"#$

Cre8terea mentenabilit*ţii

$vitaţi %olosirea macrode%iniţiilor" în special a celor exportate

$ it ţi % l i di ti i Dd %i i t t l lit l


144/167


$vitaţi %olosirea directivei Dde%ine *i a constantelor literale"(un cod care poate fi schimbat uşor este greu de întreţinut) /olosiţi programarea structurată" $vitaţi instrucţia goto *i %olosirea mai multor

instrucţii return într;o %uncţie" $vitaţi instrucţiile *i expresiile complexe# greu de înţeles" $vitaţi accesul direct la resursele microcontrolerului"

Cre8terea robusteţei 0"

9u %olosiţi `T sau TT în expresii condiţionale"- /olosiţi N# NT # O sau OT

9u vă bazaţi pe prioritatea implicită a operatorilor în expresii complexe"- Cu excepţia 2 Q and ?%olosiţi () sistematic


145/167


- Cu excepţia 2# ; # Q and ?%olosiţi () sistematic 9u combinaţi operatorii"

- 2 cu 22 sau 2T /olosiţi tMpede% pentru a de%ini propriile tipuri de date" /olosiţi blocurile"

- în mod special în macrode%iniţii

9u omiteţi breaV în instrucţia s0itc+" 9u omiteţi cazul de%ault în instrucţia s0itc+"

Cre8terea robusteţei 02

/olos

tutorial c iulie2004

Documents