SidBerry2 – enhanced Raspberry Pi 6581 SID player

I post here the great work of Davide aka Thoroide (thoroide@gmail.com). He took my Raspberry Pi SID player project and enhanced it creating SidBerry2. It features a new power stage, a better audio output stage and much more:

Here the original post:

Time ago, I recovered a 6581 SID chip from a dead C64, and then I wondered if you could connect it to an Arduino or RaspberryPi.

I have done several researches, finding various projects, most of them abandoned. Having a Raspberry card on which I was doing other work, I chose the SIDBerry project by Gianluca Ghettini
That seemed the easiest.

First of all I have slightly changed the hardware part. The original hardware was pretty basic, although perfectly functional.
To do this, I got a similar project schematic created for Arduino platform called RealShield https://github.com/atbrask/RealSIDShieldand I took some parts in order to design a more powerful version of SidBerry.

First I got a component to generate +12V from 5V (MC34063A) of which you can see the functional diagram taken from the datasheet. Starting from this schematic a proper component value were calculated in order to obtain an increase of the voltage. The original circuit generates the +12V only using MC34063A, but this require some precision resistors on feedback, so I preferred to generate an higher voltage (+ 18V / + 20V) and then using an linear regulator 78L12 to be sure that the 12V was accurate. This to avoid the premature dead of MOS6581 chips, that can burn easily if the voltages are not accurate.

image001

If you don’t like to make a Step-Up with spare components, you can easily buy an already done DC/DC like http://uk.rs-online.com/web/p/isolated-dc-dc-converters/6895015/

image003

The second modification is about the audio output stage, creating one very similar to the original C64. In RealSIDShield, the network is a bit more complex, but the stage is a simple transistor amplifier.

image005

For all remaining digital connections i use the SIDBerry original schematic.

Software

For software part I done a step by step guide to make a working SIDBerry code, starting with a clean jassie image and a RaspberryPi 3.

I started with a clean image, jessie, in particular mine was the 2016-09-23-raspbiam-jessie.zip downloaded directly from the official source.

I followed this guide for a complete update of the fresh installation. https://www.raspberrypi.org/blog/introducing-pixel/

Next configure a static IP for easily remote connect the RPI, editing the file dhcpcd.conf
sudo nano /etc/dhcpcd.conf and added at the end these following lines:


interface eth0
static ip_address=[your preferred fixed IP]/24
static routers=[your preferred gateway]
static domain_name_servers=[your preferred DNS1][your preferred DNS2]

Then I activate a VNC server to easily remote control the raspberryPi using a following commands:


sudo apt-get install -y realvnc-vnc-server
sudo vncinitconfig -service-daemon
sudo systemctl enable vncserver-x11-serviced.service

then configure from desktop (clicking on the tray VNC icon) the preferred authentication method for access on your PI via VNC.
These steps are optional, if you prefer can use an HDMI monitor with keyboard/mouse or SSH connection.

Next you need to install a WiringPi library, to make C++ program able to control I/O resources. Use the following commands:


sudo apt-get install git-core
sudo git clone git://git.drogon.net/wiringPi
cd wiringPi
sudo ./build

If you have problems with wiringPi see this link: http://wiringpi.com/download-and-install/

So next you need to get the SIDberry sources:

Return to home dir (cd ..)


sudo git clone https://github.com/gianlucag/SidBerry
cd SidBerry

Take ownership of all files


sudo chown pi:root *

Now edit with your preferred editor the file main.cpp to fix 2 little problems:


1) add #include <unistd.h> after the line #include <sys/time.h>
2) search for \mread and replace with \nread

Now compile the sources to obtain the working executable


sudo g++ -o SidBerry mos6502.cpp SidFile.cpp main.cpp -lwiringPi

Now you can test your work using this command


sudo ./SidBerry R-Type.sid 0

where 0 is the song index of the SID file.
Each SID file my contain various song or variations that you can play changing the index.

If you like to know something more about SID file format, follow this link:
http://cpansearch.perl.org/src/LALA/Audio-SID-3.11/SID_file_format.txt

qnjvo2

Fitted protoboard on PI

image010

image011

image014

You can see a video of operating hardware here:

Next?

I don’t know when, but I would try to generate a 1Mhz clock for the SID using a PI internal timer, also can be interesting make a python GUI for the SIDBerry.

Also, but a little harder, try to change the 6502 player to allow to play a SID format that includes samples, in fact this player, actually was unable to play many famous SID+PCM song that include digitized instruments or voices. When you try to play this there are a SID format error. There are not a official documentation for this mode, and probably is not really standard.

Console retrogaming con Raspberry Pi e RetroPie

Raspberry Pi 2 è il computer ideale da trasformare in un emulatore universale per le vecchie console anni 80-90.  Vi basterà la distro RetroPie, una micro SD card da almeno 8GB, un alimentatore da 2000mA ovviamente il Raspberry Pi 2 modello B.

yoshi_island

Prendete un Raspberry Pi 2 modello B, consiglio gli ottimi starter kit che trovate ai link più avanti.

Le caratteristiche del Pi2B, un piccolo mostro!

  • CPU ARM7 quad core a 900 MHz
  • 1GB di RAM
  • 40pin GPIO
  • 4 porte USB
  • HDMI
  • jack 3.5mm per audio/video analog
  • micro USB e porta micro SD
  • Lettore USB per schede micro SD

E’ possibile overcloccare il processore via software e portarlo fino a 1GHz ma occorrerà installare il dissipatore e magari una ventola. In ogni caso gli emulatori girano benissimo anche con la frequenza stock di 900MHz.

Lista dei componenti

Ecco un riassunto di tutto quello che serve:

  • Raspberry Pi 2 modello B
  • micro SD card da almeno 8GB
  • alimentatore (almeno 2000mA) con attacco micro USB (quello dei cellulari tanto per intendersi)
  • cavo HDMI
  • un joypad USB qualsiasi
  • tastiera USB (per la configurazione iniziale, poi non servirà più)
  • case più coperchio per Raspberry Pi 2 (non strettamente necessario ma sicuramente utile)

Esistono svariati kit che includono tutto quanto sopra, uno interessante è questo qui venduto su Amazon

Screen Shot 2017-10-31 at 22.22.00

Oppure quello venduto direttamente da ThePiHut, un vero e proprio kit retrogaming che include pure due joypad SNES (non originali SNES ovviamente, due joypad look&feel SNES usb)

Screen Shot 2017-10-31 at 21.59.14

Io ho preso il kit da ThePiHut. NOTA: ad oggi (Ottobre 2017) conviene prendere il Raspberry Pi3, più veloce e potente rispetto alla versione 2. Ho aggiornato i link sopra che ora mandano al modello aggiornato versione 3. Tutte le indicazioni fornite su questo articolo vanno bene pure per il modello Pi3

Cosa è RetroPie

Si tratta di una distribuzione Linux modificata contenente una vasta gamma di emulatori e il frontend EmulationStation che vi permetterà di gestire tutto il sistema tramite joypad senza mai ricorrere alla tastiera o al mouse.

Le macchine emulate da RetroPie sono le seguenti:

  • Amiga (UAE4ALL)
  • Apple II (LinApple)
  • Atari 800 (Atari800)
  • Atari 2600 (RetroArch/Stella)
  • Atari ST/STE/TT/Falcon (Hatari)
  • Apple Macintosh (Basilisk II)
  • C64 (VICE)
  • Amstrad CPC (#CPC4Rpi)
  • Final Burn Alpha (RetroArch/PiFBA, RetroArch/FBA)
  • Game Boy (RetroArch/Gambatte)
  • Game Boy Advance (GpSP)
  • Game Boy Color (RetroArch/Gambatte)
  • Sega Game Gear (Osmose)
  • Intellivision (jzIntv)
  • MAME (RetroArch/mame4all-pi, RetroArch/mame4all)
  • MSX (openMSX)
  • PC – x86 (rpix86)
  • NeoGeo (PiFBA, GnGeo)
  • Nintendo Entertainment System (RetroArch/FCEUmm)
  • Nintendo 64 (Mupen64Plus-RPi)
  • TurboGrafx 16 – PC Engine (RetroArch/Mednafen/pce_fast)
  • ScummVM
  • Sega Master System / Mark III (RetroArch/Picodrive, Osmose, DGen)
  • Sega Mega Drive / Genesis (RetroArch/Picodrive, DGen)
  • Sega Mega-CD / CD (RetroArch/Picodrive, DGen)
  • Sega 32X (RetroArch/Picodrive, DGen)
  • Playstation 1 (RetroArch/PCSX ReARMed)
  • Super Nintendo Entertainment System (RetroArch/Pocket SNES, snes9x-rpi)
  • Sinclair ZX Spectrum (Fuse, FBZX)

Più alcuni port di giochi per PC quali

  • Duke Nukem 3D
  • Doom
  • Quake 3 Arena

 

Installare RetroPie

Scaricate l’immagine ISO dal sito; il secondo link scarica la ISO per il raspberry Pi 2.

A questo punto occorre caricare la ISO nella scheda SD. Sotto Windows possiamo utilizzare l’ottimo Win32 Disk Imager. Inserite la micro SD nel vostro PC (o usate un adattatore USB) e tramite Win32DiskImager copiateci sopra il file immagine. L’operazione richiederà alcuni minuti.

Screen shot 2016-02-06 at 10.40.07 PM

Una volta terminata la copia estraete la card SD e inseritela nel RaspberryPi.

Accendete il RaspberryPi e dovreste vedere il classico log di boot Linux…

raspi2boot

 

Successivamente dovrebbe comparire lo splash screen standard di RetroPie…

splashscreen-300x169

e per finire il menù principale…

theming_system

Collegate la tastiera ad una delle prese USB e dovreste essere in grado di muovervi tra le voci del menu.

Configurazione RetroPie

E’ giunto il momento di configurare RetroPie.

Ho stilato un breve elenco delle cose da fare per configurare al meglio RetroPie:

  • configurazione dell’audio HDMI
  • configurazione joypad
  • espansione del file system sulla sd card
  • update dello script di RetroPie (opzionale)
  • cambio dell’emulatore SuperNintendo (Snes9x a PocketSnes)
  • caricare le ROM dei videogiochi

Configurazione audio HDMI

Di default l’audio non è configurato correttamente e l’uscita HDMI risulta muta (solo su alcune TV). Se siete fortunati l’audio funzionerà alla grande fin da subito, se non lo siete occorrerà forzare l’audio sull’uscita HDMI :-).

Entrate in console premendo F4 da qualsiasi punto del menu. Una volta premuto F4 dovrete premere invio o un alto tasto altrimenti il sistema ritornerà automaticamente al menu grafico.

Una volta in console abilitate l’utente root dando il comando:

sudo passwd

Scegliete una password per l’utente root, ad esempio “root” 🙂

Ora entrate in modalità  root digitando

su root

e date la password. A questo punto siete in grado di modificare le impostazioni dell’audio.

Aprite il file /boot/config.txt con il comando

 nano /boot/config.txt

e scommentate la riga hdmi_drive=2

In sostanza dovrete modifica la riga da cosi’:

#hdmi_drive=2

a cosi’:

hdmi_drive=2

Salvate il file, e riavviate digitando reboot (sempre come root).

A questo punto l’audio dovrebbe essere a posto. Tuttavia, finchè non avrete una ROM da provare non potrete testare l’audio.

Espansione del filesystem

Il file immagine di RetroPie che avete installato sulla sd card crea due partizioni, una di boot da qualche  MB e una più grande da 2GB. Per sfruttare tutta la capacità della sd card occorrerà espandere questa partizione fino alla dimensione massima possibile.

Entrate nel menu principale e andate alla voce “RetroPie”.

menu_retropie

Selezionate “Raspberry Pi configuration tool RASPI-CONFIG”

raspberry_pi_configurations

Selezionate “Expand Filesystem”

expand_filesystem

Riavviate tutto. Al boot dovrebbe partire l’operazione di espansione. A questo punto avete a disposizione tutti i GB della scheda SD per le ROM dei giochi.

Configurazione del JoyPad

L’operazione è semplicissima. Mentre siete nel menu principale collegate un joypad USB al Raspberry Pi, dovrebbe partire in automatico la fase di configurazione: premete i bottoni sul joypad secondo le indicazioni a schermo (alto, basso, sinistra, destra, pulsante “A”, pulsante “B” etc..etc…). La lista dei pulsanti è molto lunga (credo sia quella di un joypad playstation) se non avete “abbastanza bottoni” potete saltarne alcuni tenendo premuto per 2 secondi un tasto qualsiasi (anche un bottone già selezionato in precedenza)

Update dello script RetroPie

Un aggiornamento allo script principale vi risolverà grandi mal di testa in futuro. Dal menu principale selezionate “RetroPie” e quindi “RetroPie Setup”. Selezionate ora “Update RetroPie-Setup script”. Ovviamente è richiesta una connessione internet quindi il Raspberry Pi dovrà essere collegato al router tramite cavetto ethernet.

Cambio dell’emulatore di default del Super Nintendo

L’emulatore di default del Super Nintendo (snes9x) non sembra essere all’altezza di alcuni giochi (sopratutto quelli che sfruttavano il coprocessore grafico superFx, tipo Yoshi Island). Per fortuna una valida alternativa è data dall’emulatore PocketSnes, già presente in RetroPie e ottimizzato per processori ARM.

Andate nel menu “RetroPie”, quindi in “Edit retropie/retroarch configurations”

selezione_edit_retropie

Selezionate “Manually edit all configurations”

manually_edit_all_configurations

Selezionate “snes/emulator.cfg”

selezione_snes_emulators

e all’utima riga scrivete:

default=”lr-pocketsnes”

selezione_pocketsnes

Salvate e riavviate. A questo punto il nuovo emulatore è pronto ad essere utilizzato. Nessun rallentamento o glitch video e audio perfetto.

Caricare le ROM dei videogiochi sul Raspberry Pi

Anche questa operazione è semplicissima.

Potete trovare le ROM su internet, consiglio il famoso emuparadise. Mi raccomando però, in teoria potete scaricare solo le ROM dei giochi che già possedete, almeno questo è quello che dicono i disclaimer sui vari siti di download.

Collegate il Raspberry Pi alla LAN: RetroPie è configurato per condividere automaticamente la directory dove immagazzina tutte le ROM.  Da un PC qualsiasi collegato alla stessa rete dovreste vedere RetroPie sotto questo nome:

\\retropie

doppio click e trovate la cartella “rom”, all’interno altre sottocartelle, ognuna delle quali relativa ad un emulatore. Copiate le ROM nelle cartelle opportune.

Riavviate. Dal menu principale di RetroPie dovreste vedere ora tutti gli emulatori per i quali avete caricato le ROM!

emulatori

Selezionate un emulatore e troverete la lista completa delle ROM che avete caricato (per quell’emulatore).

lista giochi

 

Tutto a posto!

A questo punto staccate cavo ethernet e tastiera, non serviranno più. Tutto il sistema è gestibile via joypad, anche l’uscita da un emulatore (premete contemporaneamente i tasti start e pausa) e lo spegnimento del Raspberry Pi (dal menu, premete start e selezionate “shutdown”).

EDIT (19 Feb 2017)

In un recente articolo mostro come collegare un joypad originale del Super Nintendo al RaspberryPi tramite porta USB. La modifica è abbastanza semplice e non occorrono driver particolari

 

SidBerry – Raspberry Pi SID player

Un SID jukebox realizzato con RasberryPi e il SID chip originale 6581. Il chip è alloggiato in una board custom collegata direttamente ai gpio del Rasberry!

La board può riprodurre qualsiasi SID file, basta caricare i file .sid nella sdcard del Rasberry, avviare il player e collegare all’uscita jack un paio di casse preamplificate o meglio uno stereo.

SID chip

Il SID originale, nelle varianti 6581 e 8580, è controllato caricando i suoi 29 registri interni con i valori opportuni al momento opportuno. La sequenza di byte inviati genera l’effetto o la musica desiderati. Ogni registro è 1 byte ed i registri sono in tutto 29 quindi c’è bisogno di almeno 5 gpio di indirizzo (2^5=32) e 8 gpio di dati per un totale di 13 gpio. Un altro gpio è richiesto per la linea CS del chip (Chip Select).

220px-MOS6581.svg

Fortunatamente il Raspberry ha ben 17 gpio e i 14 richiesti sono perfettamente pilotabili con la libreria WiringPi. Gli altri pin del chip servono per i due condensatori dei filtri interni (CAP_a e CAP_b), alimentazione, linea R/W (che andremo a collegare direttamente a GND, siamo sempre in scrittura), entrata del segnale di clock, linea di reset (collegata sempre a VCC) e uscita audio analogica (AUDIO OUT).

Ecco la configurazione dei registri interni del SID:

SID_registers_fit

Qui per una descrizione più dettagliata del funzionamento interno del chip:

http://www.waitingforfriday.com/index.php/Commodore_SID_6581_Datasheet

Hardware

La board riproduce esattamente le “condizioni al contorno” per il SID chip come se si trovasse alloggiato in un Commodore 64 originale. L’application note originale mostra chiaramente i collegamenti da effettuare e i pochi componenti esterni richiesti (generatore di clock, condensatori e poco altro).

SID_original_schematic_fit

Unica differenza, le linee di indirizzo e dati vengono dirottate direttamente sui gpio del RasberryPi.

NOTA IMPORTANTE!: Il RasberryPi ragiona in logica CMOS a 3.3V mentre il SID chip è TTL a 5V quindi completamente incompatibili a livello di tensioni. Fortunatamente, siccome andiamo unicamente a scrivere nei registri, il RasberryPi dovrà soltanto applicare 3.3v ai capi del chip, più che sufficienti per essere interpretati come livello logico alto dal SID.

20150516_160221

Lo schematico completo:

sidberry

Software

Il grosso del lavoro. Volevo una soluzione completamente stand-alone, senza l’ausilio di player esterni (come ACID64) e quindi ho realizzato un player che emula gran parte di un C64 originale. L’emulatore è necessario in quanto i file .sid sono programmi in linguaggio macchina 6502 e come tali devono essere eseguiti. Il player è scritto in C/C++ e basato sul mio emulatore MOS CPU 6502   più un semplice array di 65535 byte come memoria RAM (il C64 originale ha infatti 64K di RAM). Il player carica il codice programma contenuto nel file .sid nella RAM virtuale più un codice assembly aggiuntivo che ho chiamato micro-player: sostanzialmente si tratta di un programma minimale scritta in linguaggio macchina per CPU 6502 che assolve a due compiti specifici:

  • installare i vettori di reset e interrupt alle locazioni corrette
  • chiamare la play routine del codice sid ad ogni interrupt

Questo perchè il codice che genera la musica in un comune C64 è una funzione chiamata ad intervalli regolari (50 volte al secondo, 50Hz). La chiamata è effettuata per mezzo di un interrupt esterno. In questo modo è possibile avere musica e un qualsiasi altro programma (videogioco ad esempio) in esecuzione nello stesso momento.

Altre componenti sono il parser per i file .sid e la libreria WiringPi per pilotare i GPIO del RaspberryPi.

Questo il layout dell’intero applicativo, a destra è la memoria RAM virtuale 64K

Screen shot 2015-05-17 at 5.41.36 PM

Questo è il codice assembler del micro-player:

// istallazione del vettore di reset (0x0000)
memory[0xFFFD] = 0x00;
memory[0xFFFC] = 0x00;</p>
// istallazione del vettore di interrupt, punta alla play routine (0x0013)
memory[0xFFFF] = 0x00;
memory[0xFFFE] = 0x13;

// codice del micro-player
memory[0x0000] = 0xA9;
memory[0x0001] = atoi(argv[2]); // il registro A viene caricato con il numero della traccia (0-16)

memory[0x0002] = 0x20; // salta alla init-routine nel codice sid
memory[0x0003] = init &amp; 0xFF; // lo addr
memory[0x0004] = (init &gt;&gt; 8) &amp; 0xFF; // hi addr

memory[0x0005] = 0x58; // abilitiamo gli interrupt
memory[0x0006] = 0xEA; // nop
memory[0x0007] = 0x4C; // loop infinito
memory[0x0008] = 0x06;
memory[0x0009] = 0x00;

// Interrupt service routine (ISR)
memory[0x0013] = 0xEA; // nop
memory[0x0014] = 0xEA; // nop
memory[0x0015] = 0xEA; // nop
memory[0x0016] = 0x20; // saltiamo alla play routine
memory[0x0017] = play &amp; 0xFF;
memory[0x0018] = (play &gt;&gt; 8) &amp; 0xFF;
memory[0x0019] = 0xEA; // nop
memory[0x001A] = 0x40; // return from interrupt

Pagina GitHub del progetto: https://github.com/gianlucag/SidBerry