Affichage des articles dont le libellé est arduino. Afficher tous les articles
Affichage des articles dont le libellé est arduino. Afficher tous les articles

jeudi 6 février 2014

Détecteur sonore avec amplification simple


Aujourd'hui, après une longue absence, je vais vous présenter un petit système que je cherche à réaliser depuis bien longtemps : un détecteur sonore.

J'ai enfin trouvé un schéma électronique pour amplifier simplement une tension issue d'un microphone de type électret, ci-dessous. Avec ce composant, le but est de mesurer l'intensité sonore ambiante, de l'amplifier et à terme de détecter un bruit.
Micro électret

L'amplificateur

Le signal issus de l'électret étant trop faible pour être interprété tel quel par un microcontrôleur, il faut l'amplifier. Cela consiste a augmenter les variations de tension issues du capteur. 
Le schéma de l'amplificateur que j'utilise provient du blog lowvoltage.wordpress.com. N'hésitez pas à consulter le site pour plus d'informations sur le fonctionnement du circuit.

Amplificateur pour électret
Le composant clé de se montage est le LM358. Cette puce 8 broches contient deux amplificateurs opérationnels , qui, comme leurs noms l'indiquent, amplifient une différence de potentiel à ses entrées. Le LM358 est conçu pour un usage général comme les amplificateurs , les filtres passe-haut et bas, les filtres passe-bande et les additionneurs analogiques.
Avant d'utiliser un nouveau composant, il est toujours utile de consulter sa fiche composant (datasheet), voici quelques éléments que j'ai sélectionné :

  1. Large DC Voltage Gain: 100 dB.
  2. Wide Power Supply Range: Single Supply: 3V to 32V.
  3. Very Low Supply Current Drain (500 μA)—Essentially Independent of Supply Voltage
  4. Le circuit interne qui nous permet de savoir comment le brancher par rapport à notre schéma ci-dessus. On utilise donc soit l'entrée A soit la B (mais pas les deux en même temps hein !) :

Circuit interne du LM358

Les deux condensateurs C1 et C2 sont dits "chimiques"; ils sont donc polarisés (borne + et -). Attention aux branchements !
Je préfère vous prévenir car javais fait l'erreur, attention à bien lire le schéma : il y a des fils qui se croisent mais où il n'y a pas de jonction !

! Afin d'améliorer l'amplification, il est possible d'ajouter un condensateur de 100nF entre VCC et GND, comme proposer par l'auteur.

Voilà, l'amplificateur est prêt, il ne reste plus qu'à brancher A0 sur une entrée analogique de l'Arduino par exemple !
L'amplificateur sur une plaque d'essai

Deux scripts pour utiliser ce microphone avec l'Arduino

L'article de lowvoltage.wordpress.com étant bien fait, il propose un petit exemple très intéressant. En effet, on remarque que le bruit peut être gênant en utilisant l'exemple du programme de l'Arduino "AnalogReadSerial", on manque de précision, la tension oscille bizarrement. Pour pallier ce problème, l'article propose de tester plusieurs fois (sur un intervalle de temps très court inférieur à la seconde) la valeur analogique lue par A0, de noter la valeur minimale et maximale, et de faire la différence. Et ça marche !

L'exemple lowvoltage.wordpress.com traduit et commenté :
/**
 * Mesure la tension sur une broche analogique sur une période de temps de ~1s
 * et retourner les valeurs Min, Max et Diff sur le port Serial.
 *
 * Auteur: Dimitar Kovachev, http://lowvoltage.wordpress.com/
 * Traduction: Théophile D.
 *

* Released under the Creative Commons Attribution Share-Alike 3.0 license
 * http://creativecommons.org/licenses/by-sa/3.0/
 */
const int analogPin = 0;

void setup() {
  Serial.begin(9600); 
}

void loop() {
  int mn = 1024;     // mn diminution seulement
  int mx = 0;        // mx diminution seulement


  // Exécuter 10000 lectures. Mettre à jour mn et mx à chaque fois.
  for (int i = 0; i < 10000; ++i) {
    int val = analogRead(analogPin);
    mn = min(mn, val);
    mx = max(mx, val);
  }

  // Envoyer le min, le max et delta sur le port Serial
  Serial.print("m=");
  Serial.print(mn);  
  Serial.print(" M=");
  Serial.print(mx);  
  Serial.print(" D=");
  Serial.print(mx-mn);  
  Serial.println();  
}

Mon exemple version détecteur sonore :
const int analogPin = 0;

const int led = 12;

const int seuil = 80;

void setup() {
  pinMode(led, OUTPUT);
}

void loop() {
  int mn = 1024;
  int mx = 0;

  for (int i = 0; i < 10000; ++i) {
    int val = analogRead(analogPin);
    mn = min(mn, val);
    mx = max(mx, val);
  }
  //Si la différence "seuil" est dépassée, on allume la led
  if(mx-mn>seuil)
  {
    digitalWrite(led, HIGH);
    delay(1000);
    digitalWrite(led, LOW); // il faut éteindre la led ensuite pour éviter les interférence...
    delay(100); 
  }
}


Et voilà, n'hésitez pas à commenter !

dimanche 3 mars 2013

Simuler un système complet avec ISIS

Vérifier qu'un système (programme+circuit) fonctionne c'est possible avec Proteus, un logiciel de Labcenter Electronics. Ce logiciel permet, entre autres, la création de schémas et la simulation électrique mais aussi, grâce à des modules additionnels, ISIS est également capable de simuler le comportement d'un microcontrôleur (PIC, Atmel, 8051, ARM, HC11...) et son interaction avec les composants qui l'entourent.

Se procurer le logiciel (il existe une démo) : labcenter.com

Pour vous montrer un peu comment il fonctionne, nous allons simuler un compteur d'impulsion avec affichage sur écran LCD en utilisant un Atmega328, le pic de l'Arduino (tiens tiens !).

Etape 1 : écrire le programme et le compiler avec le logiciel Arduino

On pourrait passer par un autre logiciel, peut-être plus pratique, mais cela nous évites de réinstaller quoique ce soit.
Le but étant de faire simple, on utilise deux exemples que l'on bidouille l'un dans l'autre: HelloWord et StateChangeDetection. Ce qui donne :
// include the library code:
#include <LiquidCrystal.h>

// initialize the library with the numbers of the interface pins
LiquidCrystal lcd(12, 11, 5, 4, 3, 2);

const int buttonPin = 0;
// Variables will change:
int buttonPushCounter = 0;   // counter for the number of button presses
int buttonState = 0;         // current state of the button
int lastButtonState = 0;     // previous state of the button 

void setup() {
  pinMode(buttonPin, INPUT);
  
  // set up the LCD's number of columns and rows: 
  lcd.begin(16, 2);
  // Print a message to the LCD.
  lcd.print("Compteur:"); // "counter"
}

void loop() {
  // set the cursor to column 0, line 1
  // (note: line 1 is the second row, since counting begins with 0):
  lcd.setCursor(0, 1);
  // Print the number
  lcd.print(buttonPushCounter);
  // print the number of seconds since reset:
  buttonState = digitalRead(buttonPin);

  // compare the buttonState to its previous state
  if (buttonState != lastButtonState) {
    // if the state has changed, increment the counter
    if (buttonState == HIGH) {
      // if the current state is HIGH then the button
      // wend from off to on:
      buttonPushCounter++;
    }
  }
  // save the current state as the last state, 
  //for next time through the loop
  lastButtonState = buttonState;
}

Rien de compliqué, si vous avez besoin de commentaire, laissez m'en un justement...

Etape 2 - Récupérer le fichier .hex

Nous, simples mortels, sachons lire et écrire en C (le language Arduino). Mais il en est autrement pour les microcontrôleurs et les ordinateurs de manière générale. Le logiciel fait la conversion entre C et hexadécimal au moment du téléversement sur le PIC. Pour la simulation, nous avons besoin du fichier encodé, en hexa donc.
Pour le récupérer, c'est un peu casse-tête. D'abord il faut enregistrer le programme et le compiler. Pendant cette opération, il est envoyé dans les fichiers temporaires de l'ordinateur. Cherchez où ce cache (c'est bien le cas de le dire) ce dossier. Sous Windows 8 c'est : C:\Users\Théophile\Local Settings\Temp" (oui je m'appelle Théophile).
Une fois dans ce dossier des fichiers temporaires, classez les fichiers par date et par ordre décroissante. Votre fichier .hex ce trouve dans le premier dossier, en tête, commençant par "build" (pour ce tuto le miens réponds au doux nom de "build9199467709888312371.tmp").
Copiez-le ailleurs.

Etape 3 - Réaliser le montage virtuel

Sélection des composants

Pour sélectionner un composant, cliquer sur "P" dans Devices.
Dans la base de donnée, préparer les composants suivant :
  • Atmega328p
  • PG24064F (l'afficheur 16*2)
  • RES10K
  • BUTTON
  • Un condensateur (capacitor) 10nF

Réaliser le circuit

C'est intuitif, je vous laisse découvrir comment faire : placer les composants et reliez-les comme sur mon schéma :
Ces circuits sont la combinaisons des deux exemples (à retrouver ici et là) , soient:
J'ai juste ajouter un petit filtre sur le bouton pour supprimer les rebonds.

Pour savoir comment se nomme chaque broche, on utilise une carte du microcontrôleur :

Configurer l'ATmega328

Il faut configurer l'ATmega328. Double-cliquez dessus. Dans l'absolut, il faut régler la vitesse d'horloge mais là on ne se sert pas du timer donc on peut laisser les valeurs par défaut  Il vous suffit donc de sélectionner votre fichier .hex.
Ok pour sauvergarder.

Simuler

Lancez la simulation. Cliquez plusieurs fois sur le boutons poussoirs et admirez !



N'ayant détaillé que très peu, n'hésitez pas à poser des questions. Télécharger les fichiers.

mardi 26 février 2013

Astuce : Comment utiliser une carte Arduino comme programmeur FTDI ?

Dernièrement, j'ai commandé une carte Arduino Ethernet dans l'optique de réaliser un système d'alarme (je présenterai le système dans un futur article). Seulement je n'avais pas consulté en détail les caractéristiques et il se trouve que cette Arduino ne possède pas de port USB mais 6 broches pour un adaptateur FTDI.

Il faut donc utiliser un programmeur pour charger des programmes. Il en existe dans le commerce mais pourquoi ne pas se débrouiller tout seul comme un grand ? Il vous suffit d'avoir une Arduino Uno (OU Duemilanove, Diecimila, Mega 2560, Mega 1280 ou Nano), dans le but de programmer : Arduino Pro / Pro Mini / Mini / LilyPad (ou tout Arduino avec  ATmega168 / ATmaga328). Attention, seules les cartes 5V.

Préparer la carte Uno, celle qui servira de programmeur

Retirer le PIC (ATmega328) de la carte en prenant soin de ne pas tordre les broches. Penser avant tout à noter le sens.
Puis préparer les fils de cette manière (on remarque que le PIC a été enlevé) :

Utiliser votre nouveau programmeur

Vous pouvez connecter votre Uno programmeur à la carte que vous voulez programmer. Pour le sens, il faut vérifier la position de la broche GND (masse). Exemple :

Brancher votre nouveau programmeur sur l'ordinateur (par câble USB), le voyant power de la carte qui va être programmée doit s'allumer. Dans le logiciel Arduino, sélectionner le nom de la carte programmée dans la Outils / Type de carte. C'est prêt, n'hésiter pas à téléverser un exemple pour vérifier.