Geekly articles weekly

Arduino ZX Spectrum AY Player

Pemutar lagu mandiri dari komputer ZX Spectrum di Arduino dengan detail minimal.




Tampaknya melodi Spectrum akan selamanya tersimpan di hati saya, karena saya secara teratur mendengarkan lagu favorit saya menggunakan pemutar Bulb yang indah .



Tetapi tidak nyaman untuk diikat ke komputer. Saya sementara memecahkan masalah ini menggunakan EEE PC yang tidak kalah indahnya. Tetapi saya ingin lebih miniatur lagi.



Pencarian di internet menghasilkan keindahan berikut:




Mereka menyenangkan untuk basis elemen mereka, yang membangkitkan kenangan nostalgia, tetapi saya menyadari bahwa kemalasan saya tidak akan memungkinkan saya untuk menyelesaikan proyek semacam itu.

Saya membutuhkan sesuatu yang kecil. Dan sekarang - kandidat yang hampir ideal:

AVR AY-player
- memainkan file * .PSG
- sistem file yang didukung FAT16
- jumlah direktori di root disk 32
- jumlah file dalam direktori 42 (total 32 * 42 = 1344 file)
- mengurutkan direktori dan file dalam direktori dengan dua huruf pertama dari nama tersebut



Skema ini terlihat cukup dapat diterima dalam ukuran:


Tentu saja, ada kesalahan fatal yang merusak idyll: tidak ada mode pemilihan acak untuk komposisi. (mungkin Anda harus meminta penulis untuk menambahkan fungsi ini ke firmware?).

Jva tahun ini, saya sedang mencari pilihan yang cocok, kesabaran saya berakhir dan saya memutuskan untuk bertindak.

Berdasarkan kemalasan fantastis saya, saya memilih gerakan minimum:
1. Kami mengambil Arduino Mini Pro, agar tidak mengacaukan harness.
2. Anda memerlukan kartu SD untuk menyimpan musik di suatu tempat. Jadi ambil pelindung SD.
3. Membutuhkan coprocessor musik. Yang terkecil adalah AY-3-8912.

Ada opsi lain untuk meniru coprocessor secara terprogram, tetapi saya ingin "suara tabung hangat", hampir tetap.

Untuk pemutaran, kami akan menggunakan format PSG.

Struktur format PSG
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 .

Cara mengonversi ke PSG
1. .
2. [PL].
3. .
4. , , Convert to PSG...
5. 8 , ~1..

Mari kita mulai dengan menghubungkan kartu SD. Laziness menyarankan mengambil koneksi SD-shield standar dan menggunakan perpustakaan standar untuk bekerja dengan kartu .

Satu-satunya perbedaan adalah bahwa untuk kenyamanan saya menggunakan keluaran ke-10 sebagai sinyal untuk memilih kartu:


Untuk pengujian, kami mengambil sketsa standar :

daftar file sketsa di peta
#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();
  }
}

Kami memformat kartu, menulis beberapa file di sana, untuk peluncuran ... tidak berfungsi!
Di sini saya selalu memilikinya - tugas paling standar - dan segera tiang temboknya.

Kami mengambil flash drive lain - (itu yang lama di 32Mb, kami mengambil yang baru di 2Gb) - ya, itu berhasil, tapi setelah beberapa saat. Setengah jam menggaruk dahi, mengatur ulang koneksi lebih dekat ke peta (sehingga konduktor lebih pendek), kapasitor isolasi untuk nutrisi - dan mulai bekerja di 100% kasus. Oke,

mari kita lanjutkan ... Sekarang kita perlu mendapatkan coprocessor - perlu frekuensi clock 1,75 MHz. Alih-alih menyolder generator pada kuarsa 14 MHz dan mengatur pembagi, kami menghabiskan waktu setengah hari membaca dok di mikrokontroler dan mengetahui bahwa membuat 1,77 (7) MHz menjadi sulit dilakukan menggunakan PWM cepat :

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


Selanjutnya, kami mengatur ulang prosesor musik ke pin 2, gigitan bawah bus data ke A0-A3, yang atas menjadi 4,5,6,7, BC1 ke pin 8, BDIR ke pin 9. Untuk kesederhanaan, kami menghubungkan output audio dalam mode mono:



Di papan tempat memotong roti:


Isi sketsa uji coba (Saya tidak ingat dari mana saya menyeret array dari)
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();
}

Dan kita mendengar setengah detik dari beberapa melodi yang indah! (pada kenyataannya, saya di sini selama dua jam lagi mencari bagaimana saya lupa melepaskan reset setelah inisialisasi).

Tentang ini, bagian besi selesai, dan dalam perangkat lunak kami menambahkan gangguan 50 Hz, membaca file dan menulis ke register coprocessor.

Versi terakhir dari program
#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 
}

Untuk otonomi lengkap, saya juga menambahkan penguat ke TDA2822M, pemain itu sendiri mengkonsumsi 90 mA, bersama dengan penguat yang dikonsumsi sekitar 200 mA, jika diinginkan, dapat didukung oleh baterai.



Kedua mock-up bersama:


Pada tahap ini, saya telah berhenti untuk saat ini, mendengarkan musik dari mock-up, memikirkan dalam hal apa saya ingin merakitnya. Saya berpikir untuk menghubungkan indikator, tetapi entah bagaimana saya tidak merasa perlu.

Implementasinya masih lembab, karena perangkat sedang dikembangkan, tetapi karena Saya dapat meninggalkannya selama beberapa tahun di negara ini, saya memutuskan untuk menulis artikel dalam pengejaran. Pertanyaan, saran, komentar, koreksi - selamat datang di komentar.

Literatur bekas:

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

More articles:


All Articles