Guía Eficiente de Software de Grabación ISD1700 y Configuración con Arduino

Componentes y suministros

Arduino Nano R3	×	1
Protoboard (genérica)	×	2
Módulo de grabación y reproducción de voz ISD1760	×	1
Cable USB-A a Mini-USB	×	1
Conector de audio 3.5mm	×	2
Fuente de alimentación conmutada 9V 1A	×	1
Fuente de alimentación para protoboard 5V	×	1
Cables jumpers (genéricos)	×	1

Aplicaciones y servicios en línea

• ISD1700 Record Tool (archivo con la herramienta ISD1700 Record Tool, tanto el código para Arduino como la aplicación Windows)
• Arduino IDE

Sobre el proyecto

En uno de mis proyectos recientes necesitaba añadir mensajes de voz cortos. Los shields como módulos MP3 con tarjeta SD me parecían excesivos, y «enseñar» a Arduino a reproducir habla humana habría consumido todos los recursos del microcontrolador en una tarea auxiliar. Además, me habría quedado sin memoria en cualquier caso.

Una búsqueda breve reveló los chips de grabación y reproducción de voz de la serie ISD1700, controlados por SPI, capaces de almacenar mensajes de varios minutos de duración.

Los mensajes de voz se prepararon previamente como archivos separados. La única cuestión pendiente era cómo grabar esos archivos en la memoria del IC. Los programadores para ISD1700 no son muy comunes y cuestan mucho más que los propios chips. Había información sobre cómo construir uno (https://laserwar.ru/sound_lasertag.html), pero soy programador más que radioaficionado, así que quería usar hardware estándar – las placas Arduino eran excelentes para ese papel.

Tras estudiar la hoja de datos («ISD1700 Design Guide») me di cuenta de que había una entrada analógica a través de la cual se podían grabar los archivos. Y para automatizar el proceso decidí escribir un software especial: ISD1700 Record Tool.

ISD1700 Record Tool permite grabar un conjunto de archivos de audio en el ISD1700 mediante una placa Arduino. El software consta de dos partes: un sketch para la placa Arduino (ISD1700.ino) y una aplicación standalone para Windows (ISD1700.exe).

El sketch en ISD1700.ino está escrito para placas ARDUINO basadas en ATMega328P (probado en Arduino Uno y Arduino Nano), pero probablemente también funcione en otras placas.

Lista de ISD1700 compatibles:

1. ISD1730
2. ISD1740
3. ISD1750
4. ISD1760
5. ISD1790
6. ISD17120
7. ISD17150
8. ISD17180
9. ISD17210
10. ISD17240

La aplicación Windows se basa en la librería de audio BASS, que soporta los formatos más utilizados: MP3, WAV, OGG, etc.

1. Conexión de hardware

Durante el desarrollo del software utilicé un módulo de grabación listo para usar en lugar del IC ISD1700 por separado. Antes de probar cualquier otra variante de conexión, recomiendo encarecidamente leer la hoja de datos original del ISD1700.

Las figuras 1–5 muestran mi configuración de hardware. En este caso se usa ARDUINO NANO.

En una protoboard pequeña puse dos zócalos de 3.5mm (Fig. 2) para entrada de audio (izquierda) y auriculares (derecha).

Recomiendo usar una fuente de alimentación adicional en lugar de alimentar todos los componentes a través de la salida 5V de Arduino, porque tuve muchos errores de conexión sin fuente externa. Sin embargo, esto puede deberse a mala calidad de las conexiones de cable o a otra causa.

2. Programar Arduino

Conecte la placa Arduino a su PC vía USB, abra ISD1700.ino en el IDE de Arduino y suba el sketch como de costumbre (Fig. 6).

3. Interfaz de usuario de la aplicación

Ejecute ISD1700.exe. La descripción de cada elemento de control se muestra en la Fig. 7.

4. Secuencia operativa típica

La Fig. 8 muestra la secuencia operativa típica en la aplicación Windows.

Descripción:

1. Abra los archivos de audio que desea grabar en el ISD1700. Ordénelos simplemente arrastrándolos con el ratón, o elimine los no deseados (previamente marcados) si es necesario. También puede reproducir cada archivo y ajustar el nivel de volumen.
2. Seleccione el puerto COM al que está conectada la placa ARDUINO (Fig. 9).



3. Pulse el botón "Detect ISD1700" y asegúrese de que el modelo de ISD1700 se muestra en el cuadro de la derecha.
4. Verifique que la duración total de todos los archivos de audio es inferior a la capacidad del ISD1700 en segundos; de lo contrario no podrá iniciar la grabación.
5. Pulse el botón "Start record". Verá el progreso en la barra. Pulse "Stop record" si es necesario.
6. Una vez finalizado el proceso, puede copiar las direcciones de todas las pistas al portapapeles. La Fig. 10 muestra la diferencia entre las dos opciones.

El uso del módulo de grabación ISD1700 permite reproducir los archivos de audio justo después de finalizar la grabación con la ayuda de auriculares y los botones integrados.

Código

Código ARDUINO para ISD1700 C/C++

// Código Arduino para ISD1700 Record Tool // Probado: Arduino Uno, Arduino Nano (ATMega328P) // Copyright: Anton Tsaritsynskyy, Agosto 2019 // Email: tsaritsynskyy.a.a@gmail.com // // Este software se proporciona "tal cual" sin garantías. // El autor no es responsable de efectos no deseados causados por el uso de este software. // No está permitida la distribución comercial de este software. // Bibliotecas y componentes de terceros son propiedad de sus respectivos desarrolladores.
#include <SPI.h>
const unsigned int ISD_ERASE_OK = 3002;
const unsigned int ISD_REC_OK = 3003;
const unsigned int ISD_STOP_OK = 3004;
const unsigned int ISD_RESET_OK = 3005;
const unsigned int ISD_CANCEL_OK = 3006;
const unsigned int ISD_FULL = 3007;
const byte ISD_SS_PIN = 8;
boolean isdIsUp = false;
boolean isdNotifyIfFull = true;

boolean isdPowerUp(void) {
  byte SR0B1 = 1;
  SPI.beginTransaction(SPISettings(1000000, LSBFIRST, SPI_MODE3));
  digitalWrite(ISD_SS_PIN, LOW);
  SR0B1 = SPI.transfer(0x01);
  SPI.transfer(0x00);
  digitalWrite(ISD_SS_PIN, HIGH);
  SPI.endTransaction();
  return (SR0B1 & 1) != 1;
}

boolean isdPowerDown(void) {
  SPI.beginTransaction(SPISettings(1000000, LSBFIRST, SPI_MODE3));
  digitalWrite(ISD_SS_PIN, LOW);
  SPI.transfer(0x07);
  SPI.transfer(0x00);
  digitalWrite(ISD_SS_PIN, HIGH);
  SPI.endTransaction();
}

boolean isdReset(void) {
  SPI.beginTransaction(SPISettings(1000000, LSBFIRST, SPI_MODE3));
  digitalWrite(ISD_SS_PIN, LOW);
  SPI.transfer(0x03);
  SPI.transfer(0x00);
  digitalWrite(ISD_SS_PIN, HIGH);
  SPI.endTransaction();
  delay(20);
}

void isdClrInt(void) {
  SPI.beginTransaction(SPISettings(1000000, LSBFIRST, SPI_MODE3));
  digitalWrite(ISD_SS_PIN, LOW);
  SPI.transfer(0x04);
  SPI.transfer(0x00);
  digitalWrite(ISD_SS_PIN, HIGH);
  SPI.endTransaction();
}

boolean isdIsReady(void) {
  byte SR1 = 0;
  SPI.beginTransaction(SPISettings(1000000, LSBFIRST, SPI_MODE3));
  digitalWrite(ISD_SS_PIN, LOW);
  SPI.transfer(0x05);
  SPI.transfer(0x00);
  SR1 = SPI.transfer(0x00);
  digitalWrite(ISD_SS_PIN, HIGH);
  SPI.endTransaction();
  return (~SR1 & 1) != 1;
}

void isdEnableAnaIn(void) {
  byte APC[2];
  SPI.beginTransaction(SPISettings(1000000, LSBFIRST, SPI_MODE3));
  digitalWrite(ISD_SS_PIN, LOW);
  SPI.transfer(0x44);
  SPI.transfer(0x00);
  APC[0] = SPI.transfer(0x00);
  APC[1] = SPI.transfer(0x00);
  digitalWrite(ISD_SS_PIN, HIGH);
  SPI.endTransaction();
  APC[0] &= ~B01010000;
  SPI.beginTransaction(SPISettings(1000000, LSBFIRST, SPI_MODE3));
  digitalWrite(ISD_SS_PIN, LOW);
  SPI.transfer(0x45);
  SPI.transfer(APC[0]);
  SPI.transfer(APC[1]);
  digitalWrite(ISD_SS_PIN, HIGH);
  SPI.endTransaction();
}

byte isdDeviceID(void) {
  byte ID;
  SPI.beginTransaction(SPISettings(1000000, LSBFIRST, SPI_MODE3));
  digitalWrite(ISD_SS_PIN, LOW);
  SPI.transfer(0x09);
  SPI.transfer(0x00);
  ID = SPI.transfer(0x00);
  digitalWrite(ISD_SS_PIN, HIGH);
  SPI.endTransaction();
  return ID;
}

boolean isdIsFull(void) {
  byte SR0B1 = 2;
  SPI.beginTransaction(SPISettings(1000000, LSBFIRST, SPI_MODE3));
  digitalWrite(ISD_SS_PIN, LOW);
  SR0B1 = SPI.transfer(0x05);
  SPI.transfer(0x00);
  SPI.transfer(0x00);
  digitalWrite(ISD_SS_PIN, HIGH);
  SPI.endTransaction();
  return (SR0B1 & 2) == 2;
}

void isdRec(void) {
  SPI.beginTransaction(SPISettings(1000000, LSBFIRST, SPI_MODE3));
  digitalWrite(ISD_SS_PIN, LOW);
  SPI.transfer(0x41);
  SPI.transfer(0x00);
  digitalWrite(ISD_SS_PIN, HIGH);
  SPI.endTransaction();
  delay(40);
}

void isdStop(void) {
  SPI.beginTransaction(SPISettings(1000000, LSBFIRST, SPI_MODE3));
  digitalWrite(ISD_SS_PIN, LOW);
  SPI.transfer(0x02);
  SPI.transfer(0x00);
  digitalWrite(ISD_SS_PIN, HIGH);
  SPI.endTransaction();
  delay(100);
}

void isdErase(void) {
  SPI.beginTransaction(SPISettings(1000000, LSBFIRST, SPI_MODE3));
  digitalWrite(ISD_SS_PIN, LOW);
  SPI.transfer(0x43);
  SPI.transfer(0x00);
  digitalWrite(ISD_SS_PIN, HIGH);
  SPI.endTransaction();
  while ( !isdIsReady() ) {}
}

unsigned int isdReadRecordPointer(void) {
  byte DB[2];
  SPI.beginTransaction(SPISettings(1000000, LSBFIRST, SPI_MODE3));
  digitalWrite(ISD_SS_PIN, LOW);
  SPI.transfer(0x08);
  SPI.transfer(0x00);
  DB[0] = SPI.transfer(0x00);
  DB[1] = SPI.transfer(0x00);
  digitalWrite(ISD_SS_PIN, HIGH);
  SPI.endTransaction();
  return (DB[1] << 8) | DB[0];
}

unsigned int isdInit(void) {
  while ( !isdPowerUp() ) {}
  delay(100);
  isdClrInt();
  while ( !isdIsReady() ) {}
  isdEnableAnaIn();
  return 3000+isdDeviceID();
}

void setup() {
  pinMode(ISD_SS_PIN, OUTPUT);
  digitalWrite(ISD_SS_PIN, HIGH);
  Serial.begin(9600);
  SPI.begin();
}

char cmd;
void loop() {
  if (Serial.available()) {
    cmd = Serial.read();
    switch (cmd) {
      case 'D':
        Serial.print( isdInit() );
        isdPowerDown();
        isdIsUp = false;
        break;
      case 'E':
        isdInit();
        isdErase();
        Serial.print(ISD_ERASE_OK);
        isdIsUp = true;
        isdNotifyIfFull = true;
        break;
      case 'R':
        isdRec();
        Serial.print(ISD_REC_OK);
        break;
      case 'S':
        isdStop();
        Serial.print( isdReadRecordPointer() );
        break;
      case 'X':
        isdReset();
        Serial.print(ISD_RESET_OK);
        isdIsUp = false;
        break;
      case 'C':
        if (isdIsUp) {
          isdStop();
          isdReset();
          Serial.print(ISD_CANCEL_OK);
          isdIsUp = false;
        }
        break;
    }
  }
  if (isdNotifyIfFull && isdIsUp) {
    if (isdIsFull()) {
      isdReset();
      isdIsUp = false;
      Serial.print(ISD_FULL);
      isdNotifyIfFull = false;
    }
  }
}

Esquemas