DHOB (IU5SGN)

lunedì 16 luglio 2018

PMII 19 - Philips DD 401 Cd Rom

Uno dei primissimi lettori CD Rom sul mercato. Non aveva un cassetto estraibile ma il disco doveva essere inserito ed estratto mediante un apposita guida in plastica (ovviamente aveva una scheda di interfaccia proprietaria da inserire nel PC che e' andata persa rendendo questo esemplare non funzionante)

PMII 18 - 3Com US Robotics Modem 56k

Al tempo delle BBS un sogno possedere questo modem

PMII 17 - Modem

Non ho trovato informazioni riguardanti questo vetusto modem (probabilmente un 1200 o 300 baud)

PMII 16 - Floppy Disk Drive 8 pollici Shugart

Questo

La storia di questo floppy drive e' un po' curiosa. Oltre 10 anni fa passeggiando in via Cavour a Firenze vedo al cassonetto una macchina che non conosco e la tentazione di portarsela a casa e' stata subito forte...peccato che il peso e le dimensioni erano pari a quelle di un sistema S/36 della IBM (e chi ha mai provato a spostare un S/36 sa di cosa parlo).. Sono riuscito a portarmi a casa solo questo floppy drive della Shugart Ass. (anche lui a peso non scherza)

PMII 15 - Pong Polistil

Pong, basta il nome. La cosa divertente di queste scatolette e' che erano molto semplice per le ditte costruire la propria versione. Il cuore della macchina era contenuto in un solo integrato AY-3-8500 con pochissima componentistica esterna

PMII 14 - Atari 2600

Atari 2600 ed Atari 2600 Jr

PMII 13 - Intellivision Mattel

Il grande avversario dell'Atari 2600...ho passato pomeriggi a giocare (ed invidiare mio cugino all'inizio degli anni 80). Non ho giochi per testare la macchina che comunque sembra integra

PMII 12 - MSX HX-51 Toshiba

Comprato in un lotto di consolle e' non funzionante perche' ha il cavo alimentazione tranciato (e non so se va diretto al 220 o se c'era un trasformatore)...anche se il suo valore e' modesto ho visto che e' un modello molto raro

venerdì 13 luglio 2018

Mandelbrot (per pigri) modalita' grafica con CC65

Sono riuscito ad attivare la modalita' grafica su CC65. Compilando il codice ed usando gli esempi senza modifiche avevo sempre l'errore

Error #2 initialising graphics

Cannot load driver

quando cercavo di usare TGI. Grazie al suggerimento degli sviluppatore basta flaggare a zero

# define DYN_DRV 1

e si usa il driver in modalita' statica. La prima prova e' andata bene ma non troppo....Su VICE in modalita' velocita' 100% ho impiegato 3659.9 secondi !!!!!! (quasi quasi ritorno a Simons Basic)...non capisco ....CC65 e' compilato mentre Simons Basic e' interpretato e non c'e' un guadagno sensibile e c'e' pure il trucco della integer math contro i float si Simons...gia' la integer math...se si prova a disegnare le bande di fuga si vede che queste vengono a cuspide mentre dovrebbero essere tondeggianti e cio' deriva dalla approssimazione apportata da matematica per interi

Poi capito su questo sito http://retro64.altervista.org/blog/the-mandelbrot-set-c64-assembly-program-to-draw-it-fast-using-integer-math-part-1/ con un esempio in Assembler che genera Mandelbrot in 12 minuti ....tempo per me di attaccare la tastiera al chiodo

cl65 -O -l man.lst -vm -m man -o man.prg -t c64 man.c

man.c
--------------------------------------------------

#include <stdlib.h>
#include <conio.h>
#include <cc65.h>
#include <tgi.h>

#define SCREEN_X 320
#define SCREEN_Y 200
#define MAXCOL 2

#define maxiterations 25
#define fpshift (14)
#define tofp(_x) ((_x)<<fpshift) // bitwise shift left
#define fromfp(_x) ((_x)>>fpshift)
#define fpabs(_x) (abs(_x))

#define mulfp(_a,_b) ((((signed long)_a)*(_b))>>fpshift)
#define divfp(_a,_b) ((((signed long)_a)<<fpshift)/(_b))

#pragma static-locals (1);

void mandelbrot (signed short x1, signed short y1, signed short x2,
signed short y2)
{
// le variabili register sono quelle che il compilatore mette in pagina zero
// e quindi quelle a piu' rapido accesso
register unsigned char count;
register signed short r, r1, i;
register signed short xs, ys, xx, yy;
register signed short x, y;

/* Calc stepwidth */
xs = ((x2 - x1) / (SCREEN_X));
ys = ((y2 - y1) / (SCREEN_Y));

yy = y1;
for (y = 0; y < (SCREEN_Y); y++) {
yy += ys;
xx = x1;
for (x = 0; x < (SCREEN_X); x++) {
xx += xs;
/* Do iterations */
r = 0;
i = 0;
for (count = 0; (count < maxiterations) &&
(fpabs (r) < tofp (2)) && (fpabs (i) < tofp (2));
++count) {
r1 = (mulfp (r, r) - mulfp (i, i)) + xx;
/* i = (mulfp(mulfp(r,i),tofp(2)))+yy; */
i = (((signed long) r * i) >> (fpshift - 1)) + yy;
r = r1;
}
if (count == maxiterations) {
tgi_setcolor (0);
} else {
tgi_setcolor (count%2);
}
tgi_setpixel (x, y);
}
}
}

int main (void)
{
tgi_install (tgi_static_stddrv);
tgi_init ();
tgi_clear ();

mandelbrot (tofp (-2), tofp (-2), tofp (2), tofp (2));
cgetc ();
tgi_uninstall ();
return 0;
}

Galleria drenante Impruneta

Ho avuto modo di visitare la galleria drenante dell'Impruneta, una opera acquedottistica datata 1860, che cercava di raccogliere le acque sotterranee nel povero acquifero di Gabbro quando il pozzo in piazza era diventato insufficiente per la crescente popolazione

Fa un po' strano scendere da un tombino stradale (da via Cavalleggeri) ma successivamente il passaggio e' agevole. Dopo un breve tratto finisce la parte rivestita in muratura e si puo' toccare direttamente la roccia. Interessante (anche se non ho capito bene la dinamica della messa in posto) il contatto diretto tra gabbro e basato (frugando su Internet ho trovato disponibile il pdf della tesi di dottorato di Francesco Menna che riassume il contesto geologico della sequenza ofiolitica (anche se non nell'area dell'Impruneta ma i concetti sono comunque validi) in cui si ha la coesistenza di gabbri e basalti nelle brecce ofiolitiche direttamente sopra alle peridotiti del basamento

CC65 Mandelbrot (per pigri) modalita' testo

Devo ammettere che scoprire CC65 e' stato un bel passo avanti...prima avevo due opzioni sul C64: o fare i programmi in BASIC (molto molto lenti) oppure farli in Assembler. CC65 e' invece un cross compiler indirizzato al 6503 che usa la sintassi C. Il vantaggio e' che mentre il BASIC e' un linguaggio interpretato (quindi il sistema deve ogni volta effettuare la conversione in linguaggio macchina nonostante il codice sia in ogni caso tokenizzato), con CC65 si ha gia' codice macchina (anche se ovviamente non ottimizzato)

Mandelbrot modalita' testuale su C64Debugger

per esempio si puo' fare il classico Hello World e compilarlo in questo modo

cl65 -O -l hello.lst -vm -m hello -o hello.prg -t c64 hello.c

il codice generato non e' esattamente compatto (sono circa 3Kb). Inoltre e' da notare che non e' disponibile il tipo dati float

In ogni caso con poco sforzo e' possibile generare un insieme di Mandelbrot (non sono ancora riuscito a gestire la modalita' grafica via TGI)

------------------------------------------------------

#include <stdlib.h>
#include <conio.h>
#include <cc65.h>

#define SCREEN_X 40
#define SCREEN_Y 25

#define maxiterations 25
#define fpshift (10)
#define tofp(_x) ((_x)<<fpshift) bitwise shift left
#define fromfp(_x) ((_x)>>fpshift)
#define fpabs(_x) (abs(_x))

#define mulfp(_a,_b) ((((signed long)_a)*(_b))>>fpshift)
#define divfp(_a,_b) ((((signed long)_a)<<fpshift)/(_b))

#pragma static-locals (1);

void mandelbrot (signed short x1, signed short y1, signed short x2,
signed short y2)
{
// le variabili register sono quelle che il compilatore mette in pagina zero
// e quindi quelle a piu' rapido accesso
register unsigned char count;
register signed short r, r1, i;
register signed short xs, ys, xx, yy;
register signed short x, y;

/* Calc stepwidth */
xs = ((x2 - x1) / (SCREEN_X));
ys = ((y2 - y1) / (SCREEN_Y));

yy = y1;
for (y = 0; y < (SCREEN_Y); y++) {
yy += ys;
xx = x1;
for (x = 0; x < (SCREEN_X); x++) {
xx += xs;
/* Do iterations */
r = 0;
i = 0;
for (count = 0; (count < maxiterations) &&
(fpabs (r) < tofp (2)) && (fpabs (i) < tofp (2));
++count) {
r1 = (mulfp (r, r) - mulfp (i, i)) + xx;
/* i = (mulfp(mulfp(r,i),tofp(2)))+yy; */
i = (((signed long) r * i) >> (fpshift - 1)) + yy;
r = r1;
}
if (count == maxiterations) {
cprintf("*");
} else {
cprintf(" ");
}
/* Set pixel */
//tgi_setpixel (x, y);
}
}
}

int main (void)
{
clrscr ();
mandelbrot (tofp (-2), tofp (-2), tofp (2), tofp (2));
cgetc ();
return 0;
}

mercoledì 11 luglio 2018

PRG in Vice

A volte puo' essere comodo lanciare un PRG dentro a VICE ma, almeno su Windows, il drag and drop non funziona. Vengono accettate solo immagini disco, cassetta o cartuccia

Un metodo per ovviare al problema e' creare una immagine disco da una directory da Impostazioni/Impostazioni periferiche/Directory

A questo punto la directory viene vista come un disco

LOAD"$",8
LIST

e si avra' il contenuto della directory selezionata. A questo punto basta caricare il PRG

C64 Joystick Assembler

Esempio commentato di come leggere lo stato del joystick di un C64 per muovere un carattere sullo schermo

Da notare che per la scrittura a schermo vengono usate due tecniche. La prima, nel clear screen, prevede la scrittura diretta in memoria video (che si trova a partire da $0400 ed ha le dimensioni di 1Kb, 1000 bytes per una dimensione di 40x25 celle); nella soconda viene effettuata una chiamata diretta al KERNAL

Un metodo alternativo per ripulire la memoria video con ACME e' il comando
*=$0400
!fill 1000,$20

---------------------------------------------------------------------------------------------
!cpu 6502
!to "joy.prg",cbm

; per simulare il joystick in C64 Debugger premere CTRL+Y
; nella finestra C64 e premere i tasti freccia

JOY = $DC00

!macro stampa .carattere{
JSR $E50C
lda #.carattere
JSR $FFD2

}

* = $c000
; pulisce lo schermo e lo mette nero con carattere blu
lda #$00
sta $d020
sta $d021
tax
lda #$20
loop
sta $0400,x
sta $0500,x
sta $0600,x
sta $0700,x
dex
bne loop

ldx #$14 ; lo schermo testo di C64 e' 40x25 caratteri
ldy #$0c ; qui siamo piu' o meno al centro
+stampa 65

lda #$0 ; inizializza il valore della locazione 2 a zero
sta $02

start lda $02 ; viene usata la locazione di memoria 2 della pagina zero
; che non e' usata dal sistema operativa
cmp JOY ; in DC00 c'e' la porta del joystick 2
; a seconda della bitmask si capisce se e' stato
; cliccato verso l'alto,basso,destra,sinistra o fire
; bit 0 attivato = alto
; bit 1 attivato = basso
; bit 2 attivato = sinistra
; bit 3 attivato = destra
; bit 4 attivato = fire
; per esempio il valore 17 (10001b) indica che il joystickhelpsys
; e' in alto ed e' premuto il fire
beq start ; loop until the joystick register changes.

lda JOY ; salva lo stato del joystick nella locazione 2
sta $02

lda #000001 ; controlla se e'attivato il primo bit
bit JOY ;
bne cont1 ; se non e' attivato segue
+stampa 32
inx ; altrimenti incrementa X
+stampa 65 ; e sposta il cursore con il KERNAL

cont1 lda #000010 ; continua con gli altri bit
bit JOY ; joystick giu'
bne cont2 ;
+stampa 32
dex ;
+stampa 65 ;

cont2 lda #000100 ; joystick a sinistra
bit JOY ;
bne cont3 ;
+stampa 32
iny ; incrementa il registro Y
+stampa 65

cont3 lda #001000 ; joystick a destra
bit JOY ;
bne cont4 ;
+stampa 32
dey ;
+stampa 65

cont4 lda #010000 ; fire
bit JOY ;
bne start ; esce se e' stato premuto Fire altrimenti torna all'inizio
rts ; back to basic

martedì 10 luglio 2018

C64 Autostart Assembly

Un metodo per lanciare un codice Assembler su C64 senza usare un loader basic (e gli svariati DATA). Questo codice, a differenza della macro start_at_address vista in questo post, non lancia diretttamente il codice quando finito il caricamento ma non e' necessario digitare nessun comando SYS, basta il comando RUN

Il codice e' il seguente

*=$801
BASIC: !BYTE $0B,$08,$01,$00,$9E,$32,$30,$36,$31,$00,$00,$00

LDA........
altro codice assembler

il comando precedente si traduce come
1 SYS 2061

ma come si traduce?? I comandi BASIC vengono inseriti in memoria nel C64 come token. Il codice $9E costituisce il token del comando SYS. In seguito $32, $30,$36,$31 sono i valori esadecimali dei caratteri che corrisponde in ASCII CODE al numero 2061

I due byte precedente $01,$00 indicano il numero di riga (byte basso, byte alto). In questo caso il numero di riga e' 1. I primi due byte in assoluto sono il puntatore alla prossima riga BASIC nel solito ordine byte basso/byte alto ... questo caso il puntatore e' a $80D ovvero a dove inizia il codice assembler

il valore 2061 corrisponde all'esadecimale $80D. In pratica la riga in codice BASIC fa puntare l'esecuzione del programma al primo byte dopo la stringa di inizializzione ($801 (2049) e' la base del codice basic in C64 + 12 byte della lunghezza launcher, ovvero la stringa BASIC, e' uguale a 2061)

I tre zeri finali corrispondo a : il terz'ultimo zero indica il terminatore di una riga BASIC. Gli ultimi due zeri indicano la fine del programma BASIC.

Recensione Retro Game Dev di Derek Morris

In un momento di esaltazione mi sono comprato il libro Retro Game Dev di Derek Morris sperando che fosse un sunto organizzato di quanto presente nei vari blog e forum sparsi per internet sull'argomento

E' stata una grossa delusione (non costosa perche' fortunatamente Amazon ha accettato il reso)...12 euro per scoprire in 120 pagine che praticamente non ci sono spiegazioni ma viene tutto rimandato a file da scaricare con codice commentato ma in ogni caso difficile da seguire...tanto vale fare da soli

PMII 11 - C64 con televisore anni 70

Gioco International Soccer su cartuccia e joystick originale Commodore. Per me si torna indietro al 1984 perche' con questa esatta configurazione ho iniziato ad usare un calcolatore

PMII 10 - Acecad Digitizer D-Series

PMII 9 - Canon Palmtronic 8M

Calcolatrice trovata per casa in un cestino lungo strada mentre stavo buttando via della carta sporca. Non ho potuto fare a meno di adottarla...peraltro e' funzionante .... manca lo sportello batteria

PMII 8 - Gioco anni 80 con cartrigde

Vecchio gioco anni 80 che monta un 6502 (Modello e marca non identificato ma molto probabilmente era un clone)

PMII 7 - Scheda madre portatile Cyrix Cx486SLC2

Scheda presa da un portatile con una cpu Cyrix cx486SLC2 e il coprocessore Cyrix CX83S87-33-JP

PMII 6 - AMSTRAD Z80852

Scheda madre Amstrad Z80852 del 1988 che monta un processore Siemens SAB8086. Era alloggiata in Amstrad PC 1640 (un computer curioso perche' l'alimentatore era montato nel case del monitor)
Curiosamente Wikipedia riporta che il 1640 montava cpu AMD ma e' quasi sicuramente un errore ... perche' la scheda l'ho smontata io

PMII 5 - OTS Ecotron

Direttamente dall'etichetta sul retro "Dispositivo telefonico per sordomuti OTS ECOTRON Nuova CEA"

Non ho trovato molte altre informazioni ma sicuramente e' dotato di un modem/sintetizzatore vocale (??) con il posto per appoggiare la cornetta telefonica (qualcuno ha detto War Games???)

Non ho trovato altre informazioni ma probabilmente era un apparecchio destinato ad un centralino telefonico in cui l'operatore digitava i tasti per le operazioni a voce

PMII 4 - Toshiba T1200

Portatile del 1987 funzionate con HD integrato della classe 80C86

PMII 3 - Scheda di memoria ai noduli di ferrite

Esemplare piu' unico che raro nella mia collezione derivante da uno scambio. Una memoria di 4K ai noduli di ferrite derivante da una mitragliera francese del 1972 da 4K a 18 bit

Le memorie ai noduli di ferrite (presenti anche sullo Space Shuttle) erano importanti in ambito militare perche' non sono influenzate dallo shock elettromagnetico derivante dallo scoppio di una bomba atomica

PMII 2 - Scheda M24 Clone

Scheda madre di Olivetti M24. Ci sono un paio di cose curiose: la prima e' la patch manuale della scheda con un cavo azzurro non integrato sulla scheda madre. La seconda e' che la scheda non e' stata presa da un Olivetti M24 ma da un computer sotto diverso marchio costruito sotto licenza Olivetti (nello speficico un AT&T 6300)