Arduino - Play le Piezo

-1 accéléromètre 3 axes
-1 carte arduino
-1 haut-parleur
-1 chanson en mesure de contester le son de merde de l’enceinte

Le code est basique : le rythme de la chanson est mise en œuvre et devant chaque pas de temps, le gant détecte la direction de la gravité et choisit l’un des trois notes de la chanson.

Le code est ci-dessous.

Vous pouvez regarder la vidéo sur Youtube.

Recevez les nouvelles et mises à jour sur ma page. Actuellement, je collecte des fonds contre le Cancer, s’il vous plaît faire un don !

/*
28 décembre 2012 - Sebastien RUBRECHT
Essayez de jouer une musique cool avec un haut-parleur de merde, en espérant que le « cool » compensera la « merde ».
La musique est « where is my mind » de The Pixies, qui est vraiment facile à jouer.
*/

#define AUTO 0 / / automatique mode : si 1, la musique se joue automatiquement.

Broches
const int analogInPinX = 0 ;  Broche d’entrée analogique qui les premières broches de l’accéléromètre est attaché à
const int analogInPinY = 1 ;  Broche d’entrée analogique qui les deuxième goupille de l’accéléromètre est attaché à
const int analogInPinZ = 2 ;  Broche d’entrée analogique qui revêt la troisième broche de l’accéléromètre
const int tone1Pin = 9 ;  signal de sortie de ton

const int highPin1 = 11 ;  5 alimentation V
const int highPin2 = 12 ;  5 alimentation V
const int lowPin1 = 5 ; au sol pour l’un de le 2 accéléromètre GND
const int lowPin2 = 6 ; au sol pour l’un de le 2 accéléromètre GND

const int ledOKPinGnd = 8 ;  motif de Pin OK
const int ledOKPinH = 10 ; 5 alimentation V pour broche OK
const int ledNOKPinGnd = 2 ; motif de Pin NOK
const int ledNOKPinH = 4 ;  5 alimentation V pour broche NOK

valeurs constantes
const float freq_rediese0 = 38.9;//frequency d’une forte Re en Hz, pour octave 0
const float freq_mi0 = 41.2;//frequency d’un Mi en Hz, pour octave 0
const float freq_soldiese0 = 51.9;//frequency d’un Sol pointu en Hz, pour octave 0

paramètres définis par l’utilisateur constante
const int octave = 4; //octave nombre. Attention, sous 2(low) et supérieur à 6 (aigu), il est très laid
const int temps = 380 ; //number de millisecondes pour 1 note de musique. 380 le rythme réel, mais commençant par 600 est plus facile à apprendre

variables
float freq_rediese = freq_rediese0 * pow (2, octave) ; fréquence d’une forte Re en Hz, pour l’octave retenu
float freq_mi = freq_mi0 * pow (2, octave); //frequency d’un Mi en Hz, pour l’octave retenu
float freq_soldiese = freq_soldiese0 * pow (2, octave); //frequency d’un Sol pointu en Hz, pour l’octave retenu

int noire ; //time d’une note noire
int croche ; //temps d’une note croche
fréquence de flotteur ; //frequency joué

int sensorValue1 ;        valeur lue de goupille de première de l’accéléromètre
int sensorValue2 ;        valeur lue de goupille de seconde de l’accéléromètre
int sensorValue3 ;        valeur lue de goupille de seconde de l’accéléromètre

void setup() {}
pinMode (tone1Pin, sortie) ;

pinMode (highPin1, sortie) ;
pinMode (highPin2, sortie) ;
pinMode (lowPin1, sortie) ;
pinMode (lowPin2, sortie) ;

pinMode (ledOKPinGnd, sortie) ;
pinMode (ledOKPinH, sortie) ;
pinMode (ledNOKPinGnd, sortie) ;
pinMode (ledNOKPinH, sortie) ;

digitalWrite (lowPin1, basse) ;
digitalWrite (lowPin2, basse) ;
digitalWrite (highPin1, HIGH) ;
digitalWrite (highPin2, HIGH) ;

digitalWrite (ledOKPinGnd, basse) ;
digitalWrite (ledNOKPinGnd, basse) ;
}

void loop() {}
noire = temps ;
croche = temps/2 ;

« where is my mind » est 4 * (1 mi + 1sol #) ; 2 * (1re # + 1sol #) ; 2 * (1 mi + 1/2 mi + 1 / 2re #).
pour (int j = 0; j < 4; j ++) //4 * (1 mi + 1sol #)
{
fréquence = acqNote(freq_mi) ; Obtient la direction de l’accélération plus élevée du capteur et retourne l’assofrequency. Le bon théorique est un Mi.
Note (fréquence, noire); / / joue la fréquence renvoyée à la ligne précédente pendant 1 heure « noire ».
fréquence = acqNote(freq_soldiese) ;
Note (fréquence, noire) ;
}
pour (int j = 0; j < 2; j ++) //2 * (1re # + 1sol #) ;
{
fréquence = acqNote(freq_rediese) ;
Note (fréquence, noire) ;
fréquence = acqNote(freq_soldiese) ;
Note (fréquence, noire) ;
}
pour (int j = 0; j < 2; j ++) / / 2 * (1 mi + 1/2 mi + 1 / 2re #)
{
fréquence = acqNote(freq_mi) ;
Note (fréquence, noire) ;
fréquence = acqNote(freq_mi) ;
Note (fréquence, croche) ;
fréquence = acqNote(freq_rediese) ;
Note (fréquence, croche) ;
}
}

note Sub (flotteur freq, int durée)
{
La « note » de la fonction joue une note selon une périodicité "freq" (Hz) au cours de la "durée" (ms)

conversion de la fréquence dans une période de semi
double semiperiod_micros =1/(double(freq)) * 1000000 * 0,5 ;

long duree=long(duration) ;
unsigned long un = millis() ;
tandis que (millis() < (duree a +))
{
digitalWrite (tone1Pin, HIGH) ;
delayMicroseconds(int(semiperiod_micros)) ;
digitalWrite (tone1Pin, basse) ;
delayMicroseconds(int(semiperiod_micros)) ;
}
Afin de séparer les notes (ça sonne mieux), un bref retard.
Si (durée > 300)
{delay(15);}
d’autre
{delay(7);}
}

flotteur acqNote(float freq_ref) {}

« acqNote » obtient l’accélération dans les 3 directions de la sonde, sélectionne la plus élevée et retourne la fréquence associée.
Si elle correspond à la fréquence théorique bonne « freq_ref », il bascule sur le vert, sinon le rouge led.

flotteur freq ;

lit les deux valeurs d’entrée analogiques :
sensorValue1 = analogRead(analogInPinX) ;
sensorValue2 = analogRead(analogInPinY) ;
sensorValue3 = analogRead(analogInPinZ) ;

retourne l’index de la max de 3 valeurs
Si ((max(max(sensorValue1,sensorValue2),sensorValue3))==sensorValue1) {}
FREQ = freq_rediese ;
}
else if ((max(max(sensorValue1,sensorValue2),sensorValue3))==sensorValue2) {}
FREQ = freq_mi ;
}
else {}
FREQ = freq_soldiese ;
}

bascule sur le green led si la fréquence trouvée est celle bien théorique, d’autre celui rouge.
Si (freq == freq_ref) {}
digitalWrite(ledOKPinH,HIGH) ;
digitalWrite(ledNOKPinH,LOW) ;
}
else {}
digitalWrite(ledOKPinH,LOW) ;
digitalWrite(ledNOKPinH,HIGH) ;
}
Si {(AUTO)
Return freq_ref ;
}
else {}
retour freq ;
}

};