fbpixel
Creación de un controlador MIDI con Arduino

Creación de un controlador MIDI con Arduino

En este proyecto vamos a construir una caja MIDI para poder probar los instrumentos del sintetizador CoolSoft y tocar algunas notas. Vamos a utilizar tres sensores para modificar los mensajes MIDI. Eres libre de añadir elementos para hacer un controlador MIDI más completo.

Requisitos previos: Creación de una interfaz MIDI con Arduino

Equipamiento

  • Arduino UNO
  • potenciómetro
  • codificador rotatorio
  • teclado analógico 4×4

Características

Para probar la comunicación MIDI y el sintetizador. Vamos a definir algunas funciones simples:

  • Usando el teclado, vamos a enviar notas musicales
  • Le potenciómetro permet d’ajuster la vitesse de la note
  • Y el codificador modificará el instrumento sintetizado

N.B.: Elegimos un teclado analógico para este proyecto porque es fácil de cablear y nos permite probar rápidamente el sintetizador. El inconveniente es que sólo se puede pulsar una tecla a la vez. Para obtener un controlador MIDI más eficaz, puedes optar por un teclado digital o botones arcade que te proporcionen información sobre las notas tocadas.

Diagrama

N.B.: Para facilitar la lectura, hemos eliminado la pantalla de 7 segmentos. Puede encontrar la conexión en este tutorial.

Descripción del código

En primer lugar, definiremos funciones para gestionar cada uno de los sensores.

Para el teclado 4×4, asignamos a cada tecla un identificador que corresponde a una nota. Creamos una función que devuelve el identificador cuando se pulsa una tecla.

const int valThresh[nbABtn] = {1000, 900, 820, 750, 660, 620, 585, 540, 500, 475, 455, 425, 370, 300, 260, 200};
const int pitches[nbABtn] = {50, 52, 54, 56, 58, 60, 62, 64, 66, 68, 70, 72, 74, 76, 78, 80 }
int getABtn() { /* function getABtn */
 //// Read button states from keypad
 int val = analogRead(abtnPin);
 if (val <= 200) {
   return 0;
 } else {
   for (int i = 0; i < 16; i++) {
     if (val > valThresh[i]) {
       delay(100);
       return i + 1;
     }
   }
 }
}

Definimos una función readPot que modificará el valor de la velocidad en función del valor del potenciómetro velVal.

void readPot(){
  velVal = map(int(analogRead(potPin) / 10) * 10, 0, 1023, 0, 127);
  if (oldVel != velVal) {
    //Serial.println(velVal);
    velocity = velVal;
  }
  oldVel = velVal;
}

La función que gestiona el codificador nos permite modificar el instrumento musical (identificador rotVal entre 0 y 127).

void readRotary( ) { /* function readRotary */
  ////Test routine for Rotary
  // gestion position
  clkState = digitalRead(clkPin);
  if ((clkLast == LOW) && (clkState == HIGH)) {//rotary moving
    if (digitalRead(dtPin) == HIGH) {
      rotVal = rotVal - 1;
      if ( rotVal < 0 ) {
        rotVal = 0;
      }
    }
    else {
      rotVal++;
      if ( rotVal > 127 ) {
        rotVal = 127;
      }
    }
    MIDImessage(prgmChg, rotVal, 0);
    number = rotVal;
    for (int i = 0; i < NUM_OF_DIGITS; i++)
    {
      digit_data[i] = number % 10;
      number /= 10;
    }
    delay(200);

  }
  clkLast = clkState;

  //gestion bouton
  swState = digitalRead(swPin);
  if (swState == LOW && swLast == HIGH) {
    delay(100);//debounce
  }
  swLast = swState;
}

Una vez tenida en cuenta la modificación del aparato, su valor se visualiza en el módulo 7 Segmento.

void Display(int id, unsigned char num)
{
  digitalWrite(latch, LOW);
  shiftOut(data, cs, MSBFIRST, table[num]);
  digitalWrite(latch, HIGH);
  for (int j = 0; j < NUM_OF_DIGITS; j++) digitalWrite(dPins[j], LOW);
  digitalWrite(dPins[id], HIGH);
}

void updateDigits() {
  for (int j = 0; j < NUM_OF_DIGITS; j++){
    Display(j, digit_data[j]);
    delay(2);
  }
}

Por último, volvemos a la función que nos permite enviar mensajes MIDI

void MIDImessage(byte command, byte MIDInote, byte MIDIvelocity) {
  Serial.write(command);//send note on or note off command
  Serial.write(MIDInote);//send pitch data
  if (command == noteON || command == noteOFF) {
    Serial.write(MIDIvelocity);//send velocity data
  }
}

Sólo queda enviar el mensaje cuando se pulse un botón

void readAbtn() { /* function readAbtn */
  //// Read button states from keypad
  btnId = getABtn();
  if (btnId) {
    if (lastBtnId != btnId) {
      MIDImessage(noteOFF, pitches[lastBtnId - 1], velocity);
    }
    MIDImessage(noteON, pitches[btnId - 1], velocity); //turn note on
    lastBtnId = btnId;
  }
}

Código MIDIbox completo

byte velocity = 50;//velocity of MIDI notes, must be between 0 and 127
byte noteON = 144;// = 10010000 , Note On
byte noteOFF = 128;// = 10000000 , Note Off
byte pitchBend = 224; // = 11100000, Pitch Bender Change
byte polyKey = 160; // = 10100000, Polyphonic Key Pressure
byte overallPr = 208; // = 11010000, Overall Pressure
byte prgmChg = 192; // = 11000000, Program Change
byte ctrlChg = 176; // = 10110000,  Control Change

//Keypad
#define nbABtn 16
const int abtnPin = A1;
const int valThresh[nbABtn] = {1000, 900, 820, 750, 660, 620, 585, 540, 500, 475, 455, 425, 370, 300, 260, 200};
const int pitches[nbABtn] = {50, 52, 54, 56, 58, 60, 62, 64, 66, 68, 70, 72, 74, 76, 78, 80 };
bool btnPressed = false;

//Potentiometer
const int potPin = A0; // Pin connected to sensor
int velVal = 0, oldVel = 0; // Analog value from the sensor

//rotary var
const int clkPin  = 53;
const int dtPin  = 51;
const int swPin  = 49;
int rotVal  = 0, btnId = 0, lastBtnId = 0;
bool clkState  = LOW;
bool clkLast  = HIGH;
bool swState  = HIGH;
bool swLast  = HIGH;

//4x7Segment
#define NUM_OF_DIGITS 4
int latch = 4; //74HC595  pin 9 STCP
int cs = 5; //74HC595  pin 10 SHCP
int data = 3; //74HC595  pin 8 DS
int dPins[4] = {8, 9, 10, 11};
//  DP G F E D C B A
//0: 1 1 0 0 0 0 0 0 0xc0
//1: 1 1 1 1 1 0 0 1 0xf9
//2: 1 0 1 0 0 1 0 0 0xa4
//3: 1 0 1 1 0 0 0 0 0xb0
//4: 1 0 0 1 1 0 0 1 0x99
//5: 1 0 0 1 0 0 1 0 0x92
//6: 1 0 0 0 0 0 1 0 0x82
//7: 1 1 1 1 1 0 0 0 0xf8
//8: 1 0 0 0 0 0 0 0 0x80
//9: 1 0 0 1 0 0 0 0 0x90
unsigned char table[] =
{0xc0, 0xf9, 0xa4, 0xb0, 0x99, 0x92, 0x82, 0xf8, 0x80, 0x90};
int digit_data[NUM_OF_DIGITS] = {0};
unsigned int number = 0;
unsigned long previousUpdate = 0, updateTime = 200;

void setup() {
  Serial.begin(115200);
  pinMode(potPin, INPUT);

  pinMode(clkPin, INPUT);
  pinMode(dtPin, INPUT);
  pinMode(swPin, INPUT_PULLUP);

  pinMode(latch, OUTPUT);
  pinMode(cs, OUTPUT);
  pinMode(data, OUTPUT);
  for (int j = 0; j < NUM_OF_DIGITS; j++) pinMode(dPins[j], OUTPUT);
}

void loop() {
  readRotary();
  updateDigits();
  readAbtn();
  readPot();
}

void MIDImessage(byte command, byte MIDInote, byte MIDIvelocity) {
  Serial.write(command);//send note on or note off command
  Serial.write(MIDInote);//send pitch data
  if (command == noteON || command == noteOFF) {
    Serial.write(MIDIvelocity);//send velocity data
  }
}


void readAbtn() { /* function readAbtn */
  //// Read button states from keypad
  btnId = getABtn();
  if (btnId) {
    if (lastBtnId != btnId) {
      MIDImessage(noteOFF, pitches[lastBtnId - 1], velocity);
    }
    MIDImessage(noteON, pitches[btnId - 1], velocity); //turn note on
    lastBtnId = btnId;
  }
}

int getABtn() { /* function getABtn */
  //// Read button states from keypad
  int val = analogRead(abtnPin);
  if (val <= 200) {
    return 0;
  } else {
    for (int i = 0; i < 16; i++) {
      if (val > valThresh[i]) {
        delay(100);
        return i + 1;
      }
    }
  }
}

//Potentiometer
void readPot(){
  velVal = map(int(analogRead(potPin) / 10) * 10, 0, 1023, 0, 127);
  if (oldVel != velVal) {
    //Serial.println(velVal);
    velocity = velVal;
  }
  oldVel = velVal;
}

//7Segment
void Display(int id, unsigned char num)
{
  digitalWrite(latch, LOW);
  shiftOut(data, cs, MSBFIRST, table[num]);
  digitalWrite(latch, HIGH);
  for (int j = 0; j < NUM_OF_DIGITS; j++) digitalWrite(dPins[j], LOW);
  digitalWrite(dPins[id], HIGH);
}

void updateDigits() {
  for (int j = 0; j < NUM_OF_DIGITS; j++)
  {
    Display(j, digit_data[j]);
    delay(2);
  }
}

//rotary
void readRotary( ) { /* function readRotary */
  ////Test routine for Rotary
  // gestion position
  clkState = digitalRead(clkPin);
  if ((clkLast == LOW) && (clkState == HIGH)) {//rotary moving
    if (digitalRead(dtPin) == HIGH) {
      rotVal = rotVal - 1;
      if ( rotVal < 0 ) {
        rotVal = 0;
      }
    }
    else {
      rotVal++;
      if ( rotVal > 127 ) {
        rotVal = 127;
      }
    }
    MIDImessage(prgmChg, rotVal, 0);
    number = rotVal;
    for (int i = 0; i < NUM_OF_DIGITS; i++)
    {
      digit_data[i] = number % 10;
      number /= 10;
    }
    delay(200);

  }
  clkLast = clkState;

  //gestion bouton
  swState = digitalRead(swPin);
  if (swState == LOW && swLast == HIGH) {
    delay(100);//debounce
  }
  swLast = swState;
}

Resultados

Para probar el código, es necesario abrir los programas hairless y VirtualMIDISynth como se describe en este artículo.

Si todo está configurado correctamente, deberías oír sonidos procedentes de tu ordenador cuando pulses las teclas del teclado.

También puedes cambiar la velocidad de la nota tocando el potenciómetro.

Entre dos notas tocadas, puedes seleccionar otro instrumento sintetizador con el codificador giratorio.

Próximos pasos

  • Uso de LED o botones iluminados
  • Gestión MIDI In para encender los LEDs
  • Uso de una pantalla OLED para un menú más completo

Fuentes

Generación de sonidos con una interfaz MIDI de Arduino

Generación de sonidos con una interfaz MIDI de Arduino

Para generar sonidos sintéticos en el ordenador mediante una interfaz y crear música, es posible transformar un Arduino en un dispositivo MIDI.

Material

  • Ordenador
  • Arduino con puerto USB

Introducción al protocolo MIDI

MIDI (Musical Instrument Digital Interface) es un protocolo de comunicación entre instrumentos electrónicos, controladores y software musical. Consiste en el envío de una serie de bytes (comando y luego datos) a una velocidad de 31250 (baudrate) para especificar el tipo de mensaje (reproducir nota, detener nota, cambiar programa, etc.) y la información asociada (nota reproducida, programa seleccionado, etc.). A continuación, un resumen de los mensajes MIDI.

Código para enviar mensajes MIDI con Arduino

Veremos cómo enviar mensajes MIDI a través del puerto serie. En este ejemplo, enviaremos los comandos de notas sucesivamente. Es como pulsar diferentes teclas en un piano. Para ello, enviamos la siguiente información en un orden específico:

  • El comando noteOn o Off reproduce la nota o la detiene
  • la nota tocada o el tono
  • la velocidad a la que se pulsa la tecla

En el protocolo MIDI existe un gran número de mensajes para realizar diferentes acciones como cambiar de instrumento, modular notas, etc.

 int velocity = 100;//velocity of MIDI notes, must be between 0 and 127
 //higher velocity usually makes MIDI instruments louder
 
 int noteON = 144;//144 = 10010000 in binary, note on command
 int noteOFF = 128;//128 = 10000000 in binary, note off command

void setup() {
  Serial.begin(115200);
}

void loop() {
  for (int note=50;note<70;note++) {//from note 50 (D3) to note 69 (A4)
    MIDImessage(noteON, note, velocity);//turn note on
    delay(300);//hold note for 300ms
    MIDImessage(noteOFF, note, velocity);//turn note off
    delay(200);//wait 200ms until triggering next note
  }
}

void MIDImessage(int command, int MIDInote, int MIDIvelocity) {
  Serial.write(command);//send note on or note off command 
  Serial.write(MIDInote);//send pitch data
  Serial.write(MIDIvelocity);//send velocity data
}

Lee este código en el microcontrolador Arduino antes de continuar.

Nota: la velocidad de comunicación MIDI es de 31250. En este ejemplo utilizaremos un convertidor MIDI/Serial. Así que podemos utilizar cualquier velocidad de transmisión.

Configuración de la generación de sonido MIDI con Windows

Configuración de un instrumento MIDI virtual

Para generar sonido, necesitamos un software de síntesis de sonido o un DAW (Digital Audio Workstation). Los DAW pueden ser bastante complicados de usar. Para este tutorial, utilizaremos un sintetizador de sonido virtual muy sencillo: CoolSoft Virtual MIDI Synth.

  • Descargue e instale el software de CoolSoft
  • En la pestaña MIDI Mapper, seleccione VirtualMIDISynth en el dispositivo por defecto del Windows Media Player
  • En la pestaña Opciones, seleccione el dispositivo de salida de audio
  • Pulse “Aplicar”.

Para que el software de síntesis funcione, es necesario utilizar un SoundFont para convertir los mensajes MIDI en sonidos procedentes de un piano, por ejemplo. Puedes encontrar una lista de SoundFonts en la página de CoolSoft. Entonces sólo tienes que descargar el archivo .sf2 que quieras y añadirlo en la interfaz de CoolSoft.

Configuración del convertidor de serie a MIDI

La comunicación MIDI es un protocolo particular diferente de la comunicación USB. Para tener en cuenta los mensajes MIDI enviados por el Arduino a través del puerto USB, necesitaremos un conversor de serie a MIDI

Para ello utilizamos el software Hairless Midi to Serial Bridge, que nos permitirá convertir los mensajes serie en mensajes MIDI.

  • Descargue y abra el software Hairless
  • Seleccione el Arduino que ha conectado a su PC en la lista desplegable “Serial Port”.
  • A continuación, seleccione VirtualMIDISynth en la lista desplegable “MIDI Out”.

Si activas los mensajes de depuración MIDI, deberías ver un desplazamiento de las notas tocadas y sus velocidades.

Si la salida de audio de tu ordenador está activada, escucharás notas musicales.

N.B.: No podrá cargar código en el Arduino si la casilla Serial <->MIDI Bridge On está marcada.

Ya has creado tu primera interfaz MIDI con Arduino y puedes dar tus primeros pasos en la síntesis de sonido.

Aplicaciones

  • Crea un controlador MIDI con Arduino, botones y potenciómetros.

Fuentes

Usando un Buzzer con Arduino

Usando un Buzzer con Arduino

Es posible emitir sonidos usando un microcontrolador conectando un zumbador o buzzer a una de sus salidas. Cuando se quiere crear una interfaz de usuario, es bueno tener una retroalimentación de acuerdo a las acciones realizadas, ya sea una pantalla, una luz que se enciende o cambia de color, o un sonido. En este tutorial veremos cómo utilizar un zumbador (o altavoz piezoeléctrico).

Hardware

  • Computadora
  • Arduino UNO
  • Cable USB A macho a B macho
  • Buzzer

Principio de funcionamiento

Un zumbador es una especie de altavoz pero de baja potencia que emitirá un sonido según la frecuencia y la amplitud de la vibración. Permite tocar notas y recrear melodías simples. Si desea reproducir sonidos como música o voces, deberá utilizar un altavoz con un amplificador de audio que reproducirá un archivo de audio almacenado en una tarjeta SD.

Para reproducir archivos de audio, puedes seguir este tutorial.

Esquema

Como el zumbador es de baja potencia, puede conectarse directamente al microcontrolador en cualquiera de sus pines de salida. En este tutorial, conectamos el terminal – del zumbador a la GND y el terminal + a la salida digital 2.

Código

A cada nota le corresponde una frecuencia que se registra en el archivo pitches.h. Para tocar una melodía, pondremos las notas en una tabla y especificaremos un retardo entre cada nota. Luego usamos la función de tono para aplicar esta frecuencia y duración a la salida del zumbador.
Para crear el archivo de pitches, haz clic en la flecha a la derecha del nombre del boceto, luego haz clic en “crear una nueva pestaña”. Luego copie y pegue el código con la definición de las notas.

Archivo .ino

//Libraries
#include "pitches.h" //https://www.arduino.cc/en/Tutorial/BuiltInExamples/toneMelody

//Parameters
const int buzPin  = 2;

void setup() {
  //Init Serial USB
  Serial.begin(9600);
  Serial.println(F("Initialize System"));
}

void loop() {
  playPassed();
  delay(1000);
  playFailed();
  delay(2000);
}

void playPassed() { /* function playPassed */
  ////Play 'ON' Sound
  int melodyOn[] = {NOTE_C5, NOTE_C6, NOTE_D5, NOTE_A6};
  int durationOn = 200;
  for (int thisNote = 0; thisNote < 4; thisNote++) {
    tone(buzPin, melodyOn[thisNote], durationOn);
    delay(200);
  }
}

void playFailed() { /* function playFailed */
  ////Play 'OFF' Sound
  int melodyOff[] = {NOTE_C3, NOTE_D3};
  int durationOff = 200;
  for (int thisNote = 0; thisNote < 2; thisNote++) {
    tone(buzPin, melodyOff[thisNote], durationOff);
    delay(200);
  }
}

Archivo pitches.h

/*************************************************

 * Public Constants

 *************************************************/

#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

Resultado

Modifica las notas, el tamaño de la tabla y los retardos para recrear las melodías que quieras.

Aplicaciones

  • Crear un teclado interactivo con retroalimentación de sonido
  • Crear un robot que emita sonidos como R2-D2

Fuentes

Encuentre otros tutoriales y ejemplos en el generador de código automático
Arquitecto de Código

Usando un micrófono con Arduino

Usando un micrófono con Arduino

Es posible añadir el sentido del oído a su microcontrolador conectándolo a un micrófono. El micrófono recoge las vibraciones del aire y las transforma en una señal eléctrica que puede ser analizada y procesada mediante un algoritmo. En este tutorial veremos cómo detectar un nivel de sonido usando el microcontrolador.

Equipo

  • Computador
  • Arduino UNO
  • Cable USB A macho a B macho
  • Micrófono

Principio de funcionamiento

El sensor utilizado en este tutorial es un micrófono de condensador eléctrico. Se compone de dos placas, una fija y otra móvil. Las vibraciones del aire se transforman en un desplazamiento del diafragma móvil que crea una variación del potencial eléctrico detectado por el sensor y que envía una señal eléctrica al microcontrolador.

Hay varios modelos de micrófonos con diferentes sensibilidades para detectar sonidos más fuertes o más silenciosos. Un modelo puede ser más adecuado que otro dependiendo de lo que se quiera hacer. Asegúrese de revisar la documentación del módulo.

Esquema

El micrófono requiere baja potencia y puede ser alimentado directamente en el pin 5V del Arduino. Devuelve un valor analógico que será enviado a una entrada analógica del microcontrolador. Según el modelo utilizado, el módulo dispone de un potenciómetro para ajustar la sensibilidad del micrófono.

  • AUD al pin A0
  • Vcc al pin 5V
  • GND al pin GND

Código

Para medir el nivel de sonido, usamos la función AnalogRead() como para la mayoría de los sensores analógicos.

//Parameters
const int micPin  = A0;

//Variables
int micVal  = 0;

void setup() {
  //Init Serial USB
  Serial.begin(9600);
  Serial.println(F("Initialize System"));
  //Init Microphone
  pinMode(micPin, INPUT);
}

void loop() {
  readMicrophone();
}

void readMicrophone( ) { /* function readMicrophone */
  ////Test routine for Microphone
  micVal = analogRead(micPin);
  Serial.print(F("mic val ")); Serial.println(micVal);
  if (micVal > 600) {
    Serial.println("mic detected");
  }
}

Resultado

Una vez que el código ha sido cargado en el microcontrolador debería ver el valor analógico cambiar de acuerdo con el ruido ambiental. Intenta aplaudir, chasquear los dedos o hablar para ver cómo se comporta el micrófono. Esto le permitirá determinar el nivel necesario para desencadenar una acción.

Solicitudes

  • Activar una lámpara con un aplauso de las manos
  • Crear una alarma activada por ruido

Fuentes

Encuentre otros tutoriales y ejemplos en el generador de código automático
Arquitecto de Código

Dale voz a tu proyecto Arduino

Dale voz a tu proyecto Arduino

Para que su proyecto Arduino sea más interactivo, puede ser divertido hacer sonidos basados ​​en ciertas acciones. En este tutorial, veremos cómo reproducir un archivo de audio WAV guardado en una tarjeta SD con Arduino
Requisito previo:leer y escribir en una tarjeta SD , crear o modificar un archivo de audio para Arduino

Equipo

  • Computadora
  • Arduino UNO x1
  • Cable USB para conectar el Arduino a la computadora x1
  • Blindaje o módulo para tarjeta SD x1
  • Amplificador de audio o módulo de transistor x1
  • Altavoz x1

Esquemas

El diagrama de cableado puede variar según lo que esté utilizando. Aquí hay algunas notas para ayudarlo a adaptar este tutorial a su proyecto: En nuestro ejemplo, el pin CS (Selección de chip) del módulo de la tarjeta SD está conectado al pin 10 para comunicarse con la placa Arduino. Este pin puede variar según el escudo utilizado y según dónde conecte el pin. Para obtener más información sobre cómo conectar el módulo de la tarjeta SD, leaeste artículo.
En la placa Arduino UNO, solo el pin 9 es compatible con la biblioteca TMRpcm.h. Consulte la documentación (5,6,11 o 46 para Mega, 9 para Uno, Nano, etc.).
Depending on the speaker used, it is preferable to choose an external voltage source to power the speaker in order to do not damage the Arduino board.  

Código para reproducir un archivo de audio

Download y coloque el archivo WAV en la tarjeta SD y luego insértelo en el módulo de la tarjeta SD. Luego puede cargar el siguiente código en la placa Arduino. Para reproducir el archivo de audio, utilizaremos la biblioteca TMRPcm.h que permite reproducir archivos de audio WAV de forma asíncrona desde una tarjeta SD. En este ejemplo, el archivo de audio se reproduce cada segundo.
Funciones a saber:

  • tmrpcm.play(char*) para reproducir el archivo
  • tmrpcm.setVolume(int) para ajustar el volumen del altavoz
  • tmrpcm.stopPlayback() ou tmrpcm.disable() para detener la reproducción
  • tmrpcm.isPlaying() para averiguar si el archivo se está reproduciendo

Para más información, consulte la documentación.

//Libraries
#include <SD.h>
#include <TMRpcm.h>

//Constants
#define SD_ChipSelectPin 10//4 
const int speakerPin = 9;
char* file = "bonjour.wav";

//Variables
unsigned long previousTime = 0;
unsigned long interval = 1000;
//Objects
TMRpcm tmrpcm;
/*******************************************************************
                                 MAIN
*******************************************************************/
void setup() {
  /* function setup */
  Serial.begin(9600);
  //Init sd shield
  if (!SD.begin(SD_ChipSelectPin)) {
    Serial.println("SD fail");
    return;
  }

  //Init speaker
  tmrpcm.speakerPin = speakerPin;
  tmrpcm.setVolume(3);
}

void loop() {
  /* function loop */
  if (millis() - previousTime > interval) {
    activateOutput();
    previousTime = millis();
  }
}
/*******************************************************************
                                 FUNCTIONS
 *******************************************************************/
void activateOutput() {
  /* function activateOutput */
  Serial.println("Play sound");
  tmrpcm.play(file);
  while (tmrpcm.isPlaying()) {} //wait until file is played
  //delay(1000);tmrpcm.stopPlayback(); // or wait 1sec and stop music
}

NB: en la función enableOutput (), tiene la opción de no esperar a que se lea el archivo antes de realizar otras acciones. Para eso solo tienes que comentar la línea con while.   Ahora puede reproducir cualquier sonido con su placa Arduino.  

Fuente

Próximos pasos

Encuentre otros tutoriales y ejemplos en el generador de código automático
Arquitecto de Código