Logiciels - Programmation PIC - Bases

Logiciels > Programmation PIC > Bases > MP > Production sonore

Dernière mise à jour : 03/10/2009

Présentation

Les exemples décrits ici montrent comment produire un son continu, un son bref de type "bip", une petite mélodie ou un son de sirène, avec un PIC.

Comment produire un son ?

Un son est produit par un signal électrique oscillant à une fréquence située dans le domaine audio, c'est à dire entre 20 Hz et 20 KHz. Le signal électrique doit attaquer un transducteur de type haut-parleur ou piezo-électrique pour être transformé en vibrations mécaniques transmises dans l'air et ainsi être entendu. La forme du signal peut être quelconque, de cette forme dépend le timbre du son. Produire un son avec un PIC est très simple, si on se contente d'un signal carré. Le PIC est en effet un composant "logique", qui aime travailler avec des informations de type "tout ou rien", en général des niveaux logiques bas (par exemple 0 V) ou des états logiques hauts (par exemple +5 V). Si on envoie à un petit haut-parleur une succession d'états logiques alternant entre niveaux hauts et niveaux bas à une vitesse convenable (comprise dans la fourchette 20 Hz et 20 KHz), le haut-parleur va produire un son audible, à condition bien sûr que ses caractéristiques techniques (mécaniques) lui permettent de le faire, et que nos oreilles fonctionnent encore bien. Finalement, produire un son n'est pas plus compliqué que de faire clignoter une led., il faut juste que le "clignotement" soit assez rapide pour être perçu comme un son continu et non comme une suite de "clacs" (comme celui que produirait un métronome).

Production d'un son continu

Le shéma qui suit, associé au code logiciel complet qui fait suite juste après, permet de produire un son ininterrompu avec pour seul composant externe, un buzzer piezo-électrique !

Vous avez l'idée d'un générateur sonore encore plus simple ? Je suis preneur ! Attention, je n'accepte pas le buzzer électronique avec son oscillateur intégré...

program electronique_pic_tuto_base_son_001a;
 
procedure Init;
begin
  CMCON := %00000111; // comparators OFF
  TRISIO.0 := 0; // GPIO configuré en sortie
  ANSEL.ANS0 := 0; // GPIO configuré en sortie numérique
end;
 
// main program
begin
  Init;
  while true do
  begin
    GPIO.0 := GPIO.0 xor 1; // changement d'état logique
    Delay_us(500); // delai avant de changer d'état logique
  end;
end.

Ce circuit ultra-simple produit un signal sonore dont la fréquence est voisine de 1 KHz. L'explication en est fort simple : la sortie GP0, configurée en tant que sortie logique, change d'état sans arrêt (passe de 0 V à +5 V, puis repasse à 0 V, puis repasse à +5 V, etc), à une cadence qui est liée à la durée du délai introduit dans la boucle principale, ici de 0,5 ms (500 us). On revient donc régulièrement au même état logique toutes les ms, ce qui correspond à une fréquence de 1 KHz. En réalité, la fréquence de sortie est un peu inférieure à 1 KHz car cette façon de procéder n'est pas extrêmement précise d'un point de vue timing. Pour obtenir une fréquence de 1 KHz, il faudrait diminuer un poil la durée d'attente imposée par la ligne de code Delay_us(500), un délai de 495 us devrait convenir. Mais l'idée n'est pas ici de faire dans la précision, nous verrons plus tard que pour obtenir une grande précision il faut faire autrement. Mais le code est simple, tout de même, on ne peut pas le nier et on peut bien le ranger dans une petite case de sa mémoire à soi.

Production d'un son bref (bip)

Gardons le même schéma électronique, et modifions légèrement le code logiciel précédent, de telle sorte que le son produit ne soit plus continu, mais dure seulement un bref instant.

program electronique_pic_tuto_base_son_001b;
 
var
  i: byte;
 
procedure Init;
begin
  CMCON := %00000111; // comparators OFF
  TRISIO.0 := 0; // GPIO configuré en sortie
  ANSEL.ANS0 := 0; // GPIO configuré en sortie numérique
end;
 
// main program
begin
  Init;
  i := 0;
  while true do
  begin
    if i < 200 then
    begin
      inc(i);
      GPIO.0 := GPIO.0 xor 1;
      delay_us(500);
    end;
  end;
end.

Avec ce code logiciel, le son généré à la mise sous tension du montage ne dure plus qu'un dizième de secondes, ce qui se traduit par un bref bip sonore. Pour obtenir cet effet, il suffit en effet d'autoriser les changements d'état de la sortie pendant un temps bien défini, ce temps est ici conditionné par la valeur d'une variable qui a été ajoutée pour l'occasion (variable i de type byte). Au départ, cette variable est à zéro, et elle s'incrémente de 1 à chaque changement d'état de la sortie. Au bout de 200 changements consécutifs, les changements d'états n'ont plus lieu. C'est une façon de faire, il en existe d'autres. Et si maintenant, nous utilisions une routine toute faite et proposée par MikroPascal ? On aime bien économiser ses énergies (surtout intellectuelles), et il serait dommage de ne pas profiter du travail que d'autres ont fait pour nous simplifier la vie. Je vous laisse méditer sur le code suivant.

program electronique_pic_tuto_base_son_001c;
 
procedure Init;
begin
  CMCON := %00000111; // comparators OFF
  TRISIO.0 := 0; // GPIO configuré en sortie
  ANSEL.ANS0 := 0; // GPIO configuré en sortie numérique
  Sound_Init(GPIO, 0); // Preparation du port GPIO.0 pour sortie sonore
end;
 
// main program
begin
  Init;
  Sound_Play(1000, 100); // production du bip
end.

Plus simple, non ? En fait, la procédure Sound_Play, obligatoirement précédée de la procédure Sound_Init pour un fonctionnement correct, ne fait que cacher quelques lignes de codes similaires à celle que nous avons vues précédement. Elle attend de nous qu'on lui précise la fréquence (première valeur, en Hz) et la durée du signal sonore (seconde valeur, en ms). D'un point de vue précision de la fréquence générée, ce n'est pas le top là non plus, le signal de sortie est voisin de 960 Hz quand on demande un signal de 1000 Hz et que l'horloge de base du PIC est de 4 MHz. Mais dans bien des cas, ce manque de précision n'est guère bloquant, sauf si bien sûr on envisage de réaliser un générateur BF super précis...

Production d'une petite mélodie

Le paragraphe précédent a permis de poser les premières pierres. Générer une mélodie n'est finalement guère plus compliqué que de générer un bip sonore bref. Il suffit d'en produire plusieurs à la suite, avec des durées et fréquences différentes, avec éventuellement des pauses de silence pour donner vie au morceau. Le code exemple qui suit génère les premières notes de la chanson "Au clair de la lune".

program electronique_pic_tuto_base_son_001c;
 
procedure Init;
begin
  CMCON := %00000111; // comparators OFF
  TRISIO.0 := 0; // GPIO configuré en sortie
  ANSEL.ANS0 := 0; // GPIO configuré en sortie numérique
  Sound_Init(GPIO, 0); // Preparation du port GPIO.0 pour sortie sonore
end;
 
// main program
begin
  Init;
  //
  // Do = 239; DoD = 253; Re = 268; ReD = 284; Mi = 301; Fa = 319;
  // FaD = 338; Sol = 358; SolD = 379; La = 402; LaD = 426; Si = 451;
  //
  Sound_Play(239, 200);
  Delay_ms(10);
  Sound_Play(239, 200);
  Delay_ms(10);
  Sound_Play(239, 200);
  Delay_ms(10);
  Sound_Play(268, 200);
  Delay_ms(10);
  Sound_Play(301, 400);
  Delay_ms(10);
  Sound_Play(268, 400);
  Delay_ms(10);
  Sound_Play(239, 200);
  Delay_ms(10);
  Sound_Play(301, 200);
  Delay_ms(10);
  Sound_Play(268, 200);
  Delay_ms(10);
  Sound_Play(268, 200);
  Delay_ms(10);
  Sound_Play(239, 400);
  Delay_ms(10);
end.

Le code précédent fonctionne bien, mais sa relative gourmandise en ressources ne permet pas de jouer des mélodies très longues, surtout avec un "petit" PIC comme le 12F675. Mais comme vous êtes tous aussi curieux, je ne doute pas un instant que vous allez trouver comment faire rentrer la "Marche turque" dans un petit pavé noir à quelques pattes.

Utilisation pour orgue musical

La procédure Sound_Play proposée dans l'environnement MikroPascal peut être mise à profit pour générer des notes sur commande. Je ne me suis pas gêné pour le faire dans les deux projets suivants :
Orgue 006 - Mini orgue monodique / polyphonique Audio et MIDI à base de PIC 18F2520
Orgue 008 - Mini orgue à base de clavier informatique PS2 et PIC 16F628A

Production d'un son modulé type "sirène"

Plutôt que de produire un certain nombre de sons fixes avec des intervalles de temps plus ou moins longs entre chaque, on peut aussi envisager de produire des sons de fréquences différentes tellement rapprochés en fréquence et dans le temps, qu'on entend à peine (voire pas du tout) le passage de l'un à l'autre. Dans ce cas, l'effet obtenu peut être celui d'un glissement de fréquence, tel que celui que l'on peut observer avec les sirènes modulées en fréquence (il existe aussi des sirènes modulées en amplitude, mais elles sont moins répendues car moins percutantes). Imaginez simplement qu'un son de fréquence 250 Hz soit produit pendant quelques "périodes" de temps, puis que l'on passe à la fréquence de 260 Hz, laquelle dure un même nombre de périodes (par exemple 3 ou 6), et ainsi de suite. Le son semble alors monter, assez progressivement. Un exemple de code mettant ce principe en service, est proposé ci-après.

program electronique_pic_tuto_base_son_001d;

var
  i, j, iDelay, iPeriod: integer;

procedure Init;
begin
  CMCON := %00000111;   // comparators OFF
  TRISIO.0 := 0;  // GPIO configuré en sortie
  ANSEL.ANS0 := 0;     // set as analog input
end;

// main program
begin
  Init;
  while true do
  begin
    for iDelay := 1 to 100 do
    begin
      for iPeriod := 0 to 5 do
      begin
        GPIO.0 := GPIO.0 xor 1;
        for j := 0 to iDelay do
          delay_us(1);
      end;
    end;
  end;
end.

Ce code permet la production d'un son dont la fréquence décroit progressivement, puis remonte d'un coup pour redescendre à nouveau. En le modifiant légèrement, on peut obtenir quelques variations sur le thème, voir en exemple le projet Sirène 007.