CHAPITRE PROCESSEURS DE SIGNAUX (DSP)...

eivd PROCESSEURS DE SIGNAUX (DSP)

-1- CHAPITRE 2 MEE/07.04.03/DSP_02.DOC

PROCESSEURS DE

SIGNAUX (DSP)

CHAPITRE

��L’ASSEMBLEUR DU

PROCESSEUR TEXAS TMS320C5x



Table des matières 1. CHOIX DU LANGAGE DE PROGRAMMATION [6] 5

2. DEVELOPPEMENT D’UN CODE EXECUTABLE POUR LE PROCESSEUR TEXAS TMS320C50 6 2.1. Etape 1 : programmation de l’algorithme d’un filtre numérique 6

2.2. Etape 1 (suite) : organisation en sections (format COFF) [2, chap.2] 7

2.3. Etape 2 : assemblage 9

2.4. Etape 3 : édition de liens et configuration de la mémoire du processeur 11

3. ARCHITECTURE DU PROCESSEUR TEXAS TMS320C50 [1, §3.1 ET 3.2] 13 3.1. Exécution d’une instruction machine [6] 15

3.2. Les registres du processeur Texas TMS320C50 [1, §3.3] 15 3.2.1. ACC 15 3.2.2. TREG0 15 3.2.3. PREG 16 3.2.4. ACCB 16 3.2.5. AR0...AR7 (AUXREGS) 16 3.2.6. ARP 16 3.2.7. dma 16 3.2.8. DP 16 3.2.9. IMR 16 3.2.10. IFR 16 3.2.11. ST0, ST1, PMST 16

4. FAMILLES D’INSTRUCTIONS ET MODES D’ADRESSAGE 17 4.1. Vue d’ensemble du répertoire d’instructions du processeur Texas TMS320C50 [1, §4.2.2] 17

4.1.1. Opérations entre l’accumulateur et la mémoire 17 4.1.2. Opérations logiques 18 4.1.3. Opérations sur les registres TREG0 et PREG et instructions de multiplication 18 4.1.4. Instructions de branchement 19 4.1.5. Opérations sur l’espace I/O et la mémoire de données 19 4.1.6. Opérations sur les registres auxiliaires 19 4.1.7. Instructions de contrôle 20

4.2. Adressage 20 4.2.1. Adressage immédiat [1, §3.4.2 et 4.1.3] 20 4.2.2. Adressage direct [1, §3.4.2 et 4.1.1] 21 4.2.3. Adressage indirect [1, §3.4.2 et 4.1.2] 23

5. FORMAT DES DECLARATIONS ASSEMBLEUR [2, §3.6, 3.7, 3.9] ET [6] 25 5.1. Le champ label 25

5.2. Le champ mnémonique 25

5.3. Le champ opérande 25

5.4. Le champ commentaire 25

6. UTILISATION DE CONSTANTES DANS LES DECLARATIONS 26

7. CHARGEMENT ET SAUVETAGE DES REGISTRES 26 7.1. Registres ACC, ACCB, TREG, PREG 26

7.2. Registres auxiliaires AR0..AR7 27

7.3. Registres situés en mémoire (memory mapped registers) [1, §3.4.1 et §4.1.5] 28



8. INSTRUCTIONS ARITHMETIQUES 28 8.1. Additions et soustractions avec la CALU 29

8.2. Multiplications 29

9. INSTRUCTIONS LOGIQUES ET DECALAGES 30 9.1. Opérations logiques avec la CALU 31

9.2. Opérations logiques avec la PLU 31

9.3. Décalages 32

10. STRUCTURES DE CONTROLE 32 10.1. Saut inconditionnel 32

10.2. Sauts conditionnels 33 10.2.1. Sauts conditionnels basés sur l’état de l’accumulateur ou des flags (OV, C) 33 10.2.2. Sauts conditionnels basés sur l’état d’un registre auxiliaire (AR0..AR7) 33

10.3. Unité de répétition 34

11. SOUS-PROGRAMMES ET MACRO-INSTRUCTIONS 34 11.1. Introduction 34

11.2. Sous-programmes [6] 35 11.2.1. Appel d’un sous-programme 35 11.2.2. Création d’un sous-programme 35 11.2.3. Passage des paramètres 36

11.3. Macro-instructions [2, chap.6] et [6] 37

12. DIRECTIVES ASSEMBLEUR [2,CHAP.4] 38



1. Choix du langage de programmation [6]

L’assembleur est le langage le plus proche de la machine. Le premier but de l’assembleur a été de désigner les codes binaires des instructions machine par des codes mnémoniques. Il est étroitement lié à la structure du processeur et diffère donc pour chaque type de machine. D’une manière générale, on ne peut pas dire que l’on apprend l’assembleur, mais un assembleur.

Normalement, on ne doit pas développer du code en assembleur, car

• le coût d’un développement assembleur est 2 à 3 fois plus élevé que pour un langage évolué;

• le temps de développement est généralement 2 fois plus long;

• les erreurs sont plus nombreuses et plus difficiles à détecter, ce qui entraîne de coûts de maintenance prohibitifs.

Il faut donc réserver l’utilisation de l’assembleur à des besoins bien spécifiques. Citons par exemple :

• la gestion précise des accès à certains périphériques (convertisseurs A/D, circuits de communication, etc). Dans ces cas, il est également plus facile de contrôler les timings. Mais ceci dépend également du processeur;

• la programmation en virgule fixe de certains algorithmes mathématiques. Parfois, seul l’assembleur permet d’implémenter l’algorithme avec les caractéristiques exactes, telle la précision de calcul. Le code correspondant en langage évolué pourra même s’avérer illisible et surtout très lent à l’exécution.

Enfin, le développement en assembleur n’est rentable que pour des processeurs à architecture relativement simple et à nombre d’instructions limité, appréhendable à l’échelle humaine.

A priori, on doit donc éviter le développement en assembleur et il est probable qu’à l’avenir, cet objectif puisse être atteint en toute circonstance.



2. Développement d’un code exécutable pour le processeur Texas TMS320C50

Ce paragraphe montre brièvement, sans être exhaustif, la suite des opérations à effectuer afin de produire un code exécutable. On se base sur un exemple programmé dès le départ en assembleur et l’on se réfère au système de développement du processeur Texas TMS320C50, dont une vue d’ensemble est donnée par la figure suivante :

T M S 3 2 0 D e v e l o p m e n t P r o d u c t I n t e g r a t i o n

A r c h i v e r

M a c r oL i b r a r y

M a c r oS o u r c e

F i l e s

A r c h i v e r

L i b r a r y o fO b j e c tF i l e s

T M S 3 2 0D S P

H e x C o n v e r s i o nU t i l i t y

E P R O MP r o g r a m m e r

R u n t i m eS u p p o r t L i b r a r y

X D S E m u l a t o rw i t h D e b u g g e r

A b s o l u t eL i s t e r

CS o u r c e

F i l e s

A s s e m b l e rS o u r c e

C O F FO b j e c tF i l e s

E x e c u t a b l eC O F F

F i l eS i m u l a t o r

E V Mw i t h D e b u g g e r

C C o m p i l e r

L i n k e r

A s s e m b l e r

2.1. Etape 1 : programmation de l’algorithme d’un filtre numérique

On donne ci-dessous le code assembleur d’un filtre numérique d’ordre 2 s’inspirant des exemples du chap.1.



FILTRE: LT Y1 ;charge le multiplicande dans le registre T MPY A1 ;multiplie PAC ;ajoute le résultat de la multiplication à l'ACC LT Y2 ;charge le multiplicateur dans le registre T MPY A2 ;multiplie APAC ;ajoute le résultat de la multiplication à l’ACC LT U0 ;charge le multiplicateur dans le registre T MPY B0 ;multiplie APAC ;ajoute le résultat de la multiplication à l’ACC SACH Y0,4 ;stocke la partie haute du resultat (32 bits) ;en le decalant de 4 bits a droite DMOV Y1 ;déplace d’un emplacement de mémoire data ;pour créer le délai (Y1->Y2) DMOV Y0 ;déplace d’un emplacement de mémoire data ;pour créer le délai (Y0->Y1)

2.2. Etape 1 (suite) : organisation en sections (format COFF) [2, chap.2]

En plus des commentaires, plusieurs directives assembleur doivent compléter le code de l’algorithme du filtre numérique pour

• spécifier le titre (.title),

• spécifier la mise en page du listing (.length, .width),

• spécifier les symboles définis dans le fichiers (.def),

• spécifier les symboles définis dans d’autres fichiers et utilisés par le programme (.ref),

• la réservation en mémoire de données, typiquement pour les variables définies dans le fichier (.bss)

• la réservation en mémoire de programme, typiquement pour les constantes définies dans le programme (.data)

• la réservation en mémoire de programme pour le code du programme (.text)

D’autres directives existent et seront évoquées à la fin de ce chapitre.



****************************************************************** * FILTRE.ASM ****************************************************************** * Filtre numerique passe-bas de second ordre ****************************************************************** *Version Date Auteur Motif *0 27/04/96 MEE Creation pour TMS320C50 * 03/05/98 MEE Mise a jour ****************************************************************** * Directives assembleur .title "FILTRE NUMERIQUE" .length 60 .width 80 .mmregs .def Y1,Y2,Y0 .def B0,A1,A2, FILTRE .ref U0 * Reserve de la memoire non initialisee pour les variables * dans la section .bss .bss Y0,1 .bss Y1,1 .bss Y2,1 * Reserve de la memoire initialisee pour les constantes * dans la section .data .data B0 .word 1234 A1 .word -23457 A2 .word 87 * Code dans la section .text .text FILTRE: LT Y1 ;charge le multiplicande dans le registre T MPY A1 ;multiplie PAC ;ajoute le résultat de la multiplication à l'ACC LT Y2 ;charge le multiplicateur dans le registre T MPY A2 ;multiplie APAC ;ajoute le résultat de la multiplication à l’ACC LT U0 ;charge le multiplicateur dans le registre T MPY B0 ;multiplie APAC ;ajoute le résultat de la multiplication à l’ACC SACH Y0,4 ;stocke la partie haute du resultat (32 bits) ;en le decalant de 4 bits a droite DMOV Y1 ;déplace d’un emplacement de mémoire data ;pour créer le délai (Y1->Y2) DMOV Y0 ;déplace d’un emplacement de mémoire data ;pour créer le délai (Y0->Y1) .end

La plus petite entité d’un fichier objet généré par l’assembleur est la section. Une section est un bloc de code ou de données qui va finalement occuper un espace contigu dans la mémoire.

Chaque section d’un fichier objet est une entité séparée et distincte des autres sections du même fichier. On distingue essentiellement 3 types se sections :



• la section .text qui contient normalement du code exécutable;

• la section .data qui contient normalement des données initialisées;

• la section .bss qui réserve de l’espace pour des variables non-initialisées;

Lors de l’écriture de code assembleur, il est ainsi nécessaire de spécifier dans quelles sections le code doit être assemblé, ce qui s’effectue au moyen de l’une des 3 directives assembleur :

• .text

• .data

• .bss

2.3. Etape 2 : assemblage

L’assembleur tient à jour un compteur de programme par section (SPC), dont le contenu représente l’adresse courante en une section de code ou de données. Ce compteur peut s’observer sur le listing (*.lst) produit sur demande par l’assembleur (option –l), comme on le voit sur l’exemple exemple ci-dessous, obtenu en assemblant le code du filtre numérique du paragraphe précédent par la commande

dspa -v50 -l filtre.asm



TMS320C1x/C2x/C2xx/C5x COFF Assembler Version 6.60 Sun May 3 12:49:44 1998 Copyright (c) 1987-1995 Texas Instruments Incorporated filtre.asm PAGE 1 1 ************************************************************ 2 * FILTRE.ASM 3 ************************************************************ 4 * Filtre numerique passe-bas de second ordre 5 ************************************************************ 6 *Version Date Auteur Motif 7 *0 27/04/96 MEE Creation pou 8 * 03/05/98 MEE Mise a jour 9 10 ************************************************************ 11 13 .length 60 14 .width 80 15 .mmregs 16 17 .def Y1,Y2,Y0 18 .def B0,A1,A2, FILTRE 19 .ref U0 20 21 * Reserve de la memoire non initialisee pour les varia 22 * dans la section .bss 23 0000 .bss Y0,1 24 0001 .bss Y1,1 25 0002 .bss Y2,1 26 27 * Reserve de la memoire initialisee pour les constante 28 * dans la section .data 29 0000 .data 30 0000 04d2 B0 .word 1234 31 0001 a45f A1 .word -23457 32 0002 0057 A2 .word 87 33 34 * Code dans la section .text 35 36 0000 .text 37 0000 7301- FILTRE: LT Y1 ;charge le multiplicatande dans le 38 0001 5401" MPY A1 ;multiplie 39 0002 be03 PAC ;ajoute le résultat de la multiplica 40 0003 7302- LT Y2 ;charge le multiplicateur dans le re 41 0004 5402" MPY A2 ;multiplie 42 0005 be04 APAC ;ajoute le résultat de la multiplica 43 0006 7300! LT U0 ;charge le multiplicateur dans le re 44 0007 5400" MPY B0 ;multiplie 45 0008 be04 APAC ;ajoute le résultat de la multiplica 46 0009 9c00- SACH Y0,4 ;stocke la partie haute du resultat 47 ;en le decalant de 4 bits a droite 48 000a 7701- DMOV Y1 ;déplace d’un emplacement de mémoire 49 ;pour créer le délai (Y1->Y2) 50 000b 7700- DMOV Y0 ;déplace d’un emplacement de mémoire 51 ;pour créer le délai (Y0->Y1) 52 .end No Errors, No Warnings



2.4. Etape 3 : édition de liens et configuration de la mémoire du processeur

Lorsque tous les modules (fichiers) assembleur auront été assemblés, on dipose de tous les fichiers objet (*.obj). C’est l’éditeur de liens (linker) qui aura, entre autres, pour tâche de réunir les mêmes sections (.text, .bss, .data) des différents fichiers objet, et, selon les consignes d’allocation mémoire spécifiées dans le fichier de configuration (ici memconf.cmd), les placera aux endroits indiqués afin de produire un code exécutable.

Le fichier (memconf.cmd) définissant l’allocation mémoire a la forme suivante : MEMORY { PAGE 0: SARAM0: origin = 00800h, length = 00030h PAGE 0: SARAM1: origin = 00980h, length = 02280h PAGE 1: ON_B0: origin = 00100h, length = 00200h PAGE 1: ON_B1: origin = 00300h, length = 00200h PAGE 1: SARAM1: origin = 00d80h, length = 01d80h } SECTIONS { .vectors load = SARAM0 PAGE 0 .text load = SARAM1 PAGE 0 .data load = SARAM1 PAGE 0 .bss load = ON_B0 PAGE 1 .sysmem load = ON_B1 PAGE 1 .stack load = ON_B1 PAGE 1 }

On y distingue deux directives : MEMORY et SECTIONS

• La directive MEMORY permet de définir la configuration mémoire de la cible;

• La directive SECTIONS indique au linker comment combiner les sections et où les placer en mémoire.

La commande lançant l’éditeur de liens est : dsplnk –o filtre.out –m list.map init.obj main.obj ad_da.obj

filtre.obj memconf.cmd

L’option –o spécifie le nom du fichier exécutable à produire (filtre.out) et -m provoque la génération d’un fichier (ici list.map) donnant l’allocation mémoire exacte du code.

La figure ci-dessous montre les opérations de regroupement de code appartenant à des mêmes sections de différents fichiers, effectuées à partir de 2 fichiers objet file1.obj et file2.obj.



3. Architecture du processeur Texas TMS320C50 [1, §3.1 et 3.2]

La figure de la page suivante montre le schéma bloc du processeur Texas TMS320C50. Il y a trois espaces adressables de 64 kmots chacun :

• l’espace mémoire de programme;

• l’espace mémoire de données;

• l’espace des ports d’entrée/sortie (I/O).

Les éléments adressables ont tous un format de 16 bits. Sur le schéma-bloc, on reconnaît les unités suivantes :

• les bus de programme (adresses des instructions et instructions elles-mêmes); • les bus de données (adresses des données et données elles-mêmes); • la mémoire de programme, adressée par les adresses du bus de programme et

connectée aux données du bus de programme; • la mémoire de données, adressée par les adresses du bus de données et connectée aux

données du bus de données; • le compteur de programme (PC), formant l’adresse sur le bus de programme; • une pile de 8 niveaux (Stack); • une unité de multiplication (Multiplier) avec les deux registres TREG0 et PREG; • une unité arithmétique et logique (ALU) avec les registres ACC et ACCB; • une unité logique (PLU); • plusieurs unités de décalage (Scaler); • un registre pointeur de page (DP) et un registre d’adresse relative (dma), les deux étant

concaténés et connectés aux adresses du bus de données; • un banc de 8 registres auxiliaires (AUXREGS, AR0...AR7), dont les sorties sont

connectées aux adresses du bus de données, ainsi qu’un registre (ARP) pointant sur l’un des 8 registres auxiliaires;

• une unité arithmétique opérant sur les registres auxiliaires (ARAU)



P ± S C A L E R( ± 6 , 0 , 1 , 4 )

P R E S C A L E RS F L ( 0 ± 1 6 )

T R E G 2 ( 4 )

3 2

D A T A B U S

P R O G R A M B U S

D 1 5 ± D 0

R B I T

A 1 5 ± A 0

D B M R

M U X

3 2

A C C B ( 3 2 )

3 2

A C C LA C C H

3 2

A L U ( 3 2 )

3 23 2

M U X

M U X

M U X

P R E G ( 3 2 )

M U L T I P L I E R

T R E G 0

M U X

M U X

B 1

B 2D A R A M

B 0D A R A M

M U X

f r o m I R E G7 L S B

M U X

9

M U X

S A R A M

A R A U

M U X

3

33

P R O G R A M B U S

C B S R 2

C B S R 1

C B C R ( 8 )

A R 7

A R 6

A R 4

A R 3

A R 2

A R 1

A R C R

I N D X

S e r i a l P o r t 1T R E G 1 ( 5 )

B R C R

G R E G

I F R

I M R

R P T C

P M S T

S T 1

S T 0

B M A R

I R E G

P F C

M C S

I n s t r u c t i o n

A d d r e s s

R O M

P A S R

C O M P A R E

P A E R

( 8 x 1 6 )

S t a c k

P C

M U X

N M IW ER D

C L K I N 2X 2 / C L K I NC L K O U T 1X 1

4I N T ( 1 ± 4 )

M P / M C

R S

H O L D AH O L D

X FB R

R E A D YS T R B

R W

P SD SI S

C L K M D 3C L K M D 2

PR

OG

RA

M B

US

DAT

A B

US

C B E R 2

C B E R 1

A R 5

B I O

MU

XM

UX

N o t e s : A l l r e g i s t e r s a n d d a t a l i n e s a r e 1 6 - b i t s w i d e u n l e s s o t h e r w i s e s p e c i f i e d .

D a t a / P r o g r a m

D a t a / P r o g r a m

P L U

D a t a

3 2

3 2

3 2

C L K M D 1

A R 0

P A 0

P A 1 5

I / O P o r t s

²

D A T A B U S

...

P R E S C A L E RS F R ( 0 ± 1 6 )

P O S T S C A L E R( 0 ± 7 )

I A C K

I A Q

Pro

gra

m C

on

trol

ler

DR

B

S T 0 [ A R P ] S T 0 [ D P ]

S T 1 [ C ]

1 6I O W S R

C W S R ( 5 )

P D W S R

S o f t w a r e w a i t ± s t a t e s

S e r i a l P o r t 2

²T i m e - D i v i s i o nM u l t i p l e x e dS e r i a l P o r t

²B u f f e r e d

S e r i a lP o r t

T i m e r

²H o s t P o r tI n t e r f a c e

E m u l a t i o n



3.1. Exécution d’une instruction machine [6]

Le compteur de programme (PC) contient toujours l’adresse de l’instruction à exécuter. Cette exécution peut être schématisée de la manière suivante :

Répéter

Charger l’instruction depuis la mémoire de programme

Décoder l’instruction

Si des opérandes sont nécessaires, suivant les cas :

• les prendre dans des registres (par ex. ACCB)

• les prendre dans la mémoire

Exécuter l’instruction

Mettre l’éventuel résultat, suivant les cas :

• dans un registre

• dans une mémoire

Mettre à jour les indicateurs

Mettre à jour le PC

Jusqu’à la fin du programme

3.2. Les registres du processeur Texas TMS320C50 [1, §3.3]

On décrit ici succintement les registres principaux du processeur.

3.2.1. ACC

C’est l’accumulateur, de largeur 32 bits, qui contient la sortie de l’ALU (unité arithmétique et logique). Il constitue l’un des registres essentiels, puisque toutes les opérations arithmétiques y ont recours.

3.2.2. TREG0

C’est un registre 16 bits contenant le multiplicande. Il est chargé avant d’effectuer une multiplication.



3.2.3. PREG

C’est un registre 32 bits contenant le résultat de la multiplication de contenu 16 bits du registre TREG0 et d’une donnée placée en mémoire de donnée.

3.2.4. ACCB

C’est un registre 32 bits utilisé comme copie de l’accumulateur.

3.2.5. AR0...AR7 (AUXREGS)

Il s’agit de 8 registres auxiliaires 16 bits utilisés pour spécifier des pointeurs d’adresse. Leur contenu est donc usuellement l’adresse de la donnée à laquelle on doit accéder.

3.2.6. ARP

C’est un registre 3 bits qui pointe sur l’un des 8 registres auxiliaires, le registre pointé étant alors le registre courant.

3.2.7. dma

C’est un registre 7 bits, abréviation de Direct Memory Access, contenant l’adresse d’une donnée dans une page de 128 [mot] de la mémoire de données.

La mémoire donnée du processeur est de 64 [kmot], subdivisée en 512 pages de 128 mots. Lors de l’accès à une donnée, il faut donc non seulement spécifier son adresse dans la page, mais s’assurer que la page courante est la bonne, en fixant le contenu du registre pointeur de page (DP).

3.2.8. DP

C’est le pointeur de page (Data Page Pointer), de largeur 9 bits. Sa valeur est initialisée avec l’instruction LDP.

3.2.9. IMR

C’est un registre 16 bits permettant de masquer ou valider individuellement les interruptions.

3.2.10.IFR

C’est un registre 16 bits mémorisant les interruptions activées.

3.2.11.ST0, ST1, PMST

Il s’agit de 3 registres de 16 bits contenant les bits d’état du processeur (Carry, Overflow, etc) ainsi que des bits permettant de contrôler son fonctionnement (configuration mémoire, etc).



4. Familles d’instructions et modes d’adressage

4.1. Vue d’ensemble du répertoire d’instructions du processeur Texas TMS320C50 [1, §4.2.2]

4.1.1. Opérations entre l’accumulateur et la mémoire

ACCUMULATOR MEMORY REFERENCE INSTRUCTIONS

INSTRUCTION MNEMONIC OPCODE WORDS CYCLES

Absolute value of ACCAdd ACCB to ACC with carryAdd to ACC with shiftAdd to low ACC short immediateAdd to ACC long immediate with shiftAdd to ACC with shift of 16Add ACCB to ACCAdd to ACC with carryAdd to low ACC with sign extension suppressedAdd to ACC with shift specified by TREG1 [3±0]AND ACC with data valueAND with ACC long immediate with shiftAND with ACC long immediate with shift of 16AND ACCB with ACCBarrel shift ACC rightComplement ACCStore ACC in ACCB if ACC > ACCBStore ACC in ACCB if ACC< ACCBExchange ACCB with ACCLoad ACC with ACCBLoad ACC with shiftLoad ACC long immediate with shiftLoad ACC with shift of 16Load low word of ACC with immediateLoad low word of ACCLoad ACC with shift specified by TREG1 [3±0]Load ACCL with memory-mapped registerNegate ACCNormalize ACCOR ACC with data valueOR with ACC long immediate with shiftOR with ACC long immediate with shift of 16OR ACCB with ACCRotate ACC 1 bit leftRotate ACCB and ACC leftRotate ACC 1 bit rightRotate ACCB and ACC rightStore ACC in ACCBStore high ACC with shiftStore low ACC with shiftStore ACCL to memory-mapped registerShift ACC 16 bits right if TREG1 [4] = 0Shift ACC0±ACC15 right as specified by TREG1 [3±0]Subtract ACCB from ACCSubtract ACCB from ACC with borrowShift ACC 1 bit leftShift ACCB and ACC leftShift ACC 1 bit rightShift ACCB and ACC rightSubtract from ACC with shiftSubtract from ACC with shift of 16Subtract from ACC short immediateSubtract from ACC long immediate with shift

ABSADCBADDADDADDADDADDBADDCADDSADDTANDANDANDANDBBSARCMPLCRGTCRLTEXARLACBLACCLACCLACCLACLLACLLACTLAMMNEGNORMORORORORBROLROLBRORRORBSACBSACHSACLSAMMSATHSATLSBBSBBBSFLSFLBSFRSFRBSUBSUBSUBSUB

1011 1110 0000 0000

1011 1110 0001 0001

0010 SHFT I AAA AAAA

1011 1000 I I I I I I I I

1011 1111 1001 SHFT

0110 0001 I AAA AAAA

1011 1110 0001 0000





1011 1111 1011 SHFT

1011 1110 1000 0001

1011 1110 0001 0010

1011 1111 1110 SHFT

1011 1110 0000 0001

1011 1110 0001 1011

1011 1110 0001 1100

1011 1110 0001 1101

1011 1110 0001 1111


1011 1111 1000 SHFT


1011 1001 I I I I I I I I




1011 1110 0000 0010



1011 1111 1100 SHFT

1011 1110 1000 0010

1011 1110 0001 0011

1011 1110 0000 1100

1011 1110 0001 0100

1011 1110 0000 1101

1011 1110 0001 0101

1011 1110 0001 1110

1001 1SHF I AAA AAAA

1001 0SHF I AAA AAAA


1011 1110 0101 1010

1011 1110 0101 1011

1011 1110 0001 1000

1011 1110 0001 1001

1011 1110 0000 1001

1011 1110 0001 0110

1011 1110 0000 1010

1011 1110 0001 0111



1011 1010 I I I I I I I I

1011 1111 1010 SHFT

11112111111221111111121111111122111111111111111111112

11112111111221111111121111

1 or 21112211111111

1 or 2111111111112



ACCUMULATOR MEMORY REFERENCE INSTRUCTIONS (CONTINUED)


Subtract from ACC with borrowConditional subtractSubtract from ACC with sign extension suppressedSubtract from ACC, shift specified by TREG1 [3±0]XOR ACC with data valueXOR with ACC long immediate with shiftXOR with ACC long immediate with shift of 16XOR ACCB with ACCZero ACC, load high ACC with roundingZero ACC and product register

SUBBSUBCSUBSSUBTXORXORXORXORBZALRZAP






1011 1111 1101 SHFT

1011 1110 1000 0011

1011 1110 0001 1010


1011 1110 0101 1001

1111122111

1111122111

4.1.2. Opérations logiques

PARALLEL LOGIC UNIT INSTRUCTIONS


AND DBMR with data valueAND long immediate with data valueCompare DBMR to data valueCompare data with long immediateOR DBMR to data valueOR long immediate with data valueStore long immediate to dataXOR DBMR to data valueXOR long immediate with data value

APLAPLCPLCPLOPLOPLSPLKXPLXPL










121212212

121212212

4.1.3. Opérations sur les registres TREG0 et PREG et instructions de multiplication

T REGISTER, P REGISTER, AND MULTIPLY INSTRUCTIONS


Add PREG to ACCLoad high PREGLoad TREG0Load TREG0 and accumulate previous productLoad TREG0, accumulate previous product, and move

dataLoad TREG0 and load ACC with PREGLoad TREG0 and subtract previous productMultiply/accumulateMultiply/accumulate with data shiftMult/ACC w/source ADRS in BMAR and DMOVMult/ACC with source address in BMARMultiply data value times TREG0Multiply TREG0 by 13-bit immediateMultiply TREG0 by long immediateMultiply TREG0 by data, add previous productMultiply TREG0 by data, ACC ± PREGMultiply unsigned data value times TREG0Load ACC with product registerSubtract product from ACCStore high product registerStore low product registerSet PREG shift countData to TREG0, square it, add PREG to ACCData to TREG0, square it, ACC ± PREGZero product register

APACLPH LT LTALTD

LTPLTSMACMACDMADDMADSMPYMPYMPYMPYAMPYSMPYUPACSPACSPHSPLSPMSQRASQRSZPR

1011 1110 0000 0100












110I I I I I I I I I I I I I

1011 1110 1000 0000




1011 1110 0000 0011

1011 1110 0000 0101



1011 1111 0000 00PM



1011 1110 0101 1000

11111111221111211111111111

11111111333311211111111111



4.1.4. Instructions de branchement BRANCH INSTRUCTIONS


Branch unconditional with AR updateBranch addressed by ACCBranch addressed by ACC delayedBranch AR π 0 with AR updateBranch AR π 0 with AR update delayedBranch conditionalBranch conditional delayedBranch unconditional with AR update delayedCall subroutine addressed by ACCCall subroutine addressed by ACC delayedCall unconditional with AR updateCall unconditional with AR update delayedCall conditionalCall conditional delayedSoftware interruptNonmaskable interruptReturnReturn conditionalReturn conditionally, delayedReturn, delayedReturn from interrupt with enableReturn from interruptTrapExecute next one or two INST on condition

BBACCBACCDBANZBANZDBCNDBCNDDBDCALACALADCALLCALLDCCCCDINTRNMIRETRETCRETCDRETDRETERETITRAPXC

0111 1001 1AAA AAAA

1011 1110 0010 0000

1011 1110 0010 0001

0111 1011 1AAA AAAA

0111 1111 1AAA AAAA

1110 00TP ZLVC ZLVC

1111 00TP ZLVC ZLVC

0111 1101 1AAA AAAA

1011 1110 0011 0000

1011 1110 0011 1101

0111 1010 1AAA AAAA

0111 1110 1AAA AAAA

1110 10TP ZLVC ZLVC

1111 10TP ZLVC ZLVC

1011 1110 011 I NTR#

1011 1110 0101 0010

1110 1111 0000 0000

1110 11TP ZLVC ZLVC

1111 11TP ZLVC ZLVC

1111 1111 0000 0000

1011 1110 0011 1010

1011 1110 0011 1000

1011 1110 0101 0001

111N 01TP ZLVC ZLVC

211222221122221111111111

442

2 or 42

2 or 4224242

2 or 42444

2 or 4224441

4.1.5. Opérations sur l’espace I/O et la mémoire de données

I/O AND DATA MEMORY OPERATIONS


Block move from data to data memoryBlock move data to data DEST long immediateBlock move data to data with source in BMARBlock move data to data with DEST in BMARBlock move data to PROG with DEST in BMARBlock move from program to data memoryBlock move PROG to data with source in BMARData move in data memoryInput external accessLoad memory-mapped registerOut external accessStore memory-mapped registerTable readTable write

BLDDBLDDBLDDBLDDBLDPBLPDBLPDDMOVINLMMROUTSMMRTBLRTBLW















22111211222211

332223212

2 or 33

2 or 333

4.1.6. Opérations sur les registres auxiliaires

AUXILIARY REGISTERS AND DATA PAGE POINTER INSTRUCTIONS


Add to AR short immediateCompare AR with CMPRLoad AR from addressed dataLoad AR short immediateLoad AR long immediateLoad data page pointer with addressed dataLoad data page immediateModify auxiliary registerStore AR to addressed dataSubtract from AR short immediate

ADRKCMPRLARLARLARLDPLDPMARSARSBRK

0111 1000 I I I I I I I I

1011 1111 0100 01CM

0000 0ARX I AAA AAAA

1011 0ARX I I I I I I I I

1011 1111 0000 1ARX


1011 110I I I I I I I I I


1000 0ARX I AAA AAAA

0111 1100 I I I I I I I I

1111211111

1111222111



4.1.7. Instructions de contrôle

CONTROL INSTRUCTIONS


Test bit specified immediateTest bit in data value as specified by TREG2 [3±0]Reset overflow modeReset sign extension modeReset hold modeReset TC bitReset carryReset CNF bitReset INTM bitReset XF pinIdleIdle until interrupt Ð low-power modeLoad status register 0Load status register 1No operationPop PC stack to low ACCPop stack to data memoryPush data memory value onto PC stackPush low ACC to PC stackRepeat instruction as specified by dataRepeat next INST specified by long immediateRepeat INST specified by short immediateBlock repeatClear ACC/PREG and repeat next INST long immediateSet overflow modeSet sign extension modeSet hold modeSet TC bitSet carrySet XF pin highSet CNF bitSet INTM bitStore status register 0Store status register 1

BITBITTCLRCCLRCCLRCCLRCCLRCCLRCCLRCCLRCIDLEIDLE2LSTLSTNOPPOPPOPDPSHDPUSHRPTRPTRPTRPTBRPTZSETCSETCSETCSETCSETCSETCSETCSETCSSTSST

0100 BI TX I AAA AAAA


1011 1110 0100 0010

1011 1110 0100 0110

1011 1110 0100 1000

1011 1110 0100 1010

1011 1110 0100 1110

1011 1110 0100 0100

1011 1110 0100 0000

1011 1110 0100 1100

1011 1110 0010 0010

1011 1110 0010 0011



1000 1011 0000 0000

1011 1110 0011 0010



1011 1110 0011 1100


1011 1110 1100 0100

1011 1011 I I I I I I I I

1011 1110 1100 0110

1011 1110 1100 0101

1011 1110 0100 0011

1011 1110 0100 0111

1011 1110 0100 1001

1011 1110 0100 1011

1011 1110 0100 1111

1011 1110 0100 1101

1011 1110 0100 0101

1011 1110 0100 0001



1111111111111111111121221111111111

1111111111112211111222221111111111

4.2. Adressage

De façon à fournir à l’instruction machine son opérande, il faut adresser une donnée en mémoire de données. Plusieurs modes d’adressage sont possibles. Un processeur disposant de tous les modes d’adressage pour toutes ses instructions est qualifié d’orthogonal.

4.2.1. Adressage immédiat [1, §3.4.2 et 4.1.3]

Dans ce cas de l’adressage immédiat, l’opérande est une constante connue dès l’assemblage (le contraire d’une variable). La valeur numérique de la constante fait alors partie intégrante du code binaire de l’instruction. Elle est précédée du symbole #, afin de bien préciser de qu’il s’agit d’un adressage immédiat.

Exemple :

LACC #28 ;28 dans ACC



ADD #0FFh

Machine Code 1 0 1 1 1 0 0 0 1 1 1 1 1 1 1 1

Operand 1 1 1 1 1 1 1 1

ADD opcode 0FFh

Si la valeur numérique est telle que le code binaire de l’instruction excède la longueur

limite de 16 bits, il s’agit d’un adressage immédiat long et l’instruction s’exécutera alors en 2 cycles.

4.2.2. Adressage direct [1, §3.4.2 et 4.1.1]

Avec l’adressage direct, l’adresse de l’opérande est directement spécifiée. Cependant, cette adresse est relative à la page courante (une page = 128 mots) et donc seuls les 7 LSBs de l’adresse 16 bits sont intégrés au code binaire de l’instruction.

PAGE 0

PAGE 1

PAGE 2

PAGE 3

PAGE 510

PAGE 511

28-WORDPAGE

512 DATAPAGES

(MEMORY-MAPPED

REGISTERSAND

DARAM B2)

7 LSBs

16-bit data memory address

9

DP (9)ST0 IREG (16)

0615

DP dma

DAB

On rappelle que l’espace adressable est de 64 [kmots], divisé en 512 pages. L’adresse

complète de l’opérande est ainsi formée en concaténant les 7 LSBs figurant dans le code binaire de l’instruction et le 9 bits du pointeur de page.



LDP #019DhADD 010h, 5

Machine Code 1 0

DP 110011101

ADD opcode 010h

067815

1100111010

001000

001000

110011101

Exemple :

LACC 75 ;le contenu de ;l’adresse 75 de ;la page courante ;est charge dans ;ACC

Au préalable, il est nécessaire, si ce n’est pas déjà fait, de spécifier la valeur du pointeur de page :

LDP #26 ;la page ;courante est la ;page 26

LACC 75 ;le contenu de ;l’adresse 75 de ;la page courante ;(26) est charge ;dans ACC

Il est clair qu’on ne spécifie jamais explicitement l’adresse d’un objet (ici 75 dans la page 26), celle-ci n’étant en général connue qu’après l’édition de lien. Il faut donc avoir recours à une directive assembleur réservant un emplacement mémoire et lui attachant un symbole auquel on peut se référer :

.bss dat75,16 ;le symbole dat75 ;représente ;l’adresse de la ;variable dans la ;page 26

LDP #26 ;la page ;courante est la ;page 26

LACC dat75 ;le contenu de ;l’adresse 75 de ;la page courante ;(26) est charge ;dans ACC



4.2.3. Adressage indirect [1, §3.4.2 et 4.1.2]

L’adressage indirect est le plus efficace de tous, notamment par le fait qu’il permet de spécifier une adresse sur 16 bits. Cependant, cette adresse ne fait pas partie du code de l’instruction, mais est contenue dans l’un des 8 registres auxiliaires AR0...AR7. Le code de l’instruction fait simplement référence au type d’adressage (ici donc indirect). C’est donc la donnée contenue à l’adresse spécifiée dans le registre auxiliaire courant qui est accédée. Le symbole * apparaissant dans le champ de l’opérande indique qu’il s’agit d’adressage indirect.

LACC * ;le contenu de ;l’adresse ;spécifiée dans le ;registre auxiliaire ;courant est charge ;dans ACC

16-bit data address

ARAU

1616

16

3

Auxiliary registers

AR0

AR1

AR7

AR6

AR5

AR4

AR3

AR2(ARP = 2)

3

ARPARB 3

3

Data bus (16)



Il faut donc au préalable ajuster le contenu du registre auxiliaire et s’assurer qu’il est actif en fixant le pointeur de registre auxiliaire (ARP)

MAR *,AR4 ;le registre ;auxiliaire AR4 ;devient le ;registre courant ;(ARP=4)

LAR AR4,#2de4h ;charge le ;registre AR4 ;avec la valeur ;immédiate 2de4h

LACC * ;le contenu de ;l’adresse 2de4h ;est charge dans ;ACC

Il existe d’autres possibilités offertes par l’adressage indirect : les post-incrémentation/décrémentation, permettant respectivement d’incrémenter ou de décrémenter le contenu du registre auxiliaire courant après l’opération. Selon l’organisation de la mémoire de données, le registre auxiliaire pointe donc sur la donnée suivante ou précédente, ce qui peut rendre les calculs très efficaces.

LACC *+ ;le contenu de l’adresse ;contenue dans le ;registre auxiliaire ;courant est charge dans ;ACC ;le contenu du registre ;auxiliaire est ensuite ;incrémenté

Il est également possible de changer le registre auxiliaire courant après l’opération :

LACC *+,AR0 ;idem que ;precédemment, mais ;le registre ;auxiliaire ;courant ;devient AR0

ADD *-,AR4 ;ajoute a ;l’accumulateur la ;donnee située a ;l’adresse ;specifiée dans ;AR0, décrémente ;AR0, puis rend AR4 ;registre ;auxiliaire courant



5. Format des déclarations assembleur [2, §3.6, 3.7, 3.9] et [6]

Chaque déclaration (statement) source assembleur se compose de 4 champs, dont la syntaxe est la suivante :

[label][:] mnémonique [liste d’opérandes]

[;commentaire]

Les champs sont séparés par des espaces ou mieux, par des tabulateurs. Chaque déclaration doit commencer par un label, un espace, un astérisque ou un point-virgule.

Exemple :

* FILTRE NUMERIQUE

FILT: LT Y1 ;y(k-1) dans ;registre T

MPY A1 ;a1*y(k-1) ;dans

;registre P

5.1. Le champ label

Les labels (ou étiquettes) sont optionnels; leur valeur correspond à la valeur courante du compteur de programme (PC). Il permettent ainsi de donner un nom symbolique à une adresse.

5.2. Le champ mnémonique

Le champ mnémonique contient typiquement des instructions machine (e.g. MPY), mais peut également contenir des directives assembleur (cf §�6), voire l’appel d’une macro-instruction.

5.3. Le champ opérande

Le champ opérande contient les paramètres d’une instruction, d’une macro-instruction ou d’une directive d’assemblage. S’il y a lieu de spécifier plusieurs opérandes, on les sépare par des virgules.

5.4. Le champ commentaire

Les commentaires sont optionnels. Ceux qui commençent à la colonne 1 peuvent débuter par un * ou un ; . Ceux qui débutent à toute autre colonne doivent être précédés obligatoirement d’un ; . Il peuvent s’étendre sur plusieurs lignes, auquel cas il est nécessaire de répéter le préfixe * ou ; .



Compte tenu des remarques faites au §�1, il est évidemment fortement recommandé de bien documenter les programmes, afin de faciliter leur mise au point et surtout leur entretien.

On peut distinguer deux niveaux de commentaires :

• un commentaire général, commençant à la colonne 1 plutôt par un * et se situant avant la portion de code concernée, la documentant de manière générale (e.g. données d’entrée et de sortie, fonction réalisée, etc)

• un commentaire particulier à une déclaration, situé dans le 4ème champ et débutant par un ; . Il documente une ou quelques (1 à 10) instructions.

Les commentaires sont absolument essentiels pour la lisibilité du programme assembleur. Ce dernier est inexploitable en l’absence de commentaires et devra souvent être complètement refait si un autre programmeur reprend le projet en cours de développement.

Si le programme est bien documenté, on doit pouvoir masquer tous les autres champs du fichier source et néanmoins parvenir à comprendre le déroulement du programme.

6. Utilisation de constantes dans les déclarations

L’assembleur supporte plusieurs types de constantes parmis lesquels :

• les entiers binaires, par exemple 01b ou 010101B;

• les entiers décimaux, par exemple 1000 ou -32768

• les entiers hexadécimaux, par exemple 78h ou 7fffH;

• les constantes définies au moment de l’assemblage. Dans ce cas, la directive .set permet d’assigner une constante à un symbole, par exemple :

A1 .set -1235 ;coefficient ;a1 du filtre

;A1=-4096*a1

7. Chargement et sauvegarde des registres

7.1. Registres ACC, ACCB, TREG, PREG

Les registres principaux intervenant lors d’opérations arithmétiques sont les suivants :

• ACC (accumulateur, 32 bits, avec ACCH et ACCL)

• ACCB (« copie » (buffer) de l’accumulateur, 32 bits)

• TREG (multiplicande, 16 bits)

• PREG (produit, 32 bits, avec PREGH et PREGL)



Les chargement / sauvegarde de l’accumulateur ont pour source / destination la mémoire de données dans les cas des adressages direct et indirect. Le bus de données étant de 16 bits, on aura avantage à représenter, autant que faire se peut, les variables sur 16 bits. Les instructions essentielles relatives à l’accumulateur sont :

• LACC • SACL • SACH

Le champ opérande spécifie l’adresse de la donnée, sous forme directe (dma) ou indirecte (*) ainsi qu’un décalage à gauche (=multiplication par une puissance de 2).

Exemples :

LACC TOTO,15 ;ACC=TOTO*2^15

LACC #01234h ;ACC=1234h

SACL TUTU,1 ;TUTU=ACCL*2^1

SACH *,0 ;sauve ACCH à l’adresse ;pointée par le registre ;auxiliaire courant

LACC *+,16,AR4 ;charge dans ACCH le contenu ;de l’adresse pointée par le ;registre auxiliaire courant, ;le registre auxiliaire ;courant devient ensuite AR4

Les registres TREG et PREG supportent également les adressages direct et indirect. Pour les décalages, il faut au préalable initialiser un registre de contrôle, ce qui sera brièvement évoqué au §�9.3.

Instructions :

• LT

• SPH

• SPL

Exemples :

LT TOTO ;TREG=TOTO

SPH TUTU ;TUTU=PREGH

SPL * ;sauve PREGL à l’adresse ;pointée par le registre ;auxiliaire courant

7.2. Registres auxiliaires AR0..AR7

Les registres auxiliaires jouent principalement le rôle de pointeurs dans le contexte de l’adressage indirect. On les initialise en les chargeant avec une donnée de la mémoire de



données (adressages direct et indirect) ou de la mémoire de programme (adressage immédiat) au moyen de l’instruction LAR.

Avant leur utilisation comme pointeur, il faut encore s’assurer que c’est le bon registre auxiliaire (1 parmi 8) qui est le registre courant, ceci en chargeant le pointeur de registre auxiliaire (ARP) à l’aide de l’instruction MAR.

Instructions principales :

• LAR

• SAR

• MAR

Exemple :

LAR AR6,#023f4h ;AR6 =2324h

MAR *,AR6 ;pointeur de registre ARP=6

LACC *,0 ;charge dans l’ACC la donnée ;située à l’adresse 023f4h

7.3. Registres situés en mémoire (memory mapped registers) [1, §3.4.1 et §4.1.5]

Un grand nombre de registres n’ont pas comme ACC, ACCB, PREG un emplacement spécifique sur le chip de processeur, mais sont en fait configurés dans la mémoire de données, en des endroits réservés dans la page 0 (adresses 0000h à 007fh). C’est par exemple le cas du registre IMR (Interrupt Mask Register), situé à l’adresse 0004h et également des registres auxiliaires (adresses 0010h à 0017h).

Tous ces registres étant situés en page 0, on peut y accéder comme à n’importe quelle autre donnée, pour autant que le pointeur de page (DPP) soit initialisé convenablement (instruction LDP, §�4.2.2).

Toutefois, il existe des instructions spécifiques à la page 0 ne nécessitant pas cette initialisation préalable; il s’agit de :

• LAMM

• LMMR

• SAMM

• SMMR

8. Instructions arithmétiques

Les instructions arithmétiques mettent à contribution deux unités, la CALU (Central Arithmetic and Logic Unit) pour les additions et soustractions, et l’unité de multiplication pour les produits. Plusieurs instructions existent, permettant de faire ces opérations, voire plusieurs simultanément, comme par exemple LTA, qui charge le registre TREG et



additionne le contenu du registre PREG (résultat de la multiplication précédente) à l’accumulateur.

8.1. Additions et soustractions avec la CALU

On notera essentiellement les instructions suivantes : • ADD • SUB • ABS • NEG • ADDS • SUBS

ADD et SUB supportent tous les modes d’adressage (direct, indirect, immédiat) et peuvent spécifier dans le champ opérande un décalage à gauche.

Exemples :

ADD Y1,3 ;ACC=ACC+Y1*2^3

SUB *+,AR3 ;ACC=ACC-(donnée pointée par ;registre auxiliaire courant) ;Le registre auxiliaire ;courant devient ensuite AR3

ADDS Y1 ;ACC=ACC+(Y1 AND 0000ffffh)

8.2. Multiplications

Pour les multiplications, on dispose d’instructions nécessaires au chargement du multiplicande (LT), à la multiplication par le multiplicateur (MPY) et au transfert ou à l’accumulation du résultat dans l’accumulateur (PAC, APAC), voire à la sauvegarde directe dans la mémoire de données (SPH, SPL).

Instructions principales : • LT • MPY • PAC • APAC • LTP • LTA • LTS • LTD • SPAC • MPYA • MPYS • MAC



• MADD



Certaines de ces instructions effectuent plusieurs opérations en un seul cycle : LTA = LT

APAC LTD = LT

APAC DMOV

LTP = LT PAC

MPYS = MPY SPAC

MAC = MPY APAC

MACD = MPY APAC DMOV

L’exemple le plus spectaculaire est certainement

MADD *- ;ACC=ACC+PREG (APAC) ;PREG=Ai*Yi (LT, MPY) ;Yi+1=Yi (DMOV)

semblable à celui déjà cité au chapitre 1, où pas moins de quatre opérations sont exécutées en un seul cycle (ici 50 [ns]), sans parler de la mise à jour du registre auxiliaire pointant sur Yi et d’un autre registre, appelé BMAR (Block Move Address Register), pointant sur Ai. Il s’agit de l’instruction idéale pour l’implémentation de la convolution discrète :

( ) ( ) ( )y k a y k i b u k jii

n

jj

m

= − ⋅ − + ⋅ −= =� �

1 1

à utiliser en conjugaison avec l’instruction de répétition RPT ou RPTZ (§�10.3).

9. Instructions logiques et décalages

Le processeur TMS320C50 dispose d’une unité arithmétique et logique centrale (CALU) ainsi que d’une unité logique parallèle (= indépendante) (PLU).

La CALU permet de faire des opérations logiques entre l’accumulateur et la mémoire, alors qu’avec la PLU, les opérations logiques peuvent être effectuées directement sur les données de la mémoire.

Les décalages sont une des caractéristiques essentielles des DSPs. On peut notamment charger l’accumulateur avec une donnée de la mémoire en décalant au péalable celle-ci vers la gauche de n bits de façon à réaliser une multiplication par 2n. De plus, il existe un certain nombre d’instructions spécifiques permettant de décaler directement l’accumulateur à gauche ou à droite, ainsi que de faire des rotations.



9.1. Opérations logiques avec la CALU

Les instructions suivantes sont disponibles : • AND • OR • XOR • ANDB • ORB • XORB • CMPL

Dans la plupart des cas, les modes d’adressage direct, indirect et immédiat sont possibles. Exemples :

AND Y2 ;ACCL AND Y2

OR * ;ACCL OR (donnée pointée par ;le registre auxiliaire ;courant)

XOR #0ffffh,0 ;ACCL XOR ffffh (inverse tous ;les bits de ACCL)

AND *,AR2 ;ACCL AND (donnée pointée par ;le registre auxiliaire ;courant) ;le nouveau registre ;auxiliaire est AR2

XOR #0ffffh,0 ;ACCL XOR ffffh (inverse tous ;les bits de ACCL)

9.2. Opérations logiques avec la PLU

L’avantage de la PLU est de pouvoir faire des opérations logiques sur les données de la mémoire sans devoir modifier le contenu de l’accumulateur.

Instructions : • APL • CPL • OPL • SPLK • XPL

Exemples :

OPL #0ff00h,SUM ;SUM OR ff00h

SPLK #0aaaah,*+ ;aaaah sauvé à l’adresse ;pointée par le registre ;auxiliaire courant et



;incrémente celui-ci

9.3. Décalages

Les instructions de chargement (LACC) et de sauvegarde (SACL, SACH), ainsi que les opérations arithmétiques (ADD, SUB) en liaison avec l’accumulateur permettent d’effectuer un décalage vers la gauche au préalable. Il en est de même, avec une moins grande souplesse, du registre PREG contenant le résultat de la multiplication. Les décalages effectués de cette manière sont de loin les plus utilisés.

Exemples :

LACC Y0,13 ;ACC=Y0*2^13

SACH SUM,4 ;SUM=ACC*2^4/2^16

; =SUM/1000h

SPM 10b ;fixe le décalage du registre ;PREG à 4 vers la gauche

PAC ;copie PREG dans ACC en le ;décalant de 4 bits

Il existe d’autres instructions de décalage, comme SFR et SFL, toutefois moins performantes puisque qu’elles n’effectuent qu’un décalage d’un bit à droite ou à gauche respectivement. Toutefois, l’instruction BSAR effectue un décalage à droite de 1 à 16 bits en un seul cycle.

Pour les rotations, on dispose notamment de ROL et ROR.

10. Structures de contrôle

Pour les structures de contrôle (if, if...else, for, while, repeat, etc), on fait usage, en assembleur, d’instructions de sauts conditionnels voire inconditionnels.

Pour le processeur TMS320C50, les instructions suivantes sont disponibles :

10.1. Saut inconditionnel

B pma ;saute à l’adresse pma ;(programm memory ;address)

Exemple :

B FILTRE ;saute à ;l’adresse ;correspondant au label ;(étiquette) FILTRE



10.2. Sauts conditionnels

10.2.1.Sauts conditionnels basés sur l’état de l’accumulateur ou des flags (OV, C)

La plupart des sauts conditionnels sont réalisés par l’instruction BCND, à laquelle on spécifie la ou les conditions pour que le branchement soit effectué.

BCND pma,[cond1][,cond2][,...]

;saute à l’adresse ;pma si les conditions ;sont satisfaites

Conditions :

Test Condition

ACC = 0 EQ

ACC ≠ 0 NEQ

ACC < 0 LT

ACC ≤ 0 LEQ

ACC > 0 GT

ACC ≥ 0 GEQ

C = 0 NC

C = 1 C

OV = 0 NOV

OV = 1 OV

10.2.2.Sauts conditionnels basés sur l’état d’un registre auxiliaire (AR0..AR7)

Un saut conditionnel très intéressant est basé sur le contenu d’un registre auxiliaire :

BANZ pma ;saute à l’adresse pma si le ;registre auxiliaire courant ;est différent de zéro

Si le contenu du registre auxiliaire courant (AR0..AR7) n’est pas égal à zéro, le programme poursuit son exécution à l’adresse pma et le contenu du registre auxiliaire courant est décrémenté. Dans la négative, c’est l’instruction suivante qui est exécutée.

Cette instruction est particulièrement utile pour effectuer plusieurs itérations dans un algorithme.

CHAPITRE PROCESSEURS DE SIGNAUX (DSP)...

Documents

Transcript of CHAPITRE PROCESSEURS DE SIGNAUX (DSP)...