PMII 22 - IBook G3 Blueberry

Modello boxato e completamente funzionante

Eclisse di Luna

Luna Rossa...brutto presentimento

Mandelbrot su C64 in GPascal in matematica intera

Sempre per la serie "Cosa mi sono perso negli anni 80" ho cercato se esistevano compilatori Pascal per il C64 (compilatori veri...non cross-compilatori)....io ho fatto il mio primo ed unico corso di programmazione nel 1987 su TurboPascal 5.0 su un Olivetti M24 ed usavo solo Basic su C64

Con mia grande sorpresa ho trovato diversi compilatori con caratteristiche peraltro differenti

Pascal 64 : non sono riuscito ad usarlo su VICE. Si tratta comunque di un compilatore evoluto con linker esterno. Gestisce la alta risoluzione grafica ed ha il tipo dati real. Un po' macchinoso da usare perche' si deve scrivere il file in Pascal come se si stesse editando in Basic (con i numeri di linea compresi)...si salva il file, si compila, si linka e si lancia...non proprio comodo

Oxford Pascal

GPascal : ho trovato molto comodo ed intuitivo l'editor...in 10 minuti gia' gestivo l'editing con i tasti fondamentali. Si scrive nell'editor, si compila (in PCode), si lancia ed in caso di problemi RunStop/Restore e si torna all'editor. Molto comodo. Non sono riuscito a capire come funziona il debug ed il trace. Molto intuitivo ha pero' il limite di avere solo il tipo dati numerico Integer che ha peraltro dei limiti curioso (. Si trova sia il manuale che i dischi a questo indirizzo (che dovrebbe corrispondere al sito dello sviluppatore originale)

Per mettere la prova GPascal ho provato a scrivere un programma per generare l'insieme di Mandelbrot. L'assenza di un tipo dati real mi ha costretto ad usare routine di calcolo in matematica intera...inoltre ho dovuto mantenere il moltiplicatore a 256 perche' se aumentavo la precisione di calcolo sforavo il limite degli interi che devono essere compresi tra -8388608 e + 8388607.
C'e' inoltre da segnalare che il compilatore permette di disattivare l'output video in modo da velocizzare i calcoli (con il comando graphics(6,0)

QNap T-228 WiFi

Per avere uno storage casalingo il QNap T-228 va piu' che bene....pero' volevo avere una connessione WiFI.

Asus USB-AC51 connessa nella porta USB posteriore del QNap

Frugando su Internet sembrava possibile con una scheda WiFi Usb Asus USB-AC51 aggiungere la rete senza fili....un paio di considerazioni...il sistema funziona ma e' abbastanza instabile. Quasi mai la AC51 viene montata al boot del dispositivo..bisogna aspettare il boot completo, rimuovere e reinserire il dongle per veder accendere il led blu.  Inoltre il dongle ha una antenna ovviamente di ridotte dimensioni e se ci allontana anche di poco dall'access point si perde la connessione

Blitz Compiler

Tutto cio' che mi sono perso negli anni 80...questo per esempio Blitz , un compilatore PCode per C64 che velocizza il codice Basic

Per esempio un programma per la ricerca dei numeri primi minori di 250 impiega circo 80 secondi per essere completato con l'interprete BASIC standard mentre circa 51 quando viene eseguito mediante Blitz

L'operazione peraltro e' semplice: si scrive un programma in Basic, lo si testa. lo si salva sul disco e poi lo si converte con Blitz

FIxed point math

Questo argomento a cui volevo dedicare un po' di tempo e  finalmente ho trovato degli esempi semplici  come ad esempio https://spin.atomicobject.com/2012/03/15/simple-fixed-point-math/

La logica di base e' semplice..si deve descrivere un numero a virgola mobile con un numero intero e per farlo lo si moltiplica per un valore fisso (una potenza di 2 nel caso di uso di calcolatore) ed eliminando la parte oltre la virgola.

Fixed = round(float * scale_fact)

Per scale_fact si usando potenze di due perche' e' semplice con lo shift dei byte ottenere il valore desiderato (1<< 4 = 16, 4 shift a sinistra per esempio)

Le operazioni di somma e sottrazione non sono modificate
La moltiplicazione invece diventa

r = (x * y)/(1<<scale_fact)

mentre la divisione

r=(x*(1<<scale_fact))/y

Tutto cio' velocizza i calcoli ma introduce necessariamente una approssimazione (in base al fattore di scala)

Proviamo a fare un esempio concreto
x = 3.141592655
y = 2
scale_fact = 16 = 65536

x1 = pi*65536 = 205321.92 = 205887
y1 = 2*65536 = 131072

r =  x1*y1 = 205887*131072 / 655536 = 411744

(si vede chiaramente che, dovendo applicare questo metodo ad un calcolatore, durante l'operazione si deve prevedere una variabile di tipo superiore al risultato....cerco di spiegarmi meglio...anche se gli operando sono entrambi byte ed il risultato e' un byte durante il calcolo e' necessario l'uso di una word)

riconvertendo il tutto
r = 411744/65536 = 6.2831726 (il valore dovrebbe essere 6.2831853...)

passando ad uno scale_fact = 8 (256)

x1 = pi*256 = 804
y1 = 2*256 = 512
r = 2526*512/256 = 1608

r = 1608/256 =6.28125 (il valore dovrebbe essere 6.2831853...)

passando ad uno scale_factr = 4 si ha un valore di x*y=6.25

in sintesi l'ordine dell' errore e'
16 bit : E-6
8 bit : E-4
4 bit  :  E-3

Moltiplicazione Assembly per C64

Il set di opcode del 6510 (processore del C64) non comprende in modo nativo l'operazione di moltiplicazione e divisione. Su codebase64 sono disponibili algoritmi per il calcolo e' ho provato ad usare quello piu' semplice (8 bit * 8 bit = 8 bit) usando sia la sintassi di Acme che di KickAss (anche come promemoria)
Il risultato viene salvato nell'accumulatore e quindi spostato in una variabile

KickAss
--------------
*=$c000

//sys 49152



lda #$00
  beq enterLoop

doAdd:
  clc
  adc num1

loop:
  asl num1
enterLoop: 
  lsr num2
  bcs doAdd
  bne loop

end:
sta num3
rts

num1: .byte 7
num2: .byte 3
num3: .byte 0

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


Acme
--------------
; Moltiplicazione 8bit*8bit=8bit
!source "./stdlib/stdlib.a"
!to "fixed.prg", cbm
!sl "fixed.map"
!cpu 6510
!ct pet


*=$c000

;sys 49152



lda #$00
  beq enterLoop

doAdd:
  clc
  adc num1

loop:
  asl num1
enterLoop: 
  lsr num2
  bcs doAdd
  bne loop

end:
sta num3
rts

num1: !by 7
num2: !by 3
num3: !by 0