Architecture Numérique du Traitement de Signal

Planning

• Contrôle avec documents (Cours, TD, TP)
• TD
  • Arithmétique fixe & flottante
  • Filtres & CAN

Présentation

Applications

• GEDD: Optimisation des performances de commandes
  • Onduleurs
  • Commandes moteurs
• GRIT:
  • Téléphonie

Techniques numériques incontournables dans les produits électroniques

• Les DSP (Digital Signal Processor) remplacent les technologies analogiques

Raisons ?

• Avantages
  • Stabilité (temps, humidité, temp)
  • Flexibilité (reprog)
  • Reglage min.
• Inconvénients
  • Cout élevé pour les app simples
  • Vitesse de traitement qui limité la bande passante des signaux à traiter (temps réel)

Caractéristiques

Chaine de traitement numérique

Traitement en temps réel:

• Routes les opérations effectuées en
  $t<T_e$
  • Parole :
    $T_e=125\mu s$
  • Audio :
    $T_e=22,68\mu s$
  • Vibratoire :
    $T_e=10\mu s$
  • Vidéo :
    $T_e=0,1\mu s$
• Utilisation d'architectures adaptées

Comparaison des puissances de calcul

• MIPS ou MOPS (Mega Instruction Per Seconde) pour les DSP à virgule fixe
• MFLOPS pour les DSP à virgule flottante

Multiplication et accumulation rapides

• Spécificités de l'architecture interne
  • Multiplication en un seul cycle d'horloge
• Adapté au monde de l'embarqué
  • Faible consommation / TDP
  • Intégration & Fléxibilité de programmation
• Faible coût et rapidité de développement
  • Librairie fournie avec le DSP

Application typiques de TNS

FIR

Question de contrôle: Calcul d'un filtre

• Filtrage numérique
  • Limite aux systèmes linéaires discrets invariants en temps et causaux
  • Equation aux différences
    • Entre les échantillons d'entrée et sortie
    • Filtre non-récursif (context free)
    • Filtre FIR : moyenne mobile
• Filtrage numérique récursif
  • IIR (Infinite Impulse Response)
  • IIR quand
    $z=0$
  • IIR quand
    $z\ne 0$

Filtrage Adaptatif

Filtrage adaptatif : modification des coeficients (Context Sensitive)

• RLMS: Algo récursif des moindres carrés (Wiener-Hopt)
  • Voir cours Optimisation & Filtrage

Autres

• La valeur moyenne :
  
  $$m_x=\frac{1}{N}\sum _{n=0}^{N-1}x(n)$$
• La puissance moyenne :
  
  $$P_x=\frac{1}{N}\sum _{n=0}N-1x(n{)}^2$$
• Correlation
  
  $$C_{xy}(k)=\frac{1}{N}\sum _{n=0}^{N-1}y(n).x(n-k)$$

DSP doivent faire rapidement:

• Multiplication-Accumulation
  • MACs : FFT, Filtrage adaptatif, Convolution
• Calcul d'adressage complexe
  • Accès linéaire, indexé, bit-reverse
• Avoir une bonne précision
  • Filtrage adaptatif requiert une grande précision de calcul
  • Filtre IIR: Impact la stabilité
  • Type de quantification des données: virgule flottante ou fixe
• Calcul intensif ou répétitif
• Manipuler une quantité importante de données
  • Scalaires, Vectorielles, Matricielles

Domaines d'applications

• Télécommunication
  • Suppresseur d'écho
  • Modems
  • Radiophonie & Vidéophonie
• Automatisation & Contrôle de processus
  • Contrôle de vitesse
  • Robotique
  • Gestion puissance…

Comparaison des autres processus

• ASIP: Application Specific Instruction set Processor
  • Très couteux, complexe
• ASIC: Application Specific Integrated Circuit
  • Investissement très couteux, mise en oeuvre longue

$\Rightarrow$ Les processeurs généraux sont trop lent et énergivores dans ses applications

Virgule Fixe ou Flottante ?

Deux types de DSP:

• 32 ou 64 bits à virgule flottante
• 16, 24 ou 32 bits en virgule fixe

Le choix dépend des contraintes d'application.

$\Rightarrow$ Un DSP virgule fixe peut également réaliser des calculs en virgule flottante.

• Utilisation via une librairie
• Moins bonne efficacité

Le contraire est également possible, mais ne possède pas de réel cas concret.

Représentation des nombres entiers

• Représentation avec module + signe

  • Solution simple
  • On ajoute un bit pour le signe (0
    $\to$ + et 1
    $\to$ -)
  • Le signe est le bit de poids fort
    Cette représentation est mal adapté aux additions.

• Réprésentation en complément vrai

  • Opération arithmétiques effectuée de manières différentes:
    • Par programmation
    • Par logique micro-programmée
  • Operation suivante:
    ${532}_{(10)}-{264}_{(10)}$
    
  • Equation logique
    

Arthimétique en virgule fixe

• Hypothèse
  • A: nombre de bits =
    $mA$ (partie entière) +
    $nA$ (partie fractionnaire)
  • B: nombre de bits =
    $mB$ (partie entière) +
    $nB$ (partie fractionnaire)
• Addition
  $A+B$
  • Choix d'un format identique
  • Alignement de la virgule
  • Extension du bit de signe
    
• Multiplication
  • Bit de signe du résultat double
  • Recadrage final
    • Caler le résultat sur la taille des opérandes
      

Instruction / Programmation

• L'instruction REPEAT permet de répéter
  $n+1$ fois l'instruction qui suit.
• Le signe
  $\text{You can't use 'macro parameter character \#' in math mode}$ permet d'indiquer qu'il s'agit d'une valeur immédiate. Souvent limité à des valeurs sur 16 bits.

Adressage Direct

MOVW     DP,#VarA     ; Load DP with page value containing VarA
ADD      AL,@VarA     ; Add memory location VarA to register AL
MOV      @VarB,AL     ; Store AL into memory location VarB
                      ; VarA and VarB located in the same 64 word page location
MOVW     DP,#VarC     ; Location DP with page value containing VarC
ADD      AL,@VarC     ; Add memory location VarC to register AL
MOV      @VarD,AL     ; VarC and VarD located in the same 64 word page location

ADD      AL,*-SP[5]   ; Add 16 bits content from stack location  -5 words from the top of stack to AL register
MOV      *-SP[8],AL   ; Store 16 bits AL register to stack location -8 words
ADDL     ACC,*-SP[12] ; Store 32 bits ACC register to stack location -12 words
MOVL     *-SP[34],ACC ; Add 32 bits content from ACC register to stack location -34 words

MOV      *SP++,AL     ; Push content of 16 bits AL register onto the top of stack
MOVL     *SP++,P      ; Push content of 32 bits P register on to the top of stack

ADD      AL,*--SP     ; Pop content from top of the stack and add to 16 bits AL register
MOVL     ACC,*--SP    ; Récupère un mot de 32 bits depuis le haut de la pile et le stock dans l'accumulateur

• SP pointe sur la prochaine case libre (SP[1] pointe sur la dernière case avec des données).
• ADD DEST,SRC La destination est avant la source

Adressage indirect

Copie de Array1 vers Array2 avec une boucle :

  MOVL     XAR2,#Array1  ; Load XAR2 with start address of Array1
  MOVL     XAR3,#Array2  ; Load XAR3 with start address of Array2
  MOV      @AR0,#N-1     ; Load AR0 with loop count N
Loop:                    ; Etiquette Loop pour le jump
  MOVL     ACC,*XAR2++   ; Load ACC with location pointed to by XAR2, post-increment XAR2
  MOVL     *XAR3++,ACC   ; Store ACC with location pointed to by XAR3, post-increment XAR3
  BANZ     Loop,AR0--    ; Loop until AR0 = 0, post-decrement AR0

• A la colonne 1, seule les étiquettes commencent. Pour les instructions, elles doivent commencer au moins à la colonne 2.
• L'incrément ++ dépend de la taille du mot
  • Ici on a un un processeur de 16 bits donc
    • 1 si mot de 16 bits
    • 2 si mot de 32 bits
  • Pour un STM32 qui est un CPU de 8 bits
    • 1 si mot de 8 bits
    • 2 si mot de 16 bits
    • 4 si mot de 32 bits

  MOVL     XAR2,#Array1+N*2
  MOVL     XAR3,#Array2+N*2
  MOV      @AR0,#N-1         ; @ facultatif
  
Loop:
  MOVL     ACC,*--XAR2
  MOVL     *--XAR3,ACC
  BANZ     Loop,AR0--

MOVW      DP,#Array1Ptr    ; Point to Array1 pointer location
                           ; On récupère le pointeur de page qui pointe sur le tableau
MOVL      XAR2,@Array1Ptr  ; Load XAR2 with pointer to Array1
                           ; On assigne XAR2 vers l'adresse du tableau Array1
MOVB      XAR0,#16         ; AR0L = 16, AR0H = 0
MOVB      XAR1,#68         ; AR1L = 68, AR1H = 0
MOVL      ACC,*+XAR2[AR0]  ; Swap content of location Array1[16] with Array1[68]
MOVL      P,*+XAR2[AR1]
MOVL      *+XAR2[AR1],ACC  ; On échange les valeurs entre Array1[16] et Array1[68]
MOVL      *+XAR2[AR0],P

Suffice B signifie qu'on travaille sur un octet (soit le poids fort, soit le poids faible)
XAR0,#16 << #16 pour décaler sur le poids fort

MOVW      DP,#Array1Ptr
MOVL      XAR2,Array1Ptr
MOVL      ACC,*+XAR2[2]
MOVL      P,*+XAR2[5]
MOVL      *+XAR2[5],ACC
MOVL      *+XAR2[2],P

On permute les valeurs des cases 2 et 5.

Adressage circulaire

Calcul du filtre FIR

$X[n]=data$,

$C[n]=coef$

MOVW      DP,#XPointer      ; Récupération du pointer de page
MOVL      XAR6,XPointer     ; XAR6 pointe sur les données
MOVL      XAR7,#C           ; XAR7 pointe sur les coeficients (espace programme)
MOVL      AR1,#N            ; AR1 est le compteur (taille du tableau de données)
SPM       -4                ; Set Shift Product Mode
ZAPPA                       ; Zero ACC,P,O,V,C (Mise à zero des registres et flags)
RPT       N-1               ; Répète N fois l'instruction suivante
QMACL     P,*AR6%++,*XAR7++ ; ACC = ACC + P >> 4
                            ; P = ((*AR6%++)*(*XAR7++)) >> 32
ADDL      ACC,P<<PM         ; final accumulate
MOVL      XPointer,ARG      ; Stockage de XAR6 dans XPointer
MOVL      SUM,ACC           ; Stockage du résultat dans SUM

Horloge

Horloge CPU : 100 MHz
Quartz : 8 MHz

Langage C

• Unions : Permet de défnir une même zone mémoire sous 2 aspects différents
• Champs de bits : Permet de découper un élément mémoire indivisible en différents champs

struct ADCMAXCONV_BITS
{
    uint16 MAX_CONV1: 4; // 3:0 Max number of conversions
    uint16 MAX_CONV2: 3; // 6:4 Max number of conversions
    uint16 rsvd1: 9; // 15:7 reserved
};

union ADCMAXCONV_REG
{
    uint16 all;
    struct ADCMAXCONV_BITS bit;
};

struct ADC_REGS
{
    union ADCTRL1_REF ADCTRL1;
    union ADCTRL2_REF ADCTRL2;
    union ADCMAXCONV_REG ADCMAXCONV;
};

ADCregs.ADCMAXCONV.bit.MAX_CONV1 = 7;