Examen Programmation DSP

Exercice n°l
a) Ecrire un programme avec la programmation mixte (.c et .asm) qui permet la lecture
et l'affichage d'une addition de deux entiers tout en tenant compte de gestion de
dépassement.
b) . Ecrire un programme avec la programmation assembleur (.asm) qui permet la
lecture la multiplication et l'accumulation de deux réels tout en tenant compte de gestion
de dépassement.
Exercice n°2
Ecrire un programme avec le langage C qui permet de calculer la transformée de
Fourier rapide (FFT) d'un signal a pour longueur N échantillons sur une carte DSP
BlackFin (BF) d'Analog Devices.
La fonction FFT est décrite par l'équation suivante :

X(k) = ∑n=0 → N-1 x(n) . exp ( -J2πnk / N )

Une fois le spectre est calculé, il faut localiser les pics spectraux.
Ensuite, il faut déterminer la fréquence fondamentale FO qui correspond
au premier pic spectral.
Pour ceci il faut:
- Déclarer les variables,
- Ecrire le programme principal qui contient :
1) Lecture du signal d'entrée,
2) Appel aux fonctions crées,
3) Sauvegarder le résultat qui sera sous forme d'un signal spectral dans un fichier,
4) Créer la fonction qui permet le calcul de la FFT de ce signal,
5) Créer la fonction qui permet de localiser les pics spectraux
6) Déterminer la F0 et ses harmoniques à l'aide d'un appel à la fonction précédente.

Examen Programmation DSP 1

 Pour l'exercice 1a, voici un exemple de programme en C avec une partie en
assembleur pour effectuer une addition de deux entiers avec gestion de dépassement :

// Programme en C avec programmation mixte (.c et .asm) pour l'a

#include <stdio.h>// Fonction en assembleur pour l'addition avec

extern int add_with_overflow_check(int a, int b, int *result, in

int main() {
int num1, num2, sum, overflow;

// Lecture des deux entiers

printf("Entrez le premier entier : ");
scanf("%d", &num1);

printf("Entrez le deuxième entier : ");

scanf("%d", &num2);

// Appel de la fonction en assembleur pour l'addition avec g

overflow = 0;
sum = add_with_overflow_check(num1, num2, &sum, &overflow);

// Affichage du résultat avec gestion de dépassement

if (overflow) {
printf("Dépassement détecté!\n");
} else {
printf("La somme est : %d\n", sum);
}

return 0;
}

Et voici le code assembleur (.asm) pour la fonction add_with_overflow_check :

Examen Programmation DSP 2

 section .text
global add_with_overflow_check

add_with_overflow_check:
; Arguments : eax = a, ebx = b, ecx = résultat, edx = overfl
mov edx, 0 ; Initialiser le flag de dépassement à 0

; Effectuer l'addition
add eax, ebx
jo overflow_detected ; Si un dépassement est détecté, saute

; Stocker le résultat et le flag de dépassement

mov [ecx], eax
jmp done

overflow_detected:
; Mettre le flag de dépassement à 1
mov edx, 1

done:
ret

Pour l'exercice 1b, voici un exemple de programme assembleur (.asm) pour la

multiplication et l'accumulation de deux réels avec gestion de dépassement :

section .data
real1 dd 2.5 ; Premier réel
real2 dd 1.8 ; Deuxième réel
result dd 0.0 ; Résultat initialisé à 0.0
overflow dd 0 ; Flag de dépassement initialisé à 0

section .text
global main

Examen Programmation DSP 3

 main:
; Multiplication des deux réels
fld dword [real1]
fmul dword [real2]

; Accumulation du résultat
fadd dword [result]

; Vérification du dépassement
fstsw ax
sahf
jo overflow_detected

; Stockage du résultat
fstp dword [result]

; Affichage du résultat
mov eax, 1 ; Identificateur de fichier standard output
mov ebx, result ; Adresse du résultat
mov ecx, 4 ; Taille du résultat en octets
mov edx, 0 ; Position du curseur
mov eax, 4 ; Appel système pour écrire sur la sortie s
int 0x80

; Fin du programme
mov eax, 1 ; Code de sortie
int 0x80

overflow_detected:
; Mettre le flag de dépassement à 1
mov [overflow], 1
jmp end_program

end_program:
; Fin du programme
mov eax, 1 ; Code de sortie

Examen Programmation DSP 4

 int 0x80

Notez que les exemples de programmes ci-dessus dépendent du système d'exploitation

et de l'architecture sur lesquels ils sont exécutés. Les exemples sont basés sur la
convention d'appel C pour les arguments et le stockage des registres. Assurez-vous
d'ajuster le code en fonction de votre environnement d'exécution.

L'exercice 2 concerne la réalisation d'un programme en langage C pour calculer la

transformée de Fourier rapide (FFT) d'un signal avec des échantillons sur une carte
DSP BlackFin d'Analog Devices. Voici un exemple de programme, en supposant que
vous avez une bibliothèque DSP pour les fonctions nécessaires à la FFT sur la carte
BlackFin :

#include <stdio.h>
#include <complex.h>
#include <math.h>// Déclaration des fonctions

void fft(complex float* x, int N);

void find_peaks(complex float* spectrum, int N);
float calculate_frequency(complex float peak, int N, float sampl

int main() {
int N; // Longueur de l'échantillon
float sample_rate; // Taux d'échantillonnage
complex float* signal; // Tableau des échantillons
complex float* spectrum; // Tableau pour le résultat de la F

// 1. Lecture du signal d'entrée

printf("Entrez la longueur de l'échantillon (N) : ");
scanf("%d", &N);

printf("Entrez le taux d'échantillonnage : ");

scanf("%f", &sample_rate);

Examen Programmation DSP 5

 signal = (complex float*)malloc(N * sizeof(complex float));
spectrum = (complex float*)malloc(N * sizeof(complex float))

printf("Entrez les échantillons du signal :\n");

for (int i = 0; i < N; i++) {
printf("Échantillon %d : ", i + 1);
float real, imag;
scanf("%f %f", &real, &imag);
signal[i] = real + imag * I;
}

// 2. Calcul de la FFT
fft(signal, N);

// 3. Localisation des pics spectraux

find_peaks(spectrum, N);

// 4. Sauvegarde du résultat dans un fichier

FILE* file = fopen("output_spectrum.txt", "w");
for (int i = 0; i < N; i++) {
fprintf(file, "%f %f\n", creal(spectrum[i]), cimag(spect
}
fclose(file);

// 5. Détermination de la fréquence fondamentale (F0) et de

for (int i = 0; i < N; i++) {
float frequency = calculate_frequency(spectrum[i], N, sa
printf("Pic spectral à la fréquence : %.2f Hz\n", freque
}

// Libération de la mémoire
free(signal);
free(spectrum);

return 0;

Examen Programmation DSP 6

 }

// Fonction FFT
void fft(complex float* x, int N) {
// À implémenter en utilisant votre bibliothèque DSP BlackFi
}

// Fonction pour localiser les pics spectraux

void find_peaks(complex float* spectrum, int N) {
// À implémenter en fonction des critères pour identifier le
}

// Fonction pour calculer la fréquence à partir d'un pic spectra

float calculate_frequency(complex float peak, int N, float sampl
float index = cabs(peak); // Index du pic spectral
float frequency = index * sample_rate / N;
return frequency;
}

Ce code est un exemple de structure de programme. Vous devrez implémenter les

fonctions fft et find_peaks en utilisant les fonctionnalités de votre bibliothèque DSP
BlackFin. Assurez-vous de consulter la documentation de votre matériel pour utiliser les
fonctions appropriées.

Examen Programmation DSP 7