Ho messo la gravità dentro un computer.
Un pianeta che orbita — e un Raspberry Pi che lo conta.
Non bisogna saper programmare per capire questa storia. Basta avere un po’ di curiosità e la voglia di immaginare cosa succede quando provi a spiegare a un computer come funziona l’universo. Quello che ne è uscito è qualcosa di piccolo, imperfetto e affascinante — come tutte le cose fatte in casa con le proprie mani.
La domanda di partenza
Tutto è cominciato con una domanda semplice: è possibile fare in modo che il computer capisca perché la Terra orbita attorno al Sole? Non una simulazione già pronta scaricata da internet, non un’app. Qualcosa scritto da zero, dove ogni singola cosa che succede sullo schermo è l’effetto diretto di regole fisiche scritte a mano.
La risposta, sorprendentemente, è sì. E ci vogliono meno righe di codice di quelle che potresti immaginare.
La fisica che sta dietro: una sola regola
Isaac Newton, nel 1687, scrisse una delle frasi più potenti della storia della scienza: ogni corpo nell’universo attrae ogni altro corpo con una forza che dipende dalle loro masse e dalla loro distanza. Più sono massicci, più si attraggono. Più sono lontani, meno si attraggono — e la distanza conta al quadrato, il che significa che raddoppiare la distanza riduce la forza di quattro volte, non di due.
Questa è la legge di gravitazione universale. È la stessa legge che tiene la Luna in orbita, che fa cadere una mela dall’albero, che mantiene i pianeti attorno al Sole da miliardi di anni. Ed è anche l’unica regola di cui ha bisogno la nostra simulazione.
Immagina di avere il Sole fermo al centro dello schermo. La Terra è a una certa distanza. Ad ogni istante il computer si chiede: quanta forza sta esercitando il Sole sulla Terra in questo momento? La calcola. Poi aggiorna la velocità della Terra di conseguenza. Poi sposta la Terra nella nuova posizione. Poi ricomincia. Mille volte al secondo. Il risultato è un’orbita.
Il problema del computer: il tempo non è continuo
C’è un piccolo problema filosofico da risolvere prima di iniziare. La fisica è continua: la Terra si muove senza interruzioni, la forza gravitazionale cambia istante per istante in modo fluido. Il computer, invece, lavora a passi discreti: fa un calcolo, poi il successivo, poi il successivo ancora. Non esiste il “tra un calcolo e l’altro”.
La soluzione è semplice e geniale allo stesso tempo: si divide il tempo in fettine microscopiche. Ogni fettina è così piccola che, durante quel brevissimo intervallo, si può ragionevolmente assumere che la forza sia costante. Si calcola il movimento per quella fettina, poi per la successiva, poi per la successiva ancora. Se le fettine sono abbastanza piccole, il risultato è indistinguibile dal moto continuo reale.
Questo approccio si chiama integrazione numerica ed è lo stesso usato — in versioni molto più sofisticate — dai simulatori spaziali della NASA per calcolare le traiettorie delle sonde interplanetarie.
Cosa si vede sullo schermo
La simulazione si apre nel browser — sì, nel browser, come una pagina web, perché la libreria grafica usata (VPython) funziona così. Sullo sfondo nero dello spazio appare un sole giallo al centro. Una sfera blu — la Terra — parte da una posizione laterale e inizia a muoversi. Lascia una scia dietro di sé. Nel giro di pochi secondi si vede la prima orbita completarsi.
Nella versione attuale ci sono due pianeti: la Terra e Marte. Orbite diverse, velocità diverse, scie di colori diversi che si intrecciano nello spazio 3D. Si può ruotare la scena trascinando il mouse, fare zoom con la rotella, mettere in pausa, resettare le orbite se un pianeta prende una traiettoria strana.
Sotto la scena ci sono dei controlli: uno slider che regola la velocità della simulazione, dei pulsanti di reset, dei numeri che si aggiornano in tempo reale mostrando quante orbite ha completato ogni pianeta e a che distanza si trova dal Sole in questo momento.
La velocità iniziale: il trucco per non far cadere il pianeta
Una delle cose più belle da capire è perché i pianeti non cadono sul Sole. La gravità li attrae costantemente — allora perché non ci precipitano dentro?
La risposta è la velocità laterale. Un pianeta che si muove abbastanza velocemente “manca” continuamente il Sole: cade verso di lui, ma intanto si è già spostato di lato abbastanza da non centrarlo. Il risultato è un’orbita. È esattamente come lanciare una palla in modo così forte che la curvatura della sua traiettoria segue la curvatura della Terra — non tocca mai il suolo perché il suolo si incurva altrettanto velocemente.
Nella simulazione, la velocità iniziale giusta si calcola con una formula semplice che dipende solo dalla massa del Sole e dalla distanza del pianeta. Sbagliare questa velocità significa vedere il pianeta spiralare verso il Sole oppure schizzare via nello spazio. La prima versione del codice aveva questo problema — e il pulsante “Resetta orbita (usa questo se il pianeta scappa via!)” era l’unica soluzione.
Se si aumenta troppo la velocità della simulazione, le fettine di tempo diventano troppo grandi e i calcoli perdono precisione. Il pianeta inizia a seguire un’orbita sempre più allargata finché non sfugge completamente all’attrazione del Sole. È un errore del metodo di calcolo, non della fisica. La versione attuale lo riconosce automaticamente e riporta il pianeta all’orbita corretta senza intervento umano.
Il Raspberry Pi che conta i giri
Fin qui è già tutto abbastanza curioso. Ma il dettaglio che rende questo progetto diverso da un semplice esercizio di programmazione è quello che succede ogni volta che la Terra completa un’orbita.
Il computer lo rileva — controlla se il pianeta ha attraversato un certo piano dell’orbita — e in quel momento manda un messaggio via rete a un Raspberry Pi. Un piccolo computer grande quanto un mazzo di carte, collegato allo stesso router di casa, che stava in silenzio ad aspettare.
Il messaggio è semplice ma strutturato: dice quale pianeta ha completato l’orbita, quale numero di giro è e quanto tempo simulato è trascorso. Il Raspberry Pi lo riceve, lo stampa, lo salva su un file di log. È una comunicazione vera, via rete, tra due macchine fisiche reali. La simulazione sul PC e il Raspberry Pi parlano.
Non serve un supercomputer per fare cose che sembrano complesse. Un PC di casa e un Raspberry Pi da 80 euro riescono a simulare la gravità newtoniana e a comunicare via rete in tempo reale. La fisica degli stessi principi che tengono i pianeti in orbita è accessibile a chiunque abbia un computer e qualche ora di curiosità.
Dove può arrivare questo progetto
Il simulatore che esiste adesso è un punto di partenza. Le direzioni di crescita sono molte e non tutte richiedono di saper programmare in modo avanzato.
Più pianeti
Aggiungere Giove, Saturno, Venere è semplice: basta inserire le loro masse e distanze reali. Con Giove in scena, si potrebbe osservare come la sua enorme massa perturba le orbite degli altri pianeti — esattamente come succede nel sistema solare reale.
Un display fisico sul Raspberry Pi
Il Pi potrebbe collegare un piccolo schermo che mostra in tempo reale il numero di orbite completate, il tempo simulato, la distanza dei pianeti. Un cruscotto fisico per la simulazione virtuale.
Il collegamento con il telescopio
Questo è il salto più ambizioso — e anche il più affascinante. Il Raspberry Pi 5 che controlla il telescopio EXOS-2 usa un protocollo standard chiamato INDI per muovere la montatura. In linea di principio, la simulazione potrebbe calcolare dove si trova Giove questa notte, l’utente clicca sul pianeta nello schermo 3D, e il telescopio si muove verso quella direzione. Il virtuale che controlla il reale. Il software che punta l’hardware verso il cielo.
Non è ancora stato costruito — ma tutti i pezzi esistono. È un progetto per le prossime sessioni.
I limiti onesti: cosa questa simulazione non può fare
Un simulatore scritto a casa con un PC normale ha limiti reali. Vale la pena nominarli, non per sminuire il progetto ma perché capire i limiti è parte della comprensione.
- Non è precisa come quella della NASA. Il metodo di calcolo usato accumula piccoli errori nel tempo. Su simulazioni molto lunghe, le orbite si deformano lentamente. I simulatori professionali usano metodi matematici molto più sofisticati per evitarlo.
- Non usa unità reali. Le distanze e le masse nella simulazione sono numeri comodi per la visualizzazione, non i valori reali in chilometri e chilogrammi. Per simulare il sistema solare con proporzioni esatte servirebbe una scala molto diversa.
- Non include la relatività generale. Per i pianeti del sistema solare la fisica newtoniana è più che sufficiente — ma per i buchi neri, per le onde gravitazionali, per Mercurio vicino al Sole, ci vorrebbero le equazioni di Einstein.
- Con molti pianeti rallenta. Il PC di casa non è infinitamente veloce. Con decine di corpi il calcolo diventa lento. Per simulare migliaia di asteroidi servirebbero ottimizzazioni più serie.
Questi limiti esistono anche nei simulatori che costano milioni di euro — semplicemente sono stati spinti molto più in là. Il principio di base è lo stesso.
Come provarlo: istruzioni per chi vuole partire
Installa Python. Se non ce l’hai già, scaricalo da python.org. È gratuito, gira su Windows, Mac e Linux. La versione 3.10 o superiore va benissimo.
Installa VPython. Apri il terminale (su Windows: cerca “cmd” o “PowerShell”) e scrivi: pip install vpython. Premi invio e aspetta. Scarica automaticamente tutto il necessario.
Scarica il codice. Trovi il file del simulatore in fondo a questo articolo. Salvalo in una cartella sul desktop.
Apri il file. Se non hai un Raspberry Pi, apri il file con un editor di testo e cerca la riga INVIO_ABILITATO: cambia il valore da True a False. Questo disabilita la comunicazione di rete e la simulazione gira in autonomia.
Avvia. Dal terminale, vai nella cartella dove hai salvato il file e scrivi: python universo_3d_v2.py. Si apre automaticamente il browser con la simulazione.
VPython usa il browser come schermo 3D. Se si apre una pagina con un campo vuoto e dopo qualche secondo non appare la simulazione, prova a ricaricare la pagina. Su alcuni sistemi serve qualche secondo di avvio del server locale prima che la scena sia pronta.
Cosa si può imparare guardando girare un pianeta
C’è una cosa curiosa che succede quando passi un po’ di tempo davanti a questa simulazione. Inizi a vedere cose che prima sapevi solo in astratto.
Vedi che Marte è più lento della Terra — non perché qualcuno te lo ha detto, ma perché la scia di Marte avanza più lentamente di quella della Terra davanti ai tuoi occhi. Capisci visceralmente perché un anno su Marte dura quasi due anni terrestri: non sono le orbite più lunghe, ma anche le velocità più basse.
Se aumenti la massa del Sole con lo slider, vedi le orbite stringersi. Se la diminuisci, i pianeti si allontanano. Se dai a un pianeta troppa velocità iniziale, lo vedi sfuggire e non tornare. Sono le stesse cose che i libri di fisica descrivono con formule — ma qui le guardi succedere.
E c’è una soddisfazione strana e difficile da spiegare nel sapere che quelle orbite non vengono da un database, non sono un’animazione pre-registrata. Sono il risultato di una sola equazione applicata migliaia di volte al secondo. La gravità che funziona, dentro il computer.
Non serve saper programmare per iniziare
Il codice è già scritto. Basta installare Python, scaricare il file e avviarlo. La simulazione gira, i pianeti orbitano, e se hai un Raspberry Pi in un cassetto puoi collegarlo e vederlo ricevere i messaggi in tempo reale.
Se poi la curiosità porta a voler capire come funziona il codice — a cambiare qualcosa, ad aggiungere un pianeta, a vedere cosa succede se la gravità scalasse con il cubo della distanza invece del quadrato — l’articolo tecnico completo è disponibile con tutto il codice commentato e spiegato passo per passo.
L’universo è simulabile. E costa meno di un oculare.
Nessun commento:
Posta un commento