Effiziente ISD1700 Audio-Aufnahme-Software & Arduino-Einrichtungsanleitung

Komponenten und Zubehör

Komponente	Anzahl
Arduino Nano R3	1
Steckplatine (Breadboard)	2
ISD1760 Sprachaufnahme- und Wiedergabemodul	1
USB-A auf Mini-USB Kabel	1
3,5mm Klinkenstecker (Audio)	2
9V 1A Schaltnetzteil (Wandstecker)	1
Steckplatine-Netzteil 5V	1
Jumper-Kabel (Sortiment)	1

Apps und Online-Dienste

• ISD1700 Record Tool – Archiv mit Arduino-Code und Windows-Anwendung
• Arduino IDE

Projektbeschreibung

In einem aktuellen Projekt benötigte ich die Ausgabe kurzer Textnachrichten als Sprache. MP3-Shields mit SD-Karte erschienen mir überdimensioniert, und die Implementierung von Sprachsynthese auf dem Arduino hätte alle Ressourcen des Mikrocontrollers für diese Nebentätigkeit beansprucht. Zudem wäre der Speicher in jedem Fall knapp geworden.

Eine kurze Recherche brachte die Sprachaufnahme- und Wiedergabechips der ISD1700-Serie ans Licht: SPI-gesteuert, in der Lage, Nachrichten von mehreren Minuten Länge zu speichern.

Die Sprachnachrichten lagen als separate Audiodateien vor. Die einzige offene Frage war, wie diese in den IC-Speicher geschrieben werden können. Programmer für ISD1700 sind nicht weit verbreitet und kosten ein Vielfaches der Chips selbst. Es gab zwar Informationen zum Selbstbau (https://laserwar.ru/sound_lasertag.html), aber als Programmierer statt Funkamateur wollte ich Standard-Hardware nutzen – ein Arduino-Board war dafür ideal.

Nach Studium des Datenblatts („ISD1700 Design Guide“) erkannte ich, dass es einen analogen Eingang gibt, über den Dateien aufgenommen werden können. Zur Automatisierung dieses Prozesses entwickelte ich die spezielle Software ISD1700 Record Tool.

Das ISD1700 Record Tool ermöglicht das Aufnehmen eines Satzes von Audiodateien in den ISD1700 über ein Arduino-Board. Die Software besteht aus zwei Teilen: einem Sketch für das Arduino-Board (ISD1700.ino) und einer eigenständigen Windows-Anwendung (ISD1700.exe).

Der Sketch in ISD1700.ino ist für ATMega328P-basierte Arduino-Boards geschrieben (getestet mit Arduino Uno und Arduino Nano), funktioniert aber vermutlich auch auf anderen Boards.

Unterstützte ISD1700-Chips:

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

Die Windows-Anwendung basiert auf der BASS-Audiobibliothek, die die gängigsten Formate unterstützt: MP3, WAV, OGG usw.

1. Hardware-Verbindung

Während der Softwareentwicklung verwendete ich ein fertiges Aufnahmemodul statt des einzelnen ISD1700-ICs. Bevor Sie andere Verbindungsvarianten ausprobieren, empfehle ich dringend, das originale ISD1700-Datenblatt zu lesen.

Abbildungen 1–5 zeigen meinen Hardware-Aufbau (hier mit Arduino Nano):

Auf einer kleinen Steckplatine sitzen zwei 3,5mm-Buchsen (Abb. 2) für Audio-Eingang (links) und Kopfhörer (rechts).

Ich empfehle die Verwendung eines zusätzlichen Netzteils statt der Versorgung aller Komponenten über den 5V-Ausgang des Arduino, da ich ohne externe Stromquelle viele Verbindungsfehler hatte. Dies kann jedoch auch an schlechter Kontaktqualität liegen.

2. Arduino flashen

Verbinden Sie das Arduino-Board per USB mit dem PC, öffnen Sie ISD1700.ino in der Arduino IDE und laden Sie den Sketch wie gewohnt hoch (Abb. 6).

3. Benutzeroberfläche der Anwendung

Starten Sie ISD1700.exe. Die Beschreibung jedes Steuerelements ist in Abb. 7 dargestellt.

4. Typischer Arbeitsablauf

Abbildung 8 zeigt den typischen Ablauf in der Windows-Anwendung.

Beschreibung:

1. Öffnen Sie die Audiodateien, die Sie auf den ISD1700 aufnehmen möchten. Sortieren Sie sie per Drag & Drop oder löschen Sie unerwünschte Dateien (nach vorherigem Anhören). Sie können jede Datei abspielen und die Lautstärke anpassen.
2. Wählen Sie den COM-Port, an den das Arduino-Board angeschlossen ist (Abb. 9).



3. Drücken Sie „Detect ISD1700“ und vergewissern Sie sich, dass das ISD1700-Modell rechts angezeigt wird.
4. Prüfen Sie, ob die Gesamtdauer aller Audiodateien kleiner ist als die Kapazität des ISD1700 in Sekunden; andernfalls kann die Aufnahme nicht gestartet werden.
5. Drücken Sie „Start record“. Den Fortschritt sehen Sie am Balken. Bei Bedarf „Stop record“ drücken.
6. Nach Abschluss können Sie die Adressen aller Spuren in die Zwischenablage kopieren. Abb. 10 zeigt den Unterschied zwischen den beiden Optionen.

Mit dem ISD1700-Aufnahmemodul können Audiodateien direkt nach dem Aufnahmevorgang über Kopfhörer und die onboard-Tasten wiedergegeben werden.

Code

ISD1700 Arduino-Code (C/C++)

// Arduino-Code für ISD1700 Record Tool
// Getestet: Arduino Uno, Arduino Nano (ATMega328P)
// Copyright: Anton Tsaritsynskyy, August 2019
// E-Mail: tsaritsynskyy.a.a@gmail.com
//
// Diese Software wird "wie besehen" ohne jegliche Garantien bereitgestellt.
// Der Autor haftet nicht für unerwünschte Effekte durch die Nutzung.
// Kommerzielle Verbreitung dieser Software ist nicht gestattet.
// Drittbibliotheken und -komponenten sind Eigentum ihrer jeweiligen Entwickler.

#include 

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;
    }
  }
}

Schaltplan