[Résolu - Fini] Waveshield / 8 boutons / Leds pour installation dans un musée.

Bonjour,
Grand novice dans l’électronique et malheureusement/heureusement papa; je n’ai pas assez de temps pour m’investir dans ce projet qui me tiens à cœur.

Je compte installer un boitier sous 4 marionnettes dans un musée. Un boitier avec 4 boutons pour chaque marionnettes qui lancent un son en Francais, et 4 boutons pour chaque marionnettes qui lancent un son en Anglais.
1 led sous chacune des marionnettes et 1 led sur chaque rangée du boitier.( 4x2 leds) cf image.

Scénario:
Sur Input Analog 4:
Bouton FR1 préssé = Led A1 sur le boitier + Led A2 + Son FR1
Bouton FR2 préssé = Led B1 sur le boitier + Led B2 + Son FR2
Bouton FR3 préssé = Led C1 sur le boitier + Led C2 + Son FR3
Bouton FR4 préssé = Led D1 sur le boitier + Led D2 + Son FR4

Sur Input Analog 5:
Bouton UK1 préssé = Led A1 sur le boitier + Led A2 + Son UK1
Bouton UK2 préssé = Led B1 sur le boitier + Led B2 + Son UK2
Bouton UK3 préssé = Led C1 sur le boitier + Led C2 + Son UK3
Bouton UK4 préssé = Led D1 sur le boitier + Led D2 + Son UK4

Leds allumées le temps que joue le son. Le son peux être interrompu avec une pression d’un autre bouton.

Je pensait m’inspirer de deux exemples de code:

J’avoue être un peu perdu.
Voila le schema de montage:

#include <FatReader.h>
#include <SdReader.h>
#include <avr/pgmspace.h>
#include "WaveUtil.h"
#include "WaveHC.h"


SdReader card;    // This object holds the information for the card
FatVolume vol;    // This holds the information for the partition on the card
FatReader root;   // This holds the information for the filesystem on the card
FatReader f;      // This holds the information for the file we're play

WaveHC wave;      // This is the only wave (audio) object, since we will only play one at a time

#define DEBOUNCE 5  // button debouncer

// here is where we define the buttons that we'll use. button "1" is the first, button "8" is the 8th, etc
byte buttons[] = {A4, A5};
// This handy macro lets us determine how big the array up above is, by checking the size
#define NUMBUTTONS sizeof(buttons)
// we will track if a button is just pressed, just released, or 'pressed' (the current state
volatile byte pressed[NUMBUTTONS], justpressed[NUMBUTTONS], justreleased[NUMBUTTONS];

// this handy function will return the number of bytes currently free in RAM, great for debugging!   
int freeRam(void)
{
  extern int  __bss_end; 
  extern int  *__brkval; 
  int free_memory; 
  if((int)__brkval == 0) {
    free_memory = ((int)&free_memory) - ((int)&__bss_end); 
  }
  else {
    free_memory = ((int)&free_memory) - ((int)__brkval); 
  }
  return free_memory; 
} 

void sdErrorCheck(void)
{
  if (!card.errorCode()) return;
  putstring("\n\rSD I/O error: ");
  Serial.print(card.errorCode(), HEX);
  putstring(", ");
  Serial.println(card.errorData(), HEX);
  while(1);
}
int a=0;

void setup()
{
  pinMode(A5, INPUT_PULLUP); // sets analog pin for input 
  pinMode(A4, INPUT_PULLUP); // sets analog pin for input 
} 

int readButtons(int pin)
// returns the button number pressed, or zero for none pressed 
// int pin is the analog pin number to read 
{
  int b,c,d = 0;
  c=analogRead(pinA4); // get the analog value  if (c>1000)
  d=analogRead(pinA5); // get the analog value  if (c>1000)
  {
    b=0; // buttons have not been pressed
  }   
else
  if (c>440 && c<470)
  {
    b=1; // button FR1 pressed
  }     
  else
    if (c<400 && c>370)
    {
      b=2; // button FR2 pressed
    }       
    else
      if (c>280 && c<310)
      {
        b=3; // button FR3 pressed
      }         
      else
        if (c>150 && c<180)
        {
          b=4; // button FR4 pressed
        }      
else
  if (d>440 && d<470)
  {
    b=5; // button UK1 pressed
  }      
else
    if (d<400 && d>370)
    {
      b=6; // button UK2 pressed
    }       
 else
      if (d>280 && d<310)
      {
        b=7; // button UK3 pressed
      }    
  else
     if (d>150 && d<180)
     {
       b=8; // button UK4 pressed
     }      
       return b;
}

void loop()
{
  a=readButtons(5);
  lcd.clear();
  if (a==0) // no buttons pressed
  {
  }   
  else
    if (a>0) // someone pressed a button!
    {
      switch (b) {
    case 1:
     playfile("FR1.WAV")
     digitalWrite(0, HIGH); //Led ON 
      break;
    case 2:
     playfile("FR2.WAV")
     digitalWrite(1, HIGH);
      break;
    case 3:
     playfile("FR3.WAV")
     digitalWrite(2, HIGH);
      break;
    case 4:
     playfile("FR4.WAV")
     digitalWrite(3, HIGH);
      break;

      switch (b2) {
    case 1:
     playfile("UK1.WAV")
     digitalWrite(0, HIGH);
      break;
    case 2:
     playfile("UK2.WAV")
     digitalWrite(1, HIGH);
      break;
    case 3:
     playfile("UK3.WAV")
     digitalWrite(2, HIGH);
      break;
    case 4:
     playfile("UK4.WAV")
     digitalWrite(3, HIGH);
      break;
    default: 
      // if nothing else matches, do the default
      // default is optional
  }
    }
}

Je sais pertinemment que ce code n’est ni pertinent ni fonctionnel…mais je ne comprends pas comment avancer plus loin…
Matériel: Arduino Uno Rev.3 + Adafruit Waveshield

ah en faite tu à besoin d'aide? ici c'est les choses fini tu aurais du le mètre dans le file courant la tu auras peut de réponse :s

Quel est ton vrai problème? Les codes que tu à pris son trop complexe? non fonctionnel? Tu na pas compris l'utilisation des LED? du wave shield?

Skizo.

ah zut....je faut deplacer le topic alors.... Les codes sont trop complexe pourtant le montage a l'air simple....Bon, je posterais losrque ce sera fini et fonctionnel! Merci!

Si tu à besoin d'aide pas besoin d'attendre que ce soit fonctionnel mais mets le dans le bon topic et puis essaie de cogiter pour formuler ta question et les points obscure pour toi, tu auras plus de réponse.

Skizo !

Bonjour tous!

Le projet fonctionne et est sur le point d’être terminé(codage et montage) il ne me reste plus qu'à le faire propre, fignoler le code avec les timing et le monter dans la caisse en bois. Si le Wave Shield était compatible avec la Arduino Mega, le montage des boutons auraient été plus facile mais non...je suis encore débutant, il y a surement mieux comme choix de Arduino!

Matériel: Arduino Uno + Adafruit Wave Shield 8 Leds rouge + 8 resistances 220 Ohm 8 bouton anti-vandale + Résistances: 10x1K Ohm + 2x1M Ohm 2 HP de 8 Ohm, 3W (possible amélioration avec l'ajout plus tard d'un ampli class D)

Le montage de leds n'a pas changé. 2 séries de 4 leds en parallèle. Le montage des boutons a changé:

http://www.nick-horne.com/tag/multiple-buttons-arduino/

à cela, j'ai rajouté un montage identique en A1 pour avoir 2 rangée de 4 boutons.

NOTE: J'avais BEAUCOUP d’interférences en effleurant les fils ou en faisant bouger le montage...de fausses valeurs faisait déclencher les sons... Les Fils des boutons ont été torsadés entre eux par pair mais cela n'a rien fait. J'ai "blindé" les pairs de fils avec du papier alu ménager, le tout relié a la masse du montage. Tout est stable maintenant.

Il ne me reste plus qu'à trouver comment faire pour que les leds restent allumées le temps que le son joue puis s’éteigne après.

et voila e code:

#include <FatReader.h>
#include <SdReader.h>
#include <avr/pgmspace.h>
#include "WaveUtil.h"
#include "WaveHC.h"
 
 
SdReader card;    // This object holds the information for the card
FatVolume vol;    // This holds the information for the partition on the card
FatReader root;   // This holds the information for the filesystem on the card
FatReader f;      // This holds the information for the file we're play
 
WaveHC wave;      // This is the only wave (audio) object, since we will only play one at a time
 
const int ledGendarme=6; //une led sur le Digital 6 - libre sur le wave shield
const int ledGnafron=7; //une led sur le Digital 7
const int ledMadelon=8; //une led sur le Digital 8
const int ledGuignol=9; //une led sur le Digital 9
const int analogPinFR = 0; //le circuit de boutons FR arrive en A0
const int analogPinUK = 1; //le circuit de boutons UK arrive en A0
int buttonValueFR = 0;
int buttonValueUK = 0;
int onboardLed = 13; // digital 
 
#define DEBOUNCE 100  // button debouncer
 
// this handy function will return the number of bytes currently free in RAM, great for debugging!   
int freeRam(void)
{
  extern int  __bss_end; 
  extern int  *__brkval; 
  int free_memory; 
  if((int)__brkval == 0) {
    free_memory = ((int)&free_memory) - ((int)&__bss_end); 
  }
  else {
    free_memory = ((int)&free_memory) - ((int)__brkval); 
  }
  return free_memory; 
} 
 
void sdErrorCheck(void)
{
  if (!card.errorCode()) return;
  putstring("\n\rSD I/O error: ");
  Serial.print(card.errorCode(), HEX);
  putstring(", ");
  Serial.println(card.errorData(), HEX);
  while(1);
}
 
void setup() {
  // set up serial port
  Serial.begin(9600);
  putstring_nl("WaveHC with 6 buttons");
  
   putstring("Free RAM: ");       // This can help with debugging, running out of RAM is bad
  Serial.println(freeRam());      // if this is under 150 bytes it may spell trouble!
  
  // Set the output pins for the DAC control. This pins are defined in the library
  pinMode(2, OUTPUT);
  pinMode(3, OUTPUT);
  pinMode(4, OUTPUT);
  pinMode(5, OUTPUT);
 
  // pin13 LED
  pinMode(13, OUTPUT);
  
	pinMode(ledGendarme, OUTPUT); 
	pinMode(ledGnafron, OUTPUT);
	pinMode(ledMadelon, OUTPUT);
	pinMode(ledGuignol, OUTPUT);
 
 
  //  if (!card.init(true)) { //play with 4 MHz spi if 8MHz isn't working for you
  if (!card.init()) {         //play with 8 MHz spi (default faster!)  
    putstring_nl("Card init. failed!");  // Something went wrong, lets print out why
    sdErrorCheck();
    while(1);                            // then 'halt' - do nothing!
  }
  
  // enable optimize read - some cards may timeout. Disable if you're having problems
  card.partialBlockRead(true);
 
// Now we will look for a FAT partition!
  uint8_t part;
  for (part = 0; part < 5; part++) {     // we have up to 5 slots to look in
    if (vol.init(card, part)) 
      break;                             // we found one, lets bail
  }
  if (part == 5) {                       // if we ended up not finding one  
    putstring_nl("No valid FAT partition!");
    sdErrorCheck();      // Something went wrong, lets print out why
    while(1);                            // then 'halt' - do nothing!
  }
  
  // Lets tell the user about what we found
  putstring("Using partition ");
  Serial.print(part, DEC);
  putstring(", type is FAT");
  Serial.println(vol.fatType(),DEC);     // FAT16 or FAT32?
  
  // Try to open the root directory
  if (!root.openRoot(vol)) {
    putstring_nl("Can't open root dir!"); // Something went wrong,
    while(1);                             // then 'halt' - do nothing!
  }
  
  // Whew! We got past the tough parts.
  putstring_nl("Ready!");
}
 
void loop() {
  
// *************************************************************************
// Boutons FR
// *************************************************************************

  buttonValueFR = analogRead(0); //lecture de la valeur arrivant sur l'analog 0
  putstring("."); 
if (buttonValueFR < 150) {
	digitalWrite(ledGendarme, LOW);
	digitalWrite(ledGnafron, LOW);
	digitalWrite(ledMadelon, LOW);
	digitalWrite(ledGuignol, LOW);

	putstring("\nAucun Bouton presse");
} // Tout eteins si aucun bouton n'est presse
else if (buttonValueFR > 180 && buttonValueFR < 250)  // 1er bouton presse
	{
	  digitalWrite(ledGendarme, HIGH);
	  playfile("FR1.WAV");  
          putstring("\nBouton 1 presse");			
	  delay(1000);
	  digitalWrite(ledGendarme, LOW);
	} 
else if (buttonValueFR > 350 && buttonValueFR < 450) // 2eme bouton presse
	{
          digitalWrite(ledGnafron, HIGH);	
	  playfile("FR2.WAV");  
          putstring("\nBouton 2 presse");
          digitalWrite(ledGnafron, HIGH);
	  delay(1000);
	  digitalWrite(ledGnafron, LOW);
	 }
else if (buttonValueFR > 550 && buttonValueFR < 650) // 3eme bouton pr?ss?
	{
	  digitalWrite(ledMadelon, HIGH);
	  playfile("FR3.WAV");  
	  putstring("\nBouton 3 presse");		
	  delay(1000);
	  digitalWrite(ledMadelon, LOW);
	}
else if (buttonValueFR > 750 && buttonValueFR < 850) // 4eme bouton pr?ss?
	{
          digitalWrite(ledGuignol, HIGH);
	  playfile("FR4.WAV");  
	  putstring("\nBouton 4 presse");		
	  delay(1000);		
	  digitalWrite(ledGuignol, LOW);
	}
// *************************************************************************
// Boutons UK
// *************************************************************************

  buttonValueUK = analogRead(1); //lecture de la valeur arrivant sur l'analog 0
  putstring("."); 
if (buttonValueUK < 150) {
	digitalWrite(ledGendarme, LOW);
	digitalWrite(ledGnafron, LOW);
	digitalWrite(ledMadelon, LOW);
	digitalWrite(ledGuignol, LOW);

	putstring("\nAucun Bouton presse");
} // Tout ?teins si aucun bouton n'est pr?ss?
else if (buttonValueUK > 180 && buttonValueUK < 250)  // 1er bouton pr?ss?
	{
  	  playfile("UK1.WAV");
          digitalWrite(ledGendarme, HIGH); 
          putstring("\nBouton 5 presse");			
	  delay(1000);
	  digitalWrite(ledGendarme, LOW);
	} 
else if (buttonValueUK > 350 && buttonValueUK < 450) // 2eme bouton pr?ss?
	{	
	  playfile("UK2.WAV");  
          putstring("\nBouton 6 presse");
          digitalWrite(ledGnafron, HIGH);
	  delay(1000);
	  digitalWrite(ledGnafron, LOW);
	 }
else if (buttonValueUK > 550 && buttonValueUK < 650) // 3eme bouton pr?ss?
	{
	  digitalWrite(ledMadelon, HIGH);
	  playfile("UK3.WAV");  
	  putstring("\nBouton 7 presse");		
	  delay(1000);
	  digitalWrite(ledMadelon, LOW);
	}
else if (buttonValueUK > 750 && buttonValueUK < 850) // 4eme bouton pr?ss?
	{
          digitalWrite(ledGuignol, HIGH);
	  playfile("UK4.WAV");  
	  putstring("\nBouton 8 presse");		
	  delay(1000);		
	  digitalWrite(ledGuignol, LOW);
	}
else putstring("\nProbleme de decodage du bouton");
  //putstring(".");            // uncomment this to see if the loop isnt running
}
 
byte check_switches()
{
  static byte previous[6];
  static long time[6];
  byte reading;
  byte pressed;
  byte index;
  pressed = 0;
 
  for (byte index = 0; index < 6; ++index) {
    reading = digitalRead(14 + index);
    if (reading == LOW && previous[index] == HIGH && millis() - time[index] > DEBOUNCE)
    {
      // switch pressed
      time[index] = millis();
      pressed = index + 1;
      break;
    }
    previous[index] = reading;
  }
  // return switch number (1 - 6)
  return (pressed);
}
 
 
// Plays a full file from beginning to end with no pause.
void playcomplete(char *name) {
  // call our helper to find and play this name
  playfile(name);
  while (wave.isplaying) {
  // do nothing while its playing
  }
  // now its done playing
}
 
void playfile(char *name) {
  // see if the wave object is currently doing something
  if (wave.isplaying) {// already playing something, so stop it!
    wave.stop(); // stop it
  }
  // look in the root directory and open the file
  if (!f.open(root, name)) {
    putstring("Couldn't open file "); Serial.print(name); return;
  }
  // OK read the file and turn it into a wave object
  if (!wave.create(f)) {
    putstring_nl("Not a valid WAV"); return;
  }
  
  // ok time to play! start playback
  wave.play();
}