Le projet d’aujourd’hui consiste, comme le  titre de l’article l’indique, en la réalisation d’une pédale égaliseur graphique à base d’Arduino. Dans ce qui va suivre, je vais vous expliquer comment utiliser le MSGEQ7 (un égaliseur 7 bandes), afficher le résultat sur un écran LCD et, cerise sur le gâteau, comment faire votre propre shield Arduino maison.

Etape 1: le MSGEQ7.

Je rentre direct dans le vif du sujet, je vais vous montrer comment fonctionne ce merveilleux petit circuit. Tout d’abord, où le trouver. Si vous résidez en France, je vous conseille hobbyelectro de l’ami Furrtek. Rapide et pas cher. Sinon, le MSGEQ7 est aussi dispo chez Sparkfun (trois fois plus cher, mais bon…).

Une fois que vous avez votre puce en main, il suffit de chercher la datasheet pour trouver le pinout:

mais aussi et surtout le schéma de câblage:

Bon, ça fait peur comme ça, mais en cherchant un peu sur le net j’ai trouvé une version plus facile à comprendre:

J’ai utilisé ce schéma que j’ai câblé sur une breadboard, et ça donne ça:

Les plus tâtillons d’entre vous aurons remarqué que j’ai utilisé 3 condos de 100pf en série pour faire un condo de 33pf, de même que deux résistances de 100kohms pour faire une de 200. J’ai beau avoir des milliers de résistances, j’en ai pas une seule de 200kohms…

Maintenant, la partie logicielle…

Etape 2: le code

Nous avons 3 pins à utiliser:

• STROBE, connectée à la pin Digital 2 sur l’arduino,
• RESET, connectée à la pin Digital 3,
• OUT, connectée à la pin Analog 0.

Vous pouvez utiliser les pins que vous voulez, le MSGEQ7 n’utilise pas d’interrupt, pas d’I2C, pas de SPI, rien de spécial. Chaque patte a une utilisation particulière, comme l’explique le chronogramme de la datasheet:

Là vous vous dites: “ohlàlà, mais qu’est-ce qu’il nous gonfle avec tous ces détails?”…le MSGEQ7 est une puce relativement simple à comprendre, autant se pencher un peu sur la théorie!

Ce que nous dit ce chronogramme:

1. la puce crache les valeurs de chaque fréquence (il y en a 7 différentes, d’où le “7″ de “MSGEQ7″) sur OUT.
2. pour cela, il faut effectuer un reset de la puce avant chaque lecture. pour cela, il faut passer la patte RESET à haut puis à bas.
3. ensuite, il faut passer la pin STROBE à bas
4. attendre 36 microsecondes, que la puce crache la valeur sur OUT
5. passer STROBE à haut.
6. recommencer à l’étape 3

En termes d’arduino, voici ce que cela donne:

const int ANALOG = 0;
const int STROBE = 4;
const int RESET = 5;
int outputValues[7];

void setup(void) {
  //setup MSGEQ7
  pinMode(ANALOG, INPUT);
  pinMode(STROBE, OUTPUT);
  pinMode(RESET, OUTPUT);

  analogReference(DEFAULT);

  digitalWrite(RESET, LOW);
  digitalWrite(STROBE, HIGH);

}

void loop(void) {
  //reset chip
  digitalWrite(RESET, HIGH);
  digitalWrite(RESET, LOW);

  for (int i = 0; i < 7; i++) {
    digitalWrite(STROBE, LOW);
    delayMicroseconds(30);
    outputValues[i] = analogRead(ANALOG);
    digitalWrite(STROBE, HIGH);
  }
}

Ok, c’est bien tout ça, mais comme savoir si ça fonctionne? Simple: ajoutez un Serial.begin(9600) dans le setup et quelques Serial.print dans le loop pour afficher les valeurs sur le serial monitor et hop, c’est gagné! Et là vous vous rendrez certainement compte que le MSGEQ7 est une véritable perle: donnez lui du son et il fera le reste! Je l’ai utilisé avec une basse possédant un gros niveau de sortie et avec la carte son de mon iMac, il réagit aussi bien avec l’un qu’avec l’autre. Bon maintenant, il s’agirait peut-être d’afficher les valeurs autrement, non?

Etape 3: l’écran LCD

Les écrans LCD pour arduino, c’est pas ce qu’il y a de plus difficile à trouver. On en trouve une tétrachiée chez Sparkfun par exemple…mais si on veut quelque chose de sympa et pas cher, il faut creuser un peu plus. En ce qui me concerne, eBay m’a encore une fois sauvé la vie.

Petit aparté.

Je tiens à remercier du fond du coeur nos amis les chinois sans qui ce qui va suivre aurait couté un bras, un oeil et un rein. Merci à tous les chinois qui vendent des trucs complètement dingues sur eBay à des prix ahurissants, le tout avec frais de ports offerts. Je vous aime les mecs, sincèrement.

Voilà, tout ça pour dire que j’ai déniché sur eBay cette petite perle:

Les specs: 128*64 pixels bleus, rétro éclairé, le tout pour 7€, alors qu’un modèle équivalent peut valoir jusqu’à 30$ chez adafruit ou sparkfun.  Mais le top, c’est qu’il est utilisable en mode parallèle et en série! Là tout de suite, c’est beaucoup plus intéressant! En parallèle on a facilement besoin de 15 pins, et donc d’un arduino Mega…En mode série, 8 pins suffisent!

Le câblage est le suivant pour un arduino uno ou équivalent:

• pin 10 (SS) vers RS
• pin 11 (MOSI) vers R/W
• pin 12 (MISO) vers E
• +5V vers VDD et BLA (BLA c’est l’anode du rétro éclairage)
• GND vers VSS, PSB (PSB à 0 = mode série) et BLK (cathode du rétro éclairage).

Simple, non? Ben non, parce que la partie logicielle se corse un peu. Pour afficher quoi que ce soit sur ce LCD, vous aurez besoin d’une librairie, dispo ici: http://code.google.com/p/u8glib/ . Autre astuce: pour cet écran, le constructeur à utiliser est “U8GLIB_ST7920_128X64 u8g(12, 11, 10, U8G_PIN_NONE);”. Pour le reste, à savoir comment dessiner sur l’écran, regardez la doc de la librairie. En attendant, voici le code de l’égaliseur:

#include "U8glib.h"

U8GLIB_ST7920_128X64 u8g(12, 11, 10, U8G_PIN_NONE);

const int ANALOG = 0;
const int STROBE = 4;
const int RESET = 5;
const int outputValues[7];

void drawMediumBars(void) {
  for (int i = 0; i < 7; i++) {
    u8g.drawBox(5+18*i, 64-(outputValues[i]/16), 10, outputValues[i]/16);
  }
}

void setup(void) {
  //setup MSGEQ7
  pinMode(ANALOG, INPUT);
  pinMode(STROBE, OUTPUT);
  pinMode(RESET, OUTPUT);
  analogReference(DEFAULT);
  digitalWrite(RESET, LOW);
  digitalWrite(STROBE, HIGH);
}

void loop(void) {
  u8g.firstPage();  
  do {
    //reset chip
    digitalWrite(RESET, HIGH);
    digitalWrite(RESET, LOW);

    for (int i = 0; i < 7; i++) {
      digitalWrite(STROBE, LOW);
      delayMicroseconds(30); // to allow the output to settle
      outputValues[i] = analogRead(ANALOG);
      digitalWrite(STROBE, HIGH);
    }

    //draw values
    drawMediumBars();
  } while(u8g.nextPage());
}

Avec ça, vous devriez afficher de jolies barres sur l’écran, quelque chose de ce style:

Sympa, non? Mais bon, un seul design, ca craint, si seulement on pouvait en changer à la volée…

Etape 4: les boutons et les interruptions

Tout d’abord, kesséssé une interruption? C’est tout simplement un bout de code qui est lié à une évènement matériel: le passage d’une pin de l’état haut à l’état bas par exemple. Quand l’évènement se déclenche, le code est exécuté. Le but de ce qui va suivre est de modifier la routine qui dessine les barres grâce à une interruption.

Voici le code avec les modifications:

#include "U8glib.h"

U8GLIB_ST7920_128X64 u8g(12, 11, 10, U8G_PIN_NONE);

const int ANALOG = 0;
const int STROBE = 4;
const int RESET = 5;
int outputValues[7];

const int BT1 = 0;
const int DEBOUNCE_DELAY = 200;

uint8_t mode = 0;
uint8_t nModes = 3;

void drawJointFatBars(void) {
  for (int i = 0; i < 7; i++) {
    u8g.drawBox(1+18*i, 64-(outputValues[i]/16), 18, outputValues[i]/16);
  }
}

void drawMediumBars(void) {
  for (int i = 0; i < 7; i++) {
    u8g.drawBox(5+18*i, 64-(outputValues[i]/16), 10, outputValues[i]/16);
  }
}

void drawTopLine(void) {
  for (int i = 0; i < 6; i++) {
    u8g.drawLine(10+18*i, 64-(outputValues[i]/16), 10+18*(i+1), 64-(outputValues[i+1]/16));
  }
}

void setup(void) {
  //setup MSGEQ7
  pinMode(ANALOG, INPUT);
  pinMode(STROBE, OUTPUT);
  pinMode(RESET, OUTPUT);
  analogReference(DEFAULT);
  digitalWrite(RESET, LOW);
  digitalWrite(STROBE, HIGH);

  //change mode button
  attachInterrupt(BT1, button1, FALLING);
}

void loop(void) {
  u8g.firstPage();  
  do {
    //reset chip
    digitalWrite(RESET, HIGH);
    digitalWrite(RESET, LOW);

    for (int i = 0; i < 7; i++) {
      digitalWrite(STROBE, LOW);
      delayMicroseconds(30); // to allow the output to settle
      outputValues[i] = analogRead(ANALOG);
      digitalWrite(STROBE, HIGH);
    }

    //draw values
    if (mode == 0) drawJointFatBars();
    else if (mode == 1) drawMediumBars();
    else if (mode == 2) drawTopLine();

  } while(u8g.nextPage());
}

void button1() {
  static unsigned long last_interrupt_time = 0;
  unsigned long interrupt_time = millis();
  // If interrupts come faster than 200ms, assume it's a bounce and ignore
  if (interrupt_time - last_interrupt_time > DEBOUNCE_DELAY) {
    last_interrupt_time = interrupt_time;

    //interrupt code
    if (mode == (nModes-1)) mode = 0;
    else mode++;

  }
}

La fonction “attachInterupt” relie une fonction (ici button1) à  un évènement (FALLING = passage de l’état haut à l’état bas) sur une interruption donnée (ici l’interruption 0, laquelle correspond à la pin DIGITAL 2).

En ce qui concerne le corps de la fonction button1, j’utilise une variable pour mesurer le temps entre deux appels à la fonction. Pourquoi? Parce que les boutons poussoirs ne sont pas parfaits et peuvent déclencher deux fois l’interruption lors d’un seul appui, faute à la mécanique. En ce qui me concerne, le délai minimum entre deux appuis est de 200ms.

Pour câbler l’interruption, voici le schéma:

Simple, non?

Au final, vous devez obtenir ceci:

Etape 5: transformer un prototype en shield

Quelle satisfaction de transformer un projet qui fonctionne en un produit fini! Et là, on a un montage qui ne demande qu’à être transformé en shield arduino. Pour les shields vierges, allez donc faire un tour chez l’ami semageek.

Un seul conseil: placez vos composants, soudez une fois que vous êtes sûrs. Voici à quoi ressemble le mien:

Etape 6: la mise en boîte.

Pour mettre ma pédale en boite, je voulais un boîtier petit, super costaud, transparent. J’ai donc utilisé une otterbox que j’avais chopé dans un PX sur une base militaire US. Ces boîtiers sont géniaux. Vous en trouverez chez adafruit.

Pour la découpe en rectangle dans le boitier, voici ma méthode pour faire un rectangle bien propre. C’est aussi valable pour du métal ou du bois:

• faites le tracé de votre découpe.
• réalisez une découpe grossière. tous les moyens sont bons: dremel, scie à métaux…le tout c’est de ne pas trop s’approcher du contour final.
• finissez les bords à la lime fine et plate.

De cette façon vous pourrez faires des découpes très propres et très droites à travers à peu près n’importe quel matériau:

Par exemple, mon boitier:

Pour attacher l’arduino au fond du boîtier, j’ai utilisé un pistolet à colle:

Une bande de velcro plus tard, et hop:

Adafruit vend une petite webcam USB à utiliser comme outil d’inspection pour vérifier ses soudures, lire les inscriptions sur les composants, ou s’amuser avec les enfants… C’est une sorte de microscope USB low cost mais qui donne néanmoins de très bon résultats, pour peu que l’on arrive à faire la mise au point correctement. En effet, celle-ci est manuelle et dépend de la distance lentille / objet et du niveau de grossissement. Une fois le grossissement choisit, il faut approcher / éloigner le microscope pour avoir une image nette. Avec le support de base, c’est quasiment impossible de maintenir une image stable.

Microscope

D’où l’idée de construire un support réglable !

Les pièces sont modélisées avec openscad puis imprimées sur mon imprimante 3D.

Support modélisé

Fixation basse

Plaque de contreplaqué 3mm

Coulisseau réglable

Coulisseau réglable

Bras de support

Vis de réglage

Fixation sur le support en bois

Réglage de hauteur

Support

Molette de réglage

Molette de réglage

Les supports hauts et bas sont collés à l’epoxy ( JB weld, quel produit miracle

Tests

L’ensemble des fichiers pour reproduire les pièce est disponible sur Thingiverse.

et voici pour finir ce bref article des images à divers niveaux de grossissement.

Capteur d’humidité x200

Capteur d’humidité x10

Pour l’électronique, le grossissement x10 à x20 est largement suffisant. Au delà, c’est plus pour explorer l’infiniment petit

P.S: vous avez vu, mes impressions sont quand même meilleurs qu’avant ! J’ai augmenté la température de l’extrusion de 185° à 220° ! Depuis fini les buses bouchées ou les bulles en cours d’impression.

La torture du MR3020 continue ! Comme je l’avais mentionné dans le post précédent, il me faut un bus i2c pour communiquer avec le contrôleur de mon robot qui sera basé sur un Arduino. Il existe de nombreuses GPIO sur le MR3020 mais certaines sont indisponibles car utilisées par le processeur ( initialisation de la flash par ex ). D’autres sont disponibles, comme les LED ou les interrupteurs. Je pourrais utiliser ces GPIO mais c’est dommage de supprimer des fonctionnalités du routeur…

Le routeur MR3020 a un cousin qui dispose de 2 GPIO non utilisées sur sa carte: les GPIO 7 et 29. Nous allons donc rechercher si sur notre routeur elles existent aussi. La page openwrt du MR3020 ne mentionne pas l’utilité de ces 2 GPIO mais qui sait… elles existent peut-être aussi sur ce routeur !

Pour les retrouver, on va d’abord décharger le module de gestion des LEDS pour être sûr de ne pas utiliser ces GPIO.

rmmod leds_gpio

Ensuite, on exporte ces 2 GPIO et on les place en mode OUTPUT.

cd /sys/class/gpio/
echo 7 > export
echo 29 > export
echo out > gpio7/direction
echo out > gpio29/direction

Les GPIO sont prêtes pour être utilisées. Afin de les repérer facilement sur la carte à l’aide de l’oscilloscope, on va générer un signal d’horloge bidon avec une fréquence peu élevée à l’aide d’un script « quick and dirty » en python.

import sys
import time
 
while True:
        value = open("/sys/class/gpio/gpio7/value","w")
        value.write(str(0))
        time.sleep(.0005)
        value.write(str(1))
        value.close()
        time.sleep(.0005)

Après quelques minutes de recherche, le signal carré est localisé sur les les pattes des résistance 15 et 17, comme sur son cousin le WR703N. Les autres pattes de ces résistances sont à la masse. Ce sont donc des resistances de pulldown mais à quoi servent-elles ? mystère … En tout cas, elles vont me servir

Le signal carré

R15 et R17 donnent accès aux GPIO 7 et 29

Reste maintenant une opération relativement délicate: dessouder ces 2 minuscules résistances et souder des fils sur

• R15
• R17
• GND
• +3.3v
• +5v

Résistances supprimées et fils soudés.

Oui, oui, c’est minuscule ! La preuve si vous comparez avec une résistance classique:

Les CMS font mal aux yeux

Ensuite passons à la masse. Elle sera prise sur les pattes de l’interrupteur de sélection du mode.

Masse

Le 3.3v que l’on prendra sur les pattes de ce que je pense être un régulateur.

3.3v

Et pour finir le 5V. Il est optionnel mais je pourrais en avoir besoin plus tard. Autant le câbler tout de suite.

5V

Pour résumer les positions des différentes lignes, rien ne vaut une petite photo d’ensemble.

le bus i2c prend forme

L’i2c étant un bus à collecteur ouvert, il faut placer des résistances de pullup sur les lignes SDA et CLK. Des résistances de 10k sont adaptées pour ça.

Un petit connecteur est réalisé sur un bout de protoboard.

Connecteur

Voilà, c’est presque terminé. Pour tester, je vais utiliser une eeprom i2c venant de chez HobbyElectro, le magasin en ligne créé il y a quelques temps par Furrtek.

Il faut configurer et charger le noyau i2c-gpio-custom en créant un fichier /etc/modules.d/99-i2c contenant la ligne

i2c-gpio-custom bus0=0,7,29

c’est tout

Linux est maintenant capable de dialoguer en i2c sur les GPIO 7/29. Elle n’est pas belle la vie ?

Il suffit alors de câbler notre petite eeprom en suivant le datasheet.

Eeprom 24AA256

On ne branchera que VSS ( masse ) , Vcc, SCL et SDA.

Montage rapide

L’utilitaire i2c-detect permet de scanner le bus à la recherche d’une adresse i2c.

Trouvé ! l’adresse est 0×50

Tout marche, l’eeprom est trouvée en 0×50. Parfait !

Bientôt la suite avec l’Arduino…