Paso 7: código de
Este código es propiedad de kevin Cruz en su conjunto pero no soy el propietario del sin editar las partes individuales del código / /la synthduino / /
void setup() {}
setupSleep();
setuphello();
setuphello1();
setupRun();
setupTone();
setupMelody();
setupcap();
}
void loop() {}
loopSleep();
loophello();
loophello1();
loopRun();
loopTone();
loopMelody();
loopcap();
}
/ * Demo serie de dormir
* -----------------
* Ejemplo de código para demostrar las funciones del sueño en un Arduino. Arduino se despertará
* Cuando se reciben nuevos datos en el puerto serie USART
* Basado en dormir Demo Serial de http://www.arduino.cc/playground/Learning/ArduinoSleepCode
*
* Copyright (C) 2006 MacSimski 2006-12-30
* Copyright (C) 2007 D. Cuartiella 2007-07-08 - Mexico DF
*
* Con las modificaciones de Rubén Laguna 2008-10-15
*
* Este programa es software libre: usted puede redistribuirlo y/o modificar
* que en los términos de la GNU General Public License publicada por
* la Free Software Foundation, ya sea la versión 3 de la licencia, o
* (a su opción) cualquier versión posterior.
*
* Este programa se distribuye con la esperanza de que sea útil,
* pero sin ninguna garantía; ni siquiera la garantía implícita de
* COMERCIABILIDAD o aptitud para un propósito PARTICULAR. Ver la
* GNU General Public License para más detalles.
*
* Usted debe han recibido una copia de la Licencia Pública General de GNU
* con este programa. Si no, consulte < http://www.gnu.org/licenses/>.
*
*/
#include < avr/power.h >
#include < avr/sleep.h >
int sleepStatus = 0; variable para almacenar una solicitud para el sueño
int cuenta = 0; contador
void setupSleep()
{
Serial.Begin(9600);
}
void sleepNow()
{
/ * Ahora es el momento para establecer el modo de suspensión. En la hoja de datos de Atmega8
* http://www.atmel.com/dyn/resources/prod_documents/doc2486.pdf Página 35
* hay una lista de modos de suspensión que explica qué relojes y
* despertador fuentes están disponibles en que modo de sueño.
*
* En el archivo de avr/sleep.h, los nombres de la llamada de estos modus de sueño deben ser encontrados:
*
* Los 5 diferentes modos son:
* SLEEP_MODE_IDLE-el ahorro de energía menos
* SLEEP_MODE_ADC
* SLEEP_MODE_PWR_SAVE
* SLEEP_MODE_STANDBY
* SLEEP_MODE_PWR_DOWN-el máximo ahorro de energía
*
* la gestión de reducción de energía < avr/power.h > se describe en
* http://www.nongnu.org/avr-libc/user-manual/group__avr__power.html
*/
set_sleep_mode(SLEEP_MODE_IDLE); modo de reposo se encuentra aquí
sleep_enable(); permite que el pedacito de sueño en el registro mcucr
por lo que el sueño es posible. solo un perno de seguridad
power_adc_disable();
power_spi_disable();
power_timer0_disable();
power_timer1_disable();
power_timer2_disable();
power_twi_disable();
sleep_mode(); Aquí el dispositivo realmente se pone a dormir!!
EL PROGRAMA CONTINÚA AQUÍ DESPUÉS DE DESPERTAR
sleep_disable(); lo primero después de despertar del sueño:
desactivar el sueño...
power_all_enable();
}
void loopSleep()
{
Mostrar información sobre el contador
Serial.Print ("despierto para");
Serial.Print(Count);
Serial.println("SEC");
cuenta ++;
Delay(1000);
espera un segundo
calcular la entrada serial
Si (Serial.available()) {}
int val = Serial.read();
Si (val == de ') {}
Serial.println ("Serial: entrar en Sleep mode");
Delay(100); este retraso es necesario, el sueño
función provocará un error de Serial lo contrario!!
cuenta = 0;
sleepNow(); función del sueño llamada aquí
}
Si (val == 'A') {}
Serial.println ("Hola Caracola"); clásicos mensaje dummy
}
}
Compruebe si se debe ir dormido debido a tiempo
Si (cuenta > = 10) {}
Serial.println ("contador de tiempo: entrar en Sleep mode");
Delay(100); este retraso es necesario, el sueño
función provocará un error de Serial lo contrario!!
cuenta = 0;
sleepNow(); función del sueño llamada aquí
}
}
Sonido de Arduino Hola mundo
Creado por David Fowler de uCHobby.com
Definir el pin I/O que utilizaremos para nuestra salida de sonido
#define SOUNDOUT_PIN 3
void setuphello(void) {}
Configurar el sonido pasador a modo de salida
pinMode(SOUNDOUT_PIN,OUTPUT);
}
void loophello(void) {}
Generar sonido activando el pin de I/O de alta y baja
Generar un tono de 1KHz. configurar el pin alto para 500uS entonces
baja de 500uS hacer el período de 1 ms o 1KHz.
Configurar el pin alta y retrasar de 1/2 un ciclo de 1KHz, 500uS.
digitalWrite(SOUNDOUT_PIN,HIGH);
delayMicroseconds(500);
Configurar el pin baja y retardo de 1/2 un ciclo de 1KHz, 500uS.
digitalWrite(SOUNDOUT_PIN,LOW);
delayMicroseconds(500);
}
void setuphello1() {}
pinMode (13, salida);
}
void loophello1() {}
Delay(3000); СЕК 3 ВТИК
digitalWrite (13, HIGH);
Delay(125);
digitalWrite (13, bajo); // .
Delay(125);
digitalWrite (13, HIGH);
Delay(125);
digitalWrite (13, bajo); // ..
Delay(125);
digitalWrite (13, HIGH);
Delay(125);
digitalWrite (13, bajo); // ...
Delay(125);
digitalWrite (13, HIGH);
Delay(125);
digitalWrite (13, bajo); // .... H
Delay(125);
digitalWrite (13, HIGH);
Delay(125);
digitalWrite (13, bajo); // . E
Delay(125);
digitalWrite (13, HIGH);
Delay(125);
digitalWrite (13, bajo); // .
Delay(125);
digitalWrite (13, HIGH);
Delay(375);
digitalWrite (13, bajo); // . -
Delay(125);
digitalWrite (13, HIGH);
Delay(125);
digitalWrite (13, bajo); // .-.
Delay(125);
digitalWrite (13, HIGH);
Delay(125);
digitalWrite (13, bajo); // .-.. L
Delay(125);
digitalWrite (13, bajo); // .
Delay(125);
digitalWrite (13, HIGH);
Delay(375);
digitalWrite (13, bajo); // . -
Delay(125);
digitalWrite (13, HIGH);
Delay(125);
digitalWrite (13, bajo); // .-.
Delay(125);
Delay(125);
digitalWrite (13, HIGH);
Delay(125);
digitalWrite (13, bajo); // .-.. L
Delay(125);
digitalWrite (13, HIGH);
Delay(375);
digitalWrite (13, bajo); // -
Delay(125);
digitalWrite (13, HIGH);
Delay(375);
digitalWrite (13, bajo); // --
Delay(125);
digitalWrite (13, HIGH);
Delay(375);
digitalWrite (13, bajo); // --- O
Delay(3000); СЕК 3 ВТИК
}
Auduino, Lo-Fi sintetizador granular
//
por Peter Knight, Tinker.it http://tinker.it
//
Ayuda: http://code.google.com/p/tinkerit/wiki/Auduino
Más ayuda: http://groups.google.com/group/auduino
//
Analógica de 0: 1 echada del grano
Analógica 1: decaimiento de grano 2
Analógica de 2: 1 deterioro del grano
Analógica 3: tono de grano 2
Analógica 4: campo de grano 3
Analógico en el 5: decaimiento del grano 3
//
4 digital: Frecuencia de repetirse de grano
Digital 5: Frecuencia de la amplitud del grano
//
Digital 3: Audio (Digital 11 en ATmega8)
//
Changelog:
19 de noviembre de 2008: se agrega soporte para tableros de ATmega8
21 de marzo de 2009: añadido soporte para las placas ATmega328
07 de abril de 2009: vector de interrupción fija para los tableros del ATmega328
08 de abril de 2009: añadido soporte para tableros de ATmega1280 (Arduino Mega)
#include < avr/io.h >
#include < avr/interrupt.h >
syncPhaseAcc de uint16_t;
syncPhaseInc de uint16_t;
ampPhaseAcc de uint16_t;
ampPhaseInc de uint16_t;
uint16_t grainPhaseAcc;
uint16_t grainPhaseInc;
uint16_t grainAmp;
uint8_t grainDecay;
grain2PhaseAcc de uint16_t;
grain2PhaseInc de uint16_t;
grain2Amp de uint16_t;
grain2Decay de uint8_t;
grain3PhaseAcc de uint16_t;
grain3PhaseInc de uint16_t;
grain3Amp de uint16_t;
grain3Decay de uint8_t;
Mapa de canales analógicos
#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)
Mapa Digital canales
#define SYNC_CONTROL (4)
#define AMP_CONTROL (5)
Cambio de estos se requiere también reescribir audioOn()
#if defined(__AVR_ATmega8__)
//
En antiguas placas de ATmega8.
Salida es el 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__)
//
En el Arduino Mega
Salida está en el 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
//
Para las modernas placas ATmega168 y ATmega328
Salida está en el 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
Lisa mapeo logarítmico
//
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 (entrada uint16_t) {}
volver (antilogTable [entrada & 0x3f]) >> (entrada >> 6);
}
Caminó mapeo cromático
//
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 (entrada uint16_t) {}
volver (midiTable[(1023-input) >> 3]);
}
Caminó asignación pentatónica
//
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 (entrada uint16_t) {}
valor de uint8_t = (1023-entrada) / (1024/53);
retorno (pentatonicTable[value]);
}
void audioOn() {}
#if defined(__AVR_ATmega8__)
ATmega8 tiene diferentes registros
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
Configurar el PWM a 31.25 kHz, fase precisa
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() {}
El circuito es bastante simple, simplemente actualiza los parámetros de los osciladores.
//
Evitar el uso de las funciones que hacen uso extensivo de las interrupciones, o desactivar interrupciones.
Causarán clics y poops en el audio.
Asignación de frecuencia uniforme
syncPhaseInc = mapPhaseInc(digitalRead(SYNC_CONTROL)) / 4;
ampPhaseInc = mapPhaseInc(digitalRead(AMP_CONTROL)) / 5;
Caminó a notas MIDI: C, Db, D, Eb, E, f el....
syncPhaseInc = mapMidi(digitalRead(SYNC_CONTROL));
Caminó asignación pentatónica: 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)
{
valor de uint8_t;
uint16_t de salida;
syncPhaseAcc += syncPhaseInc;
Si (syncPhaseAcc < syncPhaseInc) {}
Momento de comenzar el siguiente grano
grainPhaseAcc = 0;
grainAmp = 0x7fff;
grain2PhaseAcc = 0;
grain2Amp = 0x7fff;
grain3PhaseAcc = 0;
grain3Amp = 0x7fff;
LED_PORT ^ = 1 << LED_BIT; Más rápido que usando digitalWrite
}
Incremento de la fase de los osciladores de grano
grainPhaseAcc += grainPhaseInc;
grain2PhaseAcc += grain2PhaseInc;
Convertir la fase en una onda triangular
valor = (grainPhaseAcc >> 7) & 0xff;
Si (grainPhaseAcc & 0x8000) valor = ~ valor;
Multiplicar por la actual amplitud de grano para obtener muestra
salida = valor * (grainAmp >> 8);
Repita para el segundo grano
valor = (grain2PhaseAcc >> 7) & 0xff;
Si (grain2PhaseAcc & 0x8000) valor = ~ valor;
salida += valor * (grain2Amp >> 8);
Repita para el tercer grano
valor = (grain3PhaseAcc >> 7) & 0xff;
Si (grain3PhaseAcc & 0x8000) valor = ~ valor;
salida += valor * (grain3Amp >> 8);
Hacer el grano del decaen de las amplitudes por un factor de cada muestra (decaimiento exponencial)
grainAmp-= (grainAmp >> 8) * grainDecay;
grain2Amp-= (grain2Amp >> 8) * grain2Decay;
grain3Amp-= (grain3Amp >> 8) * grain3Decay;
Escala de la salida a la gama disponible, recorte si es necesario
salida >> = 9;
Si la salida (salida > 255) = 255;
Salida de PWM (esto es más rápido que usando analogWrite)
PWM_VALUE = salida;
}
/ * Fuertemente basado en http://ardx.org/src/circ/CIRC06-code.txt
* y también http://ardx.org/src/circ/CIRC07-code.txt
* Información circuito en http://www.oomlout.com/oom.php/products/ardx/circ-06
* y http://www.oomlout.com/oom.php/products/ardx/circ-07
* puede ayudar a
*
* El cálculo de los tonos se hace siguiendo la matemática
* operación:
*
* timeHigh = período / 2 = 1 / (2 * estándarFrecuencia)
*
* donde se describen los diversos tonos como en la tabla:
*
* Nota frecuencia período timeHigh
* c 261 Hz 3830 1915
* d 294 Hz 3400 1700
* e Hz 329 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 longitud = 1; el número de notas
Notas de Char [] = {}
'c', 'd', 'e', 'f', 'g', 'a', 'b', 'C' }; un espacio representa un resto
beats de int [] = {}
1};
tempo de int = 300;
{} void playTone (int tono, duración de int)
para (largo i = 0; i < duración * 1000L; i += tono * 2) {}
digitalWrite (speakerPin, HIGH);
delayMicroseconds(tone);
digitalWrite (speakerPin, bajo);
delayMicroseconds(tone);
}
}
{} void playNote (char nota, int duración)
char nombre [] = {}
'c', 'd', 'e', 'f', 'g', 'a', 'b', 'C' };
tonos de int [] = {}
1915, 1700, 1519, 1432, 1275, 1136, 1014, 956 };
reproducir el tono correspondiente a nombre de la nota
para (int i = 0; i < 8; i ++) {}
Si (nombres [i] == Nota) {}
playTone (tonos [i], duración);
}
}
}
void setupTone() {}
pinMode (speakerPin, salida);
pinMode (inputPin1, entrada);
pinMode (inputPin2, entrada);
pinMode (inputPin3, entrada);
pinMode (inputPin4, entrada);
}
void loopTone() {}
Si (digitalRead(inputPin1) == HIGH) {}
playNote (notas [0], 300);
}
else if (digitalRead(inputPin2) == HIGH) {}
playNote (notas [1], 300);
}
else if (digitalRead(inputPin3) == HIGH) {}
playNote (notas [2], 300);
}
else if (digitalRead(inputPin4) == HIGH) {}
playNote (notas [3], 300);
}
Else {}
digitalWrite (speakerPin, bajo);
}
}
/ * Código original creado el 21 de enero de 2010
/ modificado 30 de agosto de 2011
/ por Tom Igoe (http://pastebin.com/tCYvfky9) y configurado por mi 2013 (mi código a continuación)
/
/ Cuando te firgure hacia fuera cómo conectar arduino y juega la melodía básica. Usted debe comenzar la codificación
/
/ Primero que se necesita las notas puede copiar pegar minas o simplemente lo copie de http://arduino.cc/en/Tutorial/Tone
/
*/
Comenzamos con la búsqueda todas las notas
#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
/*
Botón
Enciende y apaga una luz emitiendo diode(LED) conectado a digital
PIN 13, al presionar un pulsador conectado al pin 7.
El circuito:
* LED conectado desde el pin 13 a tierra
* pulsador conectado al pin 6 de + 5V
* 10K resistencia atado pin 6 de la tierra
* Nota: en la mayoría de Arduinos ya hay un LED en el tablero
conectado al pin 13.
creado 2005
por DojoDave < http://www.0j0.org>
modificado 17 de junio de 2009
por Tom Igoe
http://www.Arduino.CC/en/Tutorial/Button
*/
constantes no va a cambiar. Aquí están acostumbrados a
establecer números de pin:
const int buttonPin = 6; el número de pin pulsador
int Buzzer1 = 3;
va a cambiar las variables:
int buttonState = 0; variable para lectura del estado del pulsador
void setupMelody() {}
inicializar el piezo como salida:
pinMode (Buzzer1, salida);
inicializar el perno pulsador como entrada:
pinMode (buttonPin, entrada);
}
void loopMelody() {}
leer el estado del pulsador valor:
buttonState = digitalRead(buttonPin);
comprobar si el pulsador está presionado.
Si es así, el buttonState es alta:
Si (buttonState == HIGH) {}
jugar th música
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);
}
}
/*
Táctil capacitiva Arduino teclado Piano
Reproduce tonos de piano a través de un zumbador cuando el usuario golpea ligeramente sensible al tacto de piano "llaves"
Creado el 18 de mayo de 2013
Modificado 23 de mayo de 2013
por Tyler Crumpton y Nicholas Jones
Este código está liberado al dominio público. Para obtener más información sobre el circuito,
visite el tutorial instructivo en
*/
#include < CapacitiveSensor.h >
#define COMMON_PIN 0 / / el común 'Enviar' pin para todas las claves
#define BUZZER_PIN 3 / / la salida del pin para el zumbador piezo
#define NUM_OF_SAMPLES 10 / / mayor número cuando más retraso pero las lecturas más coherentes
#define CAP_THRESHOLD 150 / / Capactive lectura que desencadena una nota (ajuste a sus necesidades)
#define NUM_OF_KEYS 2 / / número de teclas en el teclado
Esta macro crea un objeto de "tecla" sensor de capacitancia para cada tecla en el teclado del piano:
#define CS(Y) CapacitiveSensor (0, Y)
Cada tecla corresponde a una nota, que se definen aquí. Elimine la magnitud que se desea utilizar:
int notes1 [] = {}
NOTE_C4, NOTE_D4, NOTE_E4, NOTE_F4, NOTE_G4, NOTE_A4, NOTE_B4, NOTE_C5}; Escala mayor de C
int notes1 [] = {NOTE_A4, NOTE_B4, NOTE_C5, NOTE_D5, NOTE_E5, NOTE_F5, NOTE_G5, NOTE_A5}; Escala de A-Minor
int notes1 [] = {NOTE_C4, NOTE_DS4, NOTE_F4, NOTE_FS4, NOTE_G4, NOTE_AS4, NOTE_C5, NOTE_DS5}; Escala de Blues de C
Define los pines conectados a las teclas:
CapacitiveSensor las teclas [] = {}
CS(7), CS(8)};
void setupcap() {}
Desactivar autocalibrate en todos los canales:
para (int i = 0; i < 8; ++ i) {}
Keys[i].set_CS_AutocaL_Millis(0xFFFFFFFF);
}
Configurar el timbre como salida:
pinMode (BUZZER_PIN, salida);
}
void loopcap() {}
Un bucle por cada clave:
para (int i = 0; i < 8; ++ i) {}
Si la lectura de capacitancia es mayor que el umbral, tocar una Nota:
if(keys[i].capacitiveSensor(NUM_OF_SAMPLES) > CAP_THRESHOLD) {}
tono (BUZZER_PIN, notes[i]); Toca la nota correspondiente a la tecla pulsada
}
}
}