NTP Server con GPS Seriale e Arduino YUN

Nel precedente post avevo utilizzato i dati derivati da un modulo GPS collegato via USB ad una Arduino YUN come fonte dati per un server NTP

Questa configurazione e' un po' costosa ed occupa la porta USB della YUN. Usando un modulo GPS con una seriale TTL con una connessiona a soli tre fili (VCC, GND e GPS-Tx collegato ad Arduino, il cavo GPS-Rx non e' necessaria perche' la comunicazione e' a senso unico) si puo' ottenere lo stesso risultato risparmiando un po'

Per prima cosa si deve configuare la YUN modificando il file /etc/inittab e commentando la terza riga (quella che inizia con ttyATH0...) e si riavvia il dispositivo

si collega poi il pin TX del GPS al pin D8 dell'Arduino e si carica lo sketch che semplicemente prende i dati dalla SoftSeriale e li spedisce sulla Serial1 (che e' quella di collegamento tra Linino ed Arduino)

-------------------------------------------------------
#include <SoftwareSerial.h>

SoftwareSerial mySerial(8, 3); // RX, TX

void setup() {
  delay(150000); //questo serve a non inviare dati sulla seriale in fase di boot altrimenti si blocca tutto
  Serial1.begin(115200);
  Serial.begin(115200);
  mySerial.begin(9600);
}

void loop() { 
  if (mySerial.available()) {
    char c = mySerial.read();
    Serial1.write(c);
    Serial.write(c);    
  }
}
---------------------------------------------------

A questo punto doveva essere tutto facile e si dovevano solo replicare i passi del precedente post...in realta', nonostante fosse possibile visualizzare il flusso seriale mediante minicom, il demone di gpsd non riusciva ad agganciarlo. Dopo varie prove ho messo il Serial1 a 115200 e installato stty con il comando

opkg update 

opkg install coreutils-stty
a questo punto ho forzato il riconoscimento della velocita' della seriale con stty

stty -F /dev/ttyATH0 ispeed 115200 && cat </dev/ttyXXX

e lanciato demonizzato gpsd

gpsd -D 5 -N -n /dev/ttyATH0 -F /var/run/gpsd.sock
a questo punto ha iniziato a funzionare cpgs

NTP Server con Ublox M8T e Arduino Yun

Avevo gia' fatto qualcosa di simile, ma in questo esempio mostrero' come usare una Arduino Yun ed un modulo Ublox M8T per creare un server NTP che utilizza il segnale GPS per avere l'informazione del tempo

Prima di tutto si deve collegare l'Ublox alla Yun mediante la porta USB. Se si effettua tale operazione da dmesg si vede che il dispositivo e' riconosciuto ma non viene creata la porta seriale corrispondente. Questo e' dovuto al fatto che Linino e' un sistema Linux ridotto all'osso e pochi moduli del kernel sono montati di default

Si deve quindi scaricare il pacchetto kmod.usb-acm mediante le seguenti istruzioni

opkg update
opkg install kmod-usb-serial kmod-usb-acm

a questo punto viene creata una porta seriale virtuale in /dev/ttyACM0

Si scarica e si installa quindi il demone gpsd

opkg update
opkg install gpsd gpsd-clients ntpdate

e si attiva mediante il comando

gpsd /dev/ttyACM0 -n -F /var/run/gpsd.sock
per verificare se il flusso dati proveniente dal GPS e' interpretato in modo corretto si puo' digitare

cgps -s

si installa quindi il server ntp
opkg update
opkg install ntpd ntp-utils

e si modifica il file di configurazione in /etc/ntp.conf aggiungendo queste linee

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

server 127.127.28.0 minpoll 4 maxpoll 4 

fudge 127.127.28.0 time1 0.0 refid GPS 

server 127.127.28.1 minpoll 4 maxpoll 4 prefer 

fudge 127.127.28.1 refid PPS
-----------------------------------------

e si lancia il servizio
/etc/init.d/sysntpd disable
/etc/init.d/ntpd enable
/etc/init.d/ntpd start
a questo punto digitando
ntpq -p
si vedra' apparire il GPS tra la sorgente delle fonti dati (e visto che sara' anche con quello di minor latenza) sara' il preferito. La Yun e' preconfigurata per usare il tempo UTC (come quello del GPS) e non ha di default configurate le timezone

Fixed point math e Mandelbrot

Un esempio di utilizzo della matematica a virgola fissa, un metodo di rappresentazione dei numeri reali con un numero prefissato di cifre decimali utilizzato in particolar modo per calcolatori privi di coprocessore matematico (per esempio il software Fractint usava questo tipo di approccio per il calcolo di frattali su processori 386 e 486 all'inizio degli anni 90)

Per effettuare un calcolo dell'insieme di Mandelbrot si puo' usare attualmente la libreria FIXEDPTC (Fixed Point Math Library for C)  (rispetto ad altre librerie, come FPMLib o LibFoixMath , e' possibile settare il proprio formato dati secondo le proprie necessita')

Visto che il calcolo e' tutto compreso per valori inferiori a 8 puo' essere utile, per massimizzare la precisione, usare una rappresentazione 4.28 (4 digit per la parte intera e 28 per la parte frazionaria) su un calcolatore a 32 bit. In questo modo il piu' piccolo numero calcolabile e' 0.00000000372529. Per la rappresentazione grafica e' stata usata la libreria PngWriter gia' usata qui
L'uso della libreria e' abbastanza autoesplicativo...l'unico aspetto un po' confuso e' che per effettuare dei confronti in un ciclo if...then si deve convertire il dato da formato a virgola fissa in float.

mand.c
------------------------------------------------------
#include <pngwriter.h>

#define FIXEDPT_WBITS 4
#define WIDTH 640
#define    HEIGHT 480

#include "fixedptc.h"

int main() {
int     j,k,i;
float    test;
fixedpt Re,Im,DRe,DIm;
fixedpt X,Y,DUE;
fixedpt XN,YN,YNN;
fixedpt    A,B;

pngwriter png(WIDTH,HEIGHT,0,"mandelbrot.png");

Re = fixedpt_rconst(-2.00390625); //finestra reale tra -2 e +0.5
Im = fixedpt_rconst(-1.205); //finestra immaginaria tra -1.2 e 1.2
DRe = fixedpt_rconst(0.00390625); //2.5/640
DIm = fixedpt_rconst(0.005); // 2.4/480
DUE = fixedpt_rconst(2.0);

A = Re;

for (j=0;j<WIDTH;j++)
    {
    A = fixedpt_add(A,DRe);
    B = Im;
    for (k=0;k<HEIGHT;k++)
    {
    B = fixedpt_add(B,DIm);

    X = fixedpt_rconst(0.0);
    Y = fixedpt_rconst(0.0);

    for (i=0;i<=255;i++)
        {
        XN=fixedpt_sub(fixedpt_mul(X,X),fixedpt_mul(Y,Y))+A; // (x*x) - (y*y) + A
        YN=fixedpt_mul(X,Y); // x*y
        YNN=fixedpt_mul(DUE,YN); // 2*x*y
        YN=YNN + B; // 2*x*y*+B
        test = fixedpt_tofloat(fixedpt_mul(XN,XN) + fixedpt_mul(YN,YN)); //(XN*XN)+(YN*YN)
        if (test > 4.0)
            {
            png.plot(j,k,1.0,1.0,1.0);
            break;
            }
        X = XN;
        Y = YN;
        }
    }
    }
png.close();

}
------------------------------------------------------

Per compilare il sorgente si puo' usare i seguenti comandi
------------------------------------------------------
rm mandelbrot.png
g++ mand.c -o mand  -I/usr/local/include  -L/usr/local/lib -lpng -lpngwriter
./mand
display mandelbrot.png
------------------------------------------------------

Ublox M8T e vegetazione

Visto che e' in previsione una installazione di un UBlox in un'area attualmente priva di vegetazione ma che sara' vegetata con l'arrivo della bella stagione ho voluto vedere se un prato puo' degradare il segnale GPS ricevuto. La seconda antenna di riferimento per il DGPS era invece posta in un'area asfaltata con una ottima visione del cielo

L'antenna e' nascosta dall'erba a sinistra del PC

Nonostante tutto il post-processing dei dati ha mostrato un fix FGPS molto stabile

Mandelbrot 13h (2)

Un po' di effetto dimagrante (da 240 a 224 bytes) del post precedente mettendoci anche un po' di colore (certo..la palette non e' bellissima)
Ho tolto anche la dipendenza dai registri a 32 bit che non era necessaria

----------------------------------------------------------------------
org 100h            ; serve solo per DOS per fare i file .COM
section .data
    a:    dq    -2.0     ; minimo reale della finestra
    b:    dq    -1.5     ; minimo immaginario della finestra
    bb:    dq    -1.5    ; asdasd
    da:    dq    0.0078125     ; incremento parte reale ((1.2-(-2))/320px delta_a
    db:    dq    0.015    ; incremento parte immaginaria ((1.5-1.5))/200px delta_b
    limite:    dq    4.0    ; condizione di fuga

section .text

global _start                   ;must be declared for using gcc

_start:


    ; inizializza il modo 13h 320x200x8bpp (256 colori) SOLO PER DOS CON VGA
    mov     al, 13h
    int     10h
    ; fa puntare direttamente alla memoria video SOLO PER DOS
    mov     ax, 0a000h   
    mov     es, ax

    mov     di,319 ; dimensione dell'asse reale in pixel sullo schermo

loop_reale:

    mov    dx,199  ; dimensione dell'asse immaginario in pixel sullo schermo

    ; calcola a = a + delta_a
    fstp    st0
    fld    qword     [a]    ; mette a in st0
    fld    qword    [da]    ; mette l'incremento di a in st1
    fadd    st0,st1        ; a+da
    fstp    qword    [a]    ; mette il risultato in a

loop_immaginario:
    ; calcola b = b + delta_b
    ;fstp    st0        ; resetta lo stack della FPU
    fld    qword     [b]    ; mette b in st0
    fld    qword    [db]    ; mette l'incremento di b in st1
    fadd    st0,st1        ; b+db
    fstp    qword     [b]    ; mette il risultato in b

    ; pulisce tutto lo stack del 387 (8 registri portati a zero)


    ;inizia la fase di calcolo
    fstp    st0
    fld    qword    [a]     ; mette a nello stack
    fld    qword    [b]     ; mette b nello stack

    push     cx        ; salva il registro cx
    mov     cx,255    ; in cx ci sara' il contatore dei cicli di iterazioni di calcolo. Si parte da 256

    fldZ            ; mette stack st3 = 0. Sara' utilizzato come parte reale z.r = 0
    fldZ            ; mette stack st2 = 0. Sara' utilizzato come parte immaginaria z.i = 0
    fldZ              ; mette stack st1 = 0. Sara' utilizzato come parte reale quadrata z.r^2 = 0
    fldZ            ; mette stack st0 = 0. Sara' utilizzato come parte immaginaria quadrata z.i^2 = 0

l1:                ; inizia il loop di calcolo piu' interno
    fsubp    st1,st0        ; sottrae z.i^2- e lo mette nello stack come st0.
    fadd    qword     [a]    ; aggiunge a ad st0
    fstp    st3        ; prende il valore di st3 con pop
    fmulp    st1,st0        ; moltiplica st0 ed st1 z.r*z.i
    fadd    st0,st0        ; moltiplica 2*st0 facendolo come una somma st0+st0
    fadd    qword    [b]    ; aggiunge ad st0 b ovvero 2*z.r+z.i+b

    fld    st1        ; mette st1 in st0 ovvero z.r
    fmul    st0,st0        ; quadrato di z.r
    fld    st1        ; mette st1 in st0 ovvero z.i
    fmul     st0,st0        ; quadrato di z.i
    fld    st1
    fadd    st0,st1        ; somma i due quadrati z.r^2+z.i^2
    fcomp    qword     [limite]; compara st0 con il limite di calcolo 4
    fstsw    ax        ; passa il valore di st0 al registro ax
    sahf            ; mette AH nelle flags
    jae    fine        ; se ax e' sopra il valore di 4 allora esci dal ciclo di calcolo
    dec    ecx        ; decrementa il contatore della iterazioni di calcolo
    jnz    l1        ; se ecx non e' zero continua il calcolo saltando alla label l1

fine:
    ffree    st5
    ffree    st4
    ffree    st3
    ffree    st2
    ffree    st1
    ffree     st0

    ; stampa il colore a seconda del valore di cx
    push    di
    push     bx
    push     dx
    mov     bx,dx     ; in dx c'e' la coordinata schermo immaginaria
    imul    bx,320     ; viene moltiplicata per 320
    add    bx,di    ; in cx c'e' la coordinata schermo reale
    mov    di,bx    ; ha calcolato la posizione in memoria
    mov    [es:di],cl
    pop     dx
    pop    bx
    pop    di

    pop cx


ritorna:
    ;controlla se siamo alla fine di un loop immaginario
    dec     dx
    cmp    dx,0
    jnz    loop_immaginario

    ; resetta la variabile immaginaria
    fld     qword    [bb]
    fstp    qword    [b]


    ;controlla se siamo alla fine di un loop reale
    dec    di
    cmp    di,0
    jnz    loop_reale


    ;esce dal programma
    ; aspetta la pressione di un tasto (SOLO DOS)
    xor     ah, ah
    int     16h

    ; Rimette in modalita' testuale (SOLO DOS)
    mov     ax, 0003h
    int     10h
    ret

Mandelbrot Mode 13h

Ed ora qualcosa di completamente inutile...Mandelbrot in modo 13h della VGA. Il codice di base e' quello del precedente post riadattato per la visualizzazione grafica a 320x200x256 colori

Visto che per questa visualizzazione si usa l'accesso diretto alla memoria video ed un formato di eseguibile sotto DOS si deve usare DosBox oppure FreeDos in macchina virtuale (non si puo' invece usare DosEmu perche' di fatto questo programma non emula il processore ma si appoggia sul sistema sottostante per cui ogni gestione diretta della memoria crea conflitto con il sottostante sistema operativo)

-------------------------------------------------------------------------
org 100h            ; serve solo per DOS per fare i file .COM
section .data
    a:    dq    -2.0     ; minimo reale della finestra
    b:    dq    -1.5     ; minimo immaginario della finestra
    bb:    dq    -1.5    ; asdasd
    da:    dq    0.0078125     ; incremento parte reale ((1.2-(-2))/320px delta_a
    db:    dq    0.015    ; incremento parte immaginaria ((1.5-1.5))/200px delta_b
    limite:    dq    4.0    ; condizione di fuga
    cicli:    dd    255     ; numero di cicli di iterazione per ogni punto

section .text

global _start                   ;serve a gcc

_start:

    ; inizializza il modo 13h 320x200x8bpp (256 colori) SOLO PER DOS CON VGA
    mov     al, 13h
    int     10h
    ; fa puntare direttamente alla memoria video SOLO PER DOS
    mov     ax, 0a000h  
    mov     es, ax

    mov     di,319 ; dimensione dell'asse reale in pixel sullo schermo

loop_reale:

    mov    dx,199  ; dimensione dell'asse immaginario in pixel sullo schermo

    ; calcola a = a + delta_a
    fstp    st0
    fld    qword     [a]    ; mette a in st0
    fld    qword    [da]    ; mette l'incremento di a in st1
    fadd    st0,st1        ; a+da
    fstp    qword    [a]    ; mette il risultato in a

loop_immaginario:
    ; calcola b = b + delta_b
    ;fstp    st0        ; resetta lo stack della FPU
    fld    qword     [b]    ; mette b in st0
    fld    qword    [db]    ; mette l'incremento di b in st1
    fadd    st0,st1        ; b+db
    fstp    qword     [b]    ; mette il risultato in b

   ;inizia la fase di calcolo
    fstp    st0
    fld    qword    [a]     ; mette a nello stack
    fld    qword    [b]     ; mette b nello stack

    push     ecx        ; salva il registro ecx
    mov     ecx,[cicli]    ; in ecx ci sara' il contatore dei cicli di iterazioni di calcolo. Si parte da 256

    fldZ            ; mette stack st3 = 0. Sara' utilizzato come parte reale z.r = 0
    fldZ            ; mette stack st2 = 0. Sara' utilizzato come parte immaginaria z.i = 0
    fldZ            ; mette stack st1 = 0. Sara' utilizzato come parte reale quadrata z.r^2 = 0
    fldZ            ; mette stack st0 = 0. Sara' utilizzato come parte immaginaria quadrata z.i^2 = 0

l1:                ; inizia il loop di calcolo piu' interno
    fsubp    st1,st0        ; sottrae z.i^2- e lo mette nello stack come st0.
    fadd    qword     [a]    ; aggiunge a ad st0
    fstp    st3        ; prende il valore di st3 con pop
    fmulp    st1,st0        ; moltiplica st0 ed st1 z.r*z.i
    fadd    st0,st0        ; moltiplica 2*st0 facendolo come una somma st0+st0
    fadd    qword    [b]    ; aggiunge ad st0 b ovvero 2*z.r+z.i+b

    fld    st1        ; mette st1 in st0 ovvero z.r
    fmul    st0,st0        ; quadrato di z.r
    fld    st1        ; mette st1 in st0 ovvero z.i
    fmul     st0,st0        ; quadrato di z.i
    fld    st1
    fadd    st0,st1        ; somma i due quadrati z.r^2+z.i^2
    fcomp    qword     [limite]; compara st0 con il limite di calcolo 4
    fstsw    ax        ; passa il valore di st0 al registro ax
    sahf            ; mette AH nelle flags
    jae    fine        ; se ax e' sopra il valore di 4 allora esci dal ciclo di calcolo
    dec    ecx        ; decrementa il contatore della iterazioni di calcolo
    jnz    l1        ; se ecx non e' zero continua il calcolo saltando alla label l1

fine:
    ffree    st5
    ffree    st4
    ffree    st3
    ffree    st2
    ffree    st1
    ffree     st0

    cmp ecx,0        ; controlla se si e' raggiunto il limite dei cicli di iterazione
    je putpixel           ; se e' zero stampa uno spazio

    pop ecx


ritorna:
    ;controlla se siamo alla fine di un loop immaginario
    dec     dx
    cmp    dx,0
    jnz    loop_immaginario

    ; resetta la variabile immaginaria
    fld     qword    [bb]
    fstp    qword    [b]


    ;controlla se siamo alla fine di un loop reale
    dec    di
    cmp    di,0
    jnz    loop_reale


    ;esce dal programma
    ; aspetta la pressione di un tasto (SOLO DOS)
    xor     ah, ah
    int     16h

    ; Rimette in modalita' testuale (SOLO DOS)
    mov     ax, 0003h
    int     10h
    ret

putpixel:        ; scrive un pixel direttamente sulla memoria VGA
    push    di
    push     bx
    push     dx
    mov     bx,dx     ; in dx c'e' la coordinata schermo immaginaria
    imul    bx,320     ; viene moltiplicata per 320
    add    bx,di    ; in cx c'e' la coordinata schermo reale
    mov    di,bx    ; ha calcolato la posizione in memoria
    mov    dl,7
    mov    [es:di],dl
    pop     dx
    pop    bx
    pop    di
    jmp    ritorna

-------------------------------------------------------------------------
il programma compilato con nasm (disponibile sia per Linux che per Dos) e' lungo 240 bytes

Per correggere gli errori non si puo' fare debug sotto Linux perche' ddd (ovviamente) non riconosce il formato .COM. Per questo motivo mi sono ricostruito un ambiente di sviluppo in Freedos in macchina virtuale sotto VMWare

Turbo Debugger in FreeDos

Visto che non e' banalissimo usare Freedos un po' di appunti su come installarlo su VMWare. Per prima cosa di monta la .iso del Cd di Freedos e si formatta il disco C:. Al termine l'installer richiede il riavvio del sistema ma ci si trova di fronte alla schermata sottostante perche' VMWare e' ripartito dal disco fisso dove non e' ancora stato installato il sistema

Si deve entrare nel Bios di VMware ed impostare l'ordine di avvio dei dispositivi...peccato che la schermata e' velocissima ed e' praticamente impossibile trovare l'attimo giusto per premere ESC all'avvio. La soluzione piu' semplice e' quella di editare il file in Documenti/My Virtual Machines/MS-DOS/MS_DOS.vmx ed aggiungere la riga 

bios.bootDelay = "5000"

per ritardare il boot di 5 secondi ed avere il tempo di premere ESC

Da qui in poi l'installazione e' banale...rimane il problema di installare il software in un sistema come il DOS che ha pochissima confidenza con le chiavette USB ed il TCP/IP.La soluzione che ho trovato piu' semplice e' stata quella di inserire tutto il software DOS che mi serviva (Volkov Commander, Nasm e Turbo Debugger) in una cartella, convertire la cartella in un file .iso con AnyToIso ed  inserire il file .iso del CD virtuale di VMWare.
Fatta partire la macchina virtuale, dal prompt di Dos, si digita (vedi questo link)

devload uide.sys /N3 /D:CDROM01

shsucdx /D:CDROM01

il Cdrom sara' su D: e si possono copiare il file su C:. I file copiati saranno tutti read-only per cui si deve usare il programma ATTRIB per togliere il flag

Mandelbrot Assembler su Linux in FPU x87 32 bit

Calcolare l'insieme di Mandelbrot in ASM e' stata per me una specie di ossessione agli inizi degli anni 90, quando i miei amici erano presi dalla creazione di demo 4K (una competizione tra programmatori per fare vedere cosa si riusciva a creare nel limite di un eseguibile da 4K)
Grazie all'aiuto di internet (il nucleo del codice di calcolo e' stato ripreso riadattandolo da questo link) sono riuscito nel mio scopo utilizzando codice x87 per i calcoli in virgola mobile ed il terminale per la visualizzazione (l'accesso diretto alla memoria video del modo 13h della VGA e' possibile solo sotto DOS)

Il codice e' piuttosto generale e permette di generare immagini di qualsiasi grandezza (basta agire sui registri di e dx) e con una finestra di visualizzazione qualsiasi (basta agire sui parametri a,b,bb,da e db) e con una profondita' di calcolo modificabile (variabile cicli)

Il codice e' totalmente commentato
Per calcolare il valore di da e di db si prende la dimensione della finestra per esempio -1.5 e +1.5, si somma (dimensione 3) e si divide per la dimensione in pixel dello schermo da quindi assume il valore di 3/80=0.0375


Esempio con finestra (-1.5,-2/1.5,2) 80x80 pixels
------------------------------------------------------
section .data
    a:        dq    -1.5     ; minimo reale della finestra
    b:        dq    -2.0     ; minimo immaginario della finestra
    bb:      dq    -2.0    ; minimo immaginario della finestra (serve per resettare la variabile)
    da:      dq    0.0375     ; incremento parte reale ((2-(-2))/80px delta_a
    db:      dq    0.05    ; incremento parte immaginaria ((1.5-1.5))/80px delta_b
    limite:  dq    4.0    ; condizione di fuga
    cicli:    dd    255     ; numero di cicli di iterazione per ogni punto
    stella:  db '*',0    ; stella (dentro insieme Mandelbrot)
    spazio: db ' ',0    ; spazio (fuori insiemeMandelbrot)
    acapo: db 0x0a,0   

section .text

global _start                   ;serve a gcc

_start:

    mov     di,80 ; dimensione dell'asse reale in pixel sullo schermo

loop_reale:

    mov    dx,80  ; dimensione dell'asse immaginario in pixel sullo schermo

    ; calcola a = a + delta_a
    fstp    st0
    fld    qword     [a]    ; mette a in st0
    fld    qword    [da]    ; mette l'incremento di a in st1
    fadd    st0,st1        ; a+da
    fstp    qword    [a]    ; mette il risultato in a

loop_immaginario:
    ; calcola b = b + delta_b
    fld    qword     [b]    ; mette b in st0
    fld    qword    [db]    ; mette l'incremento di b in st1
    fadd    st0,st1        ; b+db
    fstp    qword     [b]    ; mette il risultato in b

    ;inizia la fase di calcolo
    fstp    st0
    fld    qword    [a]     ; mette a nello stack
    fld    qword    [b]     ; mette b nello stack

    push     ecx        ; salva il registro ecx
    mov     ecx,[cicli]    ; in ecx ci sara' il contatore dei cicli di iterazioni di calcolo. Si parte da 255

    fldZ            ; mette stack st3 = 0. Sara' utilizzato come parte reale z.r = 0
    fldZ            ; mette stack st2 = 0. Sara' utilizzato come parte immaginaria z.i = 0
    fldZ            ; mette stack st1 = 0. Sara' utilizzato come parte reale quadrata z.r^2 = 0
    fldZ            ; mette stack st0 = 0. Sara' utilizzato come parte immaginaria quadrata z.i^2 = 0

l1:                ; inizia il loop di calcolo piu' interno
    fsubp    st1,st0        ; sottrae z.i^2- e lo mette nello stack come st0.
    fadd    qword     [a]    ; aggiunge a ad st0
    fstp    st3        ; prende il valore di st3 con pop
    fmulp    st1,st0        ; moltiplica st0 ed st1 z.r*z.i
    fadd    st0,st0        ; moltiplica 2*st0 facendolo come una somma st0+st0
    fadd    qword    [b]    ; aggiunge ad st0 b ovvero 2*z.r+z.i+b

    fld    st1        ; mette st1 in st0 ovvero z.r
    fmul    st0,st0        ; quadrato di z.r
    fld    st1        ; mette st1 in st0 ovvero z.i
    fmul     st0,st0        ; quadrato di z.i
    fld    st1
    fadd    st0,st1        ; somma i due quadrati z.r^2+z.i^2
    fcomp    qword     [limite]; compara st0 con il limite di calcolo 4
    fstsw    ax        ; passa il valore di st0 al registro ax
    sahf            ; mette AH nelle flags
    jae    fine        ; se ax e' sopra il valore di 4 allora esci dal ciclo di calcolo
    dec    ecx        ; decrementa il contatore della iterazioni di calcolo
    jnz    l1        ; se ecx non e' zero continua il calcolo saltando alla label l1

fine:
    ffree    st5 ; ripulisce lo stack della FPU
    ffree    st4
    ffree    st3
    ffree    st2
    ffree    st1
    ffree     st0

    ;fase di stampa sul terminale
    push edx
    mov eax,4            ; chiamata di sistema (sys_write)
    mov ebx,1            ; File descriptor 1 - standard output
    mov edx,1          ;
    cmp ecx,0        ; controlla se si e' raggiunto il limite dei cicli di iterazione
    je stampa_stella   ; se e' zero stampa uno spazio
    mov ecx,spazio     ; punta alla variabile spazio
    jmp salta
stampa_stella:
    mov ecx,stella       ; punta alla variabile stella
salta:   
    int 80h              ; Chiama il kernel
    pop edx

    pop ecx


ritorna:
    ;controlla se siamo alla fine di un loop immaginario
    dec     dx
    cmp    dx,0
    jnz    loop_immaginario

    ; resetta la variabile immaginaria ovvero la riporta al valore minimo
    fld     qword    [bb]
    fstp    qword    [b]


    ; stampa un ritorno a capo se siamo arrivati al margine della finestra
    mov eax,4            ; (sys_write)
    mov ebx,1            ; File descriptor 1 - standard output
    mov ecx,acapo        ;
    mov edx,1
    int 80h              ; Chiama il kernel


    ;controlla se siamo alla fine di un loop reale
    dec    di
    cmp    di,0
    jnz    loop_reale

    ; Ritorna al sistema operativo
    mov     eax,1
    mov    ebx,0
    int     80h
------------------------------------------------------

L'eseguibile compilato e privato del codice di debug e' lungo attorno ai 650 bytes (sicuramente si puo' fare di meglio sia come scrittura del codice che come compattezza dell'eseguibile)

E per  concludere il ricordo del primo insieme di Mandelbrot mai visualizzato (direttamente sul calcolatore di Benoit Mandelbrot)