Tutoriel Arduino : Glockenspiel

Rédigé par lkiefer - - Aucun commentaire

Ce projet est inspiré de «Copper Pipe Glockenspiel». Pour encore plus d'informations, allez voir le manuel «Tubular Bell Chimes - Do It Yourself Handbook». Je vais expliquer ici comment j'ai réalisé un «Glockenspiel» contrôlé par Arduino. En raison de la lenteur des servomoteurs, l'instrument n'est pas parfait, mais fait un très bon TP pour apprendre l'Arduino (on s'en est d'ailleurs servi à Cappel).

J'ai pour ma part utilisé 9 tubes pour 9 notes, mais rien ne vous empêche de mettre davantage de tubes ou de choisir d'autres notes: vous pouvez pour cela afficher le tableau des fréquences en entier, et personnaliser le fichier scad «écarteur» ainsi que le programme

Matériel

Outils

  • Une imprimante 3D
  • Tournevis PZ, clé plate de 10, pince
  • Scie à métaux, coupe tube, touret à meuler, papier à poncer, mètre ruban, perceuse
  • Un ordinateur ou téléphone avec un logiciel accordeur

Déterminer la longueur des tubes

La partie instrumentale se compose principalement de 9 tubes en cuivre, dont il va falloir déterminer la longueur. Pour cela, vous pouvez vous aider du tableau ci-dessous. J'ai pour ma part utilisé du tube Ø22x1, si vous faites de même vous pourrez normalement utiliser les valeurs préréglées.

Pour commencer, coupez un tube de 250mm par exemple. Pour qu'il résonne convenablement, il faut le maintenir à 22.4 % de sa longueur de part et d'autre, par exemple en le posant sur des élastiques : ce sont les valeurs de la dernière colonne, soit 56mm pour notre tube de 250mm.

À l'aide d'un logiciel accordeur, mesurez la fréquence de résonance du tube. J'ai personnellement utilisé l'application fmit qui est disponible dans la logithèque de ma distribution. Une fois l'application lancée, frapper le tube. Le logiciel donne plusieurs indications :
La fréquence en temps réel (1412), le nom de la note qui s'en rapproche le plus (F6), et la fréquence exacte de cette note (1397). Ce qui nous intéresse est la fréquence en temps réel, dont il faut déterminer une moyenne. Maintenant que vous avez une longueur de tube et sa fréquence, vous pouvez renseigner ces valeurs dans le tableau ci-dessous, et vous aurez ainsi les longueurs de tubes que vous devrez découper

Longueur L (mm):
Fréquence f (Hz):
A = f × L2 (mm2/s):
Cocher pour afficher plus de notes:

Théorie

Si vous utilisez les valeurs du tableau, ce paragraphe ne vous sera pas utile: il vous servira uniquement si vous voulez refaire les calculs par vous-même.

La fréquence de résonance de votre tube dépend de son diamètre, son épaisseur, sa matière et sa longueur : la seule valeur sur laquelle vous pourrez influer est cette dernière. Pour déterminer la fréquence de résonance d'un tube, on utilise la formule :

f = A / L2

où f est la fréquence en hertz, A une constante et L la longueur du tube. La constante A peut se calculer en fonction de la géométrie et de la matière du tube, mais c'est assez difficile (voir le manuel pour plus d'informations). Pour simplifier la tâche, on va utiliser une application pour mesurer la fréquence de notre bout de tube, puis calculer A.

À partir de la formule précédente, on peut écrire la relation :
A = f × L2

En remplaçant f par la valeur mesurée, et L par 250, on obtient la valeur de notre constante A. Par exemple :

A=1568 × 2502 = 98 000 000

Maintenant qu'on a A, on peut calculer la longueur de tous nos tubes :

L = √( A / f )

Préparer les tubes

Pour obtenir les différents tubes : couper le tube à sa longueur théorique calculée, en laissant une petite sur-longueur. Placez ensuite le tube sur un support convenable, et vérifiez sa fréquence avec le logiciel. Si la fréquence est trop basse, raccourcissez légèrement le tube et refaites une mesure avec le logiciel, jusqu'à ce que ce soit bon. Procédez ainsi pour chaque tube, en commençant par le tube de 250mm pour ne pas l'oublier.

Montage


Prenez un plateau en bois (dessus) d’à peu près 20cm de coté, et déterminez son centre (tracez les deux diagonales). Tracez un cercle au compas d'à peu près 3cm de rayon, puis centrez la pièce «écarteur» sur ce cercle. Vous vous servirez de cette pièce pour marquer la position des 9 trous sur le plateau, que vous percerez au diamètre 6mm. Percez également le centre du plateau.


Insérez un roulement dans la pièce «palier», et fixez la au centre du plateau à l'aide de quatre vis M3.


Prenez l'autre plateau (dessous). Utilisez la pièce «support » pour y fixer un servomoteur, en plaçant son axe bien au centre du plateau. Le servomoteur devra être monté avec le raccord qui se monte dans la pièce «coupleur».


Prenez la vis M4, et meulez deux cotés de sa tête afin qu'elle rentre dans la pièce «coupleur», et soit bloquée en rotation. Maintenez-la en place avec un écrou et une rondelle. Faites passer la vis à travers le plateau du haut et la pièce «palier», en gardant le roulement M4 du coté extérieur. Sur la vis M4, insérez dans l'ordre un écrou, une rondelle, la pièce «plateau», un écrou, puis serrer le tout.


Terminez le montage avec les trois roulements Ø3, les pièces «bras», «bras2», «marteau» et un servo. Vous pouvez ajouter des écrous aux bouts du marteau.

Attention : Il faut que le bras du servo soit vertical lorsqu'il est positionné à 90°. Pour vérifier cela, vous pouvez envoyer le programme "servo90" sur votre Arduino et y connecter votre servo. Ajustez ensuite le bras en conséquence.


Découpez les tiges filetées à 33cm, puis fixez chaque bout sur le plateau du haut à l'aide de deux écrous et deux rondelles.


Fixez les quatre pieds sur le plateau du bas à l'aide de quatre vis à bois. Mettez en place le plateau du haut, en veillant à ce que la pièce «axe» se positionne correctement sur le servomoteur. Fixez le plateau du haut sur les pieds avec quatre vis.

Il faut maintenant placer les élastiques! Commencez par insérer les élastiques du bas entre les tiges, en commençant par là où sera le tube le plus court. Faites ensuite de même avec les élastiques du haut, en commençant par la même position et en tournant dans le même sens.


Placez maintenant 9 écrous et rondelles sur le haut des tiges filetées, insérez l'«écarteur», puis maintenez le serré avec 9 autres rondelles et écrous.


On place maintenant les tubes entre les élastiques, en s’assurant qu’ils soient maintenus à la position de 22,4 %. Les tubes doivent tous être alignés en bas, sans toucher le plateau, de façon à ce que le marteau puisse les frapper.

Il reste à brancher les servomoteurs. Connectez le fil «data» du servomoteur 1 (celui du bas) sur la pin 9 de votre carte Arduino, et le fil «data» de l'autre servomoteur sur la pin 3. Les fils d'alimentation des servomoteurs devront être reliés à une source d'alimentation 5V dédiée, car leur activation entraîne des pics de consommation trop importants pour les brancher sur la carte Arduino. Il faut impérativement relier ensemble les masses de la carte Arduino et de l'alimentation des servomoteurs, sinon l'Arduino ne pourra pas communiquer avec eux.

Montage électrique

Je vous ai suggéré l'achat de deux chargeurs de téléphone. Un chargeur pourra alimenter la carte Nano par le câble USB, mais le second devra être un peu modifié. Ouvrez-le pour pouvoir y souder deux fils sur les bornes 0 et 5V, afin de pouvoir alimenter les servomoteurs.

Programmation

Téléchargez le sketch et ouvrez le avec l’éditeur Arduino. Avant de le compiler, veillez à ce que la bibliothèque «servo» soit installée dans votre éditeur.

Le programme permet de jouer plusieurs airs à la suite. Voici quelques explications sur son fonctionnement :

Le tableau notes1 contient la position angulaire des 9 tubes (entre 0 et 180°). Pour info, les tubes sont espacés de 40°, on peut dont déduire facilement la position de tous les tubes une fois qu'on a déterminé l'angle du premier tube. On s'arrangera pour que notes1[0] soit la position du plus grand tube (Do).

Le tableau notes2[] sera l'angle de frappe du servo 2. La valeur sera négative ou positive suivant qu'on frappe en avant ou en arrière. Théoriquement, on devrait frapper avec le même angle sur chaque tube, mais suivant la précision du montage, il peut être utile d'ajuster plus finement l'angle pour chaque tube. De la même façon que pour notes1[0], notes2[0] sera l'angle de frappe de la note do.

Le tableau tableautemps[] contient la durée de la note la plus courte pour chaque mélodie (on peut ainsi régler séparément le tempo des mélodies).

Le tableau partition1[] contient dans l'ordre le numéro des notes à jouer (de 0 à 8). Si on souhaite jouer plusieurs mélodies, on peut le faire en ajoutant la note 9 entre les deux mélodies.

Le tableau partition2[] contient la durée de chaque note. La note la plus courte aura pour valeur 1, et les autres notes seront des multiples de cette note. Attention : il faudra ajouter une valeur supplémentaire avant chaque mélodie, afin que lors de la lecture partition1[] et partition2[] soient synchronisés.

Code : glockenspiel.ino

#include <Servo.h>

Servo servo1;         // on crée l'objet servo1
Servo servo2;         // on crée l'objet servo2
int tempsretour=100;  // delay avant retour du marteau, en ms
// Durée de la note la plus courte pour chaque mélodie
int tableautemps[]={500,150,400};
int temps=tableautemps[0];

// Position de chaque tube (de 0 à 180°)
unsigned char notes1[]={ 38,  78, 118, 158, 18, 58, 98, 138, 178};
// Angle de frappe de chaque tube (positif ou négatif suivant le sens de la frappe)
char          notes2[]={-26, -26, -26, -26, 36, 36, 36,  32,  22};

// Ce tableau contient la liste des notes à frapper, dans l'ordre
char partition1[]={    // Vive le vent
                   6,6,6,
                   6,6,6,
                   6,8,4,5,6,
                   7,7,7,7,6,6,
                   6,5,5,6,5,8,
                   6,6,6,
                   6,6,6,
                   6,8,4,5,6,
                   7,7,7,7,6,6,
                   8,8,7,5,4,          

                   9,  // Frère Jacques
                   0 ,1 ,2 ,0 ,
                   0 ,1 ,2 , 0,
                   2, 3, 4,
                   2, 3, 4,
                   4, 5, 4, 3,
                   2, 0,
                   4, 5, 4, 3,
                   2, 0,
                   7, 4, 7,
                   7, 4 ,7,

                   9,  // Ah ! vous dirai-je, maman
                   0,0,
                   4,4,5,5,
                   4,3,3,
                   2,2,1,1,
                   0,4,4,
                   3,3,2,2,
                   2,1,4,4,
                   3,3,2,2,
                   2,1,0,0,
                   4,4,5,5,
                   4,3,3,
                   2,2,1,1,
                   0};

// Ce tableau contient la durée des notes (multiples de "temps")
char partition2[]={1,1,1,2,
                    1,1,2,
                    1,1,1,1,4,
                    1,1,2,
                    1,1,2,
                    1,1,1,1,2,2,
                    1,1,2,
                    1,1,2,
                    1,1,1,1,4,
                    1,1,2,
                    1,1,1,
                    1,1,1,1,4,

                     1,
                     4,4,4,4,
                     4,4,4,4,
                     4,4,8,
                     4,4,8,
                     3,1,2,2,
                     4,4,
                     3,1,2,2,
                     4,4,
                     4,4,8,
                     4,4,8,

                     1,
                     1,1,
                     1,1,1,1,
                     2,1,1,
                     1,1,1,1,
                     2,1,1,
                     1,1,1,1,
                     1,1,1,1,
                     1,1,1,1,
                     1,1,1,1,
                     1,1,1,1,
                     2,1,1,
                     1,1,1,1,
                     2};

void setup() {
  servo1.attach(9);  // Le servo 1 est branché sur la pin 9
  servo2.attach(3);  // Le servo 2 est branché sur la pin 3
  servo2.write(90);
  //servo1.write(118);
  delay(temps);

}

void loop() {
  char musique=0;
  int i = 0;
  while  ( i < sizeof(partition1)) {
    if(partition1[i]==9){
      musique++;
      delay(3000);
      temps=tableautemps[musique];
    }
    else{
      frapper(partition1[i],partition2[i]);
    }
    i++;
  }

  delay(3000);
  musique=0;
  temps=tableautemps[0];
}

void frapper(char note, char duree){
  if (duree==0){
    duree=1;
  }
  servo1.write(notes1[note]);
  delay (duree*temps-tempsretour);
  servo2.write(90+notes2[note]);
  delay(tempsretour);
  servo2.write(90);
}

Code : servo90.ino

#include <Servo.h>
// Ce programme sert à centrer l'axe du servomoteur,
// de façon à monter correctement le bras sur celui-ci

Servo servo1;         // on crée l'objet servo1

void setup() {
  servo1.attach(3);  // Le servo 2 est branché sur la pin 3
  servo1.write(90);
}

void loop() {
}

Améliorations possibles

  • Rehausser le marteau, afin qu'il frappe les tubes en leur milieu
  • Améliorer les fixations des tubes

Images





Classé dans : Arduino - Mots clés : aucun

Écrire un commentaire

Les commentaires sont modérés avant d'être postés. Les commentaires à vocation publicitaire, ou comportant un lien vers un site non personnel, ne seront pas publiés

Quelle est la quatrième lettre du mot nhwpgj ?