Arduino - Comment créer deux ou plusieurs sons en même temps sur un buzzer piézo?

Arduinos offre exclusivement numérique de sortie: la sortie est soit sur (+5V) ou hors tension (0V). Le tone() fonction, qui, je vous ai couru dans ce point, les sorties un signal carré à la fréquence spécifiée.

Dites que vous voulez une 100Hz ton. 100Hz signifie que la sortie se répète tous les 1/100 de seconde, ou 10ms. Donc tone(PIN,100) permettra de régler une minuterie d'interruption à être appelé toutes les 5ms. La première fois que l'interruption est appelée, elle fixe la sortie faible, et renvoie à ce que votre programme est en train de faire. La prochaine fois il est appelé, il fixe la sortie haute. Ainsi, toutes les 5ms les changements de sortie, et vous obtenez une onde carrée à 50% du cycle de vie, ce qui signifie que la sortie est sur c'est précisément pour la moitié du temps.

Tout cela est très bien, mais la plupart des formes d'onde audio ne sont pas les ondes carrées. Si vous voulez jouer sur les deux ondes carrées de sons en même temps, ou même de contrôler le volume d'un seul carré de ton onde, vous devez être en mesure de produire plus de valeur qu'un simple "on" et "off".

La bonne nouvelle, c'est qu'il y a un truc que vous pouvez utiliser appelée modulation de largeur d'impulsion (couramment abrégé PWM). L'idée est que vous ne peut être en mesure de définir votre sortie à l'une des deux valeurs, mais vous pouvez le faire très vite. Les humains peuvent entendre des fréquences jusqu'à 20 khz. Si vous diddle votre sortie plus vite que ça, disons à 200kHz (bien dans les capacités de l'Arduino, qui est cadencé à 16MHz), vous n'entendez pas la sortie individuelle des transitions, mais le moyenne valeur sur une période plus longue.

Imaginer la génération d'un 200kHz ton avec tone(). Il est beaucoup trop élevé pour l'entendre, mais la valeur moyenne est à mi-chemin entre on et off (50% duty cycle, vous vous souvenez?). Donc, nous avons maintenant trois de sortie possible des valeurs: on, off, et à mi-chemin. C'est assez pour nous permettre de jouer à deux ondes carrées simultanément:

Audio de haute qualité exige beaucoup plus de valeurs que cela. Cd magasin 16-bit audio, ce qui signifie qu'il y a 65536 valeurs possibles. Et tandis que nous n'obtiendrons pas de lecteur de CD audio de qualité d'un Arduino, nous pouvons obtenir plus de valeurs de sortie par le choix d'un cycle de service autre que de 50%. En fait, l'Arduino a le matériel pour le faire pour nous.

Répondre analogWrite(). Ce faux divers niveaux de sortie à l'aide de l'Arduino intégré PWM hardware. La mauvaise nouvelle est que la fréquence PWM est généralement de 500 hz, ce qui est bien pour la variation d'un CONDUIT, mais trop faible pour l'audio. Nous avons donc au programme registres du matériel de soi-même.

Secrets de PWM Arduino a plus d'information, voici une référence détaillée sur la façon de mettre en œuvre un PWM DAC sur un Arduino.

J'ai pris 7 bits de résolution, ce qui signifie que la sortie est une 16MHz/128=125kHz onde carrée avec 128 cycles de service.

Bien sûr, une fois que vous avez une sortie PWM de travail, le plaisir ne fait que commencer.
Avec de multiples voix, vous ne pouvez pas compter sur les interruptions pour définir la fréquence de vos formes d'ondes, vous devez étirer vous-même. Connaissances de base en traitement du signal numérique (DSP) viendra à jolly à portée de main. Vous aurez besoin de code serré pour générer des données audio à partir de l'intérieur d'un gestionnaire d'interruption, puis vous aurez besoin d'un playroutine pour déclencher les bonnes notes au bon moment. Le ciel est la limite!

De toute façon, voici un peu de code:

#define PIN 9

/* these magic constants were generated by the following perl script:
   #!/usr/bin/perl -lw
   my $freq = 16000000/256;
   my $A4 = 440;
   print int(128*$freq/$A4*exp(-log(2)*$_/12)) for (-9..2);
*/
const uint16_t frtab[] = {
  30578, 28861, 27241, 25712,
  24269, 22907, 21621, 20408,
  19262, 18181, 17161, 16198
};

#define VOICES 4

struct voice { 
  uint16_t freq;
  int16_t frac;
  uint8_t octave;
  uint8_t off;
  int8_t vol;
  const uint8_t *waveform;
} voice[VOICES];

#define PITCH 50 /* global pitch adjustment */

/* some waveforms. 16 samples each */
const uint8_t square_50[] = {
  0, 0, 0, 0, 0, 0, 0, 0,15,15,15,15,15,15,15,15
};
const uint8_t square_25[] = {
  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,15,15,15,15
};
const uint8_t square_12[] = {
  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,15,15
};
const uint8_t square_6[] = {
  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,15
};
const uint8_t sawtooth[] = {
  0, 1, 2, 3, 4, 5, 6, 7, 8, 9,10,11,12,13,14,15
};
const uint8_t triangle[] = {
  0, 2, 4, 6, 8,10,12,14,15,13,11, 9, 7, 5, 3, 1
};
const uint8_t nicebass[] = {
  0, 8,14,18,22,23,24,25,26,25,24,23,22,18,14, 8
};

void setup() {
  /* TIMER0 is used by the Arduino environment for millis() etc.
   So we use TIMER1.
 */
  pinMode(PIN, OUTPUT);
  /* fast PWM, no prescaler */
  TCCR1A = 0x80;
  TCCR1B = 0x11;
  /* 7-bit precision => 125kHz PWM frequency */
  ICR1H = 0;
  ICR1L = 0x7f;
  /* enable interrupts on TIMER1 overflow */
  TIMSK1 = 1;
  OCR1AH = 0; /* hi-byte is unused */
  for (uint8_t i=0; i<VOICES; i++)
    clear_voice(i);
}

void set_voice(uint8_t v, uint8_t note, uint8_t volume, const uint8_t *waveform) {
  note += PITCH;
  voice[v].octave = note/12;
  voice[v].freq = frtab[note%12];
  voice[v].frac = 0;
  voice[v].off = 0;
  voice[v].waveform = waveform;
  voice[v].vol = volume;
}

void clear_voice (uint8_t v) {
  voice[v].freq = 0;
}

uint8_t s = 0;

ISR(TIMER1_OVF_vect) {
  /* Calculate new data every 4 pulses, i.e. at 125/4 = 31.25kHz.
     Being interrupted unnecessarily is kinda wasteful, but using another timer is messy.
  */
  if (s++ & 3)
    return;

  int8_t i;
  int8_t out = 0;
  for (i=0; i<VOICES; i++) {
    if (voice[i].freq) {
      voice[i].frac -= 128<<voice[i].octave;
      if (voice[i].frac < 0) { /* overflow */
        voice[i].frac += voice[i].freq;
        voice[i].off++;
      }
      /* warning: vol isn't a real volume control, only for square waves */
       out += (voice[i].waveform[voice[i].off & 15]) & voice[i].vol;
    }
  }

  /* out is in the range 0..127. With 4-bit samples this gives us headroom for 8 voices.
     Or we could use more than 4-bit samples (see nicebass).
   */
  OCR1AL = out;
}

/* tune data */
const uint8_t bass[8][4] = {
  { 12, 19, 23, 24 },
  {  5, 12, 19, 21 },
  { 12, 19, 23, 24 },
  {  5, 12, 19, 21 },
  { 14, 16, 17, 21 },
  {  7, 19, 14, 19 },
  { 14, 16, 17, 21 },
  {  7, 19, 14, 19 }
};

const uint8_t melody[2][8][16] = {
  {/* first voice */
    {31, 0, 0, 0, 0, 1, 2, 3,31,29,28,29, 0,28,26,24 },
    { 0, 0, 0, 0, 0, 1, 2, 3,53,54,53,54, 0, 1, 2, 3 },
    {31, 0, 0, 0, 0, 1, 2, 3,31,29,28,29, 5,28, 5,26 },
    { 5,28,24, 0, 0, 1, 2, 3,53,54,56,54, 0, 1, 2, 3 },

    {29, 0, 0, 0, 0, 1, 2, 3,31,29,28,29, 5, 0,28, 5 },
    {28, 5, 0,26, 0, 1, 2, 3,54,56,58,56, 0, 1, 2, 3 },
    {29, 0, 0, 0, 0, 1, 2, 3,31,29,28,29, 5, 0,28, 5 },
    {28, 5, 0,26, 0, 1, 2, 3, 0,19,21,23,24,26,28,29 },
  },

  {/* second voice */
    {24, 0, 0, 0, 0, 1, 2, 3,24,24,24,24, 0,24,24,21 },
    { 0, 0, 0, 0, 0, 1, 2, 3,49,51,49,51, 0, 1, 2, 3 },
    {24, 0, 0, 0, 0, 1, 2, 3,24,24,24,24, 5,24, 5,24 },
    { 5,23,21, 0, 0, 1, 2, 3,49,51,53,51, 0, 1, 2, 3 },

    {26, 0, 0, 0, 0, 1, 2, 3,24,26,24,24, 5, 0,24, 5 },
    {24, 5, 0,24, 0, 0, 0, 0,51,51,54,54, 0, 1, 2, 3 },
    {26, 0, 0, 0, 0, 1, 2, 3,24,26,24,24, 5, 0,24, 5 },
    {24, 5, 0,23, 0, 1, 2, 3, 0, 5, 0,19,21,23,24,26 },  
  }
};

void loop() {
  uint8_t pos, i, j;

  for (pos=0; pos<8; pos++) {
    for (i=0; i<16; i++) {
      /* melody: voices 0 and 1 */
      for (j=0; j<=1; j++) {
        uint8_t m = melody[j][pos][i];
        if (m>10) {
           /* new note */
           if (m > 40) /* hack: new note, keep volume */
             set_voice(j, m-30, voice[j].vol, square_50);
           else /* new note, full volume */
             set_voice(j, m, 15, square_50);
        } else {
          voice[j].vol--; /* fade existing note */
          switch(m) { /* apply effect */
            case 1: voice[j].waveform = square_25; break;
            case 2: voice[j].waveform = square_12; break;
            case 3: voice[j].waveform = square_6; break;
            case 4: clear_voice(j); break; /* unused */
            case 5: voice[j].vol -= 8; break;
          }
          if (voice[j].vol < 0)
            voice[j].vol = 0; /* just in case */
        }
      }

      /* bass: voices 2 and 3 */
      set_voice(2, bass[pos][i%4], 31, nicebass);
      set_voice(3, bass[pos][0]-12, 15-i, sawtooth);

      delay(120); /* time per event */
    }
  }
}

Cela se joue à quatre voix tune. Je n'ai qu'un Arduino Leonardo (bien, Pro Micro) pour faire des tests, de sorte que vous pouvez avoir besoin de changer PIN selon laquelle la broche est connectée à TIMER1A (si je suis en train de lire correctement, c'est la broche 9 sur une Uno et la broche 11 sur un Mega). Vous n'avez pas de choix de code pin pour utiliser, malheureusement.

Je l'ai testé avec un casque, donc je n'ai aucune idée de comment ça sur un buzzer piézo...

J'espère que ça vous donne une idée des possibilités, et un point de départ potentiel pour votre propre musique. Un plaisir de vous expliquer tout ce qui est difficile, et aussi merci de me donner une excuse pour écrire ceci 🙂

OriginalL'auteur hexwab