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

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;
}

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

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.