*********************************************************

http://playground.arduino.cc/Code/PCMAudio

*********************************************************

Arduino Audio Output

http://www.instructables.com/id/Arduino-Audio-Output/?lang=de

ARDUINO UNO Rev.3

1-bit Audio and the Arduino - Duke

David J. Zielinski
Terminology of Sound

http://people.duke.edu/~djzielin/slides/arduino_slides_12_3_2012.pdf







*********************************************************
ORIGINAL    in englisch
300_d_ArduinoNext-x_ARDUINO 8-bit Sound Generation von David Cuartielles (Arduino Co-Founder)_1a.pdf
Arduino 8-bit Sound Generation

Schwache maschinelle GOOGLE Übersetzung mit einigen Fehlern !

FEHLERMELDUNGEN an
mailto:[email protected]

ArduinoNext ist eine Initiative, angetrieben von einem Elektronik und Mikrocontroller Spezialisten-Team mit dem Ziel, all jene, die in der Welt der Technologie Eingabe, mit der bekannten Arduino-Plattform, um den nächsten Schritt in der Elektronik nehmen helfen.

Wir bemühen uns, Ihnen die notwendigen Kenntnisse und Erfahrungen für die Entwicklung eigener Anwendungen in der Elektronik zu bringen; Interaktion mit der Umwelt; Messung physikalischer Parameter; deren Verarbeitung und Durchführung der erforderlichen Kontrollmaßnahmen.
Dies ist der erste Titel in der "Hands-On"-Serie, in der Arduino-Plattform-Mitbegründer David Cuartielles führt Board-Programmierung und zeigt die Herstellung von 8-Bit-Sound Generator

Seite 26



David Cuartielles (1974, Saragossa, Spanien) ist ein Fernmeldeingenieur. Im Jahr 2000 entwickelte er die Netzkunst namens The Wake-ve-Interaktivität, eine Web-Version von Finnegans Wake, das James Joyce klassisch, die ihn zu K3, der Kunst- und Kommunikationsschule an der Universität Malmö, Schweden führte.
Seine akademische Tätigkeit fokussiert ein Modell Konzeption, Innen-Lokalisierungssysteme und Echtzeit-Technologien für künstlerische Darbietungen.
Derzeit ist er Leiter der Prototyping-Labor an K3, und besitzt ein Research Fellow Position in Interaction Design an der Medea Research Studio.
David hat eine permanente Interesse an Embedded Electronics und Bildung, mit Lehrveranstaltungen und Vorlesungen an verschiedenen Institutionen auf der ganzen Welt, einschließlich der UCLA, NYU, Samsung Kunst-und Design-Institut, Co Kopenhagener Institut für Interaction Design, Tecnologico de Monterrey und andere.
Co-Autor des bekannten Arduino-Plattform für elektronische Prototyping-ping seit 2005 ist David weiterentwickelt neuen Boards und Tee-ching-Tools, die Arduino Anwendungsbereich zu erweitern.
Im Rahmen seiner Öffentlichkeitsarbeit David arbeitet mit Elektor durch supplying didaktisch angetrieben Artikel.
In der laufenden Öffentlichkeitsarbeit, David arbeitet mit Elektor Schreiben der Artikel, die diese didaktische Sammlung zugrunde.

Seite 2



                          David Cuartielles
                                                      (Arduino Co-Founder)
                             Arduino 8-bit
                        Sound Generation
                                                              
                               arduinonoxt

Seite 3




Diese Broschüre wird sich die Grundlagen für die Erstellung von interaktiven Sound Machines mit einem Standard-Arduino Uno Board legen.
Die hier beschriebene all das Wissen und der Code kann einfach portiert sein, Mega, Arduino Mini oder einem anderen Mitglied des Arduino 8-Bit-Familie Arduino.
Wechseln Sie den Arduino Zug, das Zeug kommt direkt aus einer der Schöpfer der Plattform!

Seite 5


Übung macht den Meister und in diesem das erste einer Reihe von Broschüren werde ich in, der alle Bits und Stücke, die Sie, um 1-Bit-Sound aus einem digitalen Stift ein Arduino Board zu spielen verstehen müssen, konzentrieren. Wir werden, indem man die einfachste Art, Ton mittels eines einfachen Piezosummer oder einen Lautsprecher zu erstellen starten. Ich werde dann führen die Arduino Klangbibliothek, als eine vereinfachte Art und Weise, um die gleiche Funktionalität zu erreichen. Und ich werde durch Einführung einer fortschrittlichen Technik, die spielen kurze Töne in Form von *.wav-Dateien gespeichert.
Wenn es um die Theorie geht, werden Sie zu einer Technik, die als 1-Bit-Delta-Sigma-Digital-Analog-Konvertierung bekannt sind, eingeführt werden, aber nicht durch die Narre Angst, werden die Methoden und Technologien zusammen mit Beispielen können Sie ganz einfach vorgestellt reproduzieren mit einem minimalen Satz von Teilen.


Holen Sie sich Ihre Materialien
Wenn man sich reproduzieren alle Beispiele in dieser Broschüre wollen Sie benötigen, sind:
• ein Arduino Uno Board, auch wenn einige der anderen Boards in der Ardui-keine Linie mit ATmega328, ATmega168, ATmega128 oder ATmega256 wird auch funktionieren;
• ein USB-Kabel an den Arduino mit einem Computer verbinden;
• einen Piezosummer, um Töne zu spielen;
• wahlweise ein Mini-Lautsprecher oder Kopfhörer und eine Buchse, um sie auf dem Arduino-Board anschließen;
• einen Computer mit der Arduino IDE-und ein Tool namens SoundData für die IDE (überprüfen Sie die Download-Links in der Verweise).


Klangmaschinen
Wenn man über die interaktive Musikinstrumente, Ich mag, sie als Sound Machines beziehen. Sie bestehen aus drei Blöcken: die verwendet werden, um den Klang, die Benutzerschnittstelle und die eigentliche Sound-Engine erzeugen Daten.
Die Daten beziehen sich auf die Art und Weise der Ton verwendet wird. Es könnte generiert werden, könnten wir wieder Klänge aus einer Musterkollektion zu spielen, oder einfach nur Echtzeit-Klang Veränderung durchzuführen. Data ist der tatsächliche Klang, die Töne in einem Klavier, oder die in den Kanälen in einem Sampler gespeichert Bytes.
Die Benutzerschnittstelle definiert die Art, wie die Klangstrukturen wird manipuliert werden, oder die Mechanismen, um die Klangeigenschaften zu modifizieren. Das einfachste

Seite 6



Beispiel ist die Lautstärkeregelung in der Regel als Potentiometer oder Drehgeber implementiert. Die Benutzeroberfläche ist, was der Benutzer die Manipulation der Instrument hat seine / ihre Hände (oder Geist) auf das Verhalten der Schall Motors verändern.
Schließlich legt der Motor die Art und Weise Daten angezeigt werden. Er nimmt die Daten und macht sie als Ton entsprechend den von dem Benutzer über die UI-Steuerparameter eingeführt. In unserem Fall ist der Motor der Digital-Analog-Wandler werden wir über die Software zu implementieren.


Von blinken auf bee
Das "Hallo Welt"-Beispiel zu verwenden zu beginnen Arduino macht die LED an Pin 13 blinken.
Der Code sieht wie folgt aus:


/* Blink
    Get the LED on pin 13 to go on/off
    http://arduino.cc
*/

int ledPin = 13; // define the LEDs pin

void setup()
{
     pinMode( ledPin, OUTPUT ); // configure the pin as output
}

void loop()
{
     digitalWrite( ledPin, HIGH ); // turn the pin on
     delay( 1000 ); // wait lsec
     digitalWrite( ledPin, LOW ); // turn the pin off
     delay( 1000 ); // wait 1sec
}


Das Beispiel ist selbsterklärend. Mit wenig Veränderungen können wir das gleiche Beispiel verwenden Sound aus unserer Arduino Wiedergabe zu starten. Wir werden mit einem piezoelektrischen Summer und später werden wir in ein mit einem richtigen Lautsprecher, um die Qualität der Soundausgabe erhöhen zu bewegen.

Der piezoelektrische Summer
Die Kontaktmikrofon, auch Piezo-Summer bekannt ist eine elektronische Komponente aus einer Kombination von zwei Platten aus unterschiedlichen Materialien bestehen. einer der

Seite 7


sie metallisch ist und das andere ist in der Regel aus Keramik, mit den piezoelektrischen Eigenschaften. Beim Anlegen einer Spannung an das Bauteil, werden die Materialien gegenseitig abstoßen, ein hörbares Schwanz. Machen die Spannungsdifferenz Null bewirkt, dass die Materialien in ihre ursprüngliche Position zurück, wieder produziert einen Schwanz Sound.
Durch Anlegen einer Spannung mit einer ausreichend hohen Frequenz, wird der Schwanz durch den piezoelektrischen hergestellt in einen hörbaren Ton zu modulieren.
Sie können dies durch den Anschluss eines Piezo-Summer auf Arduino durch wringen ihre positive Stift, sagen wir, Arduino Pin 8 und der negativen Pin mit Masse (GND) Arduino, siehe Abbildung 1 zu testen. Nehmen Sie den vorherigen Code und ändern Sie die Zeile, die den Stift bestimmt : Die LED ist mit

int ledPin = 8; / / Definieren den Stift für Ihre Lautsprecher oder Piezo

Bei der Ausführung dieses Programms werden Sie die piezoelektrische Klick einmal pro Sekunde, was die Zeit ist zu hören, wenn sich die Spannung an den Stiften an. Sie können den Code ändern, um die Verzögerung zwischen den Klicks zu machen. Je kleiner die Verzögerung, desto mehr Klicks in einen modulierten Ton verschmelzen. Versuchen Sie, beide Linien im Programm, die die Zeit zwischen den Klicks zu sein ändern:

deley (1);

Jetzt werden Sie hören einen Ton mit einer Frequenz von 500 Hz. Sie werden auch feststellen, der Sound lauter wegen einer Eigenschaft der Piezo-Komponenten. Sie schwingen im Kilohertzbereich, zumindest die, die wir finden, im Handel erhältlich, da sie dazu bestimmt sind, Summer oder Kontaktmikrofone sein.
Wenn Sie weitere Klangproduktion mit dieser Technik experimentieren wollen, würde ich Sie ermutigen, nicht die deley () Funktion von Arduino. Der Grund dafür ist, dass Sie eine bessere Zeitauflösung, um eine reichere Auswahl an Klangfarben produzieren müssen. Die Funktion delay Microseconds () ist viel besser geeignet, um die Produktion klingen, da es drei Größenordnungen genauer.
Hinzufügen all diese Änderungen an der ursprünglichen Blink-Programm, wird uns die Bee-Programm:

Seite 8



/* Bee-Programm
    Make a piezoelectric oscillate an pin 8
     http://arduino.cc
*/
int piezoPin = 8;    // define where the piezoelectric is connected

void setup()
{
     pinMode( piezoPin, OUTPUT);
}

void loop()
{
     digitalWrite( piezoPin, HIGH );
     delayMicroseconds( 1000 );
     digitalWrite( piezoPin, LOW );
     delayMicroseconds( 1000 );
}



Spielen Töne
Nach Fourier-Gesetz jeder Ton ist das Ergebnis der Addition eine Reihe von sinusförmigen Schallquellen mit unterschiedlichen Phasen und Amplituden. Wir könnten sagen, dass Sinus-und Cosinus-Wellen sind die grundlegenden Komponenten des Klangs. Leider Mikrocontroller, und die, die ein Arduino Uno ist nicht eine Ausnahme, nicht die Sinusform perfekt zu imitieren. Wir können jede Art und Weise zu produzieren-Rechteckwellen durch mehrmaliges Einschalten einen Stift hoch und niedrig. Die auf diese Weise erzeugten Töne haben die gleiche Frequenz, aber sind nicht sauber, da sie Bestandteile der reinen Sinus hinzuzufügen. In der Musik hat das Instrument machen Rechteckwellen eine andere Klangcharakteristik als der Sinus machen diejenigen, obwohl die richtige Töne sind die gleichen. Die einzige Frage, die wir hier finden, ist, dass Ton in der Frequenz (Hertz oder Hz) ausgedrückt, während Mikrocontroller arbeiten mit der Zeit. Der Gesamtbetrag der Zeit ein HIGH-LOW-Schwingung dauert, ist das, was wir die Zeit (Sekunden) aufrufen. Es besteht eine Beziehung zwischen der Periode P und die Frequenz f wie in der folgenden Formel ausgedrückt:

f = Frequenz

p = Periode

f=1/p  p=1/f

Mit anderen Worten ist die Periode der Kehrwert der Frequenz und umgekehrt. Auf diese Weise, wenn wir wissen, dass die Verzögerung auf Plag benötigt sagen wollen, die A4-Klang mit Arduino, müssen wir ein wenig Mathematik wieder tun:

Seite 9



p = 1/400  = 0.002272 s = 2.272 ms = 2272 us


Wenn wir wollen, das Programm "Bee" auf A4 zu spielen, müssen wir es ändern, so dass die Gesamtzeit in beiden Anrufe zu delayMicroseconds () summiert sich auf 2272 mikrosekunden.


digitalWrite( piezoPin, HIGH );
delayMicroseconds( 1136 );
digitalWrite( piezoPin, LOW );
delayMicroseconds( 1136 );



Tabelle 1. Erhältlich Noten / Ton-Frequenzen

Tone    Frequency [Hz]    Period [ns]    Delay [Fis]
C4      261.63            3822           1911
D4      293.66            3405           1703
E4      329.63            3024           1517
F4      349.23            2863           1432
G4      392.00            2551           1276
A4      440.00            2272           1136
B4      493.88            2025           1012
C5      523.25            1911            956

usw.

Die verschiedenen Töne innerhalb einer Skala kann zu Zeit-Verzögerungen zugeordnet werden, so dass sie mit Arduino gespielt werden kann. Tabelle 1 zeigt eine volle Oktave.

Arduino Ton-Bibliothek
Es gibt mehr zu spielen klingen als nur den Ton. Partituren sind in den Anmerkungen, die die Töne nur für eine gewisse Zeit spielte sich ab gepresst. Um die Möglichkeit des Spielens Grund Melodien mit Arduino zu vereinfachen, haben wir eine Bibliothek, um das System, das all die Mathematik er-läutert bisher in diesem Artikel behandelt, sowie Notendauern. Nun, da Sie ver-stehen, wie man einen Ton auf einem relativ niedrigen Niveau zu spielen, denke ich, ist es zweckmäßig, diese Abstraktion einführen einfacher zu machen für Sie Programme Ton zu spielen erstellen.

Seite 10



Diese Bibliothek wird aufgerufen und Ton bringt eine Funktion, mit der Wiedergabe eines Ton. Im Hintergrund dieses durch Steuerung einige der internen Zeitgeber in dem Prozessor durchgeführt. Ein Timer kümmert sich um den Ton selbst, während der andere überwacht seine Dauer. Es gibt zwei Funktionen, um Sound zu spielen, genannt das gleiche, aber mit einer unterschiedlichen Menge von Parametern.


tone( pin, frequency );                      // play a tone
tone( pin, frequency, duration );     // play a note, duration in milliseconds

Sie sollten beachten, wie die Zeit gemessen wird. Argument der Funktion "Dauer" wird die Note für eine bestimmte Anzahl von Millisekunden (ms) zu spielen. Wenn Sie eine Funktion Zählen der Zeit in einer Weise, die näher an, wie es in Partituren gemacht wird haben wollen, müssen Sie entscheiden, wie lange die verschiedenen Noten werden können. Der folgende Code weist Dauern zu den verschiedenen Notizen bedenkt, dass der Grundton dauert 0,5 Sekunden.

/*  we define durations as numbers between 1 and 7:
     1 - whole note - 1 unit
     2 - half note - 0.5 units
     3 - crotchet - 0.25 units
     4 - quaver - 0.125 units
     5 - semi quaver - 0.0625 units
     6 - demi semi quaver - 0.03125 units
     7 - hemi demi semi quaver - 0.015625 units
*/
void playNote( int speaker, int theTone, int duration )
{
     // we give for granted that the half note lasts 0.5 segundos
     long time = 500 / pow( 2, duration-1 );

     // assign the note to the speaker
     tone( speaker, theTone, time );
}

Die obige Funktion kann auch in einer Weise, die Nutzung der mehr gemeinsame Variable der Beats pro Minute (bpm) machen würde geschrieben werden. Auf diese Weise konnten wir das Instrument spielen mit unterschiedlichen Geschwindigkeiten machen, je eine für das gewünschte Tempo der Melodie.

Seite 11




/* we define durations as numbers between 1 and 7:
     [...]
*/
void playNote( int speaker, int theTone, int duration, int bpm )
{
     // menmotecnic: 120 bpm - - > 1000 milliseconds for half note
     // source http://bradthemad.org/guitar/tempo_calculator.php
     long time = ( 1000 * bpm / 120 ) / pow( 2, duration );

     // assign the note to the speaker
     tone( speaker, theTone, time );
}



Chained Melodien
Es ist "genial und Zeug", um eine kurze Melodie zu einem bestimmten Zeitpunkt während der Ausführung eines Programms zu spielen. Eine Melodie besteht aus Noten und Pausen. Hier werden wir sehen, wie eine Melodie als ein Array von Zahlen gespeichert sind. In-Seite die Arduino IDE gibt es ein Beispiel genau Umgang mit diesem. Öffnen Sie das Programm unter
File > Examples > 2.Digital > toneMelody

300_d_ArduinoNext-x_120427-11 ARDUINO 8-bit Sound Generation von David Cuartielles (Software)_1a.zip

/*
     Melody
     Plays a melody
     [...]
*/
  #include 'pitches.h"

  // notes in the melody:
  int melody[] = {
     NOTE_04, NOTE_G3, NOTE G3, NOTE_A3, NOTE_03, 0, NOTE_B3, NOTE_C4};

  // note durations: 4 = quarter note, 8 = eighth note, etc.:
  int noteDurations[] =    4, 8, 8, 4, 4, 4, 4, 4 };

void setup()
{
     // iterate over the notes of the melody:
     for( int thisNote = 0; thisNote < 8; thisNote++ )
     {
          // to calculate the note duration, take one second
          // divided by the note type.
           //e.g. quarter note = 1000 / 4, eighth note = 1000/8, etc.
           int noteDuration = 1000 / noteDurations[thisNote];
           tone( 8, melody[thisNote], noteDuration );

Seite 12




          // to distinguish the notes, set a minimum time between them.
          // the note's duration + 30% seems to work well:
          int pauseBetweenNotes = noteDuration * 1.30;
          delay( pauseBetweenNotes );

          // stop the tone of playing:
          noTone( 8 );
        }
}

void loop()
{
          // no need to repeat the melody.
}


Sie werden feststellen, dass die Melodie in zwei Arrays gespeichert: die Noten sind in einem, während die Notendauern sind in einer anderen. Dauer sind unterschiedlich von dem, was wir bereits gesehen haben Ex-gepresst.
Unsere vorherigen Beispiel wurde mit Laufzeiten in der Art, in der Musik gemacht wird ausgedrückt.
Der erste Befehl in das Programm enthält eine Datei namens pitches.h, die als Teil des Codes in eine andere Registerkarte im Beispiel kommt. Die Datei ist leider zu groß für den Druck hier. Es enthält eine Reihe von Konstanten vertreten die Frequenzen für jeden Ton. Auf diese Weise stellt die ständige NOTE_A4 den numerischen Wert 440 oder die 440 Hz für die Note A4.


/****************************************
*                        Public Constants
****************************************/
#define NOTE BO 31
#define NOTE_Cl 33
#define NOTE_CS1 35
[...]
#define NOTE_G4 392
#define NOTE_GS4 415
#define NOTE_A4 440
#define NOTE_AS4 466
[...]
#define NOTE_CS8 4435
#define NOTE_D8 4699
#define NOTE DS8 4978



Das obige Beispiel kann modifiziert werden, um den Einsatz der Beats pro Minute (bpm), so wird das, was erlauben die Änderung der Geschwindigkeit, mit der die Melodie spielt.

Seite 13



Wir müssen nur die playNote Funktion, die wir früher gemacht sind und ändern Sie die Art, wie wir zum Ausdruck bringen, die Dauer, die in den gleichen Bedingungen wie in unserem neuen Funktion ausgedrückt werden:

#include "pitches.h"

int melody[]= {NOTE_C4, NOTE G3, NOTE_G3, NOTE_A3, NOTE_03, 0, NOTE_B3, NOTE 04};
int noteDurations[]    { 2, 3, 3, 2, 2, 2, 2, 2 };
int bpm = 120;

void playNote( int speaker, int theTone, int duration, int bpm )
{
          // mnemotgcnico: 120 bpm - - > 1000
          // 1000 milliseconds for half note
          // source http://bradthemad.org/
          // guitar/tempo_calculator.php
       long time = ( 1000 / bpm * 120 ) / pow( 2, duration );

       tone( speaker, theTone, time );    // assign the note to the speaker
       delay( time*1.30 );    // add 30% for the silence between notes
}

void setup()
{
       for( int thisNote = 0; thisNote < 8; thisNote++ )
     {
          playNote( 8, melody[thisNote], noteDurations[thisNote], bpm );
      }
}

void loop()
{
// let's listen to it just once
}



Versuchen Sie nun, wie ein Potentiometer oder eine andere analoge Sensor, um die BPM-Rate ändern und auf diese Weise die Melodie mit unterschiedlichen Geschwindigkeiten.

1-Bit-Klangerzeugung ... Was??
Bis zu diesem Punkt, haben Sie schon mit Code, werden direkt aus der Arduino Sprache erzeugte experimentieren können. Jetzt gehen wir mit Methoden der Hacker den Prozessor ein Arduino Uno die (der ATmega 328) auf niedrigem Niveau mit dem Ziel, einen Code-Block, das Sound-Daten verwenden, wird aus WAV-Datei für die Lagerung im Inneren Programmspeicher zu schaffen - und Spiel zurück natürlich.

Seite 14



Das verwendete Verfahren ist nicht trivial. Ein guter Anfang ist es, in Ton in Bezug auf das Spektrum nicht von jeder Art von Darstellung in der Zeit auf der Basis suchen.

Klangspektrum
Das Klangspektrum ist eine Darstellung des durch, sagen wir, einen Lautsprecher in Abhängigkeit von Frequenzenergie. Mit Blick auf das Klangspektrum,
Sie normalerweise nicht bekommen einen klaren Blick auf den Klang selbst, wie in 1.
Vielmehr stellt der Graph die Menge an Energie für verschiedene diskrete
Frequenzen innerhalb einer bestimmten Zeit. In der Regel vertreten wir die
Spektrum für einen ganzen Song (siehe Abbildung 2).
Alternativ können wir das Spektrum von nur 0,5 Sekunden eines Songs zu suchen.
Je kleiner der Zeitrahmen wir beobachten, desto besser die spektrale Darstellung des Schall in diesem Augenblick erzeugt werden. Die Form der Welle zu erzeugen, dass die Frequenzen kann alles sein. In der Tat können zwei verschiedene Schallsignale sehr ähnliche Spektren zu erzeugen.
Somit wird die Ähnlichkeit dieses Signal ist die Größe der Zeitrahmen be-stimmt mit dem Original. Das menschliche Ohr ist durch den Energieinhalt des Schall stimuliert daher zwei Signale mit identischen Spektren als gleich angesehen werden, jedoch nur, wenn die Zeitauflösung klein genug ist. Dies ist der Schlüssel für die ganze Wissenschaft der Sound-Kompression: die Fähigkeit, sich Signale, die gut genug sind "für uns, um den Ton zu verstehen, auch wenn der Sound ist ganz anders als das Original.
Dies ist auch der Weg, 1-Bit-Klangerzeugung Werke [1]. Wir können

Audacity

Seite 16


 
const unsigned char sounddata_data[] PROGMEM = {128, 128, 128,
[• • • ]
69, 62, 59, 57, 52, 50, 56, 65, 74, 86, 96, 109, 116, };

Ich habe ein Tool für die Arduino IDE, die Sie WAV-Dateien öffnen und importieren Sie sie direkt als Teil des Codes ermöglicht erstellt. Sie können es von der in der Referenzliste genannten Link herunterladen, um sie Ihren Skizzen Ordner hinzuzufügen. Legen Sie die Datei in Ihr Skizzenbuch Arduino-Ordner und entpacken Sie es dort.
Es wird den folgenden Ordner, um Ihre Skizzenbuch hinzufügen: ools t / a SoundDat Nach dem Neustart des IDE, werden Sie einen neuen Eintrag im Menü Extras aufgerufen SoundData sehen. Ein Klick darauf erzeugt ein Dialogfenster, mit dem Sie eine WAV-Datei (siehe Abbildung 3) zu wählen. Die zweite Schaltfläche mit dem Titel Code generieren werden die WAV-Datei zu öffnen, zu überprüfen, ob es richtig codiert ist, und fügen Sie einen neuen Tab, um Ihren Code mit dem Titel sounddata. h. Diese neue Datei enthält alles, was Sie Ihre WAV-Datei als eine 1-Bit-Sound Plag müssen. Die Datei wird wie folgt aussehen:

// soundData for your Arduino sound project
// automatically generated data
// - original sound file:/development/tmp/matis.wav
// - sampleRate:8000
// - encoding:8 bits
// - channels:1

const int sounddata length = 7969;

const signed char sounddata_data[] PROGMEM = {127, 127, 127, 127, 127, 127,
[...]
69, 62, 59, 57, 52, 50, 56, 65, 74, 86, 96, 109, 116, };

Aber lesen Sie weiter vor-Presse den Code generieren-Taste auf dem Dialogfenster, sein-denn es gehört mehr dazu!

Der Sound Player
Wiedergabe einer gesampelten Sound ist nicht offensichtlich, da es zu ändern einige der Features von erfordert



                           Select File
Hackerl    include player code
                      Generate Code

Abbildung 3. Dialogfenster in WAV-Dateien in Ihre Arduino Skizzen als Header-Dateien zu importieren.

Seite 17



SoundData Tool For Arduino        sounddata.h
Abbildung 4. Ansicht der "ta-ti-ti-to-tu" Sound-Datei im Arduino IDE ändern, importieren Sie es mit der SoundData tool.as erwartet. Dies betrifft nur diese Skizze.


die Arduino Kern funktioniert. Es gibt Bibliotheken für Arduino Uno, die alle von der Komplexität der Herstellung dieser Art von Klangspiel-er zu verbergen. Allerdings möchte ich Sie um eine Chance zu nehmen und sehen, wie das auf einem niedrigen Niveau wie in Abbildung 4 getan.

Der Trick, der Ardui-keine bekommen können, um ein Klangbeispiel spielen, ist die so genannte Fast-PWM, eine Funktion von Atmel ATmega Familie (andere Marken haben es als gut, aber Ardu-ino Uno läuft ein Atmel Chips). Es ist ein Register, laufendem PWM an der erstaunlichen Geschwindigkeit von bis zur Hälfte der Taktfrequenz ermöglicht. Dies ermöglicht nette Dinge wie Sound-Wiedergabe mit 1-Bit-Ausgänge erfolgen. Die einzige Einschränkung Schnelle PWM ist, dass es bei einer Auflösung arbeitet
von nur 8 Bit. Deshalb sollten Sie Ihre Sound-Dateien auf 8 Bits codieren.
Um es allen zu arbeiten, zwei der drei internen Timer-Register nutzen zu können,
im Prozessor:
• Der erste Takt arbeitet bei SAMPLE_RATE und wird verwendet, um die nächste Lese
Wert aus dem Computer generiert sounddata_data Array. Dieser Wert stellt die Einschaltdauer für die PWM-Strom ausgegeben werden über Pin 11.
• Die zweite Timerticks in 62500 mal pro sekunde (16000000/256), d.h.
viel schneller als die Wiedergaberate (Standard SAMPLE_RATE ist 8 kHz). Wie bereits erläutert, erzeugt dieser ein digitales Signal, dessen Spektrum in Form sehr ähnlich der des ursprünglichen Audiodatei. Mit anderen Worten, durch eine Erhöhung der PWM-Frequenz, wird das erzeugte Signal ein Spektrum, das eine der Klang ähnelt. In mang Anwendungen ist dies mehr als genug, um Klang zu einem niedrigen Preis zu spielen.

Hinweis: indem Sie diesen Code auf Ihre Arduino skizzieren Sie überschreiben werden einige der grundlegenden Befehle der Arduino Sprache. Z.B. die PWM wird nicht mehr funktionieren einige der Stifte, und die Verzögerung ()-Funktion funktioniert nicht wie erwartet. Dies betrifft nur diese Skizze.

Seite 18



SoundData Tool For Arduino     sketch_may08a §
Abbildung 5. Screendump der Grund Sound-Player ALTER automatischen Generierung des Codes.

Das erste Mal wurde diese Technik in der Arduino-Welt gezeigt wurde, war bereits im Jahr 2008. Michael Smith veröffentlichte ein Beispiel auf der Ardui-kein Spielplatz, der den Klang eines MAC-Computer hochfährt, beim Rücksetzen des Ar-duino Diecimila Bord spielen würde . Michael-Code wurde auf der Arbeit von vielen anderen, die ich einschließlich ed als Bezugnahmen auf Basis [3].
Nur, um es einfach, die SoundData Tool wird nicht nur erzeugen die Schallinformationen, aber auch den Code an den Grund-Sound-Wiedergabe beispielsweise in Ihrer Skizze. Passen Sie auf, stellen Sie sicher, Ihre Skizze ist leer beim Aufruf des Werkzeugs, wie es überschreiben, alles auf Ihrem IDE.
Das Grundprogramm zu 1-Bit-Sound (Abbildung 5) spielen umfasst eine Menge von Low-lev el-Befehle, um die Zeiten zu überschreiben. Ich werden die Funktionen beschreiben eine nach der anderen. Lassen Sie uns mit TIMER1 starten:


ISR(TIMERl_COMPA_vect)
{
     if (sample >= sounddata_length)
     {
          if (sample == sounddata_length + lastSample)
         {
               // this is the condition of reaching the last sample
            stopPlayback();
         } else
         {
               // Ramp down to zero to reduce the click at the end of
               // playback.
               OCR2A = sounddata_length + lastSample - sample;
          }
      }

else
   {
// OCR2A is the register in memory that will push
// PWM at high frequency to pin 11
// pgm_read_byte reads data out arrays stored in
// program memory
OCR2A = pgm_read_byte(&sounddata_data[sample]);
   }

// increase the sample count
++sample;
}

Seite 19







     // No prescaler (p.134)
     TCCR1B = (TCCR1B & ~(_BV(CS12) 1 BV(CS11))) 1 BV(CS10);

     // Set the compare register (OCR1A).
     // OCR1A is a 16-bit register, so we have to do this with
     // interrupts disabled to be safe.
     OCR1A = FCPU / SAMPLE RATE;    // 16e6 / 8000 = 2000

     // Enable interrupt when TCNT1 == OCR1A (p.136)
     TIMSK1 1= BV(OCIE1A);

     lastSample = pgm_read_byte(&sounddata_data[sounddata_length-1]);
     sample = 0;
     sei();
}



Obwohl die Reihenfolge der niedrigen Befehle im Code erläutert, kann eine Zusammenfassung der es sinnvoll, für die Nicht-Experte sein:
• Schalten Sie den Stift für den Lautsprecher in einen Ausgang;
• das Board konfigurieren, um die innere Uhr dafür zu verwenden;
• Schnelle Initialisierung PWM-Modus;
• TIMER2 konfigurieren, um die PWM, die den Klang spielen wird laufen, ist der Weg, um den Arbeitszyklus zu dem PWM eingestellt, indem der Wert des Registers genannt OCR2A;
• Laden Sie die ersten Klangprobe in OCR2A;
• Beenden Sie die Interrupts für eine zweite -  cli () -, so dass wir die TIMER1 ohne Pausen zu konfigurieren;
• konfigurieren TIMER1 für Abholung der nächsten Probe ankreuzen;
• Laden Sie die letzte Ton Probe;
• Starten Sie die Interrupts - sei ().
In ähnlicher Weise, müssen Sie eine Funktion, die die Timer zu zählen, auf diese Weise aufhören wird, sobald das Ende des Schall erreicht haben.


void stopPlayback()
{
     // Disable playback per-sample interrupt.
     TIMSK1 &= ~_BV(OCIE1A);

     // Disable the per-sample timer completely.
     TCCR1B &= ~_BV(CS10);

     // Disable the PWM timer.
     TCCR2B &= ~_BV(CS10);

     digitalWrite(speakerPin, LOW);
}

Seite 21



Dies lässt Sie mit einer Reihe von Funktionen, die Sie überall von einem Programm aufrufen können, um Plag klingen diese Weise. In diesem Fall wird das Beispiel standardmäßig startPlayback im Setup () aufrufen. Auf diese Weise wird der Ton nur einmal wiedergegeben werden.

void setup()
{
     startPlayback();
}

void loop()
{
     // do nothing
}



Schlusswort
Dieser Artikel ist eine Einführung in verschiedene Möglichkeiten der erzeugung klingen uns-
ing Arduino. Sie haben gesehen, wie man Töne mit Hilfe von Grund Ardui-spielen
keine Funktionen. Bibliotheken beschrieben, die die Art und Weise grundlegende Melodien können unter Verwendung von in-teuer Piezo-Summer abgespielt vereinfachen. Schließlich bekam man einen Einblick in die Programmierung hinter Schnelle PWM zu 1-Bit-Sound zu erzeugen.
Alle Codestücke und Werkzeuge hier diskutiert werden in einer ZIP-Datei [4] gepackt, darunter richtig formatiert Sound-Dateien für Sie alle Beispiele ausprobieren. Ich habe auch ein neues Werkzeug für die Ardu ino-IDE, die Sie mit dem Import von Kurz WAVE-Dateien in den Programmspeicher Arduino helfen. Das Tool ermöglicht Ihnen, Klänge laden und abspielen, verändern ihre Abtastrate, spielen sie nach hinten oder zerkratzen den Klang. In Bezug auf die Hardware, verbinden Sie Ihre Lautsprecher wie in Abbildung 6 dargestellt.


ARDUINO UNO R3
Abbildung 6. Arduino Uno ist durchaus in der Lage die direkte Ansteuerung einen kleinen Lautsprecher.

Seite 22



Aber hier nicht zu stoppen! Es gibt viel zu entdecken - zum Beispiel mit Pin 3 parallel zu Pin 11 Stereo-Sound. Oder erstellen Sie 8-Bit-Synthesizern-ten mit der Fähigkeit der Misch vier Klanglinien eine ein einzelner Kanal. Was ist die Umwandlung Ihrer Arduino-Board in einen MIDI-Soundkarte aktiviert.

Seite 23




References
[1] 1-bit Sigma Delta DA Converters: www.digitalsignallabs.com/presentation.pdf
[2] Audacity, the free and open source sound studio: audacity.sourceforge.net
[3] Various references from the example by Michael Smith:
Arduino reference on the use of the tone library: arduino.cc/en/Reference/Tone
Original article on the Arduino Playground: arduino.cc/playground/Code/PC-MAudio
www.uchobby.com/index.php/2007/11/11/arduino- sound-part- 1/
www.atmel.com/dyn/resources/prod_documents/doc2542.pdf
www.evilmadscientist.com/article.php/avrdac
http://gonium.net/md/2006/12/27/i-will-think-before-i-code/
http://fly.cc.fer.hr/GDM/articles/sndmus/speaker2.html
www.gamedev.net/reference/articles/article442.asp
[4] Example files for this article: www.elektor.com/120427

Seite 24



Bleiben Sie mit unserem Kommunikationskanäle dran!
Folgen Sie uns auf Facebook und auf Twitter.
          Facebook    www.facebook.com / arduinonext    https://www.facebook.com/arduino.next
              Twitter                   @ arduinonext   https://twitter.com/arduinonext/status/372734397364989952 
https://twitter.com/arduinonext/

Schauen Sie sich die Arduino-Produkte, die bereit stehen zum  Verkauf
http://arduino.cc/de/Main/ArduinoBoardUno
www.elektor.com

Seite 25

QUELLE:
David Cuartielles, Saragossa, Spanien

DIN A4  ausdrucken