Home > Technologie > SYNTHDUINO

SYNTHDUINO

0
Advertisement

SYNTHDUINO

Das Synthduino ist ein Spaß-Arduino-Projekt zu tun und als Anfänger ist es eine großartige Möglichkeit, neue Dinge über arduino's viele Funktionen zu lernen. Mit nur Haushaltsgegenstände zum Aufbau des Synthduino werden Sie mit dem Finishing-Projekt zufrieden und fühlen sich erfüllt. Verwendet der synthduino die sechs Potentiometer an den Steuerungen Joysticks und Trigger und verwendet die Tasten für verschiedene Funktionen. Der Code beinhaltet auch eine Schlaffunktion für den Arduino, um beim Einschalten automatisch zu schlafen und für den Fall, dass er versehentlich gestartet wird. Dieser Code enthält eine hallo Welt am Anfang des Codes, damit Sie wissen, ob der Code auf und arbeiten.

Schritt 1: Lieferliste

Ich verwendete nur Hausrat
1. Eine alte Steuerung zum Spielsystem (ich verwendete xbox)
2. 4 Widerstände (ich lötete sie nur von einem alten RC-Auto)
3. Viele Drähte (ich habe den Draht verwendet Drähte von einem alten Computer)
4. Arduino (Ich habe uno aber alles, was die gleiche Menge oder mehr Pins als uno funktioniert)
5. Lautsprecher oder Audio-Adapter
6. Geführt
7. Energie sorce für Steuerpult (oder Sie können arduinos 5v Energie benutzen)

Werkzeuge
1. Bohren Sie
2. Lötkolben
3. Löten
4. Heißklebepistole
5. Klebestifte
6. Klebeband
7. Verrückter Kleber
8. Schraubendreher (was auch immer für Sie arbeitet)

Schritt 2: Controller auseinandernehmen

SYNTHDUINO

SYNTHDUINO

Dieser Schritt ist ein kurzer Schritt, weil ich nicht weiß, was Controller Sie verwenden, damit dieser Schritt kann Ihnen zwei Minuten bis zehn Minuten, aber ich würde nicht langweilen Sie mit, wie ich mir auseinander genommen

Schritt 3: Streifen A LOT von Drähten

SYNTHDUINO

Sie möchten alle Drähte abisolieren, um sie an den Controller und die Pin-Ein- und Ausgänge anzulöten

Schritt 4: Lot wie verrückt

SYNTHDUINO

1. Sie wollen vier der Controller-Knöpfe löten, die relativ dicht beieinander sind. Das sind die Tone-Buttons
• Zuerst die Tasten suchen
• finden Sie den Typ ... wenn es ein Druckknopf ist dann löten es auf nur einen der vier Pins auf der Schaltfläche ... wenn es nicht finden Sie den kleinen Kreis neben der Schaltfläche und löten Sie Ihre Draht gibt
• schneiden Sie die Gummiknopfdrücker um die Drähte zu passen, stellen Sie sicher, dass die Gummilinie mit den schwarzen Kreisen auf der Kontrolltafel aufrichtet
2. Als nächstes wollen Sie die Trigger und Joysticks (Potentiometer)
• Diese sind einfacher finden Sie einfach die Achse Schieberegler und Löten auf den mittleren Pin auf allen von ihnen
3. Zuletzt müssen Sie die Weck- und Melodietasten anlöten
• Zuerst die Tasten suchen
• finden Sie den Typ ... wenn es ein Druckknopf ist dann löten es auf nur einen der vier Pins auf der Schaltfläche ... wenn es nicht finden Sie den kleinen Kreis neben der Schaltfläche und löten Sie Ihre Draht gibt
• schneiden Sie die Gummiknopfdrücker um die Drähte zu passen, stellen Sie sicher, dass die Gummilinie mit den schwarzen Kreisen auf der Kontrolltafel aufrichtet
4. auf den zwei Joysticks sind zwei Druckknöpfe, die für dieses Projekt verwendet werden, also vergessen Sie nicht, sie zu löten

Schritt 5: Lautsprecher, Wake Up, Touch-Tasten

SYNTHDUINO

Lautsprecher: Der Lautsprecher muss an einen Widerstand angeschlossen werden, bevor er an arduino angeschlossen wird, ein 8 Ohm Lautsprecher nimmt einen 100 Ohm Widerstand
Wake up: die Wake-up-Funktion nutzt Pin 2 und Pin 1 aka der RX-Pin, so dass die rx-Pin müssen Pin 2 mit einem 220 Ohm Widerstand und Pin 2 zu einem Knopf zu verbinden
Touch-Tasten: Die beiden Touch-Tasten müssen 100 Ohm Widerstände angeschlossen haben, um es vor dem Anschluss an arduino auch nach dem Anschluss an Pin 0 oder TX angeschlossen.
Berührungstasten
1. Schneiden Sie Aluminiumfolie oder Kupferpapierquadrate
2. Kleben Sie sie an den Controller
3. Schneiden Sie zwei kleinere Stücke
4. Kleben Sie den Draht oben auf die großen Stücke mit den kleineren
5. Bohren Sie ein Loch über jeder Taste
6. Durchgangsbohrung durchführen
7. Vom TX-Stift haben zwei Drähte, die zu zwei getrennten Widerständen dann zu den Schlüsseldrähten gehen
8. Schließen Sie die Schlüsseldrähte an die Stifte an

Schritt 6: verbinden

Bohren Sie Löcher, wo Notwendigkeit sein und die Drähte durch füttern
Verbinden Sie dann alle Drähte mit dem entsprechenden Stift auf arduino
0 zwei Drähte in zu zwei Widerständen
1. Draht mit Widerstand
2. Draht von der Taste, um aufzuwachen arduino
3. Lautsprecherkabel
4. Taste am Joystick ein
5. Taste am Joystick zwei
6. Melody-Taste
7. Tippen Sie auf eine Taste
8. Taste 2 drücken
9. Ton 1
10. Ton 2
11. Ton 3
12. Ton 4
13. Led
14. Masse für Lautsprecher

Analoge Anschlüsse
0. Joystick1 Achse1
1. Joystick 1 Achse2
2. Auslöser 1
3. Joystick 2 Achse 1
4. Auslöser 2
5. Joystick 2 Achse 2

Zusätzliche Stifte
0. Massepins für etwas geerdetes
1. 5v heraus Stift zu den Steuerpulten power in (rote und schwarze Drähte)

Schritt 7: Code

// dieser Code ist im Besitz von Kevin Cross als Ganzes, aber ich bin nicht der Besitzer die einzelnen unedited Teile des Codes //
// das synthduino //

Void setup () {
SetupSleep ();
Setuphello ();
Setuphello1 ();
SetupRun ();
SetupTone ();
SetupMelody ();
Setupcap ();

aufrechtzuerhalten.

Void Schleife () {
LoopSleep ();
Loophello ();
Loophello1 ();
LoopRun ();
LoopTone ();
LoopMelody ();
Loopcap ();

aufrechtzuerhalten.

/ * Sleep Demo Serial
aufrechtzuerhalten.
* Beispiel-Code, um die Schlaf-Funktionen in einem Arduino zu demonstrieren. Arduino wird aufwachen
* Wenn neue Daten im seriellen Port USART empfangen werden
* Basierend auf Sleep Demo Serial von http://www.arduino.cc/playground/Learning/ArduinoSleepCode
aufrechtzuerhalten.
* Copyright (C) 2006 MacSimski 2006-12-30
* Copyright (C) 2007 D. Cuartielles 2007-07-08 - Mexiko DF
aufrechtzuerhalten.
* Mit Änderungen von Ruben Laguna 2008-10-15
aufrechtzuerhalten.
* Dieses Programm ist freie Software: Sie können es verteilen und / oder ändern
* Es unter den Bedingungen der GNU General Public License, veröffentlicht von
* Die Free Software Foundation, entweder Version 3 der Lizenz oder
* (Nach Ihrer Wahl) jede spätere Version.
aufrechtzuerhalten.
* Dieses Programm wird in der Hoffnung, dass es nützlich sein wird,
* Aber OHNE JEGLICHE GARANTIE; Ohne auch nur die implizierte Garantie von
* MARKTGÄNGIGKEIT oder FITNESS FÜR EINEN BESTIMMTEN ZWECK. Siehe die
* GNU General Public License für weitere Details.
aufrechtzuerhalten.
* Sie sollten eine Kopie der GNU General Public License erhalten haben
* Zusammen mit diesem Programm. Falls nicht, siehe <http://www.gnu.org/licenses/>.
aufrechtzuerhalten.
* /

#include <avr / power.h>
#include <avr / sleep.h>

Int sleepStatus = 0; // Variable, um eine Anfrage für den Ruhezustand zu speichern
Int count = 0; // Zähler

Void setupSleep ()
{

Serial.begin (9600);
aufrechtzuerhalten.

Void sleepNow ()
{
/ * Jetzt ist die Zeit, den Schlafmodus einzustellen. Im Datenblatt von Atmega8
* Http://www.atmel.com/dyn/resources/prod_documents/doc2486.pdf auf Seite 35
* Es gibt eine Liste der Schlafmodi, die erklärt, welche Uhren und
* Wake up Quellen sind in dem Schlafmodus verfügbar.
aufrechtzuerhalten.
* In der avr / sleep.h-Datei befinden sich die Aufruf-Namen dieser Sleep-Modi:
aufrechtzuerhalten.
* Die 5 verschiedenen Modi sind:
* SLEEP_MODE_IDLE - die geringste Stromersparnis
* SLEEP_MODE_ADC
* SLEEP_MODE_PWR_SAVE
* SLEEP_MODE_STANDBY
* SLEEP_MODE_PWR_DOWN - die meisten Energieeinsparungen
aufrechtzuerhalten.
* Das Leistungsreduzierungsmanagement <avr / power.h> ist beschrieben in
* http://www.nongnu.org/avr-libc/user-manual/group__avr__power.html
* /

Set_sleep_mode (SLEEP_MODE_IDLE); // Der Sleep-Modus wird hier eingestellt

Sleep_enable (); // aktiviert das Sleep-Bit im mcucr-Register
// so schlafen ist möglich. Nur eine Sicherheitsnadel

Power_adc_disable ();
Power_spi_disable ();
Power_timer0_disable ();
Power_timer1_disable ();
Power_timer2_disable ();
Power_twi_disable ();

Schlafmodus(); // hier ist das Gerät tatsächlich eingeschlafen !!

// DAS PROGRAMM BETRACHT VON HIER NACH DEM WACHEN
Sleep_disable (); // Erstes nach dem Aufwachen:
// deaktivieren ...

Power_all_enable ();

aufrechtzuerhalten.

Void loopSleep ()
{
// Informationen über den Zähler anzeigen
Serial.print ( "Wach für");
Serial.print (count);
Serial.println ( "sec");
Count ++;
Verzögerung (1000);
// wartet eine Sekunde

// Berechne die serielle Eingabe
If (Serial.available ()) {
Int val = Serial.read ();
Wenn (val == 'S') {
Serial.println ( "Seriell: Eingeben des Ruhemodus");
Verzögerung (100); // diese Verzögerung wird benötigt, der Schlaf
// -Funktion wird einen Serienfehler sonst provozieren !!
Count = 0;
Schlaf jetzt(); // sleep-Funktion, die hier aufgerufen wird
aufrechtzuerhalten.
Wenn (val == 'A') {
Serial.println ( "Hola Caracola"); // klassische Dummy-Nachricht
aufrechtzuerhalten.
aufrechtzuerhalten.

// überprüfen Sie, ob es schlafen sollte, weil der Zeit
Wenn (count> = 10) {
Serial.println ( "Timer: Eingeben des Ruhemodus");
Verzögerung (100); // diese Verzögerung wird benötigt, der Schlaf
// -Funktion wird einen Serienfehler sonst provozieren !!
Count = 0;
Schlaf jetzt(); // sleep-Funktion, die hier aufgerufen wird
aufrechtzuerhalten.
aufrechtzuerhalten.

// Arduino Sound Hallo Welt
// Erstellt von David Fowler von uCHobby.com
// Definieren Sie den I / O-Pin, den wir für unseren Soundausgang verwenden
#define SOUNDOUT_PIN 3

Void setuphello (void) {
// Stellen Sie den Tonausgangsstift auf den Ausgabemodus
PinMode (SOUNDOUT_PIN, OUTPUT);
aufrechtzuerhalten.

Void loophello (void) {
// Ton durch Umschalten des I / O-Pins High und Low erzeugen
// Erzeugt einen 1KHz-Ton. Setzen Sie den Stift hoch für 500uS dann
// niedrig für 500uS, um die Periode 1ms oder 1KHz zu machen.

// Setzen Sie den Stift hoch und verzögern Sie für 1/2 einen Zyklus von 1KHz, 500uS.
DigitalWrite (SOUNDOUT_PIN, HIGH);
DelayMicroseconds (500);

// Setzen Sie den Pin low und die Verzögerung für 1/2 einen Zyklus von 1KHz, 500uS.
DigitalWrite (SOUNDOUT_PIN, LOW);
DelayMicroseconds (500);
aufrechtzuerhalten.

Void setuphello1 () {
PinMode (13, AUSGANG);
aufrechtzuerhalten.
Void loophello1 () {
Verzögerung (3000); // 3 сек втик
DigitalWrite (13, HIGH);
Verzögerung (125);
DigitalWrite (13, LOW); //.
Verzögerung (125);
DigitalWrite (13, HIGH);
Verzögerung (125);
DigitalWrite (13, LOW); Aufrechtzuerhalten.
Verzögerung (125);
DigitalWrite (13, HIGH);
Verzögerung (125);
DigitalWrite (13, LOW); // ...
Verzögerung (125);
DigitalWrite (13, HIGH);
Verzögerung (125);
DigitalWrite (13, LOW); // .... H
Verzögerung (125);
DigitalWrite (13, HIGH);
Verzögerung (125);
DigitalWrite (13, LOW); //. E
Verzögerung (125);
DigitalWrite (13, HIGH);
Verzögerung (125);
DigitalWrite (13, LOW); //.
Verzögerung (125);
DigitalWrite (13, HIGH);
Verzögerung (375);
DigitalWrite (13, LOW); //. -
Verzögerung (125);
DigitalWrite (13, HIGH);
Verzögerung (125);
DigitalWrite (13, LOW); Aufrechtzuerhalten.
Verzögerung (125);
DigitalWrite (13, HIGH);
Verzögerung (125);
DigitalWrite (13, LOW); // .- .. L
Verzögerung (125);
DigitalWrite (13, LOW); //.
Verzögerung (125);
DigitalWrite (13, HIGH);
Verzögerung (375);
DigitalWrite (13, LOW); //. -
Verzögerung (125);
DigitalWrite (13, HIGH);
Verzögerung (125);
DigitalWrite (13, LOW); Aufrechtzuerhalten.
Verzögerung (125);
Verzögerung (125);
DigitalWrite (13, HIGH);
Verzögerung (125);
DigitalWrite (13, LOW); // .- .. L
Verzögerung (125);
DigitalWrite (13, HIGH);
Verzögerung (375);
DigitalWrite (13, LOW); // -
Verzögerung (125);
DigitalWrite (13, HIGH);
Verzögerung (375);
DigitalWrite (13, LOW); // -
Verzögerung (125);
DigitalWrite (13, HIGH);
Verzögerung (375);
DigitalWrite (13, LOW); // --- O
Verzögerung (3000); // 3 сек втик
aufrechtzuerhalten.

/// Auduino, der körnige Lo-Fi-Synthesizer
//
// von Peter Knight, Tinker.it http://tinker.it
//
// Hilfe: http://code.google.com/p/tinkerit/wiki/Auduino
// Weitere Hilfe: http://groups.google.com/group/auduino
//
// Analog in 0: Korn 1 Tonhöhe
// Analog in 1: Korn 2 Zerfall
// Analog in 2: Korn 1 Zerfall
// Analog in 3: Korn 2 Tonhöhe
// Analog in 4: Korn 3 Tonhöhe
// Analog in 5: Korn 3 Zerfall
//
// Digital 4: Kornwiederholfrequenz
// Digital 5: Kornamplitudenfrequenz
//
// Digital 3: Audioausgang (Digital 11 auf ATmega8)
//
// Änderungsprotokoll:
// 19 Nov 2008: Unterstützung für ATmega8-Karten
// 21 Mrz 2009: Unterstützung für ATmega328 Boards hinzugefügt
// 7 Apr 2009: Fester Interrupt-Vektor für ATmega328-Karten
// 8. Apr 2009: Unterstützung für 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 korn2PhaseInc;
Uint16_t grain2Amp;
Uint8_t grain2Decay;
Uint16_t grain3PhaseAcc;
Uint16_t grain3PhaseInc;
Uint16_t grain3Amp;
Uint8_t grain3Decay;

// Karte Analoge Kanäle
#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)

// Karte Digitale Kanäle
#define SYNC_CONTROL (4)
#define AMP_CONTROL (5)

// Dazu müssen auch audioOn ()

#if definiert (__ AVR_ATmega8__)
//
// Auf alten ATmega8 Karten.
// Ausgang ist auf 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 definiert (__ AVR_ATmega1280__)
//
// Auf dem Arduino Mega
// Ausgang ist an 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
#sonst
//
// Für moderne ATmega168 und ATmega328 Karten
// Ausgang ist an 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

// Glatte logarithmische Abbildung
//
Uint16_t antilogTable [] = {
64830,64132,63441,62757,62081,61413,60751,60097,59449,58809,58176,57549,56929,56316,55709,55109,
5451553928,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,37914,36516,36123,35734,35349,34968,34591,34219,33850,33486,33125,32768
};
Uint16_t mapPhaseInc (uint16_t Eingabe) {
Return (antilogTable [input & 0x3f]) >> (input >> 6);
aufrechtzuerhalten.

// Schrittweise Abbildung
//
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, Wie in Fig. 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 (uint16_t Eingabe) {
Return (midiTable [(1023-input) >> 3]);
aufrechtzuerhalten.

// Schrittweise Kartierung
//
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 KartePentatonic (uint16_t Eingang) {
Uint8_t Wert = (1023-Eingang) / (1024/53);
Return (pentatonicTable [value]);
aufrechtzuerhalten.

Void audioOn () {
#if definiert (__ AVR_ATmega8__)
// ATmega8 hat verschiedene Register
TCCR2 = _BV (WGM20) | _BV (COM21) | _BV (CS20);
TIMSK = _BV (TOIE2);
#elif definiert (__ AVR_ATmega1280__)
TCCR3A = _BV (COM3C1) | _BV (WGM30);
TCCR3B = _BV (CS30);
TIMSK3 = _BV (TOIE3);
#sonst
// PWM auf 31,25 kHz einstellen, phasengenau
TCCR2A = _BV (COM2B1) | _BV (WGM20);
TCCR2B = _BV (CS20);
TIMSK2 = _BV (TOIE2);
#endif
aufrechtzuerhalten.

Void setupRun () {
PinMode (PWM_PIN, OUTPUT);
AudioOn ();
PinMode (LED_PIN, AUSGANG);
aufrechtzuerhalten.

Void loopRun () {
// Die Schleife ist ziemlich einfach - sie aktualisiert nur die Parameter für die Oszillatoren.
//
// Verwenden Sie keine Funktionen, die umfangreiche Interrupts ausnutzen oder Unterbrechungen ausschalten.
// Sie verursachen Klicks und poops im Audio.

// Glatte Frequenzzuordnung
// syncPhaseInc = mapPhaseInc (digitalRead (SYNC_CONTROL)) / 4;
// ampPhaseInc = mapPhaseInc (digitalRead (AMP_CONTROL)) / 5;

// Schrittmapping auf MIDI-Noten: C, Db, D, Eb, E, F ...
// syncPhaseInc = mapMidi (digitalRead (SYNC_CONTROL));

// Stufenweise pentatonische Abbildung: 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;
aufrechtzuerhalten.

SIGNAL (PWM_INTERRUPT)
{
Uint8_t Wert;
Uint16_t Ausgabe;

SyncPhaseAcc + = syncPhaseInc;
If (syncPhaseAcc <syncPhaseInc) {
// Zeit für das nächste Getreide
GrainPhaseAcc = 0;
GrainAmp = 0x7fff;
Grain2PhaseAcc = 0;
Grain2Amp = 0x7fff;
Grain3PhaseAcc = 0;
Grain3Amp = 0x7fff;
LED_PORT ^ = 1 << LED_BIT; // Schneller als mit digitalWrite
aufrechtzuerhalten.

// Inkrementieren Sie die Phase der Kornoszillatoren
GrainPhaseAcc + = grainPhaseInc;
Grain2PhaseAcc + = grain2PhaseInc;

// Konvertiere die Phase in eine Dreieckswelle
Wert = (grainPhaseAcc >> 7) & ohgr;
Wenn (grainPhaseAcc & 0x8000) Wert = ~ Wert;
// Multiplizieren Sie mit der aktuellen Kornamplitude, um die Stichprobe zu erhalten
Output = value * (grainAmp >> 8);

// Wiederholen für die zweite Körnung
Wert = (grain2PhaseAcc >> 7) & ohgr;
If (grain2PhaseAcc & 0x8000) Wert = ~ Wert;
Ausgabe + = Wert * (grain2Amp >> 8);
// Wiederholen für drittes Korn
Wert = (grain3PhaseAcc >> 7) & ohgr;
Wenn (grain3PhaseAcc & 0x8000) Wert = ~ Wert;
Ausgabe + = Wert * (grain3Amp >> 8);

// Stellen Sie die Kornamplituden um jeden Faktor ab (exponentieller Abfall)
GrainAmp - = (grainAmp >> 8) * grainDecay;
Grain2Amp - = (grain2Amp >> 8) * grain2Decay;
Grain3Amp - = (grain3Amp >> 8) * grain3Decay;

// Waage auf den verfügbaren Bereich skalieren, ggf. clipping
Ausgabe >> = 9;
Wenn (Ausgang> 255) Ausgang = 255;

// Ausgabe an PWM (dies ist schneller als mit analogWrite)
PWM_VALUE = Ausgang;
aufrechtzuerhalten.

/ * Schwer basierend auf http://ardx.org/src/circ/CIRC06-code.txt
* Und auch http://ardx.org/src/circ/CIRC07-code.txt
* Circuit Informationen unter http://www.oomlout.com/oom.php/products/ardx/circ-06
* Und http://www.oomlout.com/oom.php/products/ardx/circ-07
* Kann auch helfen
aufrechtzuerhalten.
* Die Berechnung der Töne erfolgt nach dem mathematischen
* Betrieb:
aufrechtzuerhalten.
* TimeHigh = Periode / 2 = 1 / (2 * toneFrequency)
aufrechtzuerhalten.
* Wobei die verschiedenen Töne wie in der Tabelle beschrieben sind:
aufrechtzuerhalten.
* Beachten Frequenz Zeitraum 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
* Eine 440 Hz 2272 1136
* B 493 Hz 2028 1014
* C 523 Hz 1912 956
aufrechtzuerhalten.
* http://www.arduino.cc/de/Tutorial/Melody
* /
Int inputPin1 = 9;
Int inputPin2 = 10;
Int inputPin3 = 11;
Int inputPin4 = 12;
Int speakerPin = 3;
Int val = 0;

Int length = 1; // die Anzahl der Noten
Char notes [] = {
'C', 'd', 'e', ​​'f', 'g', 'a', 'b', 'C'}; // ein Leerzeichen steht für eine Pause
Int beats [] = {
1};
Int tempo = 300;

Void playTone (int tone, int duration) {
(Lang i = 0, i <Dauer * 1000L, i + = Ton * 2) {
DigitalWrite (SpeakerPin, HIGH);
DelayMicroseconds (Ton);
DigitalWrite (SpeakerPin, LOW);
DelayMicroseconds (Ton);
aufrechtzuerhalten.
aufrechtzuerhalten.

Void playNote (char-Note, int-Dauer) {
Char Namen [] = {
'C', 'd', 'e', ​​'f', 'g', 'a', 'b', 'C'};
Int Töne [] = {
1915, 1700, 1519, 1432, 1275, 1136, 1014, 956};

// Den Ton entsprechend dem Notennamen abspielen
Für (int i = 0; i <8; i ++) {
Wenn (names [i] == note) {
PlayTone (Töne [i], Dauer);
aufrechtzuerhalten.
aufrechtzuerhalten.
aufrechtzuerhalten.

Void setupTone () {
PinMode (SpeakerPin, OUTPUT);
PinMode (inputPin1, INPUT);
PinMode (inputPin2, INPUT);
PinMode (inputPin3, INPUT);
PinMode (inputPin4, INPUT);
aufrechtzuerhalten.

Void loopTone () {
Wenn (digitalRead (inputPin1) == HIGH) {
PlayNote (Anmerkungen [0], 300);
aufrechtzuerhalten.
Sonst if (digitalRead (inputPin2) == HIGH) {
PlayNote (Anmerkungen [1], 300);
aufrechtzuerhalten.
Sonst if (digitalRead (inputPin3) == HIGH) {
PlayNote (Anmerkungen [2], 300);
aufrechtzuerhalten.
Sonst if (digitalRead (inputPin4) == HIGH) {
PlayNote (Anmerkungen [3], 300);
aufrechtzuerhalten.
sonst {
DigitalWrite (SpeakerPin, LOW);
aufrechtzuerhalten.
aufrechtzuerhalten.

/ * Originalcode erstellt am 21 Jan 2010
/ Geändert am 30. August 2011
/ Von Tom Igoe (http://pastebin.com/tCYvfky9) und konfiguriert von mir 2013 (mein Code unten)
/
/ Wenn Sie herauszufinden, wie die Arduino verbinden und machte es spielen die grundlegende Melodie. Sie sollten die Codierung starten
/
/ Zuerst von Ihnen benötigen Sie die Notizen, die Sie kopieren können Paste Mine oder einfach kopieren Sie es von http://arduino.cc/en/Tutorial/Tone
/
* /

// Wir beginnen mit der Festlegung aller Noten

#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 207
#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

aufrechtzuerhalten.
Taste

Schaltet eine an Digital angeschlossene Leuchtdiode (LED) ein und aus
Pin 13, wenn ein Druckknopf auf Pin 7 gedrückt wird.

Die Rennbahn:
* LED an Pin 13 an Masse angeschlossen
* Taster an Pin 6 von + 5V angeschlossen
* 10K Widerstand an Pin 6 von Masse angeschlossen

* Anmerkung: auf den meisten Arduinos gibt es bereits eine LED auf dem Brett
Befestigt am Stift 13.

erstellt 2005
Von DojoDave <http://www.0j0.org>
Geändert am 17. Juni 2009
Von Tom Igoe

http://www.arduino.cc/de/Tutorial/Button
* /

// Konstanten werden sich nicht ändern. Sie werden hier verwendet
// Pin-Nummern setzen:
Const int buttonPin = 6; // die Nummer des Drucktasters
Int Buzzer1 = 3;

// Variablen werden sich ändern:
Int buttonState = 0; // Variable zum Lesen des Tasterstatus

Void setupMelody () {
// Piezo als Ausgang initialisieren:
PinMode (Buzzer1, OUTPUT);
// den Taster als Eingang initialisieren:
PinMode (buttonPin, INPUT);
aufrechtzuerhalten.

Void loopMelody () {
// den Zustand des Drucktasters lesen:
ButtonState = digitalRead (buttonPin);

// Prüfen, ob die Drucktaste gedrückt wird.
// Wenn dies der Fall ist, ist der ButtonState HIGH:
If (buttonState == HIGH) {
// spielen th Musik
Ton (Buzzer1, 400, 200);
Verzögerung (500);
Ton (Buzzer1, 400, 200);
Verzögerung (500);
Ton (Buzzer1,450,225);
Verzögerung (300);
Ton (Buzzer1,450,225);
Verzögerung (500);
Ton (Buzzer1, 400, 200);
Verzögerung (500);
Ton (Buzzer1,450,200);
Verzögerung (300);
Ton (Buzzer1,600,300);
Verzögerung (300);
Ton (Buzzer1, 400, 200);
Verzögerung (500);
Ton (Buzzer1,700,300);
Verzögerung (300);
Ton (Buzzer1,700,300);
Verzögerung (500);
Ton (Buzzer1,600,300);
Verzögerung (300);
Ton (Buzzer1, 400, 200);
Verzögerung (1000);
Ton (Buzzer1, 400, 200);
Verzögerung (500);
Ton (Buzzer1,650,200);
Verzögerung (500);
Ton (Buzzer1, 400, 200);
Verzögerung (500);
Ton (Buzzer1,650,200);
Verzögerung (300);
Ton (Buzzer1,650,200);
Verzögerung (500);
Ton (Buzzer1,400,200);
Verzögerung (500);
Ton (Buzzer1, 400, 200);
Verzögerung (500);
Ton (Buzzer1, 400, 200);
Verzögerung (1000);
Ton (Buzzer1, 400, 200);
Verzögerung (500);
Ton (Buzzer1, 400, 200);
Verzögerung (500);
Ton (Buzzer1,600,300);
Verzögerung (500);
Ton (Buzzer1,600,300);
Verzögerung (500);
Ton (Buzzer1,800,300);
Verzögerung (500);
Ton (Buzzer1,800,300);
Verzögerung (500);
Ton (Buzzer1, 400, 200);
Ton (Buzzer1, 400, 200);
Verzögerung (500);
Ton (Buzzer1, 400, 200);
Verzögerung (500);
Ton (Buzzer1, 400, 200);
Verzögerung (500);
Ton (Buzzer1,300,150);
Verzögerung (500);
Ton (Buzzer1,300,150);
Verzögerung (500);
Ton (Buzzer1,300,150);
Verzögerung (500);
Ton (Buzzer1,300,150);
Verzögerung (500);
Ton (Buzzer1,300,150);
Ton (Buzzer1,300,150);
Ton (Buzzer1,300,150);
Ton (Buzzer1,300,150);

aufrechtzuerhalten.
aufrechtzuerhalten.

aufrechtzuerhalten.
Kapazitiv-Noten-Arduino-Tastatur-Klavier

Spielt Piano-Töne durch einen Summer, wenn der Benutzer tippt berührungsempfindliche Klavier "Tasten"

Erstellt am 18. Mai 2013
Geändert am 23. Mai 2013
Von Tyler Crumpton und Nicholas Jones

Dieser Code wird öffentlich zugänglich gemacht. Für Informationen über die Schaltung,
Besuchen Sie das Instructable Tutorial unter http://www.instructables.com/id/Capacitive-Touch-Arduino-Keyboard-Piano/
* /

#include <CapacitiveSensor.h>

#define COMMON_PIN 0 // Der gemeinsame 'Sende'-Pin für alle Tasten
#define BUZZER_PIN 3 // Der Ausgang für den Piezo-Summer
#define NUM_OF_SAMPLES 10 // Größere Verzögerung, aber konsistentere Werte
#define CAP_THRESHOLD 150 // Capaktiver Messwert, der eine Note auslöst (an Ihre Bedürfnisse anpassen)
#define NUM_OF_KEYS 2 // Anzahl der Tasten, die sich auf der Tastatur befinden

// Dieses Makro erzeugt für jede Taste auf der Klaviertastatur ein kapazitives "Schlüssel" -Sensorobjekt:
#define CS (Y) CapacitiveSensor (0, Y)

// Jede Taste entspricht einer Notiz, die hier definiert ist. Auskommentieren Sie die Skala, die Sie verwenden möchten:
Int notes1 [] = {
NOTE_C4, NOTE_D4, NOTE_E4, NOTE_F4, NOTE_G4, NOTE_A4, NOTE_B4, NOTE_C5}; // C-Dur-Skala
// int notes1 [] = {NOTE_A4, NOTE_B4, NOTE_C5, NOTE_D5, NOTE_E5, NOTE_F5, NOTE_G5, NOTE_A5}; // A-Moll-Skala
// int notes1 [] = {NOTE_C4, NOTE_DS4, NOTE_F4, NOTE_FS4, NOTE_G4, NOTE_AS4, NOTE_C5, NOTE_DS5}; // C Blues-Skala

// Definiert die Pins, mit denen die Tasten verbunden sind:
KapazitiveSensor-Tasten [] = {
CS (7), CS (8)};

Void setupcap () {
// Autokalibrierung auf allen Kanälen ausschalten:
Für (int i = 0; i <8; ++ i) {
Tasten [i] .set_CS_AutocaL_Millis (0xFFFFFFFF);
aufrechtzuerhalten.
// Setzen Sie den Summer als Ausgang:
PinMode (BUZZER_PIN, OUTPUT);
aufrechtzuerhalten.

Void loopcap () {
// Schleife durch jede Taste:
Für (int i = 0; i <8; ++ i) {
// Wenn der Kapazitätswert größer als der Schwellenwert ist, spielen Sie eine Note:
If (keys [i] .capacitiveSensor (NUM_OF_SAMPLES)> CAP_THRESHOLD) {
Ton (BUZZER_PIN, Hinweise [i]); // Spielt die Note entsprechend der gedrückten Taste
aufrechtzuerhalten.
aufrechtzuerhalten.
aufrechtzuerhalten.

Related Reading