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

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