dsp_resume.pdf

Cours/TP DSP, Benoît Decoux, 2005-2006

1

Traitement du Signal sur DSP 56303

- Résumé -

Dernière mise à jour : 1/09/2005

Sommaire

Introduction 1 I) Implémentation d’un filtre IIR sur DSP 1

I.1) Forme directe 1 I.2) Forme canonique 5 I.3) Filtres en cascade 6

II) Implémentation de la TFR (Transformée de Fourier Rapide) sur DSP 7 Annexe 1 : Programme de TFR sur DSP56303 9 Annexe 2 : Arithmétique des DSP 12 Annexe 3 : Utilisation du DSP56303 19

Introduction

Un DSP traite le signal échantillon par échantillon, et non pas par blocs comme dans la plupart des programmes tournant sur PC. Ceci est permis par le fait que le processeur est dédié à la tâche de traitement du signal.

Le DSP utilisé ici est le 56303 de Motorola. Le signal est échantillonné et mémorisé sur 24 bits, et le mode de codage est la virgule fixe. Ce mode permet de coder des valeurs décimales entre –1 et +0,99999…. Il nécessite donc de gérer les dépassements de capacité résultant des opérations de calcul, avant mémorisation ou envoi en sortie (au convertisseur numérique-analogique). Des notions d’arithmétique susceptibles d’aider à la compréhension du fonctionnement du DSP sont donnés en annexe ("Arithmétique des DSP"), ainsi que des informations spécifiques au DSP utilisé ("Utilisation des DSP").

Ce document aborde l’implantation des algorithmes de filtrage numérique dans ce DSP, ainsi que l’implantation de la Transformée de Fourier Rapide (TFR). I) Implémentation d’un filtre IIR sur DSP I.1) Forme directe

Dans la forme directe, on mémorise des valeurs passées des échantillons d’entrée et de sortie. La mémoire nécessaire pour cette implémentation est :

- 5 mots pour les coefficients ai et bj (i=0, 1, 2 ; j=1, 2) - 2 mots pour les échantillons d’entrée - 2 mots pour les échantillons de sortie


2

Une des conditions de stabilité d’un filtre du 2nd ordre étant b1max=2 (voir paragraphe sur la modélisation de filtres analogiques), on est confronté à un problème dans le cas d’un codage en virgule fixe (qui ne permet de coder que des valeurs comprises entre –1 et +1).

Une méthode consiste à diviser tous les coefficients par 2 avant codage. On retrouve le vrai résultat de traitement en multipliant l’échantillon de sortie par 2 à la fin (ce qui sera réalisé facilement, par un décalage logique d’un bit vers la gauche de la donnée). En effet, la relation entrée/sortie temporelle peut s’écrire :

S(n)=2×[a0/2×e(n)+ a1/2×e(n-1)+…] Un exemple d’organisation de la mémoire, pour les coefficients et les échantillons à mémoriser,

pourrait être : § coefficients dans mémoire X, pointée par pointeur d’adresse R0 (associé à M0 et N0) ; § échantillons dans mémoire Y, pointeurs d’adresse R1 pour les entrées et R2 pour les sorties.

Algorithme

L’algorithme à implémenter est le suivant :

Répéter indéfiniment Attente d’un nouvel échantillon e(n) dans le CAN Traitement : calcul du nouvel échantillon de sortie s(n) Mise à jour des pointeurs circulaires (remplacer s(n-2) par s(n), et remplacer e(n-2) par e(n)) Envoyer s(n) en sortie du CNA

On peut partir du programme de gestion des entrées/sorties analogiques "pass.asm", et y

intégrer un saut à la routine de traitement. Celle-ci peut se trouver dans un autre fichier, dont le nom doit alors être inclus dans le programme "pass.asm" modifié (à l’aide de la directive d’assemblage "include" : voir programme de filtrage disponible sur site web).

Pour réduire le temps d’exécution de la routine, on a tout intérêt à utiliser les capacités de traitement parallèle du DSP (voir le tutoriel sur le DSP disponible sur le site). Il permet par exemple d’effectuer en parallèle les opérations suivantes :

mac X0,Y0,A X:(R0)+,X0 Y:(R1)+,Y0

→ A=A+X0×Y0 ; =move X:(R0)+,X0 =move Y:(R1+),Y0 X0=X pointée par R0 ; Y0=Y pointée par R1

R0=R0+1 ; R1=R1+1

Pour les coefficients et les échantillons à mémoriser, on peut organiser la mémoire de la manière suivante : § coefficients dans mémoire X, pointée par le registre d’adresse R0 (associé à M0 et N0) ; § échantillons dans mémoire Y, registres d’adresse R1 pour les entrées et R2 pour les

sorties. Différentes étapes du programme

Les différentes étapes du programme à écrire sont les suivantes : Etape 1 : donner des noms aux coefficients (symboles) ; équivalent à déclarer des constantes

a0 equ 0.0001/2 ; remarquer la division par 2, possible ici a1 equ 0.0002/2


3

a2 equ ….. b1 equ ….. b2 equ …..

Etape 2 : réserver des emplacements en mémoire pour les coefficients et les échantillons

org X:$0 ; $0=adresse de la 1ère case mémoire de X coef dsm 5 ; 5 cases mémoire

org Y:$0

en dsm 2 sn dsm 2

Etape 3 : copier les valeurs des coefficients en mémoire

org X :coef ; ‘coef’ équivalent à $0 dc a0,a1,a2,b1,b2 ; 5 cases mémoire

Etape 4 : Initialisations utiles au programme

Pointeurs d’adressage : R0, M0, R1, M1, R2, M2 :

move #coef,R0 ; R0 pointe sur la zone mémoire ‘coef’ move #4,M0 ; zone de mémoire ‘coef’ modulo 5 move #en,R1 ; R1 pointe sur la zone mémoire ‘en’ move #1,M1 ; zone de mémoire ‘en’ modulo 2 move #sn,R2 ; idem pour sn avec R2 et M2

move #1,M2 ;

Mise à 0 des zones de mémoire "en" et "sn" :

clr A ; A=0 do #2,fin_raz ; répéter 2 fois jusqu’à ‘fin_raz’ move A,Y :(R1)+ ; en=0 move A,Y :(R2)+ ; sn=0 fin_raz

Etape 5 : Routine de filtrage : entrée = 1 échantillon ; sortie = 1 échantillon

Cette routine utilise les transferts parallèles du DSP (voir tutoriel sur ce DSP56303)

Initialisation préalable : move X:(R0)+,X0 ; X0=a0 1ère solution pour la routine filtrage move A,Y1 ; Y(1)=e(n) mpy X0,Y1,A ; A=a_0.e(n)

move X:(R0)+,X0 ; X0=a_1 move Y:(R1)+,Y0 ; Y0=e(n-1)

mac X0,Y0,A ; ; A=A+a_1.e(n-1) move X:(R0)+,X0 ; X0=a_2 move Y:(R1),Y0 ; Y0=e(n-2)

mac X0,Y0,A ; A=A+a_2.e(n-2) move X:(R0)+,X0 ; X0=b_1 move Y:(R2)+,Y0 ; Y0=s(n-1)

mac -X0,Y0,A ; A=A-b_1.s(n-1) move X:(R0)+,X0 ; X0=b_2 move Y:(R2),Y0 ; Y0=s(n-2)

macr -X0,Y0,A ; A=A-b_2.s(n-2)=s(n)/2


4

move Y1,Y:(R1) ; e(n) dans e(n-2) asl A ; A=2.A=s(n)

move X:(R0)+,X0 ; X0=a_0 move A,Y:(R2) ; s(n) dans s(n-2) rts 2e solution, utilisant l’adressage parallèle du DSP (donc plus rapide)

Pour réduire le temps d’exécution de la routine, on a tout intérêt à exploiter les possibilités de traitement parallèle du DSP (voir le tutoriel sur le DSP disponible sur le site web).

Pour cela on doit remplacer par exemple R1 par R4 et R2 par R5, car les registres d’adresse sont répartis en 2 groupes : R0-R3 et R4-R5, et on ne peut pas utiliser 2 registres du même groupe en parallèle.

On peut ainsi par exemple effectuer en parallèle les opérations suivantes :

mac X0,Y0,A X:(R0)+,X0 Y:(R4)+,Y0

→ A=A+X0×Y0 ; =move X:(R0)+,X0 =move Y:(R4+),Y0 X0=X pointée par R0 ; Y0=Y pointée par R4

R0=R0+1 ; R4=R4+1 La routine de filtrage devient alors : filtrage move A,Y1 ;Y(1)=e(n) mpy X0,Y1,A X:(R0)+,X0 Y:(R4)+,Y0 ;A=a_0.e(n) ; X0=a_1 ; Y0=e(n-1) mac X0,Y0,A X:(R0)+,X0 Y:(R4),Y0 ;A=A+a_1.e(n-1) ; X0=a_2 ; Y0=e(n-2) mac X0,Y0,A X:(R0)+,X0 Y:(R5)+,Y0 ;A=A+a_2.e(n-2) ; X0=b_1 ; Y0=s(n-1) mac -X0,Y0,A X:(R0)+,X0 Y:(R5),Y0 ;A=A-b_1.s(n-1) ; X0=b_2 ; Y0=s(n-2) macr -X0,Y0,A Y1,Y:(R4) ;A=A-b_2.s(n-2)=s(n)/2 ; e(n) dans e(n-2) asl A X:(R0)+,X0 ;A=2.A=s(n) ; X0=a_0 move A,Y:(R5) ;s(n) dans s(n-2) rts Calcul des temps d’exécution

Il faut se référer au document de Motorola "DSP56300 Family Manual", Appendice A : Instructions timing and restrictions, et Appendice B : Benchmark programs.

Soit T la durée d’un cycle d’horloge (=période d’horloge) du DSP, move X:(R0)+,X0 ; 1×T filtrage move A,Y1 ; 1×T mpy X0,Y1,A X:(R0)+,X0 Y:(R1)+,Y0 ; 1×T mac X0,Y0,A X:(R0)+,X0 Y:(R1),Y0 ; 1×T mac X0,Y0,A X:(R0)+,X0 Y:(R2)+,Y0 ; 1×T mac -X0,Y0,A X:(R0)+,X0 Y:(R2),Y0 ; 1×T macr -X0,Y0,A Y1,Y:(R1) ; 1×T asl A X:(R0)+,X0 ; 1×T move A,Y:(R2) ; 1×T rts

Total : 16 cycles d’horloge, un peu moins de 200ns à 80Mhz (période de 12,5ns). Cette durée est à comparer avec la condition de temps réel : le traitement doit s’effectuer dans une durée inférieure à la période d’échantillonnage, soit par exemple environ 21 µs à 48kHz. Le rapport entre ces 2 durées est d’environ 170.


5

I.2) Forme canonique Principe

Pour rappel, les relations entrées/sorties à implémenter (voir résumé de cours pour plus de détails et un exemple d’implémentation en C) sont :

)2n(wa)1n(wa)n(wa)n(s 210 −+−+= )2n(wb)1n(wb)n(e)n(w 21 −−−−=

Les avantages de la forme canonique sont : - on n’a plus que 2 échantillons passés à mémoriser, au lieu de 4 pour la forme directe (+ 5

coefficients) ; - le nombre de traitements est réduit par rapport à la forme directe ; on n’a que 5 cycles-

machine (ce qui représente par exemple 500 ns pour une horloge à 20MHz) ; - on peut augmenter les coefficients les plus faibles, en général les ai : on peut normaliser les

ai et les bi indépendamment ; ils seront donc moins sensibles aux erreurs d’arrondi.

On peut partir du programme "filtre.asm", modifier l’ordre de mémorisation des coefficients du filtre, la fonction d’initialisation, ainsi que celle de calcul de l’échantillon filtré.

Il ne faut pas oublier de gérer la division par 2 des coefficients (nécessaire pour le codage en virgule fixe).

)2n(w2

a)1n(w

2a

)n(w2

a2

)n(s 210 −+−+= et )2n(w2

b)1n(w

2b

2)n(e

2)n(w 21 −−−−=

Il faut donc d’abord diviser e(n) par 2, puis multiplier le membre de droite de la 2e équation par

2 pour obtenir w(n). Enfin, il faut multiplier le résultat final par 2 pour obtenir s(n). Voici une première version du programme non-optimisé du point de vue du temps de traitement

car n’utilisant que quelques traitements parallèles, qui auraient pu être plus nombreux : org X:coef ;copie des valeurs des coefficients dans ces mêmes emplacements

dc b_1,b_2,a_0,a_1,a_2 ;coefficients divisés par 2 …. init_filtre move #wn,R0 ;R0 pointe sur la zone memoire "wn" move #1,M0 ;zone de memoire "wn" modulo 2 move #coef,R4 ;R4 pointe sur la zone memoire "coef" move #4,M4 ;zone de memoire "coef" modulo 5 clr A ;A=0 do #2,fin_raz ;mise a zero de la zone "wn" move A,Y:(R0)+ ;A=0 dans "wn" fin_raz rts …. filtrage ;il faut A=e(n) ici asr A ;e(n)=e(n)/2 move X:(R0)+,X0 Y:(R4)+,Y0 ;X0=w(n-1), Y0=b1 mac -X0,Y0,A ;A=A-b1*w(n-1) move X:(R0)+,X0 Y:(R4)+,Y0 ;X0=w(n-2), Y0=b2 mac -X0,Y0,A ;A=A-b2*w(n-2)=w(n) asl A ;w(n)=w(n)*2 move A,X1 ;X1=w(n) (sauvegarde temporaire pour memorisation) move Y:(R4)+,Y0 ;Y0=a0 mpy X1,Y0,A ;A=a0*w(n) move X:(R0)+,X0 Y:(R4)+,Y0 ;X0=w(n-1), Y0=a1 mac X0,Y0,A ;A=A+a1*w(n-1) move X:(R0),X0 Y:(R4)+,Y0 ;X0=w(n-2), Y0=a2 mac X0,Y0,A ;A=A+a2*w(n-2) move X1,X:(R0) ;w(n)->w(n-2) asl A ;A=2.A=s(n) (car les coefficients ont ete divises par 2) rts

Voici maintenant une 2e version utilisant l’adressage parallèle :


6

org Y:$0

coef dsm 2 org Y:coeff dc a0, b1, b2, a1, a2

….. move #coef,R5 ; R5 pointe sur la zone mémoire “coef” move #4,M5 ; en mode d’adressage modulo 5 move #wn,R1 ; R1 pointe sur la zone de mémoire “wn” move #2,N1 ; pour les incrémentations sup. à 1 move #1,M1 ; en mode d’adressage modulo 2 clr A rep #2 ; répéter 2 fois la ligne suivante move A,X :(R1)+ ; A=0 dans les w(i) move Y:(R5)+,X0 ; X0=a0 move A,Y1 ; Y1=e(n)

filtrage mpy X0,Y1,A X:(R1)+,X0 Y:(R5)+,Y0 ; A=a0.e(n) ;X0=w(n-1) ;Y0=b1 mac -X0,Y0,A X:(R1),X1 Y:(R5)+,Y0 ; A=A-b1.w(n-1) ;X1=w(n-2) ;Y0=b2 mac -X1,Y0,A X0,X:(R1)- Y:(R5)+,Y0 ; A=A-b2.w(n-2) ;w(n-1)->w(n-2) ;Y0=a1 mac X0,Y0,A A,X:(R1)+ Y:(R5)+,Y0 ; A=A+a1.w(n-1) ;w(n)->w(n-1) ;Y0=a2 macr X1,Y0,A Y:(R5)+,X0 ; A=A+a2.w(n-2) ;X0=a0 rts I.3) Filtres en cascade

Comme dans le cas de la programmation en langage évolué, il est nécessaire d’utiliser des

tampons mémoire pour les coefficients ai et bi des différents filtres, ainsi que pour les valeurs passées des échantillons d’entrée et de sortie.

Considérons le cas le plus simple de la mise en cascade de plusieurs fois le même filtre du 2nd ordre : les coefficients ai et bi sont les mêmes pour tous les filtres.

Les étapes 1 et 3 ne changent pas. Etape 2 : réservation de plus d’emplacements en mémoire pour les échantillons.

org Y:$0 en dsm 4 sn dsm 4

Etape 4 : Initialisation des pointeurs d’adresse : en conséquence de l’augmentation de la taille des tampons d’échantillons, il faut augmenter d’autant la taille des modulo.

Pointeurs d’adressage : R0, M0, R4, M4, R5, M5 : move #en,R4 ; R4 pointe sur la zone mémoire ‘en’ move #3,M4 ; zone de mémoire ‘en’ modulo 4

move #sn,R5 ; idem pour sn avec R5 et M5 move #3,M5 ;

De plus il faut se déplacer différemment dans ces tampons. Il faut donc utiliser les registres

d’incrémentation Ni associés aux registres pointeurs Ri. Par conséquent on ajoute au programme du filtre unique les lignes suivantes :

move #2,N4 ; pour le passage d’un filtre à l’autre : tampon échantillons d’entrée move #2,N5 ; idem pour échantillons de sortie

Etape 5 : Routine de filtrage : les parties ajoutées ou modifiées sont mises en gras. filtrage

do #2,fin_fltr move A,Y1 ; Y1=e(n) à la 1ère itér., s(n) du filtre précédent aux autres mpy X0,Y1,A X:(R0)+,X0 Y:(R4)+,Y0 ; A=a_0.e(n) ; X0=a_1 ; Y0=e(n-1) mac X0,Y0,A X:(R0)+,X0 Y:(R4),Y0 ; A=A+a_1.e(n-1) ; X0=a_2 ; Y0=e(n-2)


7

mac X0,Y0,A X:(R0)+,X0 Y:(R5)+,Y0 ; A=A+a_2.e(n-2) ; X0=b_1 ; Y0=s(n-1) mac -X0,Y0,A X:(R0)+,X0 Y:(R5),Y0 ; A=A-b_1.s(n-1) ; X0=b_2 ; Y0=s(n-2) macr-X0,Y0,A Y1,Y:(R4)+N4 ; A=A-b_2.s(n-2)=s(n)/2 ; e(n) dans e(n-2) ; incrém. pour la proch. itér. asl A X:(R0)+,X0 ; A=2.A=s(n) ; X0=a_0 move A,Y:(R5)+N5 ; s(n) dans s(n-2) ; incrém. pour la proch. itér.

fin_fltr rts II) Implémentation de la TFR (Transformée de Fourier Rapide) sur le DSP

Il s’agit de l’implémentation du programme "fft.asm" (disponible sur le site www-dsp.efrei.fr). Dans ce programme, la TFR est déclarée comme macro-instruction. Elle possède 3 paramètres : "points" (nombre de points N), "data" (adresse des échantillons du signal) et "coef" (adresse des facteurs de phase).

Cette macro-instruction peut être appelée dans un programme principal en lui passant ses 3 paramètres de la façon suivante :

fft points, data, coef

Soient A et B les 2 entrées complexes d’un papillon : A=Re(A)+Im(A) B=Re(B)+Im(B)

Le facteur de phase kNW est défini par :

θ−θ=θ=

π

−= sinjcos)exp(-jN

k2jexpWk

N

( ) θ= cosWRe kN ; ( ) θ−= sinWIm k

N ; N

k2π=θ

Les sorties du papillon A’ et B’ sont définies par :

A’=A+B. kNW

B’=A-B. kNW

Le développement donne :

A’=Re(A)+jIm(A)+(Re(B)+jIm(B))×(cosθ-jsinθ) soit :

Re(A’)=Re(A)+Re(B).cosθ+Im(B).sinθ (1) Im(A’)=Im(A)+Im(B).cosθ-Re(B).sinθ (2)

Re(B’)=Re(A)-Re(B).cosθ-Im(B).sinθ (3) Im(B’)=Im(A)-Im(B).cosθ+Re(B).sinθ (4)

B’ peut être calculé à partir de A’, ce qui réduit le nombre d’opérations : (1)+(2) → Re(B’)=2.Re(A)-Re(A’) (3)+(4) → Im(B’)=2.Im(A)-Im(A’)

Les facteurs de phase k

NW sont stockés à l’adresse ‘coef’ - Valeurs de cosinus en mémoire X


8

- Valeurs de sinus en mémoire Y Seules N/2 valeurs sont stockées : de 0 à π-θ avec θ=2π/N. Le cœur du programme est le calcul d’un papillon, c’est à dire le calcul des 2 nombres

complexes de sortie à partir des 2 nombres complexes d’entrée. Calculs intermédiaires :

b=Im(A)-Re(B).sinθ (MAC) Im(A’)=b+Im(B).cosθ (MACR) Im(B’)=2.Im(A)-Im(A’) (SUBL)

b=Re(A)-Re(B).cosθ (MAC) Re(A’)=b+Im(B).sinθ (MACR) Re(B’)=2.Re(A)-Re(A’) (SUBL)

Les transferts parallèles du DSP sont utilisés.

Test de l’algorithme

On met quelques périodes de sinus en mémoire. Le résultat de la TFR doit être 0 partout sauf pour la composante correspondant à la fréquence du signal. Le module de cette composante est alors égal à l’amplitude du signal.

Les échantillons d’entrée sont stockés à l’adresse ‘data’ : - Partie réelle en mémoire X - Partie imaginaire en mémoire Y

- l’adressage en mode bits inversés est l’un des 3 modes d’adressage du DSP - ce mode se programme de la manière suivante :

- registre Mi chargé avec 0 - registre Ni chargé avec le nombre de bits à inverser

Un exemple de programme : copie d’une zone de mémoire dans une autre avec adressage en

bits inversés pourrait être (voir également programme ‘bit_rev.asm’) :

move #data, R3 ; R3 pointe sur une zone ‘data’ préalablement initialisée move #data2, R4 move #0, M3 ; programmation du mode ‘bit reverse’ move #nb_pts, N3 ; renversement binaire sur ‘nb_pts’ adresses do #nb_pts, fin1 move x :(R3)+N3,x0 move x0,x :(R4)+

fin1 nop


9

Annexe 1 : Programme de TFR sur DSP56303 ;***************************************************************************************************** ; fft.asm ; Algorithme de calcul de la transformee de Fourier rapide TFR ; - sur place (les sorties de la FFT écrasent les échantillons du signal) ; - décimation temporelle ; ; Benoit Decoux, TP DSP, EFREI 2002-2003 ; (à partir du programme fftc563.asm de Motorola et du travail de projet de ; fin d'études de MM. Barbiero et Valette, promotion 2002). ;***************************************************************************************************** fft macro points,data,coef ; macro fft ;initialisation des registres de décalage (papillons, groupes et coefficients W(n,k) move #points/2,n0 ; n0 = nombre de papillons par groupe (valeur initiale : 'points'/2) move #1,n2 ; n2 = nombre de groupes dans la passe (valeur initiale : 1) move #points/4,n6 ; n6 pour acceder aux valeurs sinus et cosinus des W(n,k) ; (la moitié de la taille du tableau) ;mode d'adressage move #-1,m0 ; m0 = $FFFF, adressage lineaire move m0,m1 ; idem pour m1 move m0,m4 ; idem pour m4 move m0,m5 ; idem pour m5 move #0,m6 ; adressage en binaire inverse pour r6 (acces aux W(n,k)) do #@cvi(@log(points)/@log(2)+0.5),_fin_pass ; boucles sur les passes (N=2^P itérations) ;initialisation des ptr de calcul et enreg move #data,r0 ; r0 contient l'adresse de base des échantillons "data" move r0,r4 ; idem pour r4 move #coef,r6 ; r6 pointe sur l'adresse de base de "coef" lua (r0)+n0,r1 ; r1 contient l'adresse du N/2e échantillon ;initialisation des registres de décalage move n0,n1 ; registre de decalage n1 <- nb papillon par groupe move n0,n4 ; idem n4 move n0,n5 ; idem n5 nop lua (r1)-,r5 ; r5=r1-1 (adresse du N/2-1e échantillon) do n2,_fin_grpe ; boucle sur les groupes (n2 iterations) ;init des calculs intermédiaires move x:(r1),x1 y:(r6),y0 ; x1 <- Re[B], y0 <- sinus (car r6=coef) move x:(r5),a y:(r0),b ; A <- Re[B], B <- Im[A] move x:(r6)+n6,x0 ; x0 <- cosinus (n6=points/4) et r6 remis a jour pour prochaine iteration do n0,_fin_papi ; boucle sur les papillons (n0 iterations) mac -x1,y0,b y:(r1)+,y1 ; B <- (B=Im[A])-Re[B]*sinus (calcul intermédiaire) ; y1 <- Im[B] et r1++ macr x0,y1,b a,x:(r5)+ y:(r0),a ; B <- (B=Im[A]-Re[B]*sinus)+Im[B]*cosinus=Im[A'] ; X <- (A=Re[B]) et r5++ (sauvegarde en mémoire X) ; A <- Im[A] subl b,a x:(r0),b b,y:(r4) ; A <- (Im[B']=2*Im[A]-Im[A']) ; B <- Re[A] ; Y <- Im[A'] (sauvegarde en mémoire Y) mac x1,x0,b x:(r1),x1 ; B <- (B=Re[A])+Re[B]*cosinus (calcul intermédiare) ; x1 <- Re[B] macr y1,y0,b x:(r0)+,a a,y:(r5) ; B <- Re[A']=(B=Re[A]+Re[B]*cosinus)+Im[B]*sinus) ; A <- Im[A] et r0++ ; Y <- Im[B'] (sauvegarde en mémoire Y) subl b,a b,x:(r4)+ y:(r0),b ; A <- (2*Re[A]-Re[A']=Re[B']) ; X <- Re[A'] et r4++ (sauvegarde en mémoire X) ; B <- Im[A] _fin_papi ;mises à jour pour papillons move x:(r0)+n0,x1 y:(r4)+n4,y1 ; x1 <- Re[B] et r0=r0+n0 ; r4=r4+n4 move a,x:(r5)+n5 y:(r1)+n1,y1 ; X <- (A=Re[B']) et r5=r5+n5 ; y1 <- Im[B] et r1=r1+n1 _fin_grpe move n0,b1 ; b1 <- nombre de papillons par groupe lsr b ; division du nombre de papillons/groupes par 2 move n2,a1 ; a1 <- nombre de groupes par passe lsl a ; multiplication du nombre de goupes/passe par 2 move b1,n0 ; mise à jour de n0 avec son nouveau contenu move a1,n2 ; idem pour n2 _fin_pass endm ; fin macro


10

;************************************************************************ ; Transformee de Fourier rapide (FFT) ; Benoit Decoux, cours-TP DSP 2002-2003, EFREI ;************************************************************************ include 'fft.asm' ; macroinstruction du calcul de la TFR ; DEFINITION des adresses des registres utilisés ;************************************************************************* M_PCTL equ x:$FFFFFD ; registre de commande de la PLL M_BCR equ x:$FFFFFB ; registre de commande des BUS ; DEFINITION des constantes ;************************************************************************* points equ 64 ; nombre de points de la TFR pi equ 3.141592654 ; no comment freq equ 2.0*pi/@cvf(points) ; 1 période de sinus sur 'point' pour les facteurs de phase W(n,k) np equ 8 freq2 equ 2.0*pi/@cvf(points/np) ; "fréquence" du signal de test cosinus : 'np' périodes dans le tableau de 'points' valeurs data equ $100 ; adresse mémoire de la zone de données à traiter coef equ data+points ; adresse mémoire de la zone de mémorisation des facteurs de phase affi equ $160 ; adresse mémoire de la zone de mémorisation des résultats de la FFT ; allocations en memoire X ;************************************************************************* org x:data ds points ; pour les données à traiter org x:coef ; ligne facultative puisque l'adresse 'coef' est à la suite de 'data' ds points/2 ; pour les cos & sin utilisés par la FFT org x:affi ds points ; pour les résultats du traitement ; allocations en memoire Y ;************************************************************************* org y:data ds points ; idem pour parties imaginaires org y:coef ds points/2 ;***************table generation macro*********************************** ; Sine-Cosine Table Generator ; sincosr - macro to generate sine and cosine coefficient ; lookup tables for Decimation in Time FFT ; twiddle factors. Only points/2 coefficients ; are generated. ; points - number of points (2 - 32768, power of 2) ; coef - base address of sine/cosine table ; negative cosine value in X memory ; negative sine value in Y memory ;************************************************************************** sincosr macro points,coef sincosr ident 1,1 org x:coef count set 0 dup points/2 dc @cos(@cvf(count)*freq) count set count+1 endm org y:coef count set 0 dup points/2 dc @sin(@cvf(count)*freq) count set count+1 endm endm ; fin macro sincos ; macro de génération de signal de test (cosinus) ;*********************************************** sigtst macro points,coef org x:data count set 0 ; generate a cosine input dup points dc @cos(@cvf(count)*freq2)/256 count set count+1 endm ; fin de la boucle dup org y:data count set 0 ; 0 fill the corresponding imaginary input dup points dc 0 count set count+1 endm ; fin de la boucle dup endm ; fin de la macro sincosr points,coef ; macro à lancer avant le programme : sigtst points,coef ; elle contiennent des directives d'assemblage ; Programme principal ;********************************** org p:$100 START main movep #$040003,x:M_PCTL ; set PLL for MPY of 4X movep #$012421,x:M_BCR ; set up one ext. wait state for all AAR areas ori #3,mr ; mask interrupts movec #0,sp ; clear hardware stack pointer move #0,omr ; operating mode 0 fft points,data,coef


11

; jsr module ; appel à la routine pour ne garder que le module jmp * ; tourne en rond end


12

;**************************************************************************************** ; testflt1.asm ; Test des fonctions de filtrage de filtre.asm ; TP/projets DSP EFREI 2002-2003, Benoît Decoux ;**************************************************************************************** nolist include 'ioequ.asm' include 'intequ.asm' include 'ada_equ.asm' include 'vectors.asm' list ;****************************************************************************** ;---Buffer for talking to the CS4215 org x:0 RX_BUFF_BASE equ * RX_data_1_2 ds 1 ;data time slot 1/2 for RX ISR RX_data_3_4 ds 1 ;data time slot 3/4 for RX ISR RX_data_5_6 ds 1 ;data time slot 5/6 for RX ISR RX_data_7_8 ds 1 ;data time slot 7/8 for RX ISR TX_BUFF_BASE equ * TX_data_1_2 ds 1 ;data time slot 1/2 for TX ISR TX_data_3_4 ds 1 ;data time slot 3/4 for TX ISR TX_data_5_6 ds 1 ;data time slot 5/6 for TX ISR TX_data_7_8 ds 1 ;data time slot 7/8 for TX ISR RX_PTR ds 1 ; Pointer for rx buffer TX_PTR ds 1 ; Pointer for tx buffer TONE_OUTPUT EQU HEADPHONE_EN+LINEOUT_EN+(4*LEFT_ATTN)+(4*RIGHT_ATTN) TONE_INPUT EQU MIC_IN_SELECT+(15*MONITOR_ATTN) CTRL_WD_12 equ NO_PREAMP+HI_PASS_FILT+SAMP_RATE_48+STEREO+DATA_16 ;CLB=0 CTRL_WD_34 equ IMMED_3STATE+XTAL1_SELECT+BITS_64+CODEC_MASTER CTRL_WD_56 equ $000000 CTRL_WD_78 equ $000000 org p:$100 START main movep #$040003,X:M_PCTL ; set PLL for MPY of 4X movep #$012421,X:M_BCR ; set up one ext. wait state for all AAR areas ori #3,mr ; mask interrupts movec #0,sp ; clear hardware stack pointer move #0,omr ; operating mode 0 move #$40,r6 ; initialise stack pointer move #-1,m6 ; linear addressing jsr ada_init ; initialize codec

jsr init_filtre ; initialisation des paramètres du filtre

loop_1 jset #2,X:M_SSISR0,* ; wait for frame sync to pass jclr #2,X:M_SSISR0,* ; wait for frame sync move X:RX_BUFF_BASE,B ; receive left move X:RX_BUFF_BASE+1,A ; receive right jsr process_stereo move A,X:TX_BUFF_BASE ; transmit left move A,X:TX_BUFF_BASE+1 ; transmit right move #TONE_OUTPUT,y0 ;set up control words move Y0,X:TX_BUFF_BASE+2 move #TONE_INPUT,y0 move Y0,X:TX_BUFF_BASE+3 jmp loop_1 include 'ada_init.asm' include '../prog/filtre_4.asm' ;INCLUDE YOUR OWN .ASM HERE echo process_stereo jsr filtrage ;JUMP TO YOUR PROCESSING SUBROUTINE HERE rts end


13

;-------------------------------------------------------------------------------------------------------- ; filtre.asm ; Implémentation d'un filtre passe-bas du 2e ordre sur DSP 56303 ; Forme directe ; ; TP/projets DSP EFREI 2002-2003, Benoît Decoux ;-------------------------------------------------------------------------------------------------------- a_0 equ 0.00379/2 a_1 equ 0.00758/2 a_2 equ 0.00379/2 b_1 equ -1.81845/2 b_2 equ 0.83362/2 org X:$10 ;réservation de 5 emplacements mémoire coef dsm 5 ; pour les coefficients du filtre org X:coef ;copie des valeurs des coefficients dans ces mêmes emplacements dc a_0,a_1,a_2,b_1,b_2 org Y:0 en dsm 2 sn dsm 2 org p: init_filtre move #coef,R0 ;R0 pointe sur la zone mémoire "coef" move #4,M0 ;zone de mémoire "coef" modulo 5 move #en,R4 ;R4 pointe sur la zone mémoire "en" move #1,M4 ;zone de mémoire "en" modulo 2 move #sn,R5 ;R5 pointe sur la zone mémoire "sn" move #1,M5 ;zone de mémoire "sn" modulo 2 clr A ;A=0 do #2,fin_raz ;mise à zéro des zones "en" et "sn" move A,Y:(R4)+ ;A=0 dans "en" move A,Y:(R5)+ ;X0=a_0 fin_raz move X:(R0)+,X0 rts filtrage move A,Y1 ;Y(1)=e(n) mpy X0,Y1,A X:(R0)+,X0 Y:(R4)+,Y0 ;A=a_0.e(n), X0=a_1, Y0=e(n-1) mac X0,Y0,A X:(R0)+,X0 Y:(R4),Y0 ;A=A+a_1.e(n-1), X0=a_2, Y0=e(n-2) mac X0,Y0,A X:(R0)+,X0 Y:(R5)+,Y0 ;A=A+a_2.e(n-2), X0=b_1, Y0=s(n-1) mac -X0,Y0,A X:(R0)+,X0 Y:(R5),Y0 ;A=A-b_1.s(n-1), X0=b_2, Y0=s(n-2) macr -X0,Y0,A Y1,Y:(R4) ;A=A-b_2.s(n-2)=s(n)/2, e(n)->e(n-2) asl A X:(R0)+,X0 ;A=2.A=s(n), X0=a_0 move A,Y:(R5) ;s(n) dans s(n-2) rts


14

Annexe 2 : Arithmétique des DSP

Sommaire

1) Représentations des nombres 1 2) Codage binaire 1 3) Nombres signés 2

Signe-grandeur 2 Code complément à 1 2 Code complément à 2 3

4) Nombres réels 3 Virgule fixe 3 Format mixte 4 Virgule flottante 5

5) Conversions de formats 6 Décimal vers binaire 6 Binaire vers décimal 6 Fractionnaire vers binaire 6 Conversion hexa décimal vers décimal 6 Conversion décimal vers hexadécimal 7

6) Réduction du nombre de bits du codage 7 Troncature 7 Arrondi 7

1) Représentations des nombres

Les nombres sont représentés par une succession de chiffres, eux-mêmes exprimés dans une base donnée. Les représentations les plus utilisées sont :

- Binaire : 1 chiffre possède 2 valeurs possibles : base 2 - Décimale : 1 chiffre possède 10 valeurs possibles : base 10 - Hexadécimale : 1 chiffre possède 16 valeurs possibles : base 16

Ces représentations courantes sont des cas particuliers du cas général d’une base n. Dans les systèmes numériques, les données sont représentées par groupes de 4 bits, chaque

groupe pouvant coder 16 valeurs, de 0 à 15. Les représentations utilisées sont donc le binaire et l’hexadécimal, qui permet une écriture condensée, au moyen de chiffres et de lettres : de 1 à 9 puis de A à F. 2) Codage binaire

Sur n bits, on peut coder 2n combinaisons possibles : de 0 à 2n-1. Exemples :

- 1 bit : 21=2 combinaisons de 0 à 21-1=1 - 8 bits : 28=256 combinaisons de 0 à 28-1=255 - 16 bits : 216=65536 combinaisons de 0 à 216-1=65535 - etc


15

3) Nombres signés

A résolution constante, des nombres peuvent être représentés par des valeurs positives uniquement (nombre non signés) ou par des valeurs positives et négatives (nombres signés).

Par exemple sur 8 bits, en représentation signée, un nombre peut varier de –128 à +127 (en complément à 2, voir ci-dessous) ; en représentation non-signée, il peut varier de 0 à 255.

Il existe plusieurs représentations des nombres signés :

- signe-grandeur ; - complément à 1 ; - complément à 2.

Le plus souvent, le code utilisé pour les nombres signés est le complément à 2. On obtient le

complément à 2 d’un nombre en lui appliquant d’abord le complément à 1, puis en ajoutant 1. L’opposé d’un nombre s’obtient donc en calculant son complément à 2.

L’intérêt du code complément à 2 est sa facilité de calcul, et le fait que la valeur 0 ne soit codée qu’une seule fois (ce qui n’est pas le cas du complément à 1). Toutes les opérations nécessaires pour l’obtenir (addition, soustraction, multiplication, division) peuvent être réalisées à partir de l’addition, réalisée par des additionneurs binaires.

Ce code est utilisé dans les ordinateurs et la plupart des microcontrôleurs, dont le DSP56303. Signe-grandeur

Dans cette représentation, le bit de gauche est un bit de signe et les autres représentent la grandeur.

Bit de signe : 0 → nombre positif ; 1 -> nombre négatif Exemple :

–5=1101 (pour la conversion de la représentation décimale à la représentation binaire, voir plus bas).

Code complément à 1 Dans ce mode de représentation, les poids des bits vont sont –2n-1, 2n-2, 2n-3, … 20, où n est le

nombre de bits. Pour obtenir le complément à 1 d’un nombre, on inverse tous les bits de son code binaire et on

ajoute 1. Exemple :

5=0101 ; complément à 1 : 1010+1=–5

La conversion binaire-vers-décimal s’obtient en ajoutant les poids des bits à 1 (voir paragraphe sur les conversions de formats, plus bas).

Exemple : binaire=1010 → décimal= –23+21+1= –8+2+1= –5

Code complément à 2

Les poids de bits sont les mêmes qu’en complément à 1. On obtient le complément à 2 en appliquant le complément à 1 et en ajoutant 1.


16

Exemple : 5=0101 → –5=1011

Conversion inverse : binaire=1011 → décimal= –23+21+20=5

Autre exemple :

72=01001000 inversion : 10110111

+1 : 10111000 = –72

Les valeurs sont comprises entre –(2n-1) et 2n-1–1. Exemple : n=8 : valeurs comprises entre –27= –128 et 27–1=127.

4) Nombres réels

Les nombres réels sont encore appelés nombres fractionnaires. Ils possèdent des chiffres à droite la virgule. Virgule fixe

Dans ce mode de représentation, on a 1 bit de signe (bit de gauche) et les autres qui concernent la partie fractionnaire. La virgule se situe donc à droite de ce bit.

Comme dans le cas des nombres entiers, la signification du bit de signe est : • 0 : le nombre est positif, • 1 : le nombre est négatif.

Dans ce mode on peut représenter des nombres compris entre –1 et +1, plus exactement –1 et 0,999999… , le nombre de 9 dépendant du nombre de bits.

Nombre de valeurs possibles sur n bits :

2n Précision :

2-(n-1) Valeurs min et max :

min=-1,0 ; max=1-2-(n-1) Poids des bits :

-20, 2-1, 2-2, …, 2-(n-1)

Exemple : N=3

Nombre de valeurs possibles : 23=8

Précision : 2-(n-1)=1/2 n-1=1/4=0,25

Valeurs min et max : -1,0 et 1-2-(3-1)= 1-2-2=1-1/22=1-1/4=0,75

Les 8 valeurs sont : -1,0 ; -0,75 ; -0,5 ; -0,25 ; 0 ; 0,25 ; 0,5 ; 0,75


17

Représentation sur un cercle : l’intervalle [-1,0 ; 0,999…] est décomposé en 2n valeurs, et le cercle en 2n parties.

Pour passer du binaire au décimal, on ajoute les poids des bits à 1, comme dans le cas des entiers (voir paragraphe sur les conversions de format, plus bas) :

D=-20bn-1+2-1bn-2+…+2-(n-2)b1+2-(n-1)b0

Exemples • n=3 ; binaire=010

D=-20×0+2-1×1+2-2×0=1/2 • n=3 ; binaire=111

D=-20×1+2-1×1+2-2×=-1+1/2+1/4=-1/4

• n=16 ; binaire=0011 0011 0011 0011 D=2-2+2-3+2-6+2-7+2-10+2-11+2-14+2-15

=0,25+0,125+0,01562+0,0078+… =0,3999….

Sur 24 bits (cas de la mémoire du DSP56303) : Précision :

2-23 Valeur min : tous les bits sont à 0 sauf le bit de signe

-1=$800000 Valeur max : tous les bits sont à 1 sauf le bit de signe

1-2-23=$7FFFFF=0,99999988 Exemple : quel nombre représente $FFFFFF ?

Réponse : -20+0,9999998=-1+0,9999998=-0,00000012 ; il s’agit de la valeur négative la plus petite, qui est égale en valeur absolue à la précision.

Ce format est parfois noté [I-Q] ; I désigne la partie à gauche de la virgule ; Q la partie à droite. Ici, le format est noté [1-23] ou Q23. Format mixte

Ce codage est à virgule fixe, mais avec une partie entière qui peut être supérieure à 1. L’intérêt de ce format est de permettre de sortir de la plage [-1 ; +1], ce qui facilite les calculs.

Soit I le nombre de bits de la partie entière et Q le nombre de bits de la partie fractionnaire. La correspondance entre le nombre décimal et le nombre binaire est :

D=-2I-1bI-1+2I-2bI-2+…+20b0+2-1b-1+2-2b-2+...+2-Qb-Q Il est noté [I, Q] ; Dans le cas du DSP56303, les accumulateurs A et B comportent 56 bits. Le format est [9, 47] :

la partie entière comporte 9 bits et la partie fractionnaire 47 bits. Ces accumulateurs sont constitués par la concaténation d’un registre de 8 bits et 2 registres de

24 bits : A=A2:A1:A0 et B=B2:B1:B0

Le bit le plus à gauche est le bit de signe. Les poids des 8 bits de poids fort vont de 28 à 21, et non 27 à 20 comme dans la représentation habituelle à 8 bits.

A2 : 28 à 21 ; A1 : 20 à 2-23 ; A0 : 2-24 à 2-47


18

La virgule se situe entre le bit de poids 20 et le bit de poids 21. Cela permet de n’utiliser que l’un des registres de 24 bits. Exercice 1 : Dans le format mixte [9, 47], quel nombre représente $01FFFFFFFFFFFF ?

Réponse : 20+2-1+2-2+...+2-46=1+0,5+0,25+...=1,999999..... Exercice 2 : Dans le format mixte [9, 47], comment coder –1 ?

Réponse : $FF800000000000 car -1=-28+27+26+25+...+21+20=-256+128+64+32+16+8+4+2+1

Virgule flottante

L’avantage de ce codage est de permettre de coder à la fois des nombres sur de très grandes plages de valeurs s’il s’agit d’entiers, et avec une grande précision (beaucoup de chiffres après la virgule) s’il s’agit de réels.

La position de la virgule est gérée par l’UAL. Il n’est donc pas nécessaire de gérer le dépassement de capacité.

Le codage peut être réalisé sur 32 ou 64 bits. On parle respectivement de simple ou de double précision.

En simple précision, l’étendue des valeurs pouvant être codées est : ±1,2.10-38 à ±3,4.1038

et en double précision : ±2,2.10-308 à ±1,8.10308

Ces formats suivent la norme référencée IEEE-754-1985.

La correspondance entre le nombre décimal et le nombre binaire s’obtient par la formule : (-1)S(1+F)(2E-127)

où S est le bit de signe, F la partie fractionnaire et E la partie entière.

Le principe du codage est le suivant : • 1 bit de signe, • plusieurs bits d’exposant, • plusieurs bits pour la mantisse

La virgule se trouve entre l’exposant et la mantisse.

Simple précision (32 bits) • 1 bit de signe • 8 bits d’exposant • 23 bits de mantisse

L’exposant est biaisé : la valeur 127 est ajoutée aux 8 bits pour qu’il soit toujours positif. Double précision (64 bits)

• 1 bit de signe • 11 bits d’exposant • 52 bits de mantisse

Il existe également la précision étendue sur 80 bits, mais les modes les plus répandus sont la

simple et la double précision. En programmation C, ils correspondent aux types float et double (respectivement).


19

5) Conversions de formats Conversion décimal vers binaire

La méthode est la suivante : - on divise par 2 jusqu’à ce qu’on tombe sur un résultat nul - le reste vaut 0 ou 1 ; ce reste constitue l’état des bits successifs du poids faible vers le poids

fort exemple : 14

14/2=7 (r=0) ; 7/2=3 (r=1) ; 3/2=1 (r=1) ; 1/2=0 (r=1) résultat : 1110

Conversion binaire vers décimal

Si l’on veut réaliser la conversion inverse, on applique les poids au nombre et on ajoute 1. Ce qui revient à ajouter simplement les poids des bits à 1.

exemple : 101=1×22+0×21+1×20=5 Conversion fractionnaire vers binaire Méthode :

- on multiplie la partie fractionnaire du nombre par 2 jusqu’à ce que le nombre de décimales soit atteint ou que la partie fractionnaire soit nulle

- la partie entière vaut 0 ou 1 - elle constitue successivement les bits du nombre binaire correspondant, du MSB au LSB

Exemple : 5,3 : 0,3×2=0,6 → 0 ; 0,6×2=1,2 → 1 ; 0,2×2=0,4 → 0 ; 0,4×2=0,8 → 0 ; etc

Résultat : 101,0100… Conversion hexadécimal vers décimal

2 méthodes : 1) on peut faire d’abord la conversion hexadécimal vers binaire puis binaire vers décimal 2) chaque valeur décimale des chiffres hexa est multipliée par leur poids (1, 16, 256, 4096,…) Exemple : $7A=7×16+10×1=112+10=122 Conversion décimal vers hexadécimal

On effectue des divisions successives par 16, et on multiplie la partie fractionnaire par 16. On obtient ainsi des chiffres hexadécimaux des poids faibles aux poids forts. Exemple : 250

250/16=15,625 → 0,625×16=10 soitA 15/16=0,9375 → 0, 9375×16=15 soit F

résultat : FA


20

6) Réduction du nombre de bits de codage

Dans un programme il arrive fréquemment qu’on ait besoin de transférer la valeur d’un registre vers la mémoire, ou vers un autre registre plus court. Dans ces deux cas, le nombre de bits du codage se trouve réduit, et il y a une perte d’information. Il s’agit de minimiser cette perte. Il existe deux méthodes de réduction : la troncature et l’arrondi.

Troncature

C’est la solution la plus simple. Elle consiste à enlever les bits les moins significatifs. Arrondi

Cette solution est meilleure dans la mesure où elle consiste à arrondir à la valeur la plus proche de la valeur tronquée, Elle consiste à additionner 1 si la partie enlevée est supérieure à la moitié du bit de poids le plus faible de la partie gardée, 0 sinon. Cela revient à regarder la valeur du bit de poids le plus fort de la partie enlevée. S’il est égal à 1, on ajoute 1 à la partie gardée ; s’il est égale à 0, on ne rajoute rien. Il suffit donc d’ajouter le bit de poids le plus fort de la partie enlevée au mot gardé. Cet arrondi est appelé arrondi au plus près.

Le cas où, dans la partie enlevée, seul le bit de poids le plus fort est à 1 et tous les autres à 0, est un cas particulier. Il est équivalent à 0,5 par exemple : faut-il l’arrondir à 0 ou à 1 ? On peut décider arbitrairement d’une des 2 possibilités. Dans les DSP56xxx, dans ce cas on ajoute un 1 si le bit de poids le plus faible de la partie gardée est à 1 (ce qui revient à arrondir à la valeur supérieure), s’il est à 0 on ne fait rien (arrondi à la valeur inférieure).


21

Annexe 3 : DSP 56303 et carte d’évaluation DSP56303EVM

Sommaire

I) Carte d’évaluation DSP56303EVM 1

I.1) Description succinte 1 I.2) Utilisation 1

II) DSP56303 2 II.1) Principales caractéristiques 2 II.2) Architecture 3 II.3) Formats utilisés pour le codage des données 4 II.4) Modes d’adressage 4 II.5) Programmation 7

II.5.1) Instructions 7 II.5.2) Caractères et directives d’assemblage 10

I) Carte d’évaluation DSP56303EVM I.1) Description succinte

Cette carte a été développé par Motorola. Elle comporte un Codec (codeur-décodeur) audio 16 bits de Crystal Semiconductor (Cirrus) de référence Crystal CS4215. Il s’agit d’un composant qui intègre un CAN et un CNA. Ses principales caractéristiques sont :

• Fréquence d’échantillonnage de 4kHz à 50kHz • Codage 8 ou 16 bits, linéaire, µ-law et A-law • Gain programmable pour les entrées analogiques • Atténuation programmable pour les sorties analogiques • Oscillateur intégré • Entrées analogiques : microphone et ligne (niveau normalisé) • Sorties casque, haut-parleurs et ligne • Filtres anti-aliasing et de lissage intégrés • Interface numérique série

I.2) Utilisation

Avant toutes choses il faut alimenter le kit d’évaluation, en utilisant un bloc d’alimentation réglé sur 9V. Bien vérifier ce réglage ainsi que la polarité correcte avant tout branchement.

Ensuite connecter le kit à un port série COM du PC par l’intermédiaire d’un câble 9 broches (DB9-DB9).

Voici les différentes étapes pour générer un fichier binaire, le transférer dans le DSP et l’exécuter : Assemblage, téléchargement et exécution - Copier le programme debugger "evm30xw" et le programme .asm (par exemple le programme

de test du CODEC "pass.asm"), dans un répertoire local temporaire (il faut prendre le réflexe de


22

renommer les programmes que l’on est amené à modifier, pour être sûr de conserver toujours la version initiale).

- Assembler le programme .asm à l’aide de la commande : asm56300 –a –b –g –l pass.asm

On peut également créer un fichier batch (par exemple "asm.bat") à l’aide d’un éditeur de texte, comportant la ligne de commandes :

asm56300 –a –b –g –l %1 et lancer l’assemblage par

asm pass.asm - Lancer le debugger. Si un message d’erreur apparaît, vérifier l’alimentation correcte du kit, et la

connexion série au port COM1 du PC. - Si le bouton comportant la flèche verte est enfoncé, appuyer sur le bouton "stop". - Charger le fichier .cld ; il est directement téléchargé dans le DSP du kit. - Exécuter ce programme en appuyant sur "bouton flèche verte".

ATTENTION - précautions d’utilisation -

Un des boutons-poussoirs situés sur la carte sert à tester les sorties audio, en générant un son d’amplitude maximale. Evitez de porter un casque pendant que vous faites ce test, et en règle

générale avant d’être sûr que le programme ne génère pas un son trop fort.

II) DSP56303 II.1) Principales caractéristiques

• Technologie CMOS faible consommation • Architecture parallèle permettant l’exécution d’une instruction en parallèle avec des accès

en mémoire • Mémoire interne : 4096 mots (de 24 bits) de RAM programme (en 2 zones distinctes X et Y)

et 4096 mots de RAM données • Port d’extension mémoire externe • Interface série synchrone SSI • Interface série asynchrone SCI • Interface hôte/DMA (parallèle) • Triple temporisateur (timer) de 24 bits • Emulateur intégré • Générateur d’horloge programmable à PLL • Multiplieur-accumulateur parallèle de 24*24 bits fonctionnant en 1 cycle machine

Interprétation : le processeur est spécialisé dans l’opération MAC et les transferts parallèles, contrairement à certains autres à architecture CISC. Rappel : PLL=Phase-Locked Loop=boucle à verrouillage de phase, permet de programmer une HF en fonction d’une fréquence + basse de référence.


23

II.2) Architecture

Accumulateurs A et B

Ils comportent 56 bits, et sont constitués par la concaténation de 3 registres : un de 8 bits (à gauche) et 2 de 24 bits. Notation : A=A2:A1:A0 ; B=B2:B1:B0

Le bit le plus à gauche est le bit de signe. Les poids des 8 bits de poids fort vont de 28 à 21, et non 27 à 20 comme dans la représentation habituelle à 8 bits.

A2 : 28 à 21 ; A1 : 20 à 2-23 ; A0 : 2-24 à 2-47 La virgule se situe entre le bit de poids 20 et le bit de poids 21. Cela permet de n’utiliser que

l’un des registres de 24 bits. Exemple

00000000 0,01100110011001100110011 001100110011001100110011

$ 00 333333 333333 = 0,399999999999999 L’avantage de ce format est d’être mixte : à virgule fixe mais permettant de coder des valeurs

supérieures à 1, ce qui permet de gérer les dépassements de capacité pouvant se produire dans le cas du format à virgule fixe. La gamme des valeurs est [-256, +256-2-47].

Les registres 24 bits sont à usage général : ils peuvent être utilisés pour les transferts avec la mémoire et avec d’autres registres. Par contre, les résultats des multiplications et des opérations arithmétiques et logiques ne peuvent être qu’un registre 56 bits (A ou B).

Registres X et Y

Comme A et B il s’agit de registres à usage général, mais utilisés comme opérandes des multiplications et opérations arithmétiques et logiques, pas pour les résultats. Ils comportent 48 bits et sont constitués par la concaténation de 2 registres de 24 bits.

X=X1:X0 ; Y=Y1:Y0 Mémoire : zones X et Y

La mémoire utilise des mots de 24 bits. Elle est au format à virgule fixe [1, 23]. Les accumulateurs A et B possédant 56 bits, il y a une perte d’information lors du transfert en

mémoire des valeurs résultant d’un calcul et présentes dans ces accumulateurs. Cette perte peut être minimisée en utilisant un transfert avec arrondi. Registres d’élaboration des adresses mémoire

Les 3 types de registres décrits ci-dessous sont des registres à 16 bits.

• 8 registres d’adresses (pointeurs) Rn, n=0 à 7 Utilisés pour pointer vers la mémoire en adressage indirect.

• 8 registres de mode Mn Ils permettent de programmer le mode d’adressage, selon la valeur copiée à l’intérieur :

-1 : adressage linéaire x : adressage modulo x+1


24

0 : adressage en bits inversés (utilisé pour la FFT)

• registres de décalage Nn Ils permettent d’effectuer des incrémentations/décrémentations des registres d’adresses,

supérieures à 1. Quelques registres système Registre de mode de fonctionnement : OMR

Permet : - La sélection du champ mémoire - La programmation des interruptions - La programmation de la fréquence d’horloge - etc

Registre de commande du circuit PLL : PCTL

Exemple movep #$260004, X :PCTL ; positionne la fréquence d’horloge du DSP à 20 MHz

II.3) Formats utilisés pour le codage des données

Dans les DSP56xxx, les formats utilisés sont [1-23], [1-47] et [9-47]. Le 1er est le format de base compatible avec la mémoire, le 2e est utilisé pour la multiplication,

et le 3e (format mixte) permet de gérer les cas de dépassement de la capacité du format [1-47] (dans lequel les nombres doivent être compris entre –1 et +1).

Transferts entre formats Le passage du format [1-23] au format [1-47] se fait en plaçant les 24 bits du mot de départ

dans les 24 bits de poids fort du mot d’arrivée, et en mettant les 24 autres à 0 (dans l’autre sens il y a troncature ou arrondi, voir paragraphe sur ce transfert plus loin).

Le passage des formats [1-23] et [1-47] au format [9-47] se fait avec extension du bit de signe, c’est à dire que le bit le plus à gauche du mot d’origine est recopié dans les 8 bits de poids fort du mot d’arrivée.

Exemple : [1-23] [9-47] -1=$800000 ? $FF8000000000000=-1

II.4) Modes d’adressage

Il existe 3 grandes façons d’accéder à la mémoire : les adressages • linéaire : classique • modulo : permet de gérer des buffers circulaires, utiles dans le cas du filtrage par exemple • en bits inversés : utilisé pour la FFT


25

Adressage immédiat

La valeur à charger dans un registre est donnée directement en argument. On utilise le symbole #. Cette opération prend 2 cycles machine.

Il n’est pas possible de réaliser un adressage immédiat avec la mémoire, ce qui signifie qu’on ne peut pas copier une valeur directement en mémoire. On doit obligatoirement passer par un registre.

Dans les opérations avec certains registres, ce sont les poids faible qui sont concernés, pour d’autres ce sont les poids forts :

• A0, A1, A2, B0, B1, B2, Ni, Mi, Ri (i∈[0 ; 7]) : poids faibles • A, B, Y0, Y1, X0, X1, X, Y : poids forts

Adressage immédiat long : données à transférer de 16 à 56 bits

Exemples • sur 24 bits :

move #$ABC,A0 ou

move #$ABC,X0

• sur 56 bits

move #$ABCDEF, A ; dans A1 et A0, A2 mis à $FF car nombre négatif Adressage immédiat court : données à transférer sur 8 ou 12 bits.

Exemples • sur 24 bits

move #$FF, A1 ; $FF dans les poids faibles de A1, 0 dans le reste move #$FF, Y1 ; $FF dans les poids forts de Y1, 0 dans le reste

• sur 56 bits

move #$FF, A ; $FF dans les poids forts de A1, 0 dans le reste sauf A2=$FF Adressage indirect

Utilisé pour les échanges entre registres et mémoire. L’écriture ou la lecture d’une valeur en mémoire nécessite 2 instructions.

Exemples

move A1,X:(R0) ; transfert du contenu de A1 dans la case mémoire

; pointée par R0 dans la mémoire X move A1,X:(R0)+ ; même chose avec post-incrémentation de 1 du pointeur R0


26

; (décrémentation : idem mais avec signe -) move A1,X:(R0)+N0 ; même chose avec post-incrémentation de la valeur

; contenue dans N0 move A1,X:-(R0) ; même chose mais pré-décrémentation de 1 de R0

Adressage absolu

Pour les échanges entre la mémoire et les registres. L’adresse de la case mémoire concernée est donnée directement en argument.

Exemple move X:$3393,B0 ; transfert du contenu de la case mémoire d’adresse $3393 dans B0

Traitements parallèles

L’organisation matérielle des DSP de la famille 56300, avec des communications par bus, leur permet d’effectuer plusieurs opérations en parallèle, en une seule instruction :

• 1 multiplication 24 bits × 24 bits • 1 addition 56 bits • 2 déplacements de données • 2 mises à jours de pointeurs

Exemple

mac X0,Y0,A X:(R0)+,X0 Y:(R1)+,Y0

→ A=A+X0×Y0 ; =move X:(R0)+,X0 =move Y:(R1+),Y0

X0=X pointée par R0 ; Y0=Y pointée par R1 R0=R0+1 ; R1=R1+1

Mode scaling

Les données sont multipliées par 2 lors de leur transfert en mémoire. Ceci permet d’éviter de perdre des données quand le contenu est supérieur à 1.

Programmation : on positionne à 1 le 4e bit à partir de la droite du registre MR : ori #8, MR

II.5) Programmation

Quelques instructions et directives d’assemblage couramment utilisées sont données ci-dessous. Les instructions sont traitées par le DSP, les directives d’assemblage le sont par l’assembleur : elles correspondent à des opérations effectuées avant lancement du programme.

Cette liste est non exhaustive. Pour la syntaxe exacte et les restrictions d’utilisation, voir la documentation constructeur. II.5.1) Instructions


27

Opérations arithmétiques mac Multiplication et accumulation

Idem mpy mais additionne ou soustrait le résultat au contenu actuel de l’accumulateur donné en 3e argument. Exemple

mac X0,X0,A ; A=A+X0*X0 mac -X0,X0,A ; A=A-X0*X0

macr Multiplication et accumulation, avec arrondi. mpy : Multiplication

Les transferts parallèles sont possibles. Multiplication du 1er argument avec le 2e, résultat dans le 3e. 1er et 2e arguments : 24 bits ; 3e : 56 bits. Exemples

mpy X0,X0,A ; A=X0*X0 mpy X0,X0,A X:(R0)+,X0 Y:(R1)+,Y0 ; A=X0*X0, X0=X+R0, Y0=Y+R1

X:(R0)+,X0 est équivalent à move X:(R0)+,X0

mpyr Multiplication avec arrondi rnd Opération d’arrondi sub Substract Exemple

sub A,B ; B=B-A subl Shift left and substract Exemple

subl B,A ; A=A*2-B Opérations logiques ori OU logique avec des registres système Syntaxe

ORI #xx, D ; D registre système


28

Exemple ORI #$8, MR

not Complémentation logique Syntaxe

NOT D ; D accumulateur 24 bits or OU logique Syntaxe

OR S,D ; S et D registres 24 bits (masque dans S, résultat dans D)

Transferts de données move Copie d’un registre vers un autre, ou transfert entre registre et mémoire. Les transferts entre

la mémoire et les registres utilisent les registres d’adresse. Exemples

move X0, A1 ; copie du contenu de X0 dans A1 move #10,A1 ; copie de la valeur décimale 10 dans A1 move #$10,A1 ; copie de la valeur hexadécimale $10 (16 en décimal) dans A1 move #$10,OMR ; idem dans registre OMR move X:(R0),X0 ; copie du contenu de la mémoire X pointée par R0, dans X0 move X:(R0)+,X0 ; idem avec post-incrémentation du registre d’adresse R0 move X0,X:(R0)+ ; opération inverse move A,Y1 ; transfert de A1 (mot de 24 bits de poids forts de A) dans Y1

movep Transfert vers la zone des périphériques Exemple

movep #$260004, X:PCTL ; copie du contenu de la valeur $260004 dans ; le registre PCTL

; auparavant il faut avoir fait : « PCTL equ X:$FFFD » ; (programmation de la fréquence du DSP à 20 MHz)

lua Load updated adress Exemple

lua (R0)+1,R1 ; R1 pointe sur l’adresse mémoire pointée par (R0)+1 Boucles do répète les lignes d’instructions suivantes, jusqu’au label indiqué en 2e argument, un nombre de

fois égal à la valeur donnée en 1er argument Exemple do #10, boucle1 … boucle1 …


29

rep idem do mais avec pour seul argument le nombre de répétitions ; la répétition ne concerne que

la ligne suivante. Saut jsr "jump to subroutine" : saut (inconditionnel) à la routine définie par la label donné en argument. Exemple jsr filtrage … …

filtrage … … rts

jmp saut inconditionnel à une routine ou à une adresse Exemple jmp (R1+N1) ; saut à l’adresse P:(R1+N1) Fonctions mathématiques cvi Convert FLOAT to INT log log naturel (base 10) cos cosinus sin sinus II.5.2) Caractères et directives d’assemblage

Un programme assembleur comporte des instructions du DSP et des directives d’assemblage. Ces dernières correspondent à des actions effectuées par l’assembleur et non pas le programme. Elles ne sont pas toujours traduites en langage machine.

Quelques caractères et directives d’assemblage couramment utilisées sont données ci-dessous. Caractères ; délimiteur de commentaires @ délimiteur de fonction # opérateur d’adressage immédiat Exemple

move #12,X0 ; valeur décimale 12 dans X0


30

move #$12,X0 ; valeur hexadécimale 12 dans X0

Directives org initialise l’espace mémoire et les compteurs de position

Utilisé pour définir l’adresse l’origine d’une zone mémoire pour les données end fin du programme source rts fin de routine

Le début de la routine est indiqué par un label. equ définition d’un symbole (=une constante) Exemple

a0 equ 0.00379/2 ; coefficient d’un filtre PCTL equ X:$FFFD ; symbole pour le registre de commande de la PLL intégrée

dc define constant

Pour copier des constantes en mémoire Exemple

org Y:$0 ; pointage sur l’adresse 0 en mémoire Y dc a0, b1, b2, a1, a2 ; copie à cette adresse des valeurs des symboles

; préalablement définies par des equ ds define storage

Réserve des emplacements en mémoire Exemple

org Y:$0 ; on pointe sur l’adresse 0 en mémoire Y coef dsm 5 ; allocation de 5 emplacements (cases) mémoire,

; sur laquelle on pourra pointer avec le symbole ‘coef’ dup duplicate sequence of source lines

Permet de faire une boucle au niveau de l’assembleur, jusqu’à la directive ‘endm’. macro

Définition d’une macro endm

Fin de macro set Set symbol to value Exemple

compt set compt+1 ; incrémentation d’un compteur


31

include

Indique à l’assembleur d’insérer le texte du fichier donnée en argument à cet endroit. Exemple

include ‘mon_prog.asm’

où "mon_prog.asm" contient le code assembleur à insérer à cet endroit.

dsp_resume.pdf

Documents

Transcript of dsp_resume.pdf