Documenti di Didattica
Documenti di Professioni
Documenti di Cultura
STM8-BASIC
il più piccolo computer con interprete basic
Sommario
Introduzione .................................................................................................................................................. 2
Connessione al dispositivo ........................................................................................................................ 3
Cosa? ............................................................................................................................................................. 6
Una variante... ........................................................................................................................................... 6
Esempio: calcolo per cella sul bordo laterale ............................................................................................ 7
Esempio: calcolo per cella sul bordo inferiore .......................................................................................... 7
Esempio: calcolo per cella in un angolo .................................................................................................... 8
Come? ............................................................................................................................................................ 9
Allocare la nuova generazione ................................................................................................................ 10
Il programma ........................................................................................................................................... 11
Dalle idee al codice .................................................................................................................................. 12
Algoritmo ..................................................................................................................................................... 14
Stato della cellula corrente...................................................................................................................... 14
Somma delle cellule vive ......................................................................................................................... 15
Mettiamo insieme i pezzi ........................................................................................................................ 16
Appendici: bonus content ........................................................................................................................... 17
1. Codice sorgente ............................................................................................................................... 17
2. Oscillatore ........................................................................................................................................ 18
3. Doppio glider ................................................................................................................................... 18
1
gldm Tutorial STM8-BASIC
Introduzione
Poiché negli ultimi tempi ho sviluppato una certa saudade per la tecnologia dei primi anni '80 (in particolare
gli interpreti BASIC), ho recentemente acquistato una scheda STM8 BASIC.
Il costo è irrisorio, la spedizione è stata rapida, ed in breve mi sono trovato tra le mani questo
microcontrollore, di cui consiglio senza riserve l'acquisto.
2
gldm Tutorial STM8-BASIC
Connessione al dispositivo
Naturalmente la prima cosa da fare è collegare un terminale seriale al dispositivo in modo da poter interagire
con l'interprete BASIC.
Per fare questo, occorre dotarsi di un convertitore USB/Seriale: io ho utilizzato una schedina del tipo FDTI (si
possono acquistare online a costi ragionevoli).
Qui occorre fare attenzione: la scheda SMT8 vuole i segnali seriali tra 0 e 3.3V, ma l'alimentazione Vcc a
5V.
Comprate un convertitore con il jumper che vi permetta di selezionare la tensione di uscita (3.3V - 5V)
e configuratela in modo che esca a 3.3V - altrimenti causerete danni alla scheda STM8.
Potete recuperare la tensione di alimentazione a 5V da uno dei piedini laterali, come nella figura seguente.
3
gldm Tutorial STM8-BASIC
A questo punto la connessione seriale è a posto; collegate un cavo USB, aprite un emulatore di terminale ed
impostate i parametri, come da figura (io ho usato PuTTY).
4
gldm Tutorial STM8-BASIC
Se tutto è andato per il verso giusto, collegandovi alla scheda ed eseguendo il comando RST, dovreste
vedere una schermata simile a questa.
5
gldm Tutorial STM8-BASIC
Cosa?
Abbiamo il nostro computer, collegato tramite terminale seriale, pronto ad eseguire i nostri programmi
BASIC.
Bene, cosa vogliamo far eseguire al nostro interprete?
In onore di John Conway, scomparso ad aprile di questo sciagurato 2020, ritengo opportuno programmare
una variante della simulazione LIFE in BASIC.
Date le limitazioni dell'interprete (abbiamo a disposizione una manciata di variabili numeriche, 256 byte di
RAM e 630 byte per il programma) avremo una semplice griglia di 8x8 celle, ognuna delle quali potrà essere
"viva" o "morta".
Una variante...
La griglia può essere allocata in 8 byte di RAM. Ogni byte ospiterà una riga della griglia, dove il simbolo 1
rappresenterà una cellula "viva" e lo 0 una cellula "morta".
Nella figura vediamo un esempio dei casi che dovremo gestire: durante il calcolo della nuova generazione,
per stabilire il valore del bit con indice 3 del 3° byte, dovremo contare il numero di cellule "vive" presenti
intorno al nostro bit.
Segnatamente, dovremo contare gli "1" presenti :
• nel secondo byte (alle posizioni 2, 3 e 4)
• nel terzo byte (alle posizioni 2 e 4)
• nel quarto byte (alle posizioni 2, 3 e 4)
Per rendere più interessante la simulazione, introduciamo una variante: consideriamo la griglia finita ma non
limitata. Consideriamo cioè una griglia che si ripete infinitamente: sopra, sotto, a destra ed a sinistra.
Con questa variante, la somma delle cellule vicine deve essere opportunamente adeguata.
6
gldm Tutorial STM8-BASIC
Nella figura presentata, proviamo a fare il calcolo per il bit in posizione 0 del terzo byte. Dovremo
considerare, oltre alle posizioni 0 ed 1 del 2° e del 4° byte ed alla posizione 1 del 3°, anche le posizioni 7 del
1°, 2° e 3° byte.
7
gldm Tutorial STM8-BASIC
Naturalmente la somma delle cellule "vive" conterà la posizione 6 del 1° byte e le posizioni 6 e 7 del 2° byte.
Per la non limitatezza della griglia, dovremo contare anche la posizione 0 del 1° e 2° byte.
Il calcolo deve poi tenere conto dei "vicini" che appartengono anche all'8° byte, alle posizioni 0, 6 e 7.
8
gldm Tutorial STM8-BASIC
Come?
Una prima soluzione per aggirare la limitatezza verticale della griglia è di utilizzare due byte, in testa ed in
coda alla griglia; nel byte in testa verrà replicato l'ottavo byte della griglia, nel byte in coda verrà replicato il
contenuto del 1° byte.
Usiamo gli indirizzi da $0201 a $0208 per la griglia della generazione corrente (nell'esempio in figura ho
inserito un glider).
Copiamo l'ottavo byte della griglia (all'indirizzo $0208) nel byte all'indirizzo $0200.
Copiamo anche il primo byte della griglia (all'indirizzo $0201) nel byte all'indirizzo $0209.
Questa è la mappa della RAM che ospita la generazione corrente della griglia, con il primo ed ultimo byte
replicati in testa ed in coda.
9
gldm Tutorial STM8-BASIC
Per ospitare la generazione successiva, utilizziamo gli 8 bytes immediatamente successivi della memoria.
10
gldm Tutorial STM8-BASIC
Il programma
Vediamo quindi come passare dalla generazione corrente a quella futura:
dovremo fare una scansione di tutte le cellule della generazione corrente, per ogni cellula dovremo sapere
se è viva o morta, e dovremo contare il numero di cellule vive intorno (chiamiamo questa somma S).
Con queste due informazioni stabiliremo lo stato della cellula nella prossima generazione:
• cellula attualmente morta
• se S=3, nella prossima generazione la cellula sarà viva
• cellula attualmente viva:
• se S=3 oppure S=2, nella prossima generazione la cellula sarà viva
• in tutti gli altri casi, nella prossima generazione la cellula sarà morta.
Per implementare questo algoritmo dovremo effettuare una scansione dei byte della generazione corrente,
per ogni byte effettuare una scansione dei bit (ovvero delle cellule) - calcolare lo stato del bit per la prossima
generazione ed infine memorizzare lo stato della nuova generazione nell'area di memoria preposta.
Ho evidenziato in colore blu le operazioni eseguite per ogni byte della generazione corrente, ed in
colore rosso le operazioni eseguite per ogni bit del byte corrente.
Per ogni byte preso in esame (ricordo che per calcolare la somma delle cellule vive dovrò tenere conto
anche del byte precedente e del byte successivo) nella generazione corrente il programma calcolerà il
corrispondente byte della generazione futura e lo salverà nell'opportuno indirizzo (9 locazioni più "in basso"
nella mappa della memoria).
11
gldm Tutorial STM8-BASIC
12
gldm Tutorial STM8-BASIC
Questa è la struttura generale del programma, naturalmente mancano ancora le parti per:
13
gldm Tutorial STM8-BASIC
Algoritmo
Iniziamo ora a pensare come calcolare le due informazioni che ci servono per calcolare se la cellula
sarà viva o morta nella prossima generazione:
1. stato della cellula nella generazione corrente
2. somma S delle cellule vive intorno ad essa
Riprendendo la notazione introdotta nel capitolo precedente, supponiamo di avere il byte R che
ospita la riga di cellule.
Se stiamo considerando il bit con indice N, un'operazione di AND bit a bit tra il byte R e
2N restituirà due possibili valori:
➢ 0 (se il bit con indice N è 0 su R)
➢ 2N (se il bit con indice N è 1 su R)
Nell'esempio in figura N=3, calcoliamo 23 e facciamo l'operazione (R&8): in base al valore del bit
X, otterremo 8 oppure 0.
Se vogliamo un risultato che sia 1 per cellula viva e 0 per cellula morta, l'operazione completa sarà:
bitN = (R&2N)/2N
Questa informazione mi è utile anche al fine di stampare a video lo stato della cella, continuando
nel ciclo fino alla fine del byte, quando dovrò andare a capo prima di iniziare il byte successivo.
Nota implementativa: in BASIC, l'operazione di divisione può essere sostituita con un'operazione di
confronto: l'espressione (R&2N)=2N restituisce 1 se i due membri dell'uguaglianza sono uguali, 0
altrimenti.
14
gldm Tutorial STM8-BASIC
Usiamo le variabili di tipo byte offerte dal dispositivo per i nostri "moltiplicatori" e battezziamo:
O=2N+1 P=2N Q=2N-1
Dovremo però gestire due casi limite: quando N=0, Q dovrà essere 128 (perché la griglia è illimitata
lateralmente)
La somma delle cellule vive intorno al bit corrente comprende i contributi dati dai 3 byte:
per V= byte superiore, avremo un contributo pari a:
(V&O)/O+(V&P)/P+(V&Q)/Q
15
gldm Tutorial STM8-BASIC
17
gldm Tutorial STM8-BASIC
2. Oscillatore
3. Doppio glider
18