Filtrage numérique d'un signal audio

3.a. introduction

Le programme effectue une numérisation sur une ou deux voies. Le convertisseur analogique-numérique (ADC) est déclenché avec un Timer à la fréquence d'échantillonnage. Pour chaque numérisation, une interruption est déclenchée afin de faire le filtrage et d'envoyer le résultat au convertisseur numérique-analogique (une ou deux voies). La programmation du filtre se fait depuis un ordinateur par un programme Python, mais on pourra sans difficulté construire une application embarquée autonome à partir de ce programme.

Trois formes de réalisation du filtrage sont implémentées : les formes directes de type I et II et la forme directe transposée de type II. Pour la définition de ces formes, voir Conception et mise en œuvre des filtres numériques.

Les coefficients du filtre et l'accumulateur sont soit des flottants 32 bits, soit des entiers 32 bits (plus rapide mais moins précis).

Voici tout d'abord la définition des constantes et des variables globales :

#include "Arduino.h"

#define IS_READY 100
#define SET_FILTRAGE_32BITS 103
#define SET_FILTRAGE_FLOAT 104

#define GAIN 1.45
#define SAT
#define TTLOUT 

// ADC
#define ADC_MR_TRIG1 (1<<1)
uint8_t nchannels;
#define MAX_NCHAN 2
uint8_t channels[MAX_NCHAN];
uint8_t gain[MAX_NCHAN];
uint8_t channels_pins[8] ={7,6,5,4,3,2,1,0};
uint32_t ticks;
volatile void (*ADC_Handler_function)();
uint8_t flag = 0;

// ADC
uint32_t chsel;

//filtrage
#define MAX_NCOEF 256
uint32_t nb; // nombre de coefficients b
float bbb[MAX_NCOEF];
int32_t bb[MAX_NCOEF];
uint32_t na; // nombre de coefficients a
float aaa[MAX_NCOEF];
int32_t aa[MAX_NCOEF];
uint32_t max_na_nb;
uint8_t ab_shift;
#define TAILLE_TAMPON 0x100 // supérieur à max(na,nb)
#define MASQUE_TAMPON 0xFF // TAILLE_TAMPON-1
int16_t x_0[TAILLE_TAMPON]; // tampon pour les x_k
int16_t y_0[TAILLE_TAMPON]; // tampon pour les y_k
int16_t x_1[TAILLE_TAMPON]; // tampon pour les x_k
int16_t y_1[TAILLE_TAMPON]; // tampon pour les y_k
int32_t ww_0[TAILLE_TAMPON];
int32_t ww_1[TAILLE_TAMPON];
float www_0[TAILLE_TAMPON];
float www_1[TAILLE_TAMPON];
uint8_t J_tampon; // indice pour les tampons
int16_t offset;
             

La macro GAIN fixe le gain à appliquer pour que la sortie soit de même amplitude que l'entrée (pour un filtrage de gain unité). Ce gain est déterminé par étallonnage. On peut aussi inclure ce gain dans les coefficients b_k du filtre; dans ce cas, on écrira #define GAIN 1.

Lorsque la macro SAT est définie, une saturation est appliquée à la sortie du filtre en cas de dépassement avant redirection vers le convertisseur N/A. Si cette opération n'est pas nécessaire, on peut enlever cette ligne.

Lorsque la macro TTLOUT est définie, un signal TTL (sur la borne D3) est émis par la fonction de filtrage, dont la fréquence est la moitié de la fréquence d'échantillonnage. Ce signal permet de vérifier le bon fonctionnement de l'échantillonnage.

La taille des tampons circulaires est fixée à 0x100 (256) et ne doit pas être modifiée. Cela permet d'utiliser des indices de type uint8_t qui se comportent automatiquement de manière circulaire (255+1=0 et 0-1=255). Le nombre maximal de coefficients a ou b est ici fixé à 256; il ne peut dépasser cette valeur, car l'indice d'accès aux tableaux est de type uint8_t.

3.b. Configuration des convertisseurs et de l'échantillonnage

La fonction suivante configure le convertisseur A/N en fonction du nombre de voies nchannels, du numéro des voies channels et des gain gain. Chaque voie peut avoir son propre gain, égal à 1,2 ou 4. L'amplification se fait avec un offset, c'est-à-dire que la tension amplifiée est U-offset. Pour une explication détaillée de la configuration de l'ADC, voir Conversion analogique numérique et analogique.

void config_adc() {
    int k;
    pmc_enable_periph_clk(ID_ADC);
    adc_init(ADC, VARIANT_MCK, ADC_FREQ_MAX, 0);
    adc_configure_timing(ADC, 0, ADC_SETTLING_TIME_3, 1);
    adc_set_resolution(ADC,ADC_12_BITS);
    NVIC_EnableIRQ (ADC_IRQn) ;   
    ADC->ADC_IDR=0xFFFFFFFF ;  
    ADC->ADC_CHDR = 0xFFFF; 
    ADC->ADC_CHSR = 0x0000; 
    ADC->ADC_WPMR &= ~0x1;
    ADC->ADC_CHER = 0x0000;
    ADC->ADC_SEQR1 = 0x00000000;
    ADC->ADC_CGR = 0x00000000;
    ADC->ADC_COR = 0x00000000;
    for (k=0; k<nchannels; k++) {
      ADC->ADC_SEQR1 |= ((channels[k]&0xF)<<(4*k));
      ADC->ADC_CHER |= (1<<k);
      if (gain[k]==2) ADC->ADC_CGR |= 2 << (2*k);
      if (gain[k]==4) ADC->ADC_CGR |= 3 << (2*k);
      ADC->ADC_COR |= 1 << k; 
    }
    ADC->ADC_MR = (ADC->ADC_MR & 0xFFFFFFF0) | ADC_MR_TRIG1 | ADC_MR_TRGEN | ADC_MR_USEQ;
    ADC->ADC_IDR=~(1<<channels[0]); 
    ADC->ADC_IER=1<<channels[0];
}
                

Une interruption est déclenchée dès que la conversion des voies est faite (on se limitera ici à deux voies). Voici la fonction appelée lors d'une interruption. Elle appelle une fonction que l'on définira en fonction du type de filtrage à effectuer :

void ADC_Handler() {
    (*ADC_Handler_function)();
#ifdef TTLOUT
  if (flag==0) {
      PIOC->PIO_SODR = PIO_PC28; // pin 3
      flag = 1;
    }
  else {
      PIOC->PIO_CODR = PIO_PC28;
      flag = 0;
   }
#endif
}
                 

Le convertisseur est configuré pour être déclenché par un Timer. Voici la configuration du timer, qui génère la conversion avec une période égale à ticks fois la période de l'horloge, laquelle est la moitié de l'horloge principale de l'Arduino Due, c'est-à-dire 42 MHz. Par exemple, avec ticks=1000, on a une fréquence d'échantillonnage de 42 kHz (adaptée au traitement d'un signal audio).

void config_timer(uint32_t ticks) {
  uint32_t channel = 0;
  uint8_t clock = TC_CMR_TCCLKS_TIMER_CLOCK1; // horloge 84MHz/2=42 MHz
  pmc_enable_periph_clk (TC_INTERFACE_ID + 0*3+channel) ;
  TC_Configure(TC0,channel, TC_CMR_WAVE | TC_CMR_WAVSEL_UP_RC | TC_CMR_ACPA_CLEAR | TC_CMR_ACPC_SET |clock); 
  TC_SetRC(TC0,channel,ticks); 
  TC_SetRA(TC0,channel,ticks >> 1);
  TC_Start(TC0, channel);
}
void stop_timer() {
    uint32_t channel = 0;
    TC_Stop(TC0,channel);
    pmc_disable_periph_clk (TC_INTERFACE_ID + 0*3+channel);
}
                

La fonction suivante configure une seule sortie N/A (DAC0 ou DAC1) :

void config_dac(uint32_t channel) {
   pmc_enable_periph_clk(DACC_INTERFACE_ID);
   dacc_reset(DACC_INTERFACE);
   dacc_set_transfer_mode(DACC_INTERFACE, 0); // half word transfert (16 bits)
   dacc_set_power_save(DACC_INTERFACE, 0, 0);
   dacc_set_timing(DACC_INTERFACE, 0x08, 0, 0x10);
   dacc_set_analog_control(DACC_INTERFACE, DACC_ACR_IBCTLCH0(0x02)|DACC_ACR_IBCTLCH1(0x02)|DACC_ACR_IBCTLDACCORE(0x01));
   dacc_set_channel_selection(DACC_INTERFACE, channel);
   if ((dacc_get_channel_status(DACC_INTERFACE) & (1 << channel)) == 0) 
				dacc_enable_channel(DACC_INTERFACE, channel);
}
                

L'écriture d'une valeur à convertir se fera dans le registre DACC_INTERFACE->DACC_CDR (conversion data register), sous la forme d'un mot de 16 bits (mais seulement 12 bits sont utilisés).

La fonction suivante configure les deux sorties DAC0 et DAC1, pour faire un filtrage en stéréo (les deux voies subissent le même traitement).

void config_double_dac() {
   pmc_enable_periph_clk(DACC_INTERFACE_ID);
   dacc_reset(DACC_INTERFACE);
   dacc_set_transfer_mode(DACC_INTERFACE, 1); //  word transfert (32 bits)
   dacc_set_power_save(DACC_INTERFACE, 0, 0);
   dacc_set_timing(DACC_INTERFACE, 0x08, 0, 0x10);
   dacc_set_analog_control(DACC_INTERFACE, DACC_ACR_IBCTLCH0(0x02)|DACC_ACR_IBCTLCH1(0x02)|DACC_ACR_IBCTLDACCORE(0x01));
   DACC_INTERFACE->DACC_MR |= DACC_MR_TAG;
   DACC_INTERFACE->DACC_CHER = 0x3;
   chsel = (1<<13) | (1<<28);
}
                 

Dans ce cas, les deux nombres 12 bits à convertir doivent être écrits dans les 32 bits du registre DACC_INTERFACE->DACC_CDR. Avec cette écriture simultanée, le délai entre les deux conversions est très court, de l'ordre d'une microseconde, ce qui est pratiquement instantané à l'échelle d'une période d'échantillonnage audio.

3.c. Filtrage en flottant

On considère tout d'abord le filtrage avec des coefficients et un accumulateur sous forme de nombres à virgule flottante 32 bits. Ce type de filtrage est relativement lent car le microprocesseur Cortex M3 n'a pas d'unité de calcul en virgule flottante (le compilateur génère un calcul logiciel). Pour un filtre à faible nombre de coefficients (surtout les filtres récursifs), il est toutefois préférable de filtrer avec des flottants pour limiter les erreurs d'arrondis.

Il y a trois types de filtrage : forme directe I (FD2), forme directe II (FD2), et forme directe transposée II (FDT2). Pour chacun, il y a une fonction réalisant le filtrage pour une voie, et une autre le réalisant en stéréo pour deux voies.

Les deux premières fonctions réalisent une simple recopie de l'entrée vers la sortie. Elles seront utilisées pour la détermination du gain.

volatile void adc_copie_une_voie() {
     DACC_INTERFACE->DACC_CDR = *(ADC->ADC_CDR+channels[0]);  
}

volatile void adc_copie_deux_voies() {
     
     DACC_INTERFACE->DACC_CDR = *(ADC->ADC_CDR+channels[0]) | (*(ADC->ADC_CDR+channels[1]) << 16) | chsel;  
}
                    

Voici la forme directe de type I pour une voie. Pour une explication détaillée, voir Filtrage numérique sur un microcontrôleur.

volatile void adc_filtrage_float_FD1_une_voie() {
   float accum_0;
   int16_t sortie_0;
   uint8_t i,k;
   x_0[J_tampon] = ((int16_t)*(ADC->ADC_CDR+channels[0]))-offset;
   accum_0 = 0;
   i = J_tampon;
   for (k=0; k<nb; k++) {
     accum_0 += x_0[i]*bbb[k];
     i--;  
   }
   i = J_tampon-1;
   for (k=1; k<na; k++) {
     accum_0 -= y_0[i]*aaa[k];
     i--;  
   }
   sortie_0 = accum_0;
   y_0[J_tampon] = sortie_0;
   J_tampon++;
   sortie_0 = sortie_0*GAIN+offset;
#ifdef SAT
   if (sortie_0<0) sortie_0 = 0;
   else if (sortie_0 > 0xFFF) sortie_0 = 0xFFF;
#endif
   DACC_INTERFACE->DACC_CDR = sortie_0;
}
                   

L'accumulation, c'est-à-dire le calcul de la somme des valeurs du signal multipliées par les coefficients, se fait avec des flottants. Bien sûr, la valeur obtenue est convertie en un entier 12 bits pour être envoyée au convertisseur N/A. On notera la présence d'un offset, en principe égal à 0x7FF, qui doit être retranché avant le filtrage, puis ajouté avant l'écriture dans le registre du DAC. Si la macro SAT est définie, on effectue une saturation de la sortie en cas de débordement. Si l'on est certain que le signal d'entrée est assez faible pour ne pas déborder, on peut enlever la définition de SAT dans l'en-tête. Dans le cas d'un filtrage en flottants, le filtrage lui-même ne peut pas donner de débordements accidentels.

La fonction suivante réalise la même chose pour deux voies :

volatile void adc_filtrage_float_FD1_deux_voies() {
   float accum_0,accum_1;
   int16_t sortie_0, sortie_1;
   uint8_t i,k;
   x_0[J_tampon] = (int16_t)(*(ADC->ADC_CDR+channels[0]))-offset;
   x_1[J_tampon] = (int16_t)(*(ADC->ADC_CDR+channels[1]))-offset;
   accum_0 = 0;
   accum_1 = 0;
   i = J_tampon;
   for (k=0; k<nb; k++) {
     accum_0 += x_0[i]*bbb[k];
     accum_1 += x_1[i]*bbb[k];
     i--;  
   }
   i = J_tampon-1;
   for (k=1; k<na; k++) {
     accum_0 -= y_0[i]*aaa[k];
     accum_1 -= y_1[i]*aaa[k];
     i--;  
   }
   sortie_0 = accum_0;
   sortie_1 = accum_1;
   y_0[J_tampon] = sortie_0;
   y_1[J_tampon] = sortie_1;
   J_tampon++;
   sortie_0 = sortie_0*GAIN+offset;
   sortie_1 = sortie_1*GAIN+offset;
#ifdef SAT
   if (sortie_0<0) sortie_0 = 0;
   else if (sortie_0 > 0xFFF) sortie_0 = 0xFFF;
   if (sortie_1<0) sortie_1 = 0;
   else if (sortie_1 > 0xFFF) sortie_1 = 0xFFF;
#endif
   DACC_INTERFACE->DACC_CDR = (sortie_0) | (((uint32_t)(sortie_1)) << 16) | chsel;;
}
                     

Voici la réalisation directe de type II, qui opère avec un seul tampon circulaire :

volatile void adc_filtrage_float_FD2_une_voie() {
  float accum_0;
  int16_t sortie_0;
  uint8_t i,k;
  accum_0 = ((int16_t)(*(ADC->ADC_CDR+channels[0]))-offset)*aaa[0];
  i = J_tampon-1;
  for (k=1; k<na; k++) {
    accum_0 -= www_0[i]*aaa[k];
    i--;  
  }
  www_0[J_tampon] = accum_0;
  accum_0 = 0.0;
  i = J_tampon;
  for (k=0; k<nb; k++) {
      accum_0 += www_0[i]*bbb[k];
      i--;  
  }
  J_tampon++;
   sortie_0 = accum_0*GAIN+offset;
#ifdef SAT
   if (sortie_0<0) sortie_0 = 0;
   else if (sortie_0 > 0xFFF) sortie_0 = 0xFFF;
#endif
   DACC_INTERFACE->DACC_CDR = sortie_0;
}

volatile void adc_filtrage_float_FD2_deux_voies() {
  float accum_0,accum_1;
  int16_t sortie_0,sortie_1;
  uint8_t i,k;
  accum_0 = ((int16_t)(*(ADC->ADC_CDR+channels[0]))-offset)*aaa[0];
  accum_1 = ((int16_t)(*(ADC->ADC_CDR+channels[1]))-offset)*aaa[0];
  i = J_tampon-1;
  for (k=1; k<na; k++) {
    accum_0 -= www_0[i]*aaa[k];
    accum_1 -= www_1[i]*aaa[k];
    i--;  
  }
  www_0[J_tampon] = accum_0;
  www_1[J_tampon] = accum_1;
  accum_0 = 0.0;
  accum_1 = 0.0;
  i = J_tampon;
  for (k=0; k<nb; k++) {
      accum_0 += www_0[i]*bbb[k];
      accum_1 += www_1[i]*bbb[k];
      i--;  
  }
  J_tampon++;
   sortie_0 = accum_0*GAIN+offset;
   sortie_1 = accum_1*GAIN+offset;
#ifdef SAT
   if (sortie_0<0) sortie_0 = 0;
   else if (sortie_0 > 0xFFF) sortie_0 = 0xFFF;
   if (sortie_1<0) sortie_1 = 0;
   else if (sortie_1 > 0xFFF) sortie_1 = 0xFFF;
#endif
   DACC_INTERFACE->DACC_CDR = (sortie_0) | (((uint32_t)(sortie_1)) << 16) | chsel;;
}
                     

Voici la réalisation directe transposée de type II, qui a l'avantage de ne pas nécessiter de tampon circulaire. Un simple tableau de variables d'état suffit.

volatile void adc_filtrage_float_FDT2_une_voie() {
  int16_t entree_0,sortie_0;
  uint8_t k,i;
  i = 0;
  entree_0 = (int16_t)(*(ADC->ADC_CDR+channels[0]))-offset;
  sortie_0 = bbb[0]*entree_0+www_0[0];
  for (k=1; k<max_na_nb; k++) {
      www_0[i] = bbb[k]*entree_0 - aaa[k]*sortie_0 + www_0[i+1];
      i++; 
  }
   sortie_0 = sortie_0*GAIN+offset;
#ifdef SAT
   if (sortie_0<0) sortie_0 = 0;
   else if (sortie_0 > 0xFFF) sortie_0 = 0xFFF;
#endif
   DACC_INTERFACE->DACC_CDR = sortie_0;
}

volatile void adc_filtrage_float_FDT2_deux_voies() {
  int16_t entree_0,sortie_0,entree_1,sortie_1;
  uint8_t k,i;
  i = 0;
  entree_0 = (int16_t)(*(ADC->ADC_CDR+channels[0]))-offset;
  entree_1 = (int16_t)(*(ADC->ADC_CDR+channels[1]))-offset;
  sortie_0 = bbb[0]*entree_0+www_0[0];
  sortie_1 = bbb[0]*entree_1+www_1[0];
  for (k=1; k<max_na_nb; k++) {
      www_0[i] = bbb[k]*entree_0 - aaa[k]*sortie_0 + www_0[i+1];
      www_1[i] = bbb[k]*entree_1 - aaa[k]*sortie_1 + www_1[i+1];
      i++; 
  }
   sortie_0 = sortie_0*GAIN+offset;
   sortie_1 = sortie_1*GAIN+offset;
#ifdef SAT
   if (sortie_0<0) sortie_0 = 0;
   else if (sortie_0 > 0xFFF) sortie_0 = 0xFFF;
   if (sortie_1<0) sortie_1 = 0;
   else if (sortie_1 > 0xFFF) sortie_1 = 0xFFF;
#endif
   DACC_INTERFACE->DACC_CDR = (sortie_0) | (((uint32_t)(sortie_1)) << 16) | chsel;;
}
                      

3.d. Filtrages en entiers 32 bits

Avec un microcontrôleur 32 bits, la plus grande vitesse de filtrage est réalisée si l'on utilise des entiers 32 bits pour les coefficients du filtre et pour l'accumulateur. Les calculs sont faits avec une représentation en virgule fixe. Pour une explication détaillée, voir Filtrage numérique sur un microcontrôleur.

Les coefficients réels sont multipliés par 2^s avant d'être convertis en entiers. À la fin de l'accumulation, la valeur obtenue est ramenée dans l'intervalle 12 bits [-0x7FF,0x7FF] par une division par 2^s, c'est-à-dire un décalage de s bits vers la droite. La variable définissant le nombre s est notée ab_shift.

L'inconvénient du filtrage en virgule fixe est la possibilité d'un débordement lors de l'accumulation. Pour l'éviter, il faut prévoir des bits de sécurité. Par exemple, avec 6 bits de sécurité, il reste 32-12-6=14 bits effectifs pour le stockage des coefficients (il y a 12 bits pour le signal lui-même). Il s'en suit des erreurs d'arrondi plus importantes que pour un filtrage en flottants 32 bits.

Voici tout d'abord la forme directe de type I. Pour le filtrage en virgule fixe, cette forme a l'avantage de ne jamais conduire à un débordement dans les tampons circulaires x et y, puisque ces tampons stockent les valeurs d'entrée et de sortie.

volatile void adc_filtrage_32bits_FD1_une_voie() {
   int32_t accum_0;
   int16_t sortie_0;
   uint8_t i,k;
   x_0[J_tampon] = (int16_t)(*(ADC->ADC_CDR+channels[0]))-offset;
   accum_0 = 0;
   i = J_tampon;
   for (k=0; k<nb; k++) {
      accum_0 += x_0[i]*bb[k];
      i--;
   }
   i = J_tampon-1;
   for (k=1; k<na; k++) {
      accum_0 -= y_0[i]*aa[k];
      i--;
   }
   sortie_0 = accum_0 >> ab_shift;
   y_0[J_tampon] = sortie_0;
   J_tampon++;
   sortie_0 = sortie_0*GAIN+offset;
#ifdef SAT
   if (sortie_0<0) sortie_0 = 0;
   else if (sortie_0 > 0xFFF) sortie_0 = 0xFFF;
#endif
   DACC_INTERFACE->DACC_CDR = sortie_0;
}

volatile void adc_filtrage_32bits_FD1_deux_voies() {
   int32_t accum_0, accum_1;
   int16_t sortie_0, sortie_1;
   uint8_t i,k;
   x_0[J_tampon] = (int16_t)(*(ADC->ADC_CDR+channels[0]))-offset;
   x_1[J_tampon] = (int16_t)(*(ADC->ADC_CDR+channels[1]))-offset;
   accum_0 = 0;
   accum_1 = 0;
   i = J_tampon;
   for (k=0; k<nb; k++) {
      accum_0 += x_0[i]*bb[k];
      accum_1 += x_1[i]*bb[k];
      i--;
   }
   i = J_tampon-1;
   for (k=1; k<na; k++) {
      accum_0 -= y_0[i]*aa[k];
      accum_1 -= y_1[i]*aa[k];
      i--;
   }
   sortie_0 = accum_0 >> ab_shift;
   sortie_1 = accum_1 >> ab_shift;
   y_0[J_tampon] = sortie_0;
   y_1[J_tampon] = sortie_1;
   J_tampon++;
   sortie_0 = sortie_0*GAIN+offset;
   sortie_1 = sortie_1*GAIN+offset;
#ifdef SAT
   if (sortie_0<0) sortie_0 = 0;
   else if (sortie_0 > 0xFFF) sortie_0 = 0xFFF;
   if (sortie_1<0) sortie_1 = 0;
   else if (sortie_1 > 0xFFF) sortie_1 = 0xFFF;
#endif
   DACC_INTERFACE->DACC_CDR = (sortie_0) | (((uint32_t)(sortie_1)) << 16) | chsel;;
}
                   

Dans la méthode directe de type II, les valeurs stockées dans le tampon w peuvent dépasser très largement la plage [-0x7FF,0x7FF]. Il faut donc prévoir plus de bits de sécurité. En général, 4 ou 5 bits de sécurité suffisent.

volatile void adc_filtrage_32bits_FD2_une_voie() {
   int32_t accum_0;
   int16_t sortie_0;
    uint8_t i,k;
    accum_0 =  ((int16_t)(*(ADC->ADC_CDR+channels[0]))-offset)*aa[0];
    i = J_tampon-1;
    for (k=1; k<na; k++) {
      accum_0 -= ww_0[i]*aa[k];
      i--; 
    }
    ww_0[J_tampon] = accum_0 >> ab_shift;
    i = J_tampon;
    accum_0 = 0;
    for (k=0; k<nb; k++) {
      accum_0 += ww_0[i]*bb[k];
      i--;  
    }
    J_tampon++;
    sortie_0 = (accum_0 >> ab_shift)*GAIN+offset;
#ifdef SAT
   if (sortie_0<0) sortie_0 = 0;
   else if (sortie_0 > 0xFFF) sortie_0 = 0xFFF;
#endif
   DACC_INTERFACE->DACC_CDR = sortie_0;
}

volatile void adc_filtrage_32bits_FD2_deux_voies() {
   int32_t accum_0,accum_1;
   int16_t sortie_0,sortie_1;
    uint8_t i,k;
    accum_0 =  ((int16_t)(*(ADC->ADC_CDR+channels[0]))-offset)*aa[0];
    accum_1 =  ((int16_t)(*(ADC->ADC_CDR+channels[1]))-offset)*aa[0];
    i = J_tampon-1;
    for (k=1; k<na; k++) {
      accum_0 -= ww_0[i]*aa[k];
      accum_1 -= ww_1[i]*aa[k];
      i--; 
    }
    ww_0[J_tampon] = accum_0 >> ab_shift;
    ww_1[J_tampon] = accum_1 >> ab_shift;
    i = J_tampon;
    accum_0 = 0;
    accum_1 = 0;
    for (k=0; k<nb; k++) {
      accum_0 += ww_0[i]*bb[k];
      accum_1 += ww_1[i]*bb[k];
      i--;  
    }
    J_tampon++;
   sortie_0 = (accum_0 >> ab_shift)*GAIN+offset;
   sortie_1 = (accum_1 >> ab_shift)*GAIN+offset;
#ifdef SAT
   if (sortie_0<0) sortie_0 = 0;
   else if (sortie_0 > 0xFFF) sortie_0 = 0xFFF;
   if (sortie_1<0) sortie_1 = 0;
   else if (sortie_1 > 0xFFF) sortie_1 = 0xFFF;
#endif
   DACC_INTERFACE->DACC_CDR = (sortie_0) | (((uint32_t)(sortie_1)) << 16) | chsel;;
}
                   

Voici pour finir la réalisation directe transposée de type II :

volatile void adc_filtrage_32bits_FDT2_une_voie() {
   int32_t entree_0, sortie_0;
   uint8_t k,i;
   i = 0;
   entree_0 = (int16_t)(*(ADC->ADC_CDR+channels[0]))-offset;
   sortie_0 = (bb[0]*entree_0+ww_0[0]) >> ab_shift;
   for (k=1; k<max_na_nb; k++) {
       ww_0[i] = entree_0*bb[k] - sortie_0*aa[k] + ww_0[i+1];
       i++;
   }
   sortie_0 = sortie_0*GAIN+offset;
#ifdef SAT
   if (sortie_0<0) sortie_0 = 0;
   else if (sortie_0 > 0xFFF) sortie_0 = 0xFFF;
#endif
   DACC_INTERFACE->DACC_CDR = sortie_0;
}

volatile void adc_filtrage_32bits_FDT2_deux_voies() {
   int32_t entree_0, sortie_0, entree_1, sortie_1;
   uint8_t k,i;
   i = 0;
   entree_0 = (int16_t)(*(ADC->ADC_CDR+channels[0]))-offset;
   entree_1 = (int16_t)(*(ADC->ADC_CDR+channels[1]))-offset;
   sortie_0 = (bb[0]*entree_0+ww_0[0]) >> ab_shift;
   sortie_1 = (bb[0]*entree_1+ww_1[0]) >> ab_shift;
   for (k=1; k<max_na_nb; k++) {
       ww_0[i] = entree_0*bb[k] - sortie_0*aa[k] + ww_0[i+1];
       ww_1[i] = entree_1*bb[k] - sortie_1*aa[k] + ww_1[i+1];
       i++;
   }
   sortie_0 = sortie_0*GAIN+offset;
   sortie_1 = sortie_1*GAIN+offset;
#ifdef SAT
   if (sortie_0<0) sortie_0 = 0;
   else if (sortie_0 > 0xFFF) sortie_0 = 0xFFF;
   if (sortie_1<0) sortie_1 = 0;
   else if (sortie_1 > 0xFFF) sortie_1 = 0xFFF;
#endif
   DACC_INTERFACE->DACC_CDR = (sortie_0) | (((uint32_t)(sortie_1)) << 16) | chsel;;
}
                   

La fonction suivante initialise les tampons utilisés pour le filtrage :

void init_tampons() {
   int i;
   J_tampon = 0;
   for (i=0; i<TAILLE_TAMPON; i++) {
     x_0[i] = 0;
     y_0[i] = 0;
     x_1[i] = 0;
     y_1[i] = 0; 
     www_0[i] = 0.0;
     www_1[i] = 0.0;
     ww_0[i] = 0;
     ww_1[i] = 0;
   } 
}
                   

3.e. Communication avec l'ordinateur

Ces fonctions permettent à un programme Python (présenté plus loin) de fournir les coefficients du filtre et les différents paramètres de la numérisation.

La première fonction lit les informations de configuration de l'ADC. Les valeurs lues sont :

• Le nombre de voies (8 bits).
• Les numéros des bornes des voies utilisées (8 bits chacun), par exemple 0 et 1 pour les bornes A0 et A1.
• Les gains des voies (8 bits chacun) égaux à 1,2 ou 4.
• Le nombre de tops d'horloge à 42 MHz définissant la période d'échantillonnage (32 bits).

Il est possible de définir plus de deux voies en entrée, mais seules les deux premières sont filtrées. Les autres pourront servir à lire des informations de la part de capteurs, par exemple un potentiomètre pour modifier un paramètre d'un filtre.

void lecture_config_adc() {
   uint32_t c1,c2,c3,c4;
   int k;
   while (Serial.available()<1) {};
    nchannels = Serial.read();
    while (Serial.available()<nchannels) {};
    for (k=0; k<nchannels; k++) {
      if (k < MAX_NCHAN) channels[k] = channels_pins[Serial.read()]; 
    }
    while (Serial.available()<nchannels) {};
    for (k=0; k<nchannels; k++) {
      if (k < MAX_NCHAN) gain[k] = Serial.read(); 
    }
    if (nchannels > MAX_NCHAN) nchannels = MAX_NCHAN;
    while (Serial.available()<4) {};
    c1 = Serial.read();
    c2 = Serial.read();
    c3 = Serial.read();
    c4 = Serial.read();
    ticks = ((c1 << 24) | (c2 << 16) | (c3 << 8) | c4);
}
                  

La fonction suivante effectue la configuration d'un filtrage à virgule flottante. Elle appelle tout d'abord la fonction précédente, puis lit les informations suivantes :

• Nombre de coefficients a_k (8 bits).
• Valeurs des coefficients a_k, sous forme d'une mantisse 32 bits et d'un exposant 8 bits.
• Nombre de coefficients b_k (8 bits).
• Valeurs des coefficients a_k.
• Valeur de l'offset (16 bits).
• Type de réalisation, 1 pour FD1, 2 pour FD2, 3 pour FDT2. Une autre valeur conduit à une recopie de l'entrée vers la sortie.

Après la lecture de ces informations, la fonction d'interruption est choisie, les convertisseurs sont configurés, puis le Timer est déclenché.

void lecture_filtrage_float() {
  uint32_t c1,c2,c3,c4;
  int k;
  int32_t m;
  int8_t e;
  uint8_t type;
  lecture_config_adc();
    
    // filtrage
   while (Serial.available()<1) {};
   na = Serial.read();
   for (int k=0; k<na; k++) {
       while (Serial.available()<5) {};
       c1 = Serial.read();
       c2 = Serial.read();
       c3 = Serial.read();
       c4 = Serial.read();
       e = Serial.read();
       m = ((c1 << 24) | (c2 << 16) | (c3 << 8) | c4);
       aaa[k] = ((float)m)*pow(2,e-30);
   }
   while (Serial.available()<1) {};
   nb = Serial.read();
   for (int k=0; k<nb; k++) {
       while (Serial.available()<5) {};
       c1 = Serial.read();
       c2 = Serial.read();
       c3 = Serial.read();
       c4 = Serial.read();
       e = Serial.read();
       m = ((c1 << 24) | (c2 << 16) | (c3 << 8) | c4);
       bbb[k] = ((float)m)*pow(2,e-30);
   }
   while (Serial.available()<2) {};
   c1 = Serial.read();
   c2 = Serial.read();
   offset = ((c1 << 8) | c2);
   while (Serial.available()<1) {};
   type = Serial.read();
 
   init_tampons();
   max_na_nb = max(na,nb);
   for (k=na; k<max_na_nb; k++) aaa[k] = 0.0;
   for (k=nb; k<max_na_nb; k++) bbb[k] = 0.0;
   if (nchannels==1) {
     config_dac(0);
     if (type==1) ADC_Handler_function = adc_filtrage_float_FD1_une_voie;
     else if (type==2) ADC_Handler_function = adc_filtrage_float_FD2_une_voie;
     else if (type==3) ADC_Handler_function = adc_filtrage_float_FDT2_une_voie;
     else ADC_Handler_function = adc_copie_une_voie;
   }
   else if (nchannels==2) {
     config_double_dac();
     if (type==1) ADC_Handler_function = adc_filtrage_float_FD1_deux_voies;
     else if (type==2) ADC_Handler_function = adc_filtrage_float_FD2_deux_voies;
     else if (type==3) ADC_Handler_function = adc_filtrage_float_FDT2_deux_voies;
     else ADC_Handler_function = adc_copie_deux_voies;
   }
   config_adc();
   config_timer(ticks);
}
                   

La configuration du filtrage en virgule fixe (entiers 32 bits) est similaire à la précédente, mais les coefficients du filtre sont des entiers 32 bits. Il y en plus la lecture de ab_shift, un entier 8 bits.

void lecture_filtrage_32bits() {
  uint32_t c1,c2,c3,c4;
  int k;
  uint8_t type;
  lecture_config_adc();
  while (Serial.available()<1) {};
   na = Serial.read();
   for (int k=0; k<na; k++) {
       while (Serial.available()<4) {};
       c1 = Serial.read();
       c2 = Serial.read();
       c3 = Serial.read();
       c4 = Serial.read();
       aa[k] = ((c1 << 24) | (c2 << 16) | (c3 << 8) | c4);
   }
   while (Serial.available()<1) {};
   nb = Serial.read();
   for (int k=0; k<nb; k++) {
       while (Serial.available()<4) {};
       c1 = Serial.read();
       c2 = Serial.read();
       c3 = Serial.read();
       c4 = Serial.read();
       bb[k] = ((c1 << 24) | (c2 << 16) | (c3 << 8) | c4);
   }
   while (Serial.available()<1) {};
   ab_shift = Serial.read();
   while (Serial.available()<2) {};
   c1 = Serial.read();
   c2 = Serial.read();
   offset = ((c1 << 8) | c2);
   while (Serial.available()<1) {};
   type = Serial.read();
   init_tampons();
   max_na_nb = max(na,nb);
   for (k=na; k<max_na_nb; k++) aa[k] = 0.0;
   for (k=nb; k<max_na_nb; k++) bb[k] = 0.0;
   if (nchannels==1) {
     config_dac(0);
     if (type==1) ADC_Handler_function = adc_filtrage_32bits_FD1_une_voie;
     else if (type==2) ADC_Handler_function = adc_filtrage_32bits_FD2_une_voie;
     else if (type==3) ADC_Handler_function = adc_filtrage_32bits_FDT2_une_voie;
     else ADC_Handler_function = adc_copie_une_voie;
   }
   else if (nchannels==2) {
     config_double_dac();
     if (type==1) ADC_Handler_function = adc_filtrage_32bits_FD1_deux_voies;
     else if (type==2) ADC_Handler_function = adc_filtrage_32bits_FD2_deux_voies;
     else if (type==3) ADC_Handler_function = adc_filtrage_32bits_FDT2_deux_voies;
     else ADC_Handler_function = adc_copie_deux_voies;
   }
   config_adc();
   config_timer(ticks);
}
                    

Voici la fonction d'initialisation :

void setup() {
  Serial.begin(115200);
  pinMode(3,OUTPUT);
}
                    

La fonction suivante effectue la lecture du port série. Si un caractère de commande est lu, la fonction de lecture correspondante est appelée. Si la commande IS_READY est reçue, le Timer est stoppé et un caractère est renvoyé. Cette commande devra être exécutée avant de configurer le filtre, pour vérifier que l'Arduino n'est pas bloqué (à cause d'une cadence d'interruption trop élevée).

void lecture_serie() {
  char com;
    if (Serial.available()>0) {
        com = Serial.read();
        if (com==SET_FILTRAGE_FLOAT) lecture_filtrage_float();
        else if (com==SET_FILTRAGE_32BITS) lecture_filtrage_32bits();
        else if (com==IS_READY) {
          stop_timer();
          Serial.write("O");  
        }
    }
}
                     

La fonction principale effectue une lecture du port série toute les demi secondes :

void loop() {
  lecture_serie();
  delay(500);
}
                     

La fonction lecture_serie étant non bloquante, on pourra ajouter ici d'autres opérations d'interaction avec l'extérieur. Si des entrées analogiques autres que celles des deux signaux à filtrer sont utilisées, il est préférable de numériser toutes les voies simultanément. Par exemple, si l'on a besoin d'une troisième voie pour lire la valeur d'un capteur, on stockera sa valeur dans une variable globale uint16_t v3. Il suffit d'ajouter la ligne suivante dans la fonction de traitement :

v3 = *(ADC->ADC_CDR+channels[3]);
                         

La variable uint16_t v3 pourra être lue dans la fonction loop afin de déclencher différentes actions.