Geekly articles weekly

Arduino ZX Spectrum AY Spieler

Standalone-Player für Musik vom ZX Spectrum-Computer auf dem Arduino mit minimaler Detailgenauigkeit.




Es scheint, dass Spectrum-Melodien für immer in meinem Herzen bleiben werden, da ich regelmäßig meine Lieblingslieder mit dem wunderbaren Bulb-Player höre .



Es ist jedoch nicht sehr praktisch, an einen Computer gebunden zu sein. Ich habe dieses Problem vorübergehend mit dem nicht weniger wunderbaren EEE-PC gelöst. Aber ich wollte noch mehr Miniatur.



Internetrecherchen führten zu folgenden Schönheiten:




Sie sind entzückend für ihre elementare Basis, die nostalgische Erinnerungen hervorruft, aber ich erkannte, dass meine Faulheit es mir nicht erlauben würde, ein solches Projekt abzuschließen.

Ich brauchte etwas Kleines. Und jetzt - ein fast idealer Kandidat:

AVR AY-Player
- spielt * .PSG-Dateien ab
- unterstütztes Dateisystem FAT16
- Anzahl der Verzeichnisse im Stammverzeichnis der Festplatte 32
- Anzahl der Dateien im Verzeichnis 42 (insgesamt 32 * 42 = 1344 Dateien)
- Sortieren von Verzeichnissen und Dateien in Verzeichnisse durch die ersten beiden Buchstaben des Namens



Das Schema sieht in der Größe ziemlich akzeptabel aus:


Natürlich gab es einen fatalen Fehler , der die Idylle verdarb: Es gibt keinen zufälligen Auswahlmodus für die Komposition. (Vielleicht sollten Sie den Autor einfach bitten, diese Funktion zur Firmware hinzuzufügen?).

Jva des Jahres, ich suchte nach einer geeigneten Option, meine Geduld war vorbei und ich entschied mich zu handeln.

Aufgrund meiner fantastischen Faulheit habe ich die minimalen Gesten gewählt:
1. Wir nehmen den Arduino Mini Pro, um nicht mit dem Gurt herumzuspielen.
2. Sie benötigen eine SD-Karte, um Musik irgendwo zu speichern. Also nimm das SD-Schild.
3. Benötigen Sie einen musikalischen Coprozessor. Das kleinste ist AY-3-8912.

Es gab noch eine andere Möglichkeit, den Coprozessor programmgesteuert zu emulieren, aber ich wollte fast trotzdem einen „warmen Röhrensound“.

Für die Wiedergabe verwenden wir das PSG-Format.

PSG-Formatstruktur
Offset Number of byte Description
+0 3 Identifier 'PSG'
+3 1 Marker “End of Text” (1Ah)
+4 1 Version number
+5 1 Player frequency (for versions 10+)
+6 10 Data

Data — .
— ( 0 0x0F), — .
: 0xFF, 0xFE 0xFD
0xFD — .
0xFF — 20 .
0xFE — 80 .

So konvertieren Sie zu PSG
1. .
2. [PL].
3. .
4. , , Convert to PSG...
5. 8 , ~1..

Beginnen wir mit dem Anschließen einer SD-Karte. Laziness schlug vor, eine Standard-SD-Shield-Verbindung zu verwenden und eine Standardbibliothek für die Arbeit mit der Karte zu verwenden .

Der einzige Unterschied besteht darin, dass ich der Einfachheit halber den 10. Ausgang als Signal für die Auswahl einer Karte verwendet habe:


Zum Testen nehmen wir eine Standardskizze :

Skizze Dateiliste auf der Karte
#include <SPI.h>
#include <SD.h>

void setup() {
  Serial.begin(9600);
  Serial.print("Initializing SD card...");

  if (!SD.begin(10)) {
    Serial.println("initialization failed!");
    return;
  }
  Serial.println("initialization done.");

  File root = SD.open("/");
  printDirectory(root);

  Serial.println("done!");
}

void loop() {
}

void printDirectory(File dir) {
  while (true) {
    File entry =  dir.openNextFile();
    if (!entry)  break;
    Serial.print(entry.name());
    if (!entry.isDirectory()) {
      Serial.print("\t\t");
      Serial.println(entry.size(), DEC);
    }
    entry.close();
  }
}

Wir formatieren die Karte, schreiben dort mehrere Dateien, um zu starten ... funktioniert nicht!
Hier habe ich es immer - die Standardaufgabe - und sofort die Pfosten.

Wir nehmen ein anderes Flash-Laufwerk - (es war ein altes mit 32 MB, wir nehmen ein neues mit 2 GB) - ja, es hat funktioniert, aber nach einer Weile. Eine halbe Stunde Kratzer auf der Stirn, Neuanordnung der Anschlüsse näher an der Karte (so dass die Leiter kürzer sind), ein Isolationskondensator für die Ernährung - und es begann in 100% der Fälle zu funktionieren. Okay,

lass uns weitermachen ... Jetzt brauchen wir einen Coprozessor - er braucht eine Taktfrequenz von 1,75 MHz. Anstatt einen Generator auf 14-MHz-Quarz zu löten und einen Teiler einzustellen, lesen wir einen halben Tag lang Docks auf dem Mikrocontroller und stellen fest, dass es möglich ist, mit einer schnellen PWM harte 1,77 (7) MHz zu erzeugen :

  pinMode(3, OUTPUT);
  TCCR2A = 0x23;
  TCCR2B = 0x09;
  OCR2A = 8;
  OCR2B = 3;


Als nächstes setzen wir den Musikprozessor auf Pin 2 zurück, das untere Halbbyte des Datenbusses auf A0-A3, das obere auf 4,5,6,7, BC1 auf Pin 8, BDIR auf Pin 9. Der Einfachheit halber werden die Audioausgänge im Mono-Modus angeschlossen:



Auf dem Steckbrett:


Füllen Sie die Testskizze aus (ich kann mich nicht erinnern, woher ich das Array gezogen habe).
void resetAY(){
  pinMode(A0, OUTPUT); // D0
  pinMode(A1, OUTPUT);
  pinMode(A2, OUTPUT);
  pinMode(A3, OUTPUT); // D3
  
  pinMode(4, OUTPUT); // D4
  pinMode(5, OUTPUT);
  pinMode(6, OUTPUT);
  pinMode(7, OUTPUT); // D7
  
  pinMode(8, OUTPUT);  // BC1
  pinMode(9, OUTPUT);  // BDIR
  
  digitalWrite(8,LOW);
  digitalWrite(9,LOW);
  
  pinMode(2, OUTPUT);
  digitalWrite(2, LOW);
  delay(100);
  digitalWrite(2, HIGH);
  delay(100);
  
  for (int i=0;i<16;i++) ay_out(i,0);
}

void setupAYclock(){
  pinMode(3, OUTPUT);
  TCCR2A = 0x23;
  TCCR2B = 0x09;
  OCR2A = 8;
  OCR2B = 3; 
}

void setup() {
  setupAYclock();
  resetAY();
}

void ay_out(unsigned char port, unsigned char data){
  PORTB = PORTB & B11111100;

  PORTC = port & B00001111;
  PORTD = PORTD & B00001111;

  PORTB = PORTB | B00000011;
  delayMicroseconds(1);
  PORTB = PORTB & B11111100;

  PORTC = data & B00001111;
  PORTD = (PORTD & B00001111) | (data & B11110000);

  PORTB = PORTB | B00000010;
  delayMicroseconds(1);
  PORTB = PORTB & B11111100;
}

unsigned int cb = 0;

byte rawData[] = {
    0xFF, 0x00, 0x8E, 0x02, 0x38, 0x03, 0x02, 0x04, 0x0E, 0x05, 0x02, 0x07, 
    0x1A, 0x08, 0x0F, 0x09, 0x10, 0x0A, 0x0E, 0x0B, 0x47, 0x0D, 0x0E, 0xFF, 
    0x00, 0x77, 0x04, 0x8E, 0x05, 0x03, 0x07, 0x3A, 0x08, 0x0E, 0x0A, 0x0D, 
    0xFF, 0x00, 0x5E, 0x04, 0x0E, 0x05, 0x05, 0x0A, 0x0C, 0xFF, 0x04, 0x8E, 
    0x05, 0x06, 0x07, 0x32, 0x08, 0x00, 0x0A, 0x0A, 0xFF, 0x05, 0x08, 0x0A, 
    0x07, 0xFF, 0x04, 0x0E, 0x05, 0x0A, 0x0A, 0x04, 0xFF, 0x00, 0x8E, 0x04, 
    0x8E, 0x05, 0x00, 0x07, 0x1E, 0x08, 0x0F, 0x0A, 0x0B, 0x0D, 0x0E, 0xFF, 
    0x00, 0x77, 0x08, 0x0E, 0x0A, 0x06, 0xFF, 0x00, 0x5E, 0x07, 0x3E, 0x0A, 
    0x00, 0xFF, 0x07, 0x36, 0x08, 0x00, 0xFF, 0xFF, 0xFF, 0x00, 0x8E, 0x07, 
    0x33, 0x08, 0x0B, 0x0A, 0x0F, 0x0D, 0x0E, 0xFF, 0x04, 0x77, 0x08, 0x06, 
    0x0A, 0x0E, 0xFF, 0x04, 0x5E, 0x07, 0x3B, 0x08, 0x00, 0xFF, 0x07, 0x1B, 
    0x0A, 0x00, 0xFF, 0xFF, 0xFF, 0x02, 0x1C, 0x03, 0x01, 0x04, 0x8E, 0x07, 
    0x33, 0x08, 0x0B, 0x0A, 0x0B, 0x0B, 0x23, 0x0D, 0x0E, 0xFF, 0x04, 0x77, 
    0x08, 0x06, 0x0A, 0x0A, 0xFF, 0x04, 0x5E, 0x07, 0x3B, 0x08, 0x00, 0x0A, 
    0x09, 0xFF, 0x07, 0x1B, 0x0A, 0x00, 0xFF, 0xFF, 0xFF, 0x02, 0x8E, 0x03, 
    0x00, 0x04, 0x0E, 0x05, 0x01, 0x07, 0x18, 0x08, 0x0F, 0x09, 0x0B, 0x0A, 
    0x0E, 0xFF, 0x00, 0x77, 0x02, 0x77, 0x04, 0x8E, 0x06, 0x01, 0x08, 0x0E, 
    0x09, 0x0A, 0x0A, 0x0D, 0xFF, 0x00, 0x5E, 0x02, 0x5E, 0x04, 0x0E, 0x05, 
    0x02, 0x06, 0x02, 0x09, 0x09, 0x0A, 0x0C, 0xFF, 0x02, 0x8E, 0x04, 0x8E, 
    0x07, 0x30, 0x08, 0x00, 0x09, 0x08, 0x0A, 0x0A, 0xFF, 0x02, 0x77, 0xFF,
    0xFF
}

void pseudoInterrupt(){
  while (rawData[cb]<0xFF) {
   ay_out(rawData[cb],rawData[cb+1]);
   cb++;
   cb++;
 }
 if (rawData[cb]==0xff) cb++;
 
 if (cb>20*12)  cb=0;
}

void loop() {
  delay(20);
  pseudoInterrupt();
}

Und wir hören eine halbe Sekunde einer wunderschönen Melodie! (Tatsächlich bin ich noch zwei Stunden hier und suche, wie ich vergessen habe, den Reset nach der Initialisierung freizugeben.)

Damit ist der Eisenteil fertig, und in der Software fügen wir Unterbrechungen von 50 Hz hinzu, lesen die Datei und schreiben in die Register des Coprozessors.

Endgültige Version des Programms
#include <SPI.h>
#include <SD.h>

void resetAY(){
  pinMode(A0, OUTPUT); // D0
  pinMode(A1, OUTPUT);
  pinMode(A2, OUTPUT);
  pinMode(A3, OUTPUT); // D3
  
  pinMode(4, OUTPUT); // D4
  pinMode(5, OUTPUT);
  pinMode(6, OUTPUT);
  pinMode(7, OUTPUT); // D7
  
  pinMode(8, OUTPUT);  // BC1
  pinMode(9, OUTPUT);  // BDIR
  
  digitalWrite(8,LOW);
  digitalWrite(9,LOW);
  
  pinMode(2, OUTPUT);
  digitalWrite(2, LOW);
  delay(100);
  digitalWrite(2, HIGH);
  delay(100);
  
  for (int i=0;i<16;i++) ay_out(i,0);
}


void setupAYclock(){
  pinMode(3, OUTPUT);
  TCCR2A = 0x23;
  TCCR2B = 0x09;
  OCR2A = 8;
  OCR2B = 3; 
}

void setup() {
  Serial.begin(9600);
  randomSeed(analogRead(4)+analogRead(5));

  initFile();

  setupAYclock();
  resetAY();
  setupTimer();
}

void setupTimer(){
  cli();
  
  TCCR1A = 0;
  TCCR1B = 0;
  TCNT1  = 0;
  OCR1A = 1250;

  TCCR1B |= (1 << WGM12);
  TCCR1B |= (1 << CS12);
  TIMSK1 |= (1 << OCIE1A);

  sei();
}

void ay_out(unsigned char port, unsigned char data){
  PORTB = PORTB & B11111100;

  PORTC = port & B00001111;
  PORTD = PORTD & B00001111;

  PORTB = PORTB | B00000011;
  delayMicroseconds(1);
  PORTB = PORTB & B11111100;

  PORTC = data & B00001111;
  PORTD = (PORTD & B00001111) | (data & B11110000);

  PORTB = PORTB | B00000010;
  delayMicroseconds(1);
  PORTB = PORTB & B11111100;
}

unsigned int playPos = 0;
unsigned int fillPos = 0;
const int bufSize = 200;
byte playBuf[bufSize]; // 31 bytes per frame max, 50*31 = 1550 per sec, 155 per 0.1 sec

File fp;
boolean playFinished = false;

void loop() {
  fillBuffer();
  if (playFinished){
    fp.close();
    openRandomFile();
    playFinished = false;
  }
}

void fillBuffer(){
  int fillSz = 0;
  int freeSz = bufSize;
  if (fillPos>playPos) {
    fillSz = fillPos-playPos;
    freeSz = bufSize - fillSz;
  }
  if (playPos>fillPos) {
    freeSz = playPos - fillPos;
    fillSz = bufSize - freeSz;
  }
  
  freeSz--; // do not reach playPos
  while (freeSz>0){
    byte b = 0xFD;
    if (fp.available()){
      b = fp.read();
    }
    playBuf[fillPos] = b;
    fillPos++;
    if (fillPos==bufSize) fillPos=0;
    freeSz--;
  }
}

void prepareFile(char *fname){
  Serial.print("prepare [");
  Serial.print(fname);
  Serial.println("]...");
  
  fp = SD.open(fname);
  
  if (!fp){
    Serial.println("error opening music file");
    return;
  }  
    
  while (fp.available()) {
    byte b = fp.read();
    if (b==0xFF) break;
  }
 
  fillPos = 0;
  playPos = 0;
  cli();  
  fillBuffer();
  resetAY();
  sei();
}

File root;
int fileCnt = 0;

void openRandomFile(){
  int sel = random(0,fileCnt-1);

  Serial.print("File selection = ");
  Serial.print(sel, DEC);
  Serial.println();
  
  root.rewindDirectory();
  
  int i = 0;
  while (true) {
    File entry =  root.openNextFile();
    if (!entry)  break;

    Serial.print(entry.name());
    if (!entry.isDirectory()) {
      Serial.print("\t\t");
      Serial.println(entry.size(), DEC);
      
      if (i==sel) prepareFile(entry.name());
      i++;
    }
    entry.close();
  }
}

void initFile(){
  Serial.print("Initializing SD card...");
  pinMode(10, OUTPUT);
  digitalWrite(10, HIGH);

  if (!SD.begin(10)) {
    Serial.println("initialization failed!");
    return;
  }
  Serial.println("initialization done.");

  root = SD.open("/");

  // reset AY

  fileCnt = countDirectory(root);
  Serial.print("Files cnt = ");
  Serial.print(fileCnt, DEC);
  Serial.println();
  openRandomFile();

  Serial.print("Buffer size = ");
  Serial.print(bufSize, DEC);
  Serial.println();
  
  Serial.print("fillPos = ");
  Serial.print(fillPos, DEC);
  Serial.println();

  Serial.print("playPos = ");
  Serial.print(playPos, DEC);
  Serial.println();

  for (int i=0; i<bufSize;i++){
    Serial.print(playBuf[i],HEX);
    Serial.print("-");
    if (i%16==15) Serial.println();
  }

  Serial.println("done!");
}

int countDirectory(File dir) {
  int res = 0;
  root.rewindDirectory();
  while (true) {

    File entry =  dir.openNextFile();
    if (!entry)  break;

    Serial.print(entry.name());
    if (!entry.isDirectory()) {
      Serial.print("\t\t");
      Serial.println(entry.size(), DEC);
      res++;
    }
    entry.close();
  }
  
  return res;
}

int skipCnt = 0;

ISR(TIMER1_COMPA_vect){
  if (skipCnt>0){
    skipCnt--;
  } else {
    int fillSz = 0;
    int freeSz = bufSize;
    if (fillPos>playPos) {
      fillSz = fillPos-playPos;
      freeSz = bufSize - fillSz;
    }
    if (playPos>fillPos) {
      freeSz = playPos - fillPos;
      fillSz = bufSize - freeSz;
    }

    boolean ok = false;
    int p = playPos;
    while (fillSz>0){
      byte b = playBuf[p];
      p++; if (p==bufSize) p=0;
      fillSz--;
      
      if (b==0xFF){ ok = true; break; }
      if (b==0xFD){ 
        ok = true; 
        playFinished = true;
        for (int i=0;i<16;i++) ay_out(i,0);
        break; 
      }
      if (b==0xFE){ 
        if (fillSz>0){
          skipCnt = playBuf[p];
          p++; if (p==bufSize) p=0;
          fillSz--;
          
          skipCnt = 4*skipCnt;
          ok = true; 
          break; 
        } 
      }
      if (b<=252){
        if (fillSz>0){
          byte v = playBuf[p];
          p++; if (p==bufSize) p=0;
          fillSz--;
          
          if (b<16) ay_out(b,v);
        } 
      }
    } // while (fillSz>0)
  
    if (ok){
      playPos = p;
    }
  } // else skipCnt 
}

Für vollständige Autonomie habe ich dem TDA2822M auch einen Verstärker hinzugefügt. Der Player selbst verbraucht 90 mA. Zusammen mit dem Verstärker verbraucht er etwa 200 mA. Falls gewünscht, kann er mit Batterien betrieben werden.



Beide Modelle zusammen:


Zu diesem Zeitpunkt habe ich vorerst angehalten, Musik aus dem Modell gehört und darüber nachgedacht, in welchem ​​Fall ich sie zusammenbauen möchte. Ich dachte daran, einen Indikator anzuschließen, aber irgendwie habe ich nicht das Bedürfnis.

Die Implementierung ist noch feucht, weil Das Gerät ist in der Entwicklung, aber weil Ich kann ihn für ein paar Jahre in diesem Zustand verlassen, ich habe beschlossen, einen Artikel in heißer Verfolgung zu schreiben. Fragen, Vorschläge, Kommentare, Korrekturen - willkommen in den Kommentaren.

Gebrauchte Literatur:

Source: https://habr.com/ru/post/de392625/

More articles:


All Articles