cronaca di un fallimento.....
Lunedi' 9 maggio nel pomeriggio Mercurio era in transito davanti al Sole ed avevo letto che non era possibile vederlo ad occhio nudo (previa protezione) ma era possibile con binocolo o con piccoli telescopi
Fortunatamente le nuvole per le 13 erano scomparse ed ho provato se riuscivo ad osservare il transito. L'immagine, peraltro abbastanza sgranata, sottostante rende l'idea di cio' stavo (non osservando)
Certo la mia attrezzatura era un po' (troppo artigianale)..un binocolo da campagna con un oculare oscurato ed un altro a cui erano stati messi due filtri da saldatore (una non era sufficiente) in entrata (i filtri devono essere messi in entrata allo strumento ottico...non tra lo strumento e l'occhio)
Deluso mi sono messo a guardare il live streaming della Nasa...da notare il confronto tra il piccolo cerchietto nero (Mercurio) e la curvatura del Sole
Per rendere l'idea ancora meglio delle differenza di dimensioni angolari questo e' tutto il disco solare con sovraimpresso il disco di Mercurio
Non si vede ??? E' il puntino nero poco al di sotto dell'equatore circa sulla meta' verticale del disco solare
Dire che era possibile vederlo con un binocolo era diciamo di un estremo ottimismo...
mercoledì 11 maggio 2016
martedì 10 maggio 2016
Arduino YUN e Centos 7
In modo un po' curioso Centos 7 non riesce a risolvere l'indirizzo arduino.local (default di Yun) usando Avahi/Bonjour
Dopo un po' di tentativi, in modo molto pragamatico, ho preferito effettuare un ping sweep con nmap per trovare l'indirizzo ip della Yun tramite
nmap -sP 192.168.43.1/24
(di solito uso l'hotspot di Android come access point il cui DHCP stranamente non distribuisce gli ip in modo sequenziale, per esempio il telefono e' 192.168.43.1, Centos aveva preso 192.168.43.4 mentre la Yun l'ho trovata su 192.168.43.174)
Un altro piccolo dettaglio: tentando di aprire minicom dall'interno di una sessione SSH compare l'errore
Cannot find termcap entry for 'xterm-256color'
TERM=xterm screen
Dopo un po' di tentativi, in modo molto pragamatico, ho preferito effettuare un ping sweep con nmap per trovare l'indirizzo ip della Yun tramite
nmap -sP 192.168.43.1/24
(di solito uso l'hotspot di Android come access point il cui DHCP stranamente non distribuisce gli ip in modo sequenziale, per esempio il telefono e' 192.168.43.1, Centos aveva preso 192.168.43.4 mentre la Yun l'ho trovata su 192.168.43.174)
Un altro piccolo dettaglio: tentando di aprire minicom dall'interno di una sessione SSH compare l'errore
che si risolve digitando
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);
}
}
---------------------------------------------------
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 update
opkg install coreutils-stty
a questo punto ho forzato il riconoscimento della velocita' della seriale con stty
a questo punto ho forzato il riconoscimento della velocita' della seriale con stty
venerdì 6 maggio 2016
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
opkg update
opkg install gpsd gpsd-clients ntpdate
per verificare se il flusso dati proveniente dal GPS e' interpretato in modo corretto si puo' digitare
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.sockper verificare se il flusso dati proveniente dal GPS e' interpretato in modo corretto si puo' digitare
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
/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
martedì 3 maggio 2016
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
------------------------------------------------------
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
------------------------------------------------------
venerdì 29 aprile 2016
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
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
Iscriviti a:
Post (Atom)
Physics informed neural network Fukuzono
Visto che puro ML non funziona per le serie tempo di cui mi sto occupando ed le regressioni basate su formule analitiche mostrano dei limiti...

-
In questo post viene indicato come creare uno scatterplot dinamico basato da dati ripresi da un file csv (nel dettaglio il file csv e' c...
-
La scheda ESP32-2432S028R monta un Esp Dev Module con uno schermo TFT a driver ILI9341 di 320x240 pixels 16 bit colore.Il sito di riferiment...
-
Questo post e' a seguito di quanto gia' visto nella precedente prova Lo scopo e' sempre il solito: creare un sistema che permet...