Il Control Program for Microprocessor (CP/M) è stato il più diffuso sistema operativo per personal computer prima dell’avvento dei sistemi IBM compatibili. Ha avuto un ruolo cruciale nel periodo pionieristico dello sviluppo della informatica personale. Il suo influsso é stato così marcato da arrivare sino ai nostri giorni: l’MsDos, ed il suo pronipote Prompt dei comandi di Windows sono stati direttamente ispirati al pargolo di Gary Kildall e della sua Digital Research. E’ quindi evidente che abbia un interesse rilevante per ogni appassionato di retrocomputing.  Può essere, peraltro, anche molto istruttivo per chi volesse sperimentare, sul campo, cosa fosse l’informatica di quarant’anni fa. Con questo semplice progetto potrete avere fra le mani un microcomputer in grado di eseguire sia il sistema operativo CP/M, che i programmi che hanno segnato la storia di tutti, dando il la al processo di trasformazione digitale che ha rivoluzionato il nostro modo di essere. Il tutto utilizzando componenti economici, e di facile reperibilità.

Il sistema è in effetti così semplice da richiedere solo due componenti principali: un microcontrollore ESP32 ed una scheda SD anche di piccola capacità.

ESP32 è un microcontrollore nato per il mercato IoT, utilizza una CPU a 32 bit Xtensa dual-core operante a 160MHz, 448 KB di memoria flash e 520kByte di RAM. Ha onboard sia il supporto per il WiFi (802.11 b/g/n) che per Bluetooth (v4.2 BR/EDR e BLE). Lavora a 3.3V (~80mA). Il processore è normalmente commercializzato in moduli di sviluppo, pronti ad essere utilizzati in progetti come il mio. Io ho utilizzato un DOIT Esp32 DevKit v1, come gli altri ha una interfaccia USB che viene utilizzata sia per l’alimentazione (a 5V) che per il collegamento dati seriale.
Il secondo componente è una scheda SD. La capacità non è importante – negli anni ’70 si lavorava con poche manciate di kByte – ma deve essere compatibile con l’alimentazione a 3.3V: è probabile quindi che schedine molto vecchie risultino non compatibili.
Ovviamente è utile, sebbene tecnicamente non indispensabile, utilizzare anche un connettore per la scheda SD: io ho utilizzato uno preso dalla galassia degli accessori per Arduino.
Se usate bene uno dei tanti motori di ricerca, potrete procurarvi tutti i componenti non arrivando a spendere 10€

Il cablaggio richiede giusto sei collegamenti, secondo questo schema: D5 -> CS, D18 -> SCK, D19 -> MISO, D23 -> MOSI, oltre ovviamente a +3.3V e GND. E’ bene però precisare che questi dati, per quanto validi per il modulo che ho usato io, non sono però universali. Altre versioni di ESP32 potrebbero mappare l’interfaccia SPI su altri pin. E’ quindi sempre bene verificare preventivamente la documentazione del modulo usato per individuare i pin corretti, ed adattare cablaggio e configurazione al vostro hardware.
Per il cablaggio è sconsigliabile usare una breadboard, specie quelle economiche cinesi. I piedini dell’ESP32 non sono standard, e potrebbero facilmente deformare i contatti della tavoletta, rendendola poco affidabile. Meglio usare dei jumper, come quelli della foto, oppure una basetta millefori su cui saldare gli appositi connettori.

Altro suggerimento è quello di usare come riferimento la serigrafia dei contatti e non la posizione fisica sui moduli, sempre perchè la disposizione può differire a seconda del modello. Il mio modulo ha già onboard i due led che servono: uno rosso per l’alimentazione, ed uno blu per l’attività dell’I/O.

Per impegare l’ESP32 come computer CP/M ho utilizzato l’ottimo emulatore RunCPM di Marcelo Dantas, che può essere scaricato in sorgente da Github. Per compilarlo ed installarlo è sufficiente utilizzare l’IDE di Arduino, disponibile sia per Windows che per Linux. Per connettere il modulo ESP32 su windows potrebbe essere necessario installare anche il driver per il chip CP2102, che implementa l’interfaccia USB/Seriale. Può essere scaricato dal sito di Silicon Labs. 

L’installazione dell’IDE è lineare, ma se fosse necessario supporto è sufficiente seguire una delle tante guide disponibili su Internet.
Dopo l’installazione dell’IDE è necessario aggiungere i moduli per gestire l’ESP32. L’operazione richiede quattro passaggi:
1) Su File->Impostazioni è necessario inserire in URL Aggiuntivo per il gestore delle schede l’indirizzo https://dl.espressif.com/dl/package_esp32_index.json separandolo con una virgola da altri eventuali valori già presenti. 
2) Aprire Gestore Schede, e cercare i moduli ESP32
3) Installare i moduli.
4) Su Strumenti->Scheda individuare il modulo utilizzato e selezionarlo come scheda attiva.

A questo punto rimane solo da selezionare l’interfaccia seriale da usare per la programmazione. Collegate il modulo con il cavo USB e selezionate la porta, che sarà una COMx per Windows, e ttyUSBx per Linux.

Abbiamo a questo punto il sistema di sviluppo pronto per la compilazione, possiamo scaricare i sorgenti da Github all’URL https://github.com/MockbaTheBorg/RunCPM e salvarli in una directory del nostro computer.

RunCPM richiede la libreria SDFat, che può essere installata da Strumenti->Gestione librerie. Facendo una ricerca fra le librerie predefinite ne troverete due, quella che serve è la SdFat- Ardafruit fork.  Dopo averla scaricata sarà necessario modificare due valori di configurazione (cambiando il valore 0 in 1) nel file SdFatConfig.h:

#define ENABLE_EXTENDED_TRANSFER_CLASS 1 (intorno alla linea 71)
#define ENABLE_SOFTWARE_SPI_CLASS 1 (intorno alla linea 87) 

E’ ora possibile aprire con l’IDE lo sketch dell’emulatore,  RunCPM.ino, che si trova nella subdirectory RunCPM. I file così come sono scaricati da Github sono configurati per un altro microcontrollore, il Teensy, ma è facilissimo riconfigurarli per l’ESP32.
In RunCPM.ino modificare

#include "hardware/esp32.h" (intorno alla linea 23)

in hardware/esp32.h indicare i valori corretti per l’interfaccia SPI e per la linea del LED. Questi valori sono quelli adatti alla mia scheda.

SdFatSoftSpiEX<19, 23, 18> SD; // MISO, MOSI, SCK
#define SDINIT 5 // CS
#define LED 2 // DOIT_Esp32=2
#define LEDinv 0
#define BOARD "DOIT_Esp32"

A questo punto il software è pronto per la compilazione: cliccando il pulsante verifica l’IDE dovrebbe generare l’eseguibile, restituendo dopo qualche manciata di secondi un messaggio con l’indicazione dell’occupazione di memoria, senza emettere errori.

L’ultimo passaggio è quello di caricare il programma sulla scheda, cliccando sull’icona del’IDE. In alcuni casi l’operazione viene completata automaticamente, senza interventi manuali. In altri casi è necessario mettere manualmente il modulo in modalità caricamento. In questo caso è sufficiente attendere che nella finestra dei messaggi dell’IDE appaia l’indicazione  connecting…  e premere per un paio di secondi il pulsante boot (a lato del connettore usb dell’ESP32) per portare l’operazione a termine.

A questo punto la parte hardware dell’emulatore è ora pronta. Nella seconda parte passeremo al software.

Per il mio progetto ho realizzato un piccolo (9x6x2.5 xm) contenitore stampato in 3D, di cui allego due foto.

Il file .slt è scaricabile dal mio account thingverse.