Stap 7: code
Deze code is eigendom van kevin cross als geheel maar ik ben niet de eigenaar de de afzonderlijke onbewerkte delen van de code / /de synthduino / /
VOID Setup {}
setupSleep();
setuphello();
setuphello1();
setupRun();
setupTone();
setupMelody();
setupcap();
}
void loop {}
loopSleep();
loophello();
loophello1();
loopRun();
loopTone();
loopMelody();
loopcap();
}
/ * Demo Serial slapen
* -----------------
* Voorbeeld code om aan te tonen van de functies van de slaap in een Arduino. Arduino zal wakker worden
* Wanneer nieuwe gegevens wordt ontvangen in de seriële poort USART
* Gebaseerd op slapen Demo seriële uit http://www.arduino.cc/playground/Learning/ArduinoSleepCode
*
* Copyright (C) 2006 MacSimski 2006-12-30
* Copyright (C) 2007 D. Cuartielles 2007-07-08 - Mexico DF
*
* Met wijzigingen van Ruben Laguna 2008-10-15
*
* Dit programma is vrije software: je kunt het herdistribueren en/of wijzigen
* het onder de voorwaarden van de GNU General Public License zoals gepubliceerd door
* de Free Software Foundation, hetzij versie 3 van de licentie, of
* (naar uw keuze) een latere versie.
*
* Deze software wordt verspreid in de hoop dat het bruikbaar,
* maar zonder enige garantie; zelfs zonder de impliciete garantie van
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. Zie de
* De GNU General Public License voor meer details.
*
* U moet hebt ontvangen een kopie van de GNU General Public License
* samen met dit programma. Zo niet, zie < http://www.gnu.org/licenses/>.
*
*/
#include < avr/power.h >
#include < avr/sleep.h >
int sleepStatus = 0; variabele op te slaan van een verzoek om slaap
int count = 0; teller
VOID setupSleep()
{
Serial.begin(9600);
}
VOID sleepNow()
{
/ * Nu is het tijd om de slaapstand te activeren. In het gegevensblad Atmega8
* http://www.atmel.com/dyn/resources/prod_documents/doc2486.pdf op pagina 35
* Er is een lijst van slaap zedig waarin wordt uitgelegd welke klokken en
* Wekdienst bronnen zijn beschikbaar in welke slaap-modus.
*
* In het avr/sleep.h-bestand zijn de namen van de oproep van deze slaap-modus te vinden:
*
* De 5 verschillende modi zijn:
* SLEEP_MODE_IDLE-de minste energiebesparing
* SLEEP_MODE_ADC
* SLEEP_MODE_PWR_SAVE
* SLEEP_MODE_STANDBY
* SLEEP_MODE_PWR_DOWN-de meest energiebesparing
*
* het energiebeheer voor vermindering < avr/power.h > wordt beschreven in
* http://www.nongnu.org/avr-libc/user-manual/group__avr__power.html
*/
set_sleep_mode(SLEEP_MODE_IDLE); slaapstand ligt hier
sleep_enable(); kunnen de slaap bit in het mcucr-register
slapen is dus mogelijk. gewoon een veiligheidsspeld
power_adc_disable();
power_spi_disable();
power_timer0_disable();
power_timer1_disable();
power_timer2_disable();
power_twi_disable();
SLEEP_MODE(); Hier is het apparaat eigenlijk laten inslapen!!
HET PROGRAMMA BLIJFT VANAF HIER NA HET WAKKER WORDEN
sleep_disable(); eerste ding na het ontwaken uit de slaap:
Ontredderen slaap...
power_all_enable();
}
VOID loopSleep()
{
informatie weergeven over de teller
Serial.Print ("Awake voor");
Serial.Print(Count);
Serial.println("sec");
Graaf ++;
delay(1000);
wacht een seconde
de ingang voor seriële berekenen
Als (Serial.available()) {}
int val = Serial.read();
Als (val == de ') {}
Serial.println ("seriële: invoeren van slaap wijze");
delay(100); deze vertraging is nodig, de slaap
functie zal provoceren een seriële fout anders!!
Graaf = 0;
sleepNow(); Sleep functie genaamd hier
}
Als (val == 'A') {}
Serial.println ("Hola Caracola"); klassieke dummy bericht
}
}
Controleer als het in slaap moet gaan vanwege de tijd
Als (graaf > = 10) {}
Serial.println ("Timer: invoeren van slaap wijze");
delay(100); deze vertraging is nodig, de slaap
functie zal provoceren een seriële fout anders!!
Graaf = 0;
sleepNow(); Sleep functie genaamd hier
}
}
Arduino Sound Hallo wereld
Gemaakt door David Fowler van uCHobby.com
Definiëren van de I/O pin die we voor onze geluid gebruiken zullen
#define SOUNDOUT_PIN 3
ongeldig setuphello(void) {}
Het geluid uit pin ingesteld op uitvoermodus
pinMode(SOUNDOUT_PIN,OUTPUT);
}
ongeldig loophello(void) {}
Geluid genereren door het wisselen van de I/O pin High and Low
Het genereren van een Toon van 1KHz. vervolgens de pincode hoog voor 500uS instellen
laag voor 500uS te maken de periode 1ms of 1KHz.
De hoge pincode instellen en vertraging voor 1/2 een cyclus van 1KHz, 500uS.
digitalWrite(SOUNDOUT_PIN,HIGH);
delayMicroseconds(500);
De pin laag ingesteld en vertraging voor 1/2 een cyclus van 1KHz, 500uS.
digitalWrite(SOUNDOUT_PIN,LOW);
delayMicroseconds(500);
}
ongeldig setuphello1() {}
pinMode (13, OUTPUT);
}
ongeldig loophello1() {}
delay(3000); 3 СЕК ВТИК
digitalWrite (13, hoge);
delay(125);
digitalWrite (13, laag); // .
delay(125);
digitalWrite (13, hoge);
delay(125);
digitalWrite (13, laag); // ..
delay(125);
digitalWrite (13, hoge);
delay(125);
digitalWrite (13, laag); // ...
delay(125);
digitalWrite (13, hoge);
delay(125);
digitalWrite (13, laag); // .... H
delay(125);
digitalWrite (13, hoge);
delay(125);
digitalWrite (13, laag); // . E
delay(125);
digitalWrite (13, hoge);
delay(125);
digitalWrite (13, laag); // .
delay(125);
digitalWrite (13, hoge);
delay(375);
digitalWrite (13, laag); // . -
delay(125);
digitalWrite (13, hoge);
delay(125);
digitalWrite (13, laag); // .-.
delay(125);
digitalWrite (13, hoge);
delay(125);
digitalWrite (13, laag); // .-.. L
delay(125);
digitalWrite (13, laag); // .
delay(125);
digitalWrite (13, hoge);
delay(375);
digitalWrite (13, laag); // . -
delay(125);
digitalWrite (13, hoge);
delay(125);
digitalWrite (13, laag); // .-.
delay(125);
delay(125);
digitalWrite (13, hoge);
delay(125);
digitalWrite (13, laag); // .-.. L
delay(125);
digitalWrite (13, hoge);
delay(375);
digitalWrite (13, laag); // -
delay(125);
digitalWrite (13, hoge);
delay(375);
digitalWrite (13, laag); // --
delay(125);
digitalWrite (13, hoge);
delay(375);
digitalWrite (13, laag); // --- O
delay(3000); 3 СЕК ВТИК
}
Auduino, de Lo-Fi granular synthesizer
//
door Peter Knight, Tinker.it http://tinker.it
//
Help: http://code.google.com/p/tinkerit/wiki/Auduino
Meer informatie: http://groups.google.com/group/auduino
//
Analoge in 0: 1 worp van graan
Analoge in 1: graan 2 verval
Analoge in 2: 1 verval van graan
Analoog in 3: graan 2 toonhoogte
Analoge in 4: graan 3 pitch
Analoge in 5: graan 3 verval
//
Digitale 4: Graan repition frequentie
Digitale 5: Graan amplitude frequentie
//
Digitale 3: Audio-uitgang (digitale 11 op ATmega8)
//
Changelog:
19 Nov 2008: Added support voor ATmega8 boards
21 Mar 2009: Added support voor ATmega328 boards
7 Apr 2009: vaste interruptvector voor ATmega328 boards
8 Apr 2009: toegevoegde ondersteuning voor ATmega1280 boards (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;
Kaart analoge kanalen
#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)
Kaart van digitale kanalen
#define SYNC_CONTROL (4)
#define AMP_CONTROL (5)
Wijzigt deze zal ook, moet herschrijven van audioOn()
#if defined(__AVR_ATmega8__)
//
Op oude ATmega8 boards.
Uitvoer is op pin 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__)
//
Op de Arduino Mega
Uitvoer is op pin 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
//
Voor moderne ATmega168 en ATmega328 boards
Uitvoer is op pin 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
Soepele logaritmische toewijzing
//
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 (ingang uint16_t) {}
retourneren (antilogTable [input & 0x3f]) >> (ingang >> 6);
}
Stapte chromatische toewijzing
//
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 (ingang uint16_t) {}
retourneren (midiTable[(1023-input) >> 3]);
}
Stapte pentatonische toewijzing
//
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 (ingang uint16_t) {}
uint8_t waarde = (1023-input) / (1024/53);
terugkeer (pentatonicTable[value]);
}
ongeldig audioOn() {}
#if defined(__AVR_ATmega8__)
ATmega8 heeft verschillende registers
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
PWM instellen voor 31,25 kHz, fase nauwkeurig
TCCR2A = _BV(COM2B1) | _BV(WGM20);
TCCR2B = _BV(CS20);
TIMSK2 = _BV(TOIE2);
#endif
}
ongeldig setupRun() {}
pinMode(PWM_PIN,OUTPUT);
audioOn();
pinMode(LED_PIN,OUTPUT);
}
ongeldig loopRun() {}
De lus is vrij eenvoudig - het werkt alleen de parameters voor de oscillatoren.
//
Vermijd het gebruik van alle functies die uitgebreid gebruik van interrupts maken of interrupts uitschakelen.
Zij zal leiden tot klikken en poept in de audio.
Soepele frequentie toewijzing
syncPhaseInc = mapPhaseInc(digitalRead(SYNC_CONTROL)) / 4;
ampPhaseInc = mapPhaseInc(digitalRead(AMP_CONTROL)) / 5;
Stapte toewijzen aan MIDI notities: C met Db, D, Eb, E, F...
syncPhaseInc = mapMidi(digitalRead(SYNC_CONTROL));
Stapte pentatonische toewijzing: 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)
{
uint8_t waarde;
uint16_t output;
syncPhaseAcc += syncPhaseInc;
Als (syncPhaseAcc < syncPhaseInc) {}
Tijd om te beginnen de volgende korrel
grainPhaseAcc = 0;
grainAmp = 0x7fff;
grain2PhaseAcc = 0;
grain2Amp = 0x7fff;
grain3PhaseAcc = 0;
grain3Amp = 0x7fff;
LED_PORT ^ = 1 << LED_BIT; Sneller dan met behulp van digitalWrite
}
_ / / Verhogen de fase van de korrel oscillatoren
grainPhaseAcc += grainPhaseInc;
grain2PhaseAcc += grain2PhaseInc;
Fase omzetten in een driehoek golf
waarde = (grainPhaseAcc >> 7) & 0xff;
Als (grainPhaseAcc & 0x8000) waarde = ~ waarde;
Vermenigvuldig met huidige graan amplitude om monster
uitvoer = value * (grainAmp >> 8);
Herhaal voor tweede graan
waarde = (grain2PhaseAcc >> 7) & 0xff;
Als (grain2PhaseAcc & 0x8000) waarde = ~ waarde;
uitgang += waarde * (grain2Amp >> 8);
Herhaal voor derde graan
waarde = (grain3PhaseAcc >> 7) & 0xff;
Als (grain3PhaseAcc & 0x8000) waarde = ~ waarde;
uitgang += waarde * (grain3Amp >> 8);
Maken van de korrel amplitudes verval met een factor van elke steekproef (exponentiële afname)
grainAmp-= (grainAmp >> 8) * grainDecay;
grain2Amp-= (grain2Amp >> 8) * grain2Decay;
grain3Amp-= (grain3Amp >> 8) * grain3Decay;
Schaal output naar het beschikbare bereik, knippen indien nodig
uitvoer >> = 9;
als output (uitgang > 255) = 255;
Uitvoer naar PWM (dit is sneller dan het gebruik van analogWrite)
PWM_VALUE = output;
}
/ * Zwaar op basis van http://ardx.org/src/circ/CIRC06-code.txt
* en ook http://ardx.org/src/circ/CIRC07-code.txt
* Circuit informatie op http://www.oomlout.com/oom.php/products/ardx/circ-06
* en http://www.oomlout.com/oom.php/products/ardx/circ-07
* kan ook helpen
*
* De berekening van de tonen is gemaakt na de wiskundige
* bewerking:
*
* timeHigh = periode / 2 = 1 / (2 * toneFrequency)
*
* waar de verschillende tonen worden beschreven als in de tabel:
*
* Opmerking frequentie periode 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
* een 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 lengte = 1; het aantal notities
char merkt [] {} =
'c', 'd', 'e', 'f', 'g', 'a', 'b', 'C' }; een ruimte vertegenwoordigt een rust
int verslaat [] {} =
1};
int tempo = 300;
VOID playTone (int Toon, int duur) {}
voor (lang ik = 0; ik < duur * 1000L; ik += Toon * 2) {}
digitalWrite (speakerPin, hoge);
delayMicroseconds(tone);
digitalWrite (speakerPin, laag);
delayMicroseconds(tone);
}
}
VOID playNote (char opmerking, int duur) {}
char names [] {} =
'c', 'd', 'e', 'f', 'g', 'a', 'b', 'C' };
int tonen [] {} =
1915, 1700, 1519, 1432, 1275, 1136, 1014, 956 };
spelen van de Toon die overeenkomt met de naam van de noot
for (int i = 0; ik < 8; i ++) {}
Als (namen [i] == Opmerking) {}
playTone (tonen [i], duur);
}
}
}
ongeldig setupTone() {}
pinMode (speakerPin, OUTPUT);
pinMode (inputPin1, INPUT);
pinMode (inputPin2, INPUT);
pinMode (inputPin3, INPUT);
pinMode (inputPin4, INPUT);
}
ongeldig loopTone() {}
Als (digitalRead(inputPin1) == HIGH) {}
playNote (notes [0], 300);
}
else if (digitalRead(inputPin2) == HIGH) {}
playNote (notes [1], 300);
}
else if (digitalRead(inputPin3) == HIGH) {}
playNote (notes [2], 300);
}
else if (digitalRead(inputPin4) == HIGH) {}
playNote (notes [3], 300);
}
else {}
digitalWrite (speakerPin, laag);
}
}
/ * Oorspronkelijke code gemaakt van 21-Jan-2010
/ vernieuwde 30 Aug 2011
/ door Tom Igoe (http://pastebin.com/tCYvfky9) en geconfigureerd door mij 2013 (mijn code hieronder)
/
/ Wanneer u firgure aansluiten op de arduino uit en maakte het spelen de fundamentele melodie. U moet beginnen met coderen
/
/ Eerst van u zal moeten de notities die u kunt kopiëren en plakken de mijne of gewoon kopiëren van de http://arduino.cc/en/Tutorial/Tone
/
*/
We beginnen met definining alle notities
#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
/*
Knop
Bochten in- en uitschakelen een oplichtende diode(LED) verbonden met digitale
pin 13, bij het indrukken van een drukknop verbonden met pin 7.
Het circuit:
* LED verbonden vanaf pin 13 op grond
* drukknop verbonden met pin 6 van + 5V
* De 10K weerstand zijn verbonden met pin 6 vanaf de grond
* Opmerking: op de meeste Arduinos bestaat al een LED op het bord
verbonden met pin 13.
gemaakte 2005
door DojoDave < http://www.0j0.org>
gemodificeerde 17 Jun 2009
door Tom Igoe
http://www.Arduino.CC/en/tutorial/button
*/
constanten niet gewijzigd. Ze gewend bent hier
pin-codes instellen
Const int buttonPin = 6; het nummer van de drukknop pin
int Buzzer1 = 3;
variabelen zal veranderen:
int buttonState = 0; variabele voor het lezen van de drukknop status
ongeldig setupMelody() {}
Initialiseer de piezo als output:
pinMode (Buzzer1, uitvoer);
Initialiseer de drukknop pin als input:
pinMode (buttonPin, INPUT);
}
ongeldig loopMelody() {}
Lees de stand van de drukknop waarde:
buttonState = digitalRead(buttonPin);
Controleer als de drukknop ingedrukt is.
Als het is, is de buttonState hoog:
Als (buttonState == HIGH) {}
th spelen muziek
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);
}
}
/*
Capacitieve-Touch Arduino toetsenbord Piano
Speelt piano tonen via een zoemer wanneer de gebruiker aanraakgevoelige piano "keys kranen"
Gemaakt van 18 mei 2013
Gemodificeerde 23 mei 2013
door Tyler Crumpton en Nicholas Jones
Deze code wordt vrijgegeven aan het publiek domein. Voor informatie over het circuit,
Bezoek de Instructable tutorial op
*/
#include < CapacitiveSensor.h >
#define COMMON_PIN 0 / / het gemeenschappelijk 'verzenden' pin voor alle sleutels
#define BUZZER_PIN 3 / / de uitvoer pin voor de piëzo-zoemer
#define NUM_OF_SAMPLES 10 / / hoger aantal wanneer meer vertraging maar consequenter lezingen
#define CAP_THRESHOLD 150 / / Capactive lezen dat triggers een notitie (aanpassen aan uw behoeften)
#define NUM_OF_KEYS 2 / / aantal sleutels die op het toetsenbord
Deze macro maakt u een capaciteit "sleutel" sensor-object voor elke sleutel op de piano toetsenbord:
#define CS(Y) CapacitiveSensor (0, Y)
Elke sleutel overeenkomt met een noot, die hier zijn gedefinieerd. Uncomment de schaal die u wilt gebruiken:
int notes1 [] {} =
NOTE_C4, NOTE_D4, NOTE_E4, NOTE_F4, NOTE_G4, NOTE_A4, NOTE_B4, NOTE_C5}; C-grote schaal
int notes1 [] = {NOTE_A4, NOTE_B4, NOTE_C5, NOTE_D5, NOTE_E5, NOTE_F5, NOTE_G5, NOTE_A5}; A-Minor schaal
int notes1 [] = {NOTE_C4, NOTE_DS4, NOTE_F4, NOTE_FS4, NOTE_G4, NOTE_AS4, NOTE_C5, NOTE_DS5}; C Blues schaal
Definieert de pinnen die de sleutels zijn verbonden met:
CapacitiveSensor toetsen [] {} =
CS(7), CS(8)};
ongeldig setupcap() {}
Autocalibrate op alle kanalen uitschakelen:
for (int i = 0; ik < 8; ++ ik) {}
Keys[i].set_CS_AutocaL_Millis(0xFFFFFFFF);
}
De zoemer als uitgang instellen
pinMode (BUZZER_PIN, uitvoer);
}
ongeldig loopcap() {}
Elke sleutel doorlopen:
for (int i = 0; ik < 8; ++ ik) {}
Als de capaciteit lezing groter dan de drempel is, een noot speelt:
if(Keys[i].capacitiveSensor(NUM_OF_SAMPLES) > CAP_THRESHOLD) {}
Toon (BUZZER_PIN, notes[i]); De notitie die overeenkomt met de ingedrukte speelt
}
}
}