Music Air Play
Air Play Music
Auteurs :
– YANG Likuang
– El harem Hicham
– Idlimam Marwan
– KANTE Souleymane Cheick
I- Idée :
Vous vous êtes déjà demandés s’il serait intéressant de jouer de la musique juste avec le mouvement de la main ? Le projet Air Play Music vous apporte la réponse. Avec une grande simplicité, notre solution vous donne la possibilité de faire de musique un peu comme avec piano mais cette fois-ci selon le mouvement de votre main (dans l’air) dans un certain nombre d’endroits de l’espace entourant le dispositif.
II- Principe de fonctionnement :
Le principe de l’appareil repose sur la détection de la main de l’utilisateur et la détermination de la distance à laquelle elle se trouve, après quoi l’appareil joue une note correspondante à cette configuration.
III-Matériel utilisé :
– Des capteurs de proximité (Voir https://www.sparkfun.com/products/8959 ) : Pour pouvoir détecter un présence de même que la distance à la quelle elle se trouve avec un assez bonne précision. Les valeurs récoltées de ce capteur serviront à la prise de décision plus tard ;
– Un Controller Arduino (Voir http://arduino.cc/en/ ) : Pour pouvoir décider du type d’interaction pour tout le système afin de le rendre interactif. Là résidera l’action à proposer en fonction de chaque cas d’utilisation (en fonction des données du capteur) ;
- Un MP3 Shield relié à un haut parleur : Avec une carte mémoire sur la quelle chaque son dont nous auront besoin pour mener à bien le projet sera stocké sous forme de fichier mp3 d’un débit de 32 kbps. Ensuite il servira de support (de bonne qualité) pour émettre un son en particulier.La programmation de cette carte exige l’import de la bibliothèque Sparkfun MP3 Player Shield Arduino Library .
– D’autres matériaux secondaires : tels que des fils de connexion, des BreadBords, une planche pour supporter et stabiliser le dispositif et des leds pour montrer l’activation de l’un des capteurs.
III- Description détaillée du fonctionnement :
Comme expliqué précédemment le produit fonctionnera en trois étapes : récolte d’informations de proximité (par l’un des capteurs), détermination du cas d’utilisation et par conséquent de la note (Au niveau du Controller Arduino) et émission d’une note audible à la demande du Controller par le lecteur MP3.
Le produit développé est composé de 4 détecteurs ayant chacun deux zones de détection : 250 à 300 pour la zone lointaine et au-delà de 300 pour la zone proche.
A l’aide du Controller qui répète une serie d’actions à chaque 100 ms, on déterminera la position du capteur le plus proche de la main de l’utilisateur pour ensuite l’activer au besoin.
IV- Améliorations Possibles :
– Maîtrise du niveau sonore : possibilité d’ajuster le niveau du son (dans le programme Arduino puisque la fonctionnalité existe déjà dans les librairies qui permettent de manipuler le la carte MP3 Shield);
– Proposer plusieurs types d’instrument : proposer d’autres instruments de musique à l’instar du piano ;
– Ajouter une interface : des images qui changent en fonction de l’interaction et donnent un peu plus d’animation ;
LUMIDUINO
Constat et concept
Aujourd’hui, il existe de multiples effets de sons et lumières, pour agrémenter toutes les soirées. Le système réalisé porte le nom de lumiduino, c’est un système très visuel. Il permet d’afficher une luminosité, définie selon l’utilisateur, lors de la présence de sonorités aux alentours du capteur.
Il est composé d’un capteur et d’un néon. Le tout fonctionne par l’utilisation d’un Arduino et d’un code.
Technique
Pour réaliser ce système, j’ai utilisé une carte Aduino, un capteur et enfin un « ring neo-pixel ». J’ai élaboré le code pour me changement de luminosité selon la sonorité.
Perspectives d’améliorations
La synchronisation du changement de couleur peut être améliorée par l’amélioration du code existant. Enfin la création d’un boitier pour contenir le système sera intéressant pour pourvoir transporter le système.
Le code
#include <Adafruit_NeoPixel.h>
#define SOUND_SENSOR A0
#define PIN 6
#define NUMPIXELS 16
Adafruit_NeoPixel pixels = Adafruit_NeoPixel(NUMPIXELS, PIN, NEO_GRB + NEO_KHZ800);
void setup() {
pixels.begin(); // This initializes the NeoPixel library.
Serial.begin(9600);
}
void loop()
{int sensorValue = analogRead(SOUND_SENSOR);//use A0 to read the electrical signal
Serial.print(« sensorValue « );
Serial.println(sensorValue);
If (250 >sensorValue )
{
for(int i=0;i<NUMPIXELS;i++){ // pixels.Color takes RGB values, from 0,0,0 up to 255,255,255
pixels.setPixelColor(i, pixels.Color(0,150,150)); // Moderately bright green color.
pixels.show(); // This sends the updated pixel color to the hardware.
delay(50); // Delay for a period of time (in milliseconds).
}
}
else if ( sensorValue > 250 && sensorValue < 500)
{
for(int i=0;i<NUMPIXELS;i++){ // pixels.Color takes RGB values, from 0,0,0 up to 255,255,255
pixels.setPixelColor(i, pixels.Color(250,100,0)); // Moderately bright green color.
pixels.show(); // This sends the updated pixel color to the hardware.
delay(1); // Delay for a period of time (in milliseconds).
}
}
else if ( sensorValue > 500 && sensorValue < 700)
{
for(int i=0;i<NUMPIXELS;i++){ // pixels.Color takes RGB values, from 0,0,0 up to 255,255,255
pixels.setPixelColor(i, pixels.Color(0,200,0)); // Moderately bright green color.
pixels.show(); // This sends the updated pixel color to the hardware.
delay (5); // Delay for a period of time (in milliseconds).
}
}
else
{
for(int i=0;i<NUMPIXELS;i++) { // pixels.Color takes RGB values, from 0,0,0 up to 255,255,255
pixels.setPixelColor(i, pixels.Color(250,250,250)); // Moderately bright green color.
pixels.show(); // This sends the updated pixel color to the hardware.
delay(1); // Delay for a period of time (in milliseconds).
}
}
delay (100);
}
Photo du système en cours de fonctionnement
Synesthésia
Dans le cadre d’un intersemestre ayant pour thème la « musique ». Nous avons décidé de travailler sur la production de son à partir de la couleur de notre environnement. Bref de réaliser une impression de synesthésie.
Le groupe est composé de membre venant de l’EESAB et de TELECOM Bretagne ( Mathieu BARON , Mélinda BOUKHANA , Sisi CHEN , Xing LI , François NÉRON , Chloé TROUSSIER , Gabriel VAUDOUR ).
Nous avons créé à l’aide de MAX/MSP un programme permettant de déterminer la couleur d’une image et de jouer des notes en fonction de celle-ci. Nous avons aussi créer un tableau présentant une grande palette de couleur. Ainsi chacun pourra se placer devant la caméra et modifier les sons produit en obstruant certaines couleurs et en ajoutant les siennes.
Pour rendre l’ensemble plus visuel, on ajoute des lumières montrants les couleurs majoritaires dans les images qui sont jouées. A la fois sur l’écran de l’ordinateur et sur un ruban de LEDs
Partie Technique
I- Matériel
– logiciel Max/MSP
-une caméra (ici webcam intégrée à un ordinateur portable)
-un arduino
-un ruban à LED
-un câble USB (arduino)
-une capacité 220 μF
-une alimentation extérieur par câble
-fer à souder
-fils
II- Code
Nous nous sommes organisés en plusieurs modules :
-Détermination des couleurs présentes
-Traduction des données couleur en son
-Contrôle des LEDs
a. Détermination des couleurs présentes
Nous avons décidé de découper l’image filmée par la caméra en plusieurs bloc (ici 8) et de faire une moyenne sur ces blocs des coefficient de la coloration RVB (Rouge Vert Bleu). Afin de simplifier et de rendre plus rapide le traitement du flux continu d’image ainsi que d’éviter de nombreux sons trop proche entre eux.
Ensuite nous lisons les blocs de l’image dans un sens prédéterminé et produisons le son associé à chaque coefficient selon un traitement défini ci-dessus.
b. Traduction couleur son
Le mode de traitement des données est tout-à-fait subjectif et arbitraire. On a choisit d’associer chaque couleurs à un instrument puis chaque instrument à une note. Les instruments sont changés de façon aléatoire afin de nous préserver de la monotonie.
c. Contrôle des LEDs
On contrôle le ruban de LEDs avec Arduino
#include <Adafruit_NeoPixel.h>
#define PIN 6
char incomingByte[10];// for incoming serial data
int i = 0;
int red;
int green;
int blue;
Adafruit_NeoPixel strip = Adafruit_NeoPixel(50, PIN, NEO_GRB + NEO_KHZ800);
void setup() {
strip.begin();
strip.show();
Serial.begin(9600); // opens serial port, sets data rate to 9600 bps
}
void loop() {
// send data only when you receive data:
if (Serial.available() > 0) {
// read the incoming byte:
incomingByte[i] = Serial.read();
i ++;
if (i==9){
for (int j = 0; j <9; j++){
Serial.println(incomingByte[j]);
if (j==8){
i=0;
}
}
red = (incomingByte[0]-48)*100+(incomingByte[1]-48)*10+(incomingByte[2]-48);
green = (incomingByte[3]-48)*100+(incomingByte[4]-48)*10+(incomingByte[5]-48);
blue = (incomingByte[6]-48)*100+(incomingByte[7]-48)*10+(incomingByte[8]-48);
Serial.println(« rouge »);
Serial.println(red);
Serial.println(« bleu »);
Serial.println(blue);
Serial.println(« vert »);
Serial.println(green);
colorWipe(strip.Color(red,green, blue), 20);
}
}
}
void colorWipe(uint32_t c, uint8_t wait) {
for(uint16_t i=0; i<strip.numPixels(); i++) {
strip.setPixelColor(i, c);
strip.show();
delay(wait);
}
}
on utilise en parallèle l’écran de l’ordinateur qui affiche la couleur dominante sur chaque blocs.
III- Fabrication
a.Schéma de montage
Montage
branchement ruban/ arduino
On soude ensemble les fils le condensateur et l’alimentation du ruban de LEDs.
Les informations transmises par le logiciel MAX sont celles des 3 coefficients de couleur.
b. Décoration
Pour créer le tableau que nous utiliserons comme support de son, nous avons décider de créer un tableau qui présentera des zones de couleurs différentes. Nous nous sommes inspirés du haut parleur : de sa forme et de sa texture.
La sculpture est composée de carton et d’un grand papier. Elle a été peinte à la bombe. Les photos présentent plusieurs « tapes de sa construction.
Arduino sur FutureMag
Vous voulez découvrir arduino : son origine en Italie, son utilisation en collège ou au sein des fablabs, n’hésitez pas à regarder le reportage proposé par Arte.
Vous y verrez en particulier les activités des petits hackers proposées par la Maison du Libre au sein des Fabriques du Ponant.
Étoiles de Noël
C’est bientôt Noël ! Le moment parfait pour réaliser soi-même une guirlande électrique à mettre dans le sapin. Pour changer un peu des guirlandes électriques que l’on trouve dans le commerce, j’ai décidé de faire un guirlande de grands étoiles translucides, contenant chacune une LED multicolore par branche. Voici un aperçu du résultat en vidéo (en vertical désolé, mais sinon on n’aurait pas vu tout le sapin) :
Dans la vidéo, il n’y a qu’onze étoiles dans le sapin. L’objectif final est une guirlande de vingt étoiles mais le rendu est déjà sympa. Différents modes sont proposés : fixe blanc, changement de couleurs, clignotant blanc, fixe multicolore, scintillement blanc, rotation colorée des branches des étoiles, et flammes rouges et jaunes. Ce ne sont que des exemples, je n’ai pas encore eu beaucoup de temps pour programmer les effets.
Voici quelques photos détaillant la guirlande :
Si vous voulez construire une guirlande du même genre pour Noël, ce n’est pas très compliqué. Il suffit d’un peu de matériel, d’une imprimante 3D et de patience. Je détaille dans la suite comment j’ai fait ma guirlande, et ce que je compte améliorer.
Le matériel
Voici le matériel que j’ai utilisé pour construire cette guirlande :
- du plastique ABS transparent 1,5 mm (environ 500g) ;
- un ruban à LEDs Neopixel d’Adafruit de 2m avec 120 LEDs RGB (multicolores) contrôlables individuellement, PCB blanc ;
- 5m de câble 3G0,75mm noir pour la base de la guirlande ;
- 20m de câble RJ11 noir pour les branches vers les étoiles ;
- un Arduino Nano pour contrôler les LEDs ;
- une alimentation 5V 4A pour alimenter l’Arduino et les LEDs ;
- un gros condensateur pour protéger le ruban et l’Arduino.
Au niveau des outils, il faut une imprimante 3D et un poste de soudure.
L’étoile en plastique
L’étoile est entièrement réalisée à l’imprimante 3D. Le modèle a été dessiné sous OpenSCAD. Il est disponible sur Github, avec les fichiers STL exportés pour l’impression. Le fichier est paramétrable. Il est possible de modifier le nombre de branches ou la taille de l’étoile par exemple.
La pièce à imprimer se décompose en 3 parties, dont 2 identiques. Voici à quoi ça ressemble une fois imprimé :
L’étoile est faite de deux moitiés, qui s’emboitent sur un anneau central. Ceci permet de fermer simplement l’étoile en force. Je n’ai pas mis de colle, même s’il pourrait être utile d’en ajouter pour solidifier le tout. Il y a une encoche en bas de chaque demi-étoile pour laisser passer le fil électrique. Il y a aussi un petit trou en haut de chaque demi-étoile pour accrocher du fil de pêche qui servira à accrocher l’étoile au sapin. La partie circulaire au centre de l’étoile servira de support au ruban à LEDs.
J’ai imprimé toutes les pièces avec un remplissage de 100%. Le rendu visuel est différent avec un remplissage de 0%, plus transparent. Vous pouvez faire des tests.
Pour faire une guirlande complète, il faut imprimer 40 demi-étoiles et 20 anneaux, ce qui peut prendre du temps selon la rapidité de votre imprimante 3D…
Les LEDs et le câblage
La partie électronique dans chaque étoile est extrêmement simple et se compose uniquement d’un bout de ruban à LEDs contenant 5 LEDs. Les dimensions de l’étoile sont faites pour que les LEDs s’alignent toutes seules face à chaque branche de l’étoile. Voici à quoi ressemble l’intérieur d’une étoile : 
La seule chose à faire pour construire l’étoile est de souder sur le ruban le fil qui servira à faire une branche de la guirlande. Ce fil est du fil RJ11. J’ai découpé des morceaux de 70cm pour chaque étoile. L’intérêt du câble RJ11 est qu’il a 4 conducteurs : le noir est la masse, le rouge me sert de 5V, le vert me sert de « data in » et le jaune de « data out ». Le fil de données fait ainsi un aller retour : il arrive par le vert, traverse le ruban, et repart par le jaune. C’est ce qui permettra de contrôler indépendamment toutes les LEDs. Voici le circuit global de la guirlande :
La câble horizontal en bas est le câble 3G0,75mm et les câbles verticaux sont les câbles RJ11. Avec 20 étoiles, il y a 3 mètres de guirlande, avec une branche de 70cm qui part tous les 15 cm. Il est aussi possible d’ajouter 1 mètre de câble en début de guirlande pour éloigner le contrôleur et faciliter la mise en place dans le sapin.
La longueur et la section du câble sont importantes. Plus le câble est long, plus il doit avoir une large section (une faible résistivité) pour que la tension dans l’étoile la plus éloignée reste suffisante. De même, plus il y a d’étoiles, plus l’intensité qui traverse le fil est importante. C’est pourquoi j’utilise des fils très fins pour les branches et un gros câble pour le « tronc » de la guirlande. J’utilise cet outil en ligne pour estimer les sections à utiliser.
Pour souder le câble RJ11 au câble 3G0,75mm tous les 15cm, il suffit de dénuder un petit tronçon (2cm) du cable 3G0,75mm au cutter, puis de dénuder à des endroits différents le fil 5V et le fil de masse. On soude ensuite directement sur les parties dénudées. Il faut ensuite couper le troisième fil (données) et souder le fil vert du câble RJ11 du côté du contrôleur et le fil jaune de l’autre côté. Pour éviter des court-circuits, j’ai mis de la gaine thermo-rétractable sur les fils de données. J’ai ensuite enrobé le tout dans du scotch d’électricien noir pour isoler et cacher les fils.
Une précaution importante à prendre lors de la construction de la guirlande est que l’étoile la plus proche du contrôleur doit être faite d’un bout de ruban pris à un début de ruban. Tous les 50cm sur le ruban, il y a une soudure et une première LED avec une résistance de protection devant le « data in ». C’est une de ces LEDs qui doit être la première connectée au contrôleur.
Le contrôleur
Le contrôleur est simplement un Arduino Nano qui se situe en bout de guirlande (côté « data in »). Il envoie les commandes par le fil bleu vers les LEDs et peut contrôler chaque LED indépendemment.
Le circuit électronique est composé de l’Arduino Nano, d’un condensateur (2 en parallèle en fait) pour protéger l’alimentation, et d’une résistance d’1 MΩ servant de « pull-up » pour un bouton qui fonctionne au toucher. Le bouton sert à changer de mode d’affichage. J’ai soudé les composants sous forme d’un « shield » pour l’Arduino Nano, ce qui m’évite de le souder. Je n’ai pas encore fait de boitier pour le circuit, ni décidé comment je vais faire le bouton, ce qui explique les fils dans le vide :
Le programme est fait sous la forme d’une librairie pour contrôler les étoiles (Stars.h et Stars.cpp) et d’un sketch avec plusieurs modes d’affichage. Il est disponible sur Github et utilise la librairie NeoPixel d’Adafruit (à installer sur votre ordinateur). Les modes actuels sont assez basiques. Je compte les améliorer.
Améliorations
Plusieurs améliorations sont possibles à partir de ce premier jet :
- Faire un joli boitier pour le contrôleur.
- Coller les étoiles pour qu’elles tiennent mieux, ou concevoir un meilleur système de fixation.
- Améliorer les animations de la guirlande. L’Arduino Nano peut être utilisé pour faire des millions d’effets différents. je n’ai pas encore passé assez de temps là-dessus.
- Ajouter des capteurs pour faire réagir la guirlande à son environnement : le bruit, la lumière, la date ou l’heure pourraient faire changer les animations. Tout est possible !
- Ajouter une LED au centre de l’étoile. Je ne suis pas sûr de vouloir faire ça, mais certaines personnes me l’ont suggéré.
À vous !
Cette guirlande n’est pas très compliquée à construire. Il faut juste un peu de patience. Si vous en manquez, vous pouvez aussi construire une seule étoile, qui illuminera votre sapin. Même sans la partie électronique, l’étoile seule peut faire joli dans le sapin, et vous pouvez mettre n’importe quelle sorte de choses dedans.
Si vous faites évoluer l’idée, tenez-moi au courant !
Réorganisation du matériel mercredi 3/12
Ce mercredi 3 décembre, nous allons réorganiser le matériel du Téléfab (classement, recensement, étiquetage) pour le rendre plus facile à trouver et à ranger pour tous les utilisateurs. Ce sera aussi l’occasion d’intégrer le nouveau matériel que nous avons reçu récemment.
Pour que cette opération soit rapide et agréable pour tout le monde, nous avons besoin de main d’œuvre. Participer au rangement vous permettra d’être au courant de tout le matériel disponible, et de montrer votre implication dans le Téléfab. N’hésitez pas à venir !
Nous commencerons à 9h00 et continuerons probablement toute la journée. Même si vous avez des empêchements pendant une partie de la journée, venez quand vous pouvez.
Nouveaux horaires pour le Téléfab
Le Téléfab a de nouveaux horaires cette année :
- Tous les mardis de 18h00 à 20h30 : ouverture assurée par les étudiants : vous pouvez venir et utiliser les machines et le matériel en libre-service, mais vous ne pouvez pas emprunter de matériel.
- Tous les jeudis de 12h à 14h00 : ouverture assurée par les enseignants : vous pouvez utiliser les machines et emprunter du matériel.
À tous les créneaux, des gens seront présents pour vous aider à utiliser les ressources du Téléfab, donc n’hésitez pas à venir !
Des ateliers seront aussi organisés sur le créneau du jeudi : imprimante 3D, Arduino… Consultez les ateliers prévus dans le calendrier.
Le premier créneau aura lieu demain soir.
Inauguration des Fabriques du Ponant
Le 20 septembre, dès 14h, les Fabriques du Ponant ouvrent leurs portes.
C’est l’occasion de venir faire la fête du numérique : des ateliers de découverte, de co-construction d’objets connectés, d’aménagements du lieu vous seront proposés.
Les activités pour les 9-17 « Les Petits Hackers » de la Maison du Libre seront aussi présentées à cette occasion.
N’hésitez pas à venir.
Sonar DIY : Fonctionnement et architecture générale
Un sonar, c’est un dispositif qui se base sur la propagation d’une onde acoustique pour détecter et positionner des objets. Le radar est basé sur le même principe, mais utilise des ondes électromagnétiques. C’est un dispositif qui existe dans la nature : beaucoup d’animaux utilisent un sonar pour se repérer, comme par exemple la chauve-souris ou les dauphins. Dans les sonars artificiels, on distingue les sonars passifs (on écoute seulement les bruits ambiants), et les sonars actifs (on émet un son, puis on écoute le retour du son émis).
Le but n’est pas de faire un cours théorique sur le sonar, mais d’en expliquer grossièrement le fonctionnement et les caractéristiques dans notre cas. Je vais donc m’intéresser uniquement au sonar actif (sous-)marin. Le principe d’un sonar actif est simple : on émet une onde à un instant t connu, puis on mesure l’intensité du signal sonore reçu. Chaque matériau a ses propres caractéristiques de diffraction et de réflexion des ondes sonores, et les éléments présents dans le faisceau d’émission de l’onde sonore vont donc chacun renvoyer une portion plus ou moins grande de l’impulsion vers l’antenne du sonar (en gros, un micro). En mesurant cette puissance du signal reçu en fonction du temps, on peut savoir quels éléments sont présents à quelle distance. En traitant un peu le signal reçu, on peut aussi obtenir d’autres informations, comme par exemple la vitesse de l’élément qui renvoie (avec l’effet Doppler). Un dispositif sonar doit donc être capable d’émettre et de recevoir une onde sonore, et de traiter cette onde.
Un sonar est donc constitué de trois éléments principaux :
- une antenne, qui peut être soit émettrice (comme un haut parleur), soit réceptrice (un micro), soit les deux ;
- un dispositif électronique de réception et d’émission,
- un dispositif de traitement des données et d’affichage.
Je passe sur la partie électronique et traitement de données, qui ne présentent que peu de particularités. C’est un élément standard de toute chaine de transmission, et le sonar ne déroge donc pas à cette règle. Ca ne rend pas ces parties faciles à réaliser cependant, comme on le verra lors de la réalisation ! Je vais détailler dans la suite les caractéristiques de l’antenne.
Lorsqu’on émet une impulsion sonore, on va insonifier (c’est à dire « éclairer » mais avec une onde sonore au lieu de lumière) une zone. La zone insonifiée dépend de facteurs géométriques (forme du faisceau sonore émis), du milieu (vitesse de propagation du son, atténuation) et de facteurs temporels (en particulier, la durée de l’impulsion). Commençons par les contraintes : le milieu. L’eau de mer est un milieu hétérogène, mais l’équation de MacKenzie permet d’obtenir une approximation suffisante pour nos besoins. Vous trouverez un calculateur ici : http://resource.npl.co.uk/acoustics/techguides/soundseawater/. Dans les eaux brestoises, au mois de septembre, on peut tabler sur une température de 18°C en surface, et de 14/15°C à 30m de fond. Si on fait une approximation à 16°C, avec une salinité de 35, et une profondeur (très rarement atteinte !) de 50m, on obtient environ 1510m/s. La température est la variable qui influe le plus sur cette vitesse. Concernant l’atténuation de l’onde dans le milieu, on reste dans du classique : plus la fréquence de l’onde est faible, moins il y a d’atténuation. Par contre, d’après les règles de la diffraction, la pouvoir de résolution d’un sonar est de l’ordre de la longueur d’onde utilisée. Ainsi, plus on diminue la fréquence, plus la résolution diminue. Si on cherchait à trouver des poissons solitaires, ou si on travaillait dans la guerre numérique et la chasse aux mines sous-marines, il nous faudrait une résolution très faible, et on chercherait donc à avoir une fréquence élevée. Cependant, ce n’est pas du tout l’objectif. De plus, comme on le verra, la réalisation d’une antenne sonar est relativement complexe sans les moyens adéquats, et notre antenne sera donc forcément un peu limitée. On va donc chercher à minimiser l’atténuation plutot que de travailler sur la résolution. Ceci a également l’avantage de nous faire travailler sur des fréquences faibles (< 100kHz), plus faciles à manipuler en électronique. En l’occurrence, on choisira une fréquence de l’ordre de 25kHz pour des raisons pratiques que je détaillerai dans une partie suivante.
Maintenant qu’on a nos contraintes, voyons sur quoi on peut influer. On se place dans le cas idéal, dans lequel on peut réaliser n’importe quelle antenne. La forme géométrique du faisceau sonore est l’élément crucial lors de la conception de l’antenne. Il existe différentes configurations d’utilisation d’un sonar. Par exemple, un sondeur bathymétrique est en fait un sonar, qui envoie une onde sonore étroite directement vers le fond, et qui compte le temps nécessaire pour le retour, ce qui donne la profondeur. Il faut une onde étroite, afin d’éviter d’avoir trop de reliefs à l’intérieur de la zone insonifiée, mais cette contrainte n’est pas forte. Une faisceau en cône est tout à fait satisfaisant.
Il existe d’autres types de systèmes sonars. Par exemple, on peut positionner plusieurs antennes fixes sur des bouées dans une zone que l’on veut couvrir. Puis, on émet un (ou plusieurs) bruit(s) depuis un endroit connu, et on traite les données reçues sur chacune des antennes pour « cartographier » la zone. Dans ce cas, il n’y a que des antennes de réception, qui peuvent avoir un angle d’ouverture très large. Dans notre cas, un tel système est trop complexe à mettre en œuvre, mais il est pratique pour des systèmes de détection destinés à rester en place. Dans un système plus portable, le problème est de couvrir une large zone. On va donc utiliser un bateau qui déplacera l’antenne. En répétant des mesures le long du déplacement, on pourra également cartographier une zone sans avoir besoin de plusieurs antennes de réception. Dans ce cas, la zone insonifiée doit être la plus grande possible, mais également la plus fine possible. En effet, si le faisceau est trop large, on saura qu’il y a un objet à une distance connue, mais cet objet sera sur un arc de cercle, on ne pourra pas le positionner en deux dimensions. Par contre, il faut balayer une grande largeur autour du sonar. Un faisceau en cône ne convient donc pas, il va falloir une forme de pyramide très large sur le côté perpendiculaire au déplacement (altitude), et très étroit sur l’autre côté (azimut).
Afin de se débarrasser des problèmes liés aux mouvements du bateau et à la thermocline (changement brutal de température, qui réfléchit les ondes sonores), on va utiliser un sonar à balayage latéral (side scan sonar). Un tel sonar utilise un engin tracté (« towfish ») que j’appellerai poisson ou poisson tracté par la suite. L’antenne est installée sur le poisson, qui est tracté sous l’eau par le bateau. Le long du cable de tractage, on fait également passer les données reçues. Il est également possible de refaire ce travail sur un sonar embarqué sur le bateau.
Image issue de Wikipedia
Un schéma d’un sonar à balayage latéral est présenté dans l’image précédente, issue de Wikipedia. L’antenne est sur le poisson. Le faisceau idéal pour un transducteur de ce type est un faisceau rectangulaire. L’angle d’azimuth est très étroit (idéalement, 1° ou moins), et l’angle de l’altitude est large, idéalement 30° de chaque côté dans des eaux peu profondes. On trouve des antennes performantes à un prix abordable chez Garmin ou Humminbird, cependant les spécifications ne sont pas disponibles et ces antennes ne fonctionnent qu’avec l’électronique associée. On va donc construire notre propre antenne (ou transducteur).
Etant donnée la solution adoptée, il y a quatre grosses parties à concevoir et construire pour le sonar :
- le transducteur (et son poisson)
- la partie électronique de transmission, qui sera principalement analogique
- la partie traitement du signal
- l’affichage et le stockage des résultats du sonar
Les deux dernières parties seront numériques, il faudra donc aussi réaliser une interface analogique/numérique. Dans le prochain article, je commencerai à présenter la solution utilisée pour l’antenne.
Globe à persistance rétinienne
Le globe à persistance rétinienne consiste à donner l’impression d’un globe de LEDs sur lequel on peut afficher des images, en faisant simplement tourner à grande vitesse un demi-cercle sur lequel sont fixées des LEDs RGB. En allumant les LEDs exactement aux bons instants, on peut produire n’importe quelle image. Voici quelques exemples :
Ce globe est le résultat du travail d’une succession de personnes au Téléfab. Un premier projet S2 (CHAIEB Hassen, EL AABOUDI Khalid, RAYNAL Damien et TELLAT Wael, étudiants en première année) a permis de construire la structure du globe ainsi que les premières version des logiciels de contrôle et d’obtenir le premier prototype fonctionnel. Un projet d’intersemestre (Boris Claverie et Rémy Bétus, étudiants en troisième année) a permis de travailler sur la conception du contact électrique entre les parties fixes et tournantes et sur la synchronisation de l’image par rapport à la vitesse du moteur. Enfin, divers intervenants du Téléfab (Benoit Larras, Pierre-Henri Horrein et Tristan Groléat) ont travaillé sur la fiabilisation générale du globe (structure, électronique, logiciel). Cet article mis à jour régulièrement présente le fonctionnement du globe dans son état actuel, ainsi que les leçons apprises des tentatives précédentes.
Voici le globe à l’arrêt :
Il est composé de plusieurs parties importantes :
- la partie fixe qui permet la stabilité du système, avec un moteur à courant continu qui fait tourner le globe ;
- la partie tournante avec les LEDs contrôlées par un Arduino Mega ;
- l’interface entre la partie fixe et tournante, qui permet à la partie tournante de recevoir de l’énergie et des ordres, et de détecter sa vitesse de rotation ;
- la carte électronique de contrôle, fixe, qui fournit une alimentation à différents niveaux de tension, contrôle le moteur, et facilite la communication entre les parties fixes et tournantes ;
- le logiciel embarqué, qui contrôle le tout ;
- les logiciels de support, qui permettent de travailler avec le globe.
Le code et les objets 3D utilisés pour la conception du globe sont disponibles sur Github.
La partie fixe
La partie fixe est composée d’une planche de contreplaqué sur laquelle sont fixés quatre mâts faits de profilés d’acier en cornière. Ces mâts sont rejoints en haut par des profilés plats en acier qui se rejoignent au centre. À cet endroit, un trou est percé. L’axe de la partie tournante est une tige filetée. En haut, une tige lisse graissée est vissée sur la tige fileté. C’est ce qui sert à maintenir la tige.
Le bas de la tige est fixé au moteur à courant continu fixé au centre de la planche de contreplaqué. Il s’agit d’un moteur récupéré qui provient apparemment d’un essuie-glace.
Cette structure remplace la précédente qui était faite en bois, avec un seul mât. Elle est beaucoup plus rigide que la précédente, ce qui permet de parer en partie au balancement dû à un mauvais équilibrage de la partie tournante.
La partie tournante
La structure de la partie tournante est un anneau en plastique. Cette anneau est traversé par une tige filetée servant d’axe. Des trous sont percés sur l’anneau pour laisser passer 39 LEDs RGB réparties uniformément en un demi-cercle. Chaque LED est connectée directement à l’Arduino MEGA accroché sur l’axe au centre de l’anneau. Pour faciliter les connexions, un shield a été créé pour l’Arduino avec une plaque de prototype.
Pour diminuer les connexions, les cathodes des LEDs sont reliées. Ainsi, toutes les cathodes « rouge » sont reliées à un pin de l’Arduino, de même pour les cathodes « vert » et « bleu ». L’anode de chaque LED est connectée à un pin différent de l’Arduino. De cette manière pour contrôler 39 LEDs, il faut 39 + 3 = 42 pins. Cela signifie qu’à un instant donné, toutes les LEDs allumées ont la même couleur. Pour afficher des images, il faut donc allumer très rapidement chaque LED l’une après l’autre.
Cette partie est celle qui a été la moins modifiée depuis le début. La seule nouveauté est le remplacement des serre-joints utilisés pour fixer l’Arduino par des pièces faites à l’imprimante 3D, disponibles sur Github dans le dossier Things (ficher OpenSCAD ou STL arduino_holder).
L’interface fixe/tournant
Contact électrique
L’interface entre les parties fixes et tournantes est une partie cruciale du globe. Elle sert avant tout à alimenter en énergie la partie tournante. Pour cela, deux contacts doivent être faits : la masse, et un 9V qui permet d’alimenter l’Arduino Mega par le pin Vin. Un composant appelé collecteur tournant est disponible dans le commerce pour réaliser des contacts électriques tournants. Mais celui utilisé est fait maison à l’imprimante 3D. Les plans sont sur Github dans le dossier Things. (fichier OpenSCAD connection-base, les fichiers STL sont aussi disponibles).
Le principe est simple : deux larges rondelles sont utilisées comme contacts tournants. Elles sont fixées à la partie tournante par des pièce réalisées à l’imprimante 3D (une base, un séparateur pour éviter le contact entre les deux rondelles, et des petites cales pour tenir le tout fixé). Des fils électriques passent par l’intérieur de la base et sont soudés aux rondelles. Sur la partie fixe, deux petites vis poussées par des ressorts appuient sur les rondelles. Elles sont visibles à gauche sur la photo. Elles sont maintenues par une pièce faite à l’imprimante 3D, et sont chacune soudées à un fil électrique arrivant par derrière.
Ce mécanisme permet d’alimenter l’Arduino MEGA sans avoir de problèmes de fils qui s’emmêlent. Le défaut est que cela crée des frottements et du bruit. Mais le contact est fiable. Pour s’assurer que l’Arduino fonctionne sans problème en rotation, une grosse capacité a été placée sur la partie tournante en parallèle de l’alimentation de l’Arduino. Elle agit comme une mini batterie en cas de coupure de très courte durée.
Ce contact électrique a été une source majeure de difficultés dans la conception de ce globe. Différentes solutions ont été tentées : enrouler du fil de fer sur la partie tournante et tendre un fil entre deux bouts de bois pour appuyer sur la partie tournante, coller du scotch cuivré sur la partie tournante et tendre des bandes de cuivre avec une pièce faite à l’imprimante 3D, utiliser une prise jack en faisant tourner la partie mâle dans la partie femelle. Toutes ces solutions ont marché pendant un temps, mais se sont vite usées et ont cessé de fonctionner. La solution actuelle a duré beaucoup plus longtemps que ces solutions.
Détection de la vitesse de rotation
Une fonction annexe de l’interface fixe/tournant est de permettre à l’Arduino MEGA de détecter un point fixe lors de la rotation, pour avoir une référence et permettre d’afficher une image fixe. Ceci est réalisé grâce à une LED cachée dans le petit cube noir visible à droite sur la photo précédente. La LED est constamment allumée et fixe. Dans la partie tournante, en face de la LED, se trouve une photorésistance (fils violets qui arrivent en haut de la photo). Quand la photorésistance passe devant la LED, elle détecte la lumière. La photorésistance est directement connectée à l’Arduino MEGA, avec un montage pull-down, qui fait que la valeur 0 est lue constamment, sauf quand la photorésistance est devant la LED. Dans ce cas, la valeur 1 est lue par l’Arduino.
Au début, nous utilisions un montage pull-up, la photorésistance lisait un 1 constamment et un 0 en passant devant la LED. Mais nous avons remarqué que ce montage était beaucoup plus sensible au bruit provoqué par l’alimentation instable, provoquant des fausses détections difficiles à ignorer côté logiciel.
La carte électronique de contrôle
Alimentation
L’objectif principal de cette carte est d’alimenter l’Arduino et le moteur. Elle reçoit en entrée du 12V (ou un peu plus) fourni par un vieux transformateur récupéré. Pour alimenter l’Arduino, elle contient un simple régulateur 9V.
L’alimentation du moteur est un peu plus complexe car nous voulons pouvoir contrôler sa vitesse. Cela permet de le ralentir pour montrer aux gens le fonctionnement de la persistance rétinienne. Pour cela, nous utilisons un potentiomètre visible en bas à droite sur la photo. Mais le moteur demande beaucoup de puissance, il n’est donc pas possible de le mettre simplement en série avec le potentiomètre. La meilleure manière de contrôler un moteur à courant continu est d’utiliser des PWM, c’est à dire un signal carré alternant rapidement entre la tension maximale (les 12V reçus en entrée) et 0. Selon le rapport cyclique entre la durée à 12V et la durée à 0v, la vitesse du moteur change. Pour générer ces PWMs à rapport cyclique variable en fonction de la valeur d’un potentiomètre, nous avons utilisé un montage à partir du composant NE 555 trouvé sur instructables. Le montage décrit dans l’article est exactement celui réalisé ici. Les valeurs de résistance sont adaptées pour aller avec la valeur du potentiomètre, selon la formule indiquée dans l’article. Les PWMs générées ne supportent pas assez de puissance pour contrôler le moteur. C’est pourquoi elles sont utilisées comme signal de contrôle pour un transistor MOSFET, qui contrôle le moteur, suivant le montage décrit dans la partie « Simple Power MOSFET Motor Controller » de cet article.
Dans sa première version, le globe n’avait aucune carte de contrôle. Une alimentation réglable à deux sorties était donc nécessaire pour le faire fonctionner, ce qui était encombrant. Dans une version suivante, une alimentation de PC a été récupérée, et la vitesse du moteur était contrôlée par un gros potentiomètre en série avec le moteur. Ce système fonctionnait mais toute la puissance non utilisée par le moteur était dissipée par le potentiomètre, qui chauffait beaucoup et risquait de brûler l’utilisateur. La version actuelle est plus compacte et ne chauffe quasiment pas.
Communication avec la partie tournante
Envoyer des informations à la partie tournante sans l’arrêter permet d’apporter de l’interactivité au globe. Pour ce faire, un bus de communication entre la partie fixe et la partie tournante est nécessaire. Mais nous ne disposons que de deux conducteurs entre la partie fixe et mobile : la masse et le 9V. Pour ne pas compliquer la mécanique, l’alimentation peut être modulée par un Arduino fixe pour envoyer des informations à l’Arduino MEGA tournant. Pour ceci, il modifie la masse en la passant à 5V pendant de très courts instants, ce qui crée des impulsions. Le délai entre les impulsions permet de coder des 1 et des 0, et donc d’envoyer des messages binaires.
Le mécanisme pour créer ces impulsions sur le fil de masse est intégré à la carte. Il est visible sur la partie gauche de la photo et détaillé sur le schéma ci-dessus. La sortie GND_MOD peut être utilisée à la place de la vraie masse pour alimenter la partie tournante. Un condensateur branché en parallèle sur l’alimentation de l’Arduino évite qu’il ne soit perturbé par les impulsions. Ce condensateur est isolé du PIN de lecture (3) par une diode pour rendre les impulsions visibles par le PIN 3. L’entrée CTRL est un signal géré par l’Arduino externe. Quand cette entrée passe à 0, GND_MOD passe à 5V à cause du transistor (un MOSFET N) par l’intermédiaire d’une résistance de pull-up d’1kΩ. Sinon GND_MOD reste à la masse. Si aucun fil n’est connecté à CTRL, GND_MOD reste à la masse grâce à la résistance de pull-up de 10kΩ sur CTRL. L’Arduino de contrôle externe est donc facultatif.
Le circuit qui permet de générer les impulsions a été fait « au feeling », en s’inspirant du système de communication 1-wire. Des retours d’experts pour améliorer le circuit seraient les bienvenus. Mais pour le moment, ce circuit fonctionne bien.
Le logiciel embarqué
Le logiciel embarqué est en une librairie qui gère l’affichage et la communication, et des exemples d’utilisation. Tout le code est sur Github dans le dossier « Globe ».
Librairie : l’affichage
L’affichage est géré par la classe singleton Globe. Cette classe fournit une méthode d’initialisation (begin), à partir de son appel, l’affichage sur le globe est géré par l’Arduino. La classe fournit aussi des méthodes de dessin (setLed, getLed, rotate, setLedRot, getLedRot) qui permettent de modifier l’image affichée sur le globe. Les changements sont visibles dés le prochain rafraichissement de l’image. Enfin, la librairie contient des méthodes de synchronisation (delayRound, passedRound) qui permettent de synchroniser le déroulement du programme par rapport à la vitesse de rotation.
Le fonctionnement de la librairie est entièrement basé sur des interruptions : les interruptions du capteur de tour permettent de mesurer la vitesse de rotation et de commencer l’affichage ; les interruptions d’un timer permettent d’allumer les LEDs les unes après les autres. L’exécution de la librairies est critique et les interruptions ne doivent pas être inhibées. La librairie utilise une part non négligeable du temps du processeur, qui augmente avec la vitesse de rotation.
L’affichage de l’image se fait colonne par colonne et LED par LED. Une seule LED est allumée à un instant donné. Chacune des trois couleurs est gérée en binaire (allumée ou éteinte), ceci à cause du faible nombre de sorties analogiques de l’Arduino. Il serait possible d’afficher les colonnes couleur par couleur (rouge puis vert puis bleu) au lieu de LED par LED pour aller plus vite. Cette alternative a été tentée, mais elle nuit au mélange des couleurs.
Librairie : la communication
La communication entre la partie fixe et tournante ne fonctionne que dans un seul sens : l’Arduino fixe envoie des ordres à l’Arduino MEGA tournant. L’Arduino fixe est donc le maître et l’Arduino tournant est l’esclave. La librairie est donc divisée en deux classes : BusMaster et BusSlave. Elles ont toutes les deux une méthode d’initialisation (begin). Ensuite la classe maître a une méthode send et la classe esclave a des méthodes available, read et readString pour savoir si un message est disponible, lire un octet du message, ou lire une chaine entière.
La communication fonctionne par impulsions. Il y a 3 symboles : 0, 1, et fin qui correspondent à des délais différents entre deux impulsions. Chaque octet est envoyé suivi de 2 bits permettant de numéroter l’octet, d’un bit de parité, et d’un symbole fin. Chaque octet est envoyé à 3 reprises. Cette redondance est ajoutée pour fiabiliser la communication. Deux facteurs rendent la communication complexe : le bruit dû au contact tournant et l’imprécision de mesure due au fait que l’Arduino esclave s’occupe déjà de l’affichage, ce qui l’empêche de mesurer les délais avec précision. Le second facteur est au moins aussi important que le premier.
Du côté maitre, les messages sont envoyés de manière bloquante en utilisant la fonction Arduino delay. Du côté esclave, les mesures sont faites à l’aide d’interruptions et de deux timers. Nous avons essayé d’utiliser un ICP (Input Capture Pin) de l’ATMega pour rendre les mesures plus précises (le timer est déclenché automatiquement par les interruptions) mais les interruptions ICP ont une priorité trop forte qui ne peut pas être réglée, ce qui empêche le fonctionnement de l’affichage du globe.
Les exemples
Différents exemples sont disponibles avec la librairie : une carte du monde qui tourne sur lui-même, un texte qui défile et un bonhomme qui court à contre-sens du globe. Deux exemples interactifs sont aussi disponibles : la possibilité d’afficher le texte qu’on veut en l’envoyant sur le port série de l’Arduino fixe, ainsi qu’un jeu de Snake pouvant se jouer à 2. Pour ce dernier jeu, des joysticks doivent être connectés à l’Arduino fixe.
Les logiciels de support
Certains logiciels ne servent pas directement à faire fonctionner le globe, mais sont utiles pour le programmer. C’est le cas par exemple du programme ImageConverter disponible sur Github. Il a été développé en Java par les premiers étudiants qui ont travaillé sur le globe. Il permet de prendre une image, de diminuer sa résolution, de convertir ses couleurs, et de générer un format qui permet d’intégrer l’image dans du code pour l’afficher le globe. C’est ainsi qu’a été fait le programme avec la carte du monde qui tourne.
