---
title: Arch. Num. du Trait. Sig.
author: Rémi {Hyperion} MAUBANC
tags: ESIEE, I4
---

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 \neq 0$

### Filtrage Adaptatif

Filtrage adaptatif : modification des coeficients (Context Sensitive)

- RLMS: Algo récursif des moindres carrés (Wiener-Hopt)
- Voir [cours Optimisation & Filtrage](https://hackmd.io/Z4qd30TlR4apM2nxc-o1lA?view#Algorithme-récursif-des-moindres-carrés-RLMS)

### 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-1}x(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 $\rightarrow$ + et 1 $\rightarrow$ -)
- 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 $#$ 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

:::warning
- 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

:::info
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;