Comment envoyer le son d'un haut-parleur

En supposant que vous avez un 8 bits non compressé 22.1 kHz mono fichier wave:

1) Bande de l'en-tête

2) Chaque 1/22,100 ème seconde:

2.1) Lecture 8 bits

2.2) l'Utilisation d'un DAC pour convertir le haut-parleur de la gamme de tension

2.3) l'Envoyer à l'orateur

Cela vous donnera [22.1 kHz/8 bits/mono] la qualité sonore et est un moyen simple de jouer réaliste des échantillons.

Tous que la fréquence des choses est nécessaire pour les différents synthétiseurs. Le haut-parleur du PC, par exemple, est effectivement un peu. Afin d'avoir des amplitudes différentes (de "aucun" et "maximum") certains trucs comme la modulation de largeur d'impulsion peut être nécessaire (maj les fréquences autour, comme vous l'avez dit, de sorte que le haut-parleur du diaphragme efficacement a plus de postes que deux).

Mais vous n'avez pas besoin de s'embêter avec ça. Tout ce que vous devez faire est de dégorger quelques 22,100 ou 44,200 échantillons sonores par seconde à la le président, à dire 8 ou 16 bits par échantillon pour désigner l'amplitude.

Une méthode pour la génération d'un ton ferme est Synthèse Numérique Directe. Vous aurez besoin d'un DAC, soit d'une puce dédiée ou une résistance échelle.

Vous configurez un compteur de dépassement à la fréquence que vous souhaitez générer, et à chaque tick de la contre vous de l'utiliser pour indexer une table d'onde et d'obtenir une valeur de sortie de votre DAC.

J'ai écrit un couple de tonalité différentes techniques de génération pour l'Arduino ici à De Nouveaux Bruits De MidiVox. Le DAC de la mise à jour de code est spécifique à MidiVox (et le Adafruit WaveShield s) MCP4921, mais la génération de signaux sinusoïdaux devrait être généralement applicables. J'ai essayé de garder le code pour la plupart générale à ATmegas, mais il ya un couple de Arduino-ismes qui s'installe.

Collé à partir de ce post, voici un peu de code pour jouer un 440Hz ton sur un Arduino avec un MCP4921 sur le bus SPI:

uint16_t sample = 0;
/* incr = freq * (2^16 /15625) 
* So for 440Hz, incr = 1845 */
uint16_t incr = 1845;
/* oscillator position */
uint16_t pos = 0;
const uint8_t sine[] = {
0x80, 0x83, 0x86, 0x89, 0x8C, 0x8F, 0x92, 0x95, 0x98, 0x9B, 0x9E, 0xA2,
0xA5, 0xA7, 0xAA, 0xAD, 0xB0, 0xB3, 0xB6, 0xB9, 0xBC, 0xBE, 0xC1, 0xC4,
0xC6, 0xC9, 0xCB, 0xCE, 0xD0, 0xD3, 0xD5, 0xD7, 0xDA, 0xDC, 0xDE, 0xE0,
0xE2, 0xE4, 0xE6, 0xE8, 0xEA, 0xEB, 0xED, 0xEE, 0xF0, 0xF1, 0xF3, 0xF4,
0xF5, 0xF6, 0xF8, 0xF9, 0xFA, 0xFA, 0xFB, 0xFC, 0xFD, 0xFD, 0xFE, 0xFE,
0xFE, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFE, 0xFE, 0xFE, 0xFD,
0xFD, 0xFC, 0xFB, 0xFA, 0xFA, 0xF9, 0xF8, 0xF6, 0xF5, 0xF4, 0xF3, 0xF1,
0xF0, 0xEE, 0xED, 0xEB, 0xEA, 0xE8, 0xE6, 0xE4, 0xE2, 0xE0, 0xDE, 0xDC,
0xDA, 0xD7, 0xD5, 0xD3, 0xD0, 0xCE, 0xCB, 0xC9, 0xC6, 0xC4, 0xC1, 0xBE,
0xBC, 0xB9, 0xB6, 0xB3, 0xB0, 0xAD, 0xAA, 0xA7, 0xA5, 0xA2, 0x9E, 0x9B,
0x98, 0x95, 0x92, 0x8F, 0x8C, 0x89, 0x86, 0x83, 0x80, 0x7D, 0x7A, 0x77,
0x74, 0x71, 0x6E, 0x6B, 0x68, 0x65, 0x62, 0x5E, 0x5B, 0x59, 0x56, 0x53,
0x50, 0x4D, 0x4A, 0x47, 0x44, 0x42, 0x3F, 0x3C, 0x3A, 0x37, 0x35, 0x32,
0x30, 0x2D, 0x2B, 0x29, 0x26, 0x24, 0x22, 0x20, 0x1E, 0x1C, 0x1A, 0x18,
0x16, 0x15, 0x13, 0x12, 0x10, 0x0F, 0x0D, 0x0C, 0x0B, 0x0A, 0x08, 0x07,
0x06, 0x06, 0x05, 0x04, 0x03, 0x03, 0x02, 0x02, 0x02, 0x01, 0x01, 0x01,
0x01, 0x01, 0x01, 0x01, 0x02, 0x02, 0x02, 0x03, 0x03, 0x04, 0x05, 0x06,
0x06, 0x07, 0x08, 0x0A, 0x0B, 0x0C, 0x0D, 0x0F, 0x10, 0x12, 0x13, 0x15,
0x16, 0x18, 0x1A, 0x1C, 0x1E, 0x20, 0x22, 0x24, 0x26, 0x29, 0x2B, 0x2D,
0x30, 0x32, 0x35, 0x37, 0x3A, 0x3C, 0x3F, 0x42, 0x44, 0x47, 0x4A, 0x4D,
0x50, 0x53, 0x56, 0x59, 0x5B, 0x5E, 0x62, 0x65, 0x68, 0x6B, 0x6E, 0x71,
0x74, 0x77, 0x7A, 0x7D
};
void setup() {
cli();
/* Enable interrupt on timer2 == 127, with clk/8 prescaler. At 16MHz,
this gives a timer interrupt at 15625Hz. */
TIMSK2 = (1 << OCIE2A);
OCR2A = 127;
/* clear/reset timer on match */
TCCR2A = 1<<WGM21 | 0<<WGM20; /* CTC mode, reset on match */
TCCR2B = 0<<CS22 | 1<<CS21 | 0<<CS20; /* clk, /8 prescaler */
SPCR = 0x50;
SPSR = 0x01;
DDRB |= 0x2E;
PORTB |= (1<<1);
sei();
}
ISR(TIMER2_COMPA_vect) {
/* OCR2A has been cleared, per TCCR2A above */
OCR2A = 127;
pos += incr;
/* shift left a couple of bits for more volume */
sample = sine[highByte(pos)] << 2;
PORTB &= ~(1<<1);
/* buffered, 1x gain, active mode */
SPDR = highByte(sample) | 0x70;
while (!(SPSR & (1<<SPIF)));
SPDR = lowByte(sample);
while (!(SPSR & (1<<SPIF)));
PORTB |= (1<<1);
}
void loop() {
}

La chouette chose à propos de la Synthèse Numérique Directe est qu'il est extrêmement facile de jouer de plusieurs tons ensemble (par addition) ou de les mélanger à des volumes (en multipliant par le volume avant de l'ajouter).

J'ai trouvé que l'Arduino peut jouer environ 30 sons en même temps à l'aide de cette méthode. Ma demande est pour L'orgue Hammond de simulation, et qui peut s'avérer utile de la lecture.

Si vous vous sentez particulièrement créatifs, vous pouvez créer vos propres numérique-analogique convertisseur à l'aide d'un résistance échelle.

Vous pouvez prendre un coup d'oeil à la open source lecteur MP3 et de voir comment ils le font. Ma conjecture est que vous aurez besoin d'un convertisseur D/A à produire des sons d'une qualité décente.