Étape 7: code
Ce code est détenu par kevin croix dans son ensemble, mais je ne suis pas le propriétaire des différentes parties inédites du code / /le synthduino / /
void setup() {}
setupSleep() ;
setuphello() ;
setuphello1() ;
setupRun() ;
setupTone() ;
setupMelody() ;
setupcap() ;
}
void loop() {}
loopSleep() ;
loophello() ;
loophello1() ;
loopRun() ;
loopTone() ;
loopMelody() ;
loopcap() ;
}
/ * Dormir série de démo
* -----------------
* Exemple de code pour démontrer les fonctions du sommeil dans un Arduino. Arduino se réveillera
* lorsqu’il sont reçues de nouvelles données dans le port série USART
* Basé sur dormir démo série de http://www.arduino.cc/playground/Learning/ArduinoSleepCode
*
* Copyright (C) 2006 MacSimski 2006-12-30
* Copyright (C) 2007 d. Cuartielles 2007-07-08 - Mexico DF
*
* Sous réserve de modifications de Ruben Laguna 2008-10-15
*
* Ce programme est un logiciel libre : vous pouvez le redistribuer et/ou le modifier
* elle aux termes de la GNU General Public License telle que publiée par
* la Free Software Foundation, soit la version 3 de la licence, ou
* (à votre choix) toute version ultérieure.
*
* Ce programme est distribué dans l’espoir qu’il sera utile,
* mais sans aucune garantie ; sans même la garantie implicite de
* Qualité marchande ou ADEQUATION a un usage particulier. Voir le
* GNU General Public License pour plus de détails.
*
* Vous devriez avoir reçu une copie de la GNU General Public License
* Parallèlement à ce programme. Si non, voir < http://www.gnu.org/licenses/>.
*
*/
#include < avr/power.h >
#include < avr/sleep.h >
int sleepStatus = 0 ; pour stocker une demande pour le sommeil
int count = 0 ; compteur
Sub setupSleep()
{
Serial.Begin(9600) ;
}
Sub sleepNow()
{
/ * C’est le moment de mettre le mode "veille". Dans la fiche technique Atmega8
* http://www.atmel.com/dyn/resources/prod_documents/doc2486.pdf à la page 35
* Il existe une liste des modes de veille qui explique les horloges et
* réveil sources sont disponibles dans quel mode de sommeil.
*
* Dans le fichier de avr/sleep.h, les noms de l’appel de ces modus de sommeil sont trouvent :
*
* Les 5 différents modes sont :
* SLEEP_MODE_IDLE-les économies d’énergie moins
* SLEEP_MODE_ADC
* SLEEP_MODE_PWR_SAVE
* SLEEP_MODE_STANDBY
* SLEEP_MODE_PWR_DOWN-la plupart des économies d’énergie
*
* la gestion de la réduction de l’alimentation < avr/power.h > est décrite dans
* http://www.nongnu.org/avr-libc/user-manual/group__avr__power.html
*/
set_sleep_mode(SLEEP_MODE_IDLE) ; mode "veille" est défini ici
sleep_enable() ; permet le peu de sommeil dans le registre mcucr
sommeil est donc possible. juste une épingle de sûreté
power_adc_disable() ;
power_spi_disable() ;
power_timer0_disable() ;
power_timer1_disable() ;
power_timer2_disable() ;
power_twi_disable() ;
sleep_mode() ; ici, l’appareil est effectivement mis à dormir!!
LE PROGRAMME CONTINUE D’ICI APRÈS LE RÉVEIL
sleep_disable() ; la première chose après le réveil du sommeil :
désactiver le sommeil...
power_all_enable() ;
}
Sub loopSleep()
{
afficher des informations sur le compteur
Serial.Print ("Awake pour") ;
Serial.Print(Count) ;
Serial.println("sec") ;
Count ++ ;
Delay(1000) ;
attend une seconde
calculer l’entrée série
Si (Serial.available()) {}
int val = Serial.read() ;
Si (val == les de ') {}
Serial.println ("Serial : mode entrant veille ») ;
Delay(100) ; ce délai est nécessaire, le sommeil
fonction provoquera une erreur de la série sinon!!
Count = 0 ;
sleepNow() ; fonction Sleep, appelée ici
}
Si (val == « A ») {}
Serial.println ("Hola Caracola") ; message de mannequin classique
}
}
vérifier si il devrait aller endormi à cause du temps
Si (comte > = 10) {}
Serial.println ("Timer : mode entrant veille ») ;
Delay(100) ; ce délai est nécessaire, le sommeil
fonction provoquera une erreur de la série sinon!!
Count = 0 ;
sleepNow() ; fonction Sleep, appelée ici
}
}
Bonjour tout le monde sonore de l’Arduino
Créé par David Fowler de uCHobby.com
Définir l’axe de I/O que nous allons utiliser pour notre sortie audio
#define SOUNDOUT_PIN 3
void setuphello(void) {}
Réglez le son axe de sortie mode
pinMode(SOUNDOUT_PIN,OUTPUT) ;
}
void loophello(void) {}
Générer son en activant/désactivant le code pin de I/O haute et basse
Générer une tonalité de 1KHz. régler la tige haute pour 500uS puis
faible pour 500uS rendre la période 1 ms ou 1KHz.
Régler la tige haute et retarder pendant 1/2 un cycle de 1KHz, 500uS.
digitalWrite(SOUNDOUT_PIN,HIGH) ;
delayMicroseconds(500) ;
L’axe faible et retarder pendant 1/2 un cycle de 1KHz, 500uS.
digitalWrite(SOUNDOUT_PIN,LOW) ;
delayMicroseconds(500) ;
}
void setuphello1() {}
pinMode (13, sortie) ;
}
void loophello1() {}
Delay(3000) ; СЕК 3 ВТИК
digitalWrite (13, HIGH) ;
Delay(125) ;
digitalWrite (13, faible) ; // .
Delay(125) ;
digitalWrite (13, HIGH) ;
Delay(125) ;
digitalWrite (13, faible) ; // ..
Delay(125) ;
digitalWrite (13, HIGH) ;
Delay(125) ;
digitalWrite (13, faible) ; // ...
Delay(125) ;
digitalWrite (13, HIGH) ;
Delay(125) ;
digitalWrite (13, faible) ; // .... H
Delay(125) ;
digitalWrite (13, HIGH) ;
Delay(125) ;
digitalWrite (13, faible) ; // . E
Delay(125) ;
digitalWrite (13, HIGH) ;
Delay(125) ;
digitalWrite (13, faible) ; // .
Delay(125) ;
digitalWrite (13, HIGH) ;
Delay(375) ;
digitalWrite (13, faible) ; // . -
Delay(125) ;
digitalWrite (13, HIGH) ;
Delay(125) ;
digitalWrite (13, faible) ; // .-.
Delay(125) ;
digitalWrite (13, HIGH) ;
Delay(125) ;
digitalWrite (13, faible) ; // .-.. L
Delay(125) ;
digitalWrite (13, faible) ; // .
Delay(125) ;
digitalWrite (13, HIGH) ;
Delay(375) ;
digitalWrite (13, faible) ; // . -
Delay(125) ;
digitalWrite (13, HIGH) ;
Delay(125) ;
digitalWrite (13, faible) ; // .-.
Delay(125) ;
Delay(125) ;
digitalWrite (13, HIGH) ;
Delay(125) ;
digitalWrite (13, faible) ; // .-.. L
Delay(125) ;
digitalWrite (13, HIGH) ;
Delay(375) ;
digitalWrite (13, faible) ; // -
Delay(125) ;
digitalWrite (13, HIGH) ;
Delay(375) ;
digitalWrite (13, faible) ; // --
Delay(125) ;
digitalWrite (13, HIGH) ;
Delay(375) ;
digitalWrite (13, faible) ; // --- O
Delay(3000) ; СЕК 3 ВТИК
}
Auduino, la synthèse granulaire de Lo-Fi
//
par Peter Knight, Tinker.it http://tinker.it
//
Aide : http://code.google.com/p/tinkerit/wiki/Auduino
Plus d’aide : http://groups.google.com/group/auduino
//
Analogique à 0: 1 terrain de Grain
Analogique dans 1: décomposition de Grain 2
Analogique à 2: 1 désintégration du Grain
Analogique dans 3: terrain de Grain 2
Analogique 4: terrain de Grain 3
Analogique dans 5: décomposition de Grain 3
//
Numérique 4: Fréquence de repition Grain
5 numérique : Grain amplitude fréquence
//
3 numérique : Audio (numérique 11 sur ATmega8)
//
Changelog :
19 novembre 2008: ajout du support pour les planches de l’ATMEGA8.
21 mars 2009 : ajout du support pour les planches de l’ATmega328
7 avril 2009: le vecteur d’interruption fixe pour les planches de l’ATmega328
8 avril 2009: ajout du support pour cartes ATmega1280 (Arduino Mega)
#include < avr/io.h >
#include < avr/interrupt.h >
uint16_t syncPhaseAcc ;
uint16_t syncPhaseInc ;
uint16_t ampPhaseAcc ;
uint16_t ampPhaseInc ;
uint16_t grainPhaseAcc ;
uint16_t grainPhaseInc ;
uint16_t grainAmp ;
uint8_t grainDecay ;
uint16_t grain2PhaseAcc ;
uint16_t grain2PhaseInc ;
uint16_t grain2Amp ;
uint8_t grain2Decay ;
uint16_t grain3PhaseAcc ;
uint16_t grain3PhaseInc ;
uint16_t grain3Amp ;
uint8_t grain3Decay ;
Carte des canaux analogiques
#define GRAIN3_FREQ_CONTROL (4)
#define GRAIN3_DECAY_CONTROL (5)
#define GRAIN_FREQ_CONTROL (0)
#define GRAIN_DECAY_CONTROL (2)
#define GRAIN2_FREQ_CONTROL (3)
#define GRAIN2_DECAY_CONTROL (1)
Carte des voies numériques
#define SYNC_CONTROL (4)
#define AMP_CONTROL (5)
Ce changement sera exige également réécriture audioOn()
#if defined(__AVR_ATmega8__)
//
Sur les anciennes commissions ATmega8.
Sortie est sur la broche 11
//
#define LED_PIN 13
#define LED_PORT PORTB
#define LED_BIT 5
#define PWM_PIN 11
#define PWM_VALUE OCR2
#define PWM_INTERRUPT TIMER2_OVF_vect
#elif defined(__AVR_ATmega1280__)
//
Sur l’Arduino Mega
Sortie est sur la broche 3
//
#define LED_PIN 13
#define LED_PORT PORTB
#define LED_BIT 7
#define PWM_PIN 3
#define PWM_VALUE OCR3C
#define PWM_INTERRUPT TIMER3_OVF_vect
#else
//
Pour les planches de ATmega168 et ATmega328 modernes
Sortie est sur la broche 3
//
#define PWM_PIN 3
#define PWM_VALUE OCR2B
#define LED_PIN 13
#define LED_PORT PORTB
#define LED_BIT 5
#define PWM_INTERRUPT TIMER2_OVF_vect
#endif
Cartographie logarithmique lisse
//
uint16_t antilogTable [] = {}
64830,64132,63441,62757,62081,61413,60751,60097,59449,58809,58176,57549,56929,56316,55709,55109,
54515,53928,53347,52773,52204,51642,51085,50535,49991,49452,48920,48393,47871,47356,46846,46341,
45842,45348,44859,44376,43898,43425,42958,42495,42037,41584,41136,40693,40255,39821,39392,38968,
38548,38133,37722,37316,36914,36516,36123,35734,35349,34968,34591,34219,33850,33486,33125,32768
};
uint16_t mapPhaseInc (entrée uint16_t) {}
Return (antilogTable [entrée & 0x3f]) >> (entrée >> 6) ;
}
A fait un pas de mappage chromatique
//
uint16_t midiTable [] = {}
17,18,19,20,22,23,24,26,27,29,31,32,34,36,38,41,43,46,48,51,54,58,61,65,69,73,
77,82,86,92,97,103,109,115,122,129,137,145,154,163,173,183,194,206,218,231,
244,259,274,291,308,326,346,366,388,411,435,461,489,518,549,581,616,652,691,
732,776,822,871,923,978,1036,1097,1163,1232,1305,1383,1465,1552,1644,1742,
1845,1955,2071,2195,2325,2463,2610,2765,2930,3104,3288,3484,3691,3910,4143,
4389,4650,4927,5220,5530,5859,6207,6577,6968,7382,7821,8286,8779,9301,9854,
10440,11060,11718,12415,13153,13935,14764,15642,16572,17557,18601,19708,20879,
22121,23436,24830,26306
};
uint16_t mapMidi (entrée uint16_t) {}
retour (midiTable[(1023-input) >> 3]) ;
}
Gradin cartographie pentatonique
//
uint16_t pentatonicTable [54] = {}
0,19,22,26,29,32,38,43,51,58,65,77,86,103,115,129,154,173,206,231,259,308,346,
411,461,518,616,691,822,923,1036,1232,1383,1644,1845,2071,2463,2765,3288,
3691,4143,4927,5530,6577,7382,8286,9854,11060,13153,14764,16572,19708,22121,26306
};
uint16_t mapPentatonic (entrée uint16_t) {}
uint8_t valeur = (1023-entrée) / (1024/53) ;
retour (pentatonicTable[value]) ;
}
void audioOn() {}
#if defined(__AVR_ATmega8__)
ATmega8 a différents registres
TCCR2 = _BV(WGM20) | _BV(COM21) | _BV(CS20) ;
TIMSK = _BV(TOIE2) ;
#elif defined(__AVR_ATmega1280__)
TCCR3A = _BV(COM3C1) | _BV(WGM30) ;
TCCR3B = _BV(CS30) ;
TIMSK3 = _BV(TOIE3) ;
#else
Mettre en place la PWM à 31,25 kHz, phase précise
TCCR2A = _BV(COM2B1) | _BV(WGM20) ;
TCCR2B = _BV(CS20) ;
TIMSK2 = _BV(TOIE2) ;
#endif
}
void setupRun() {}
pinMode(PWM_PIN,OUTPUT) ;
audioOn() ;
pinMode(LED_PIN,OUTPUT) ;
}
void loopRun() {}
La boucle est assez simple - il juste met à jour les paramètres pour les oscillateurs.
//
Évitez d’utiliser toutes les fonctions qui utilisent des interruptions ou désactiver les interruptions.
Qu’ils engendreront clics et fait ses besoins dans l’audio.
Cartographie de fréquence lisse
syncPhaseInc = mapPhaseInc(digitalRead(SYNC_CONTROL)) / 4 ;
ampPhaseInc = mapPhaseInc(digitalRead(AMP_CONTROL)) / 5 ;
A fait un pas de mappage à notes MIDI: Db, D, Eb, C, E, F....
syncPhaseInc = mapMidi(digitalRead(SYNC_CONTROL)) ;
A fait un pas de mappage pentatonique: D, E, G, A, B
syncPhaseInc = mapPentatonic(digitalRead(SYNC_CONTROL)) ;
grainPhaseInc = mapPhaseInc(analogRead(GRAIN_FREQ_CONTROL)) / 2 ;
grainDecay = analogRead(GRAIN_DECAY_CONTROL) / 8 ;
grain2PhaseInc = mapPhaseInc(analogRead(GRAIN2_FREQ_CONTROL)) / 2 ;
grain2Decay = analogRead(GRAIN2_DECAY_CONTROL) / 4 ;
grain3PhaseInc = mapPhaseInc(analogRead(GRAIN3_FREQ_CONTROL)) 2 ;
grain3Decay = analogRead(GRAIN2_DECAY_CONTROL) / 2 ;
}
SIGNAL(PWM_INTERRUPT)
{
valeur d’uint8_t ;
uint16_t de sortie ;
syncPhaseAcc += syncPhaseInc ;
Si (syncPhaseAcc < syncPhaseInc) {}
Temps de commencer le prochain grain
grainPhaseAcc = 0 ;
grainAmp = 0x7fff ;
grain2PhaseAcc = 0 ;
grain2Amp = 0x7fff ;
grain3PhaseAcc = 0 ;
grain3Amp = 0x7fff ;
LED_PORT ^ = 1 << LED_BIT ; Plus rapide que l’utilisation de digitalWrite
}
Incrémenter la phase des oscillateurs grain
grainPhaseAcc += grainPhaseInc ;
grain2PhaseAcc += grain2PhaseInc ;
Transformer une onde triangulaire de phase
valeur = (grainPhaseAcc >> 7) & 0xff ;
Si (grainPhaseAcc & 0 x 8000) valeur = ~ valeur ;
Multipliez par l’amplitude du courant grain pour obtenir l’échantillon
sortie = valeur * (grainAmp >> 8) ;
Répétez pour le second grain
valeur = (grain2PhaseAcc >> 7) & 0xff ;
Si (grain2PhaseAcc & 0 x 8000) valeur = ~ valeur ;
sortie valeur += * (grain2Amp >> 8) ;
Répéter pour le troisième grain
valeur = (grain3PhaseAcc >> 7) & 0xff ;
Si (grain3PhaseAcc & 0 x 8000) valeur = ~ valeur ;
sortie valeur += * (grain3Amp >> 8) ;
Faire le grain amplitudes carie causée par un facteur de chaque échantillon (décroissance exponentielle)
grainAmp-= (grainAmp >> 8) * grainDecay ;
grain2Amp-= (grain2Amp >> 8) * grain2Decay ;
grain3Amp-= (grain3Amp >> 8) * grain3Decay ;
Échelle de sortie à la plage disponible, détourage si nécessaire
sortie >> = 9 ;
Si sortie (sortie > 255) = 255 ;
Sortie de PWM (c’est plus rapide que l’utilisation d’analogWrite)
PWM_VALUE = output ;
}
/ * Fortement basé sur http://ardx.org/src/circ/CIRC06-code.txt
* et aussi http://ardx.org/src/circ/CIRC07-code.txt
* Informations circuit à http://www.oomlout.com/oom.php/products/ardx/circ-06
* et http://www.oomlout.com/oom.php/products/ardx/circ-07
* peut aussi aider à
*
* Le calcul des tons est fait suite à la mathématique
* opération :
*
* timeHigh = période / 2 = 1 / (2 * toneFrequency)
*
* où les tons différents sont décrits comme dans le tableau :
*
* note fréquence période timeHigh
* c 261 Hz 3830 1915
* d 294 Hz 3400 1700
* e 329 Hz 3038 1519
* f 349 Hz 2864 1432
* g 392 Hz 2550 1275
* un 440 Hz 2272 1136
* b 493 Hz 2028 1014
* C 523 Hz 1912 956
*
* http://www.arduino.cc/en/Tutorial/Melody
*/
int inputPin1 = 9 ;
int inputPin2 = 10 ;
int inputPin3 = 11 ;
int inputPin4 = 12 ;
int speakerPin = 3 ;
int val = 0 ;
int longueur = 1 ; le nombre de billets
note de char [] = {}
'c', 'd', 'e', 'f', 'g', 'a', 'b', 'C' }; un espace représente un repos
int bat [] = {}
1} ;
int tempo = 300 ;
playTone Sub (ton int, int duration) {}
pour (long j’ai = 0; i < durée * 1000L; i += ton * 2) {
digitalWrite (speakerPin, HIGH) ;
delayMicroseconds(tone) ;
digitalWrite (speakerPin, basse) ;
delayMicroseconds(tone) ;
}
}
void playNote (char Remarque, int duration) {}
char nom [] = {}
'c', 'd', 'e', 'f', 'g', 'a', 'b', 'C' };
les tons int [] = {}
1915, 1700, 1519, 1432, 1275, 1136, 1014, 956 };
Jouez le ton correspondant au nom de la note
pour (int i = 0; i < 8; i ++) {}
Si (noms [i] == note) {}
playTone (tons [i], durée) ;
}
}
}
void setupTone() {}
pinMode (speakerPin, sortie) ;
pinMode (inputPin1, entrée) ;
pinMode (inputPin2, entrée) ;
pinMode (inputPin3, entrée) ;
pinMode (inputPin4, entrée) ;
}
void loopTone() {}
Si (digitalRead(inputPin1) == HIGH) {}
playNote (notes [0], 300) ;
}
ElseIf (digitalRead(inputPin2) == HIGH) {}
playNote (notes [1], 300) ;
}
ElseIf (digitalRead(inputPin3) == HIGH) {}
playNote (notes [2], 300) ;
}
ElseIf (digitalRead(inputPin4) == HIGH) {}
playNote (notes [3], 300) ;
}
else {}
digitalWrite (speakerPin, basse) ;
}
}
/ * Code original, créé le 21 janvier 2010
/ mis à jour le 30 août 2011
/ par Tom Igoe (http://pastebin.com/tCYvfky9) et configuré par moi 2013 (mon code ci-dessous)
/
/ Quand vous seulement comment faire pour connecter l’arduino et de fait il joue la mélodie de base. Vous devriez commencer à coder
/
/ Tout d’abord de vous seront besoin les notes que vous pouvez copier coller le mien ou juste copier à partir de http://arduino.cc/en/Tutorial/Tone
/
*/
Nous commençons par definining toutes les notes
#define NOTE_B0 31
#define NOTE_C1 33
#define NOTE_CS1 35
#define NOTE_D1 37
#define NOTE_DS1 39
#define NOTE_E1 41
#define NOTE_F1 44
#define NOTE_FS1 46
#define NOTE_G1 49
#define NOTE_GS1 52
#define NOTE_A1 55
#define NOTE_AS1 58
#define NOTE_B1 62
#define NOTE_C2 65
#define NOTE_CS2 69
#define NOTE_D2 73
#define NOTE_DS2 78
#define NOTE_E2 82
#define NOTE_F2 87
#define NOTE_FS2 93
#define NOTE_G2 98
#define NOTE_GS2 104
#define NOTE_A2 110
#define NOTE_AS2 117
#define NOTE_B2 123
#define NOTE_C3 131
#define NOTE_CS3 139
#define NOTE_D3 147
#define NOTE_DS3 156
#define NOTE_E3 165
#define NOTE_F3 175
#define NOTE_FS3 185
#define NOTE_G3 196
#define NOTE_GS3 208
#define NOTE_A3 220
#define NOTE_AS3 233
#define NOTE_B3 247
#define NOTE_C4 262
#define NOTE_CS4 277
#define NOTE_D4 294
#define NOTE_DS4 311
#define NOTE_E4 330
#define NOTE_F4 349
#define NOTE_FS4 370
#define NOTE_G4 392
#define NOTE_GS4 415
#define NOTE_A4 440
#define NOTE_AS4 466
#define NOTE_B4 494
#define NOTE_C5 523
#define NOTE_CS5 554
#define NOTE_D5 587
#define NOTE_DS5 622
#define NOTE_E5 659
#define NOTE_F5 698
#define NOTE_FS5 740
#define NOTE_G5 784
#define NOTE_GS5 831
#define NOTE_A5 880
#define NOTE_AS5 932
#define NOTE_B5 988
#define NOTE_C6 1047
#define NOTE_CS6 1109
#define NOTE_D6 1175
#define NOTE_DS6 1245
#define NOTE_E6 1319
#define NOTE_F6 1397
#define NOTE_FS6 1480
#define NOTE_G6 1568
#define NOTE_GS6 1661
#define NOTE_A6 1760
#define NOTE_AS6 1865
#define NOTE_B6 1976
#define NOTE_C7 2093
#define NOTE_CS7 2217
#define NOTE_D7 2349
#define NOTE_DS7 2489
#define NOTE_E7 2637
#define NOTE_F7 2794
#define NOTE_FS7 2960
#define NOTE_G7 3136
#define NOTE_GS7 3322
#define NOTE_A7 3520
#define NOTE_AS7 3729
#define NOTE_B7 3951
#define NOTE_C8 4186
#define NOTE_CS8 4435
#define NOTE_D8 4699
#define NOTE_DS8 4978
/*
Bouton
Tours et éteindre un feu émettant diode(LED) connecté au numérique
broche 13, lorsqu’en appuyant sur un bouton poussoir relié à la broche 7.
Le circuit :
* LED joint de pin 13 à terre
* bouton poussoir joint à la broche 6 de + 5V
* 10K résistance joint à la broche 6 du sol
* Remarque : sur la plupart des Arduinos il y a déjà une LED sur la carte
attaché à la broche 13.
créé 2005
par DojoDave < http://www.0j0.org>
mis à jour le 17 juin 2009
par Tom Igoe
http://www.Arduino.cc/en/Tutorial/Button
*/
les constantes ne changeront pas. Ils sont utilisés ici pour
Définissez les codes pin :
const int buttonPin = 6 ; le nombre de la tige poussoir
int Buzzer1 = 3 ;
variables vont changer :
buttonState int = 0 ; variable pour la lecture de l’état de bouton poussoir
void setupMelody() {}
initialiser le piezo en sortie :
pinMode (Buzzer1, sortie) ;
initialiser la tige poussoir comme entrée :
pinMode (buttonPin, entrée) ;
}
void loopMelody() {}
lire l’état de la valeur du bouton poussoir :
buttonState = digitalRead(buttonPin) ;
Vérifiez si le bouton est appuyé.
Si c’est le cas, le buttonState est haute :
Si (buttonState == HIGH) {}
jouer th musique
Tone(Buzzer1,400,200) ;
Delay(500) ;
Tone(Buzzer1,400,200) ;
Delay(500) ;
Tone(Buzzer1,450,225) ;
Delay(300) ;
Tone(Buzzer1,450,225) ;
Delay(500) ;
Tone(Buzzer1,400,200) ;
Delay(500) ;
Tone(Buzzer1,450,200) ;
Delay(300) ;
Tone(Buzzer1,600,300) ;
Delay(300) ;
Tone(Buzzer1,400,200) ;
Delay(500) ;
Tone(Buzzer1,700,300) ;
Delay(300) ;
Tone(Buzzer1,700,300) ;
Delay(500) ;
Tone(Buzzer1,600,300) ;
Delay(300) ;
Tone(Buzzer1,400,200) ;
Delay(1000) ;
Tone(Buzzer1,400,200) ;
Delay(500) ;
Tone(Buzzer1,650,200) ;
Delay(500) ;
Tone(Buzzer1,400,200) ;
Delay(500) ;
Tone(Buzzer1,650,200) ;
Delay(300) ;
Tone(Buzzer1,650,200) ;
Delay(500) ;
Tone(Buzzer1,400,200) ;
Delay(500) ;
Tone(Buzzer1,400,200) ;
Delay(500) ;
Tone(Buzzer1,400,200) ;
Delay(1000) ;
Tone(Buzzer1,400,200) ;
Delay(500) ;
Tone(Buzzer1,400,200) ;
Delay(500) ;
Tone(Buzzer1,600,300) ;
Delay(500) ;
Tone(Buzzer1,600,300) ;
Delay(500) ;
Tone(Buzzer1,800,300) ;
Delay(500) ;
Tone(Buzzer1,800,300) ;
Delay(500) ;
Tone(Buzzer1,400,200) ;
Tone(Buzzer1,400,200) ;
Delay(500) ;
Tone(Buzzer1,400,200) ;
Delay(500) ;
Tone(Buzzer1,400,200) ;
Delay(500) ;
Tone(Buzzer1,300,150) ;
Delay(500) ;
Tone(Buzzer1,300,150) ;
Delay(500) ;
Tone(Buzzer1,300,150) ;
Delay(500) ;
Tone(Buzzer1,300,150) ;
Delay(500) ;
Tone(Buzzer1,300,150) ;
Tone(Buzzer1,300,150) ;
Tone(Buzzer1,300,150) ;
Tone(Buzzer1,300,150) ;
}
}
/*
Tactile capacitif Arduino clavier Piano
Joue piano tons par un signal sonore lorsque l’utilisateur clique sur tactile piano « clés »
Créé le 18 mai 2013
Mis à jour le 23 mai 2013
par Tyler Crumpton et Nicholas Jones
Ce code est rejeté dans le domaine public. Pour plus d’informations sur le circuit,
Visitez le didacticiel Instructable à
*/
#include < CapacitiveSensor.h >
#define COMMON_PIN 0 / / le bon « envoyer » broche pour toutes les clés
#define BUZZER_PIN 3 / / la sortie pin pour le buzzer piezo
#define NUM_OF_SAMPLES 10 / / NB plus élevés quand les de plus retarder mais des mesures plus homogènes
#define CAP_THRESHOLD 150 / / capacitif qui déclenche une note de lecture (ajuster selon vos besoins)
#define NUM_OF_KEYS 2 / / nombre de touches qui se trouvent sur le clavier
Cette macro crée un objet de « clé » capteur de capacité pour chaque touche sur le clavier de piano :
#define CS(Y) CapacitiveSensor (0, Y)
Chaque touche correspond à une note, qui sont définies ici. Décommentez l’échelle que vous souhaitez utiliser :
int observe1 [] = {}
NOTE_C4, NOTE_D4, NOTE_E4, NOTE_F4, NOTE_G4, NOTE_A4, NOTE_B4, NOTE_C5} ; Échelle de do majeur
int observe1 [] = {NOTE_A4, NOTE_B4, NOTE_C5, NOTE_D5, NOTE_E5, NOTE_F5, NOTE_G5, NOTE_A5} ; Gamme de la mineur
int observe1 [] = {NOTE_C4, NOTE_DS4, NOTE_F4, NOTE_FS4, NOTE_G4, NOTE_AS4, NOTE_C5, NOTE_DS5} ; Gamme de Blues C
Définit les broches que les touches sont connectés à :
CapacitiveSensor touches [] = {}
CS(7), CS(8)} ;
void setupcap() {}
Désactiver l’option autocalibrate sur tous les canaux :
pour (int i = 0; i < 8; ++ j’ai) {
Keys[i].set_CS_AutocaL_Millis(0xFFFFFFFF) ;
}
Définissez le buzzer en tant que sortie :
pinMode (BUZZER_PIN, sortie) ;
}
void loopcap() {}
Effectuer une boucle sur chaque clé :
pour (int i = 0; i < 8; ++ j’ai) {
Si la lecture de la capacité est supérieure au seuil, jouez une note :
if(Keys[i].capacitiveSensor(NUM_OF_SAMPLES) > CAP_THRESHOLD) {}
ton (BUZZER_PIN, notes[i]) ; Joue la note correspondant à la touche enfoncée
}
}
}