Nuova sezione libri disponibile!

Simuliamo il moto parabolico in Python e Spyder

Ludovico Russo

lettura in 5 minuti

Eccomi qui con un brevissimo tutorial su come possiamo utilizzare Spyder per fare delle semplici simulazioni di fisica meccanica.

Come primo esperimento ho scelto di lavorare sul moto parabolico, classico problema di fisica del liceo che voglio provare a risolvere e simulare in Python utilizzando il tool Spyder.

finestra di Spyder

Scopo del tutorial

Quello che voglio fare, quindi, è scrivere un semplice e veloce programmino che permette di simulare il moto parabolico 2D, in particolare permettendo di

  • calcolare gittata e tempo di volo;
  • disegnare il grafico della traiettoria.

Un po' di teoria

Si definisce moto parabolico il moto bidimensionale di un corpo soggetto alla forza di gravità che percorre una traiettoria parabolica.

Se facciamo l'ipotesi che l'asse XX sia quello orizzontale e l'asse YY quello verticale e che l'accelerazione di gravità agisca verso il basso, quindi nel verso negativo rispetto all'asse YY

Il moto parabolico è la composizione bidimensionale di due moti distinti:

  • Un moto lineare uniforme x(t)=vx‚čÖtx(t) = v_x\cdot t lungo l'asse orizzontale XX
  • Un moto accelerato uniforme y(t)=h0+vy‚čÖt‚ąí12gt2y(t) = h_0 + v_y\cdot t - \frac{1}{2}gt^2 lungo l'asse verticale YY

In forma vettoriale, scriveremo

p(t)=(x(t)y(t))=(vx‚čÖth0+vy‚čÖt‚ąí12gt2)p(t) = \begin{pmatrix}x(t) \\ y(t)\end{pmatrix} = \begin{pmatrix} v_x\cdot t \\ h_0 + v_y\cdot t - \frac{1}{2}gt^2\end{pmatrix}

Dove gg è l'accelerazione di gravità, h0h_0 è l'altezza iniziale a cui viene lanciato il grave e vxv_x e vyv_y sono le componenti della velocità iniziale lungo i due assi XX e YY.

v0=(vxvy)v_0 = \begin{pmatrix}v_x \\ v_y\end{pmatrix}

Solitamente si considera t0=0t_0=0 come istante di partenza e x0=0x_0=0 come posizione di partenza lungo l'asse xx.

Si noti che il moto parabolico termina quando si ha y=0y = 0, si può quindi calcolare l'istante di tempo tft_f in cui il grave tocca terra ponendo

y(tf)=0‚Üíh0+vy‚čÖtf‚ąí12gtf2=0y(t_f) = 0 \rightarrow h_0 + v_y\cdot t_f - \frac{1}{2}g t_f ^2 = 0

che si risolve, in tft_f, ottenendo

tf=vy+vy2+2gh0gt_f=\frac{v_y+\sqrt{v_y^2+2gh_0}}{g}

Una volta calcolato tft_f possiamo calcolare la posizione xf=x(tf)x_f = x(t_f) che corrisponde al punto sul terreno in cui il grave tocca terra:

xf=vx‚čÖtf=vxvy+vy2+2gh0gx_f = v_x\cdot t_f = v_x\frac{v_y+\sqrt{v_y^2+2gh_0}}{g}

Non mi voglio addentrare su considerazioni fisiche e meccaniche e su semplificazioni della formula trovata, che si possono fare in casi particolari per cui h0=0h_0=0. Le soluzioni nella forma che abbiamo scritto fino ad ora bastano per poter risolvere il problema che ci siamo posti.

Simulazione in Python e Spyder

Una volta scaricato e installato Spyder ci troveremo davanti ad una finestra simile a questa.

finestra di Spyder

Nella finestra indicata come Editor (a me √® mostrata sulla destra), possiamo andare ad implementare il codice che poi verr√† eseguito da python. Sulla finistra indicata come Console potremo interagine utilizzando la console dinamica iPython. Per il momento, limitiamoci ad utilizzare l'editor di testo per rendere il programma pi√Ļ leggibile.

Importiamo pyLab

Per prima cosa, √® importante importare tutti gli elementi di pyLab. pyLab √® una suit python che include utilissimi moduli per l'analisi dei dati, come funzioni e costati matematiche (ad esempio sin o la costante ŌÄ\pi indicata con pi) o la libreria per plottare plot.

from pylab import *

A questo punto, possiamo definire alcune variabili e costanti che useremo nel codice. Prima di tutto, è importante definire l'accelerazione di gravità

Definiamo variabili e costanti

g = 9.81        #m/s**2

e i valori numerici di velocità e altenzza iniziale.

v0 = 10.        #m/s
alpha = pi/3    #radianti
h0 = 10.        #m

Preferisco indicare la velocit√† iniziale utilizzando il suo modulo v0v_0 e l'angolo di inclinazione őĪ\alpha, da cui possiamo calcolare le componenti vxv_x e vyv_y che useremo nel codice

vx = v0*cos(alpha)
vy = v0*sin(alpha)

Calcoliamo tempo di volo e gittata

A questo punto, possiamo calcolare il tempo tft_f e la posizione xfx_f finali del moto

tf = (vy + sqrt(vy**2+2*g*h0))/g
xf = vx*tf

Simulazione

A questo punto, possiamo scrivere il codice per la simulazione ed il disegno. Notiamo che non ha senso far prolungare la simulazione oltre il tempo tft_f. Per questo motivo, simuleremo solo nell'intervallo t‚ąą(0,tf)t \in (0, t_f).

Per farlo, generiamo un array di campioni di tempo in questo intervallo ad un passo predefinito e piccolo, ad esempio őĒt=0.01\Delta t = 0.01 con il comando arange

t = arange(0,tf, 0.01)

Adesso possiamo calcolare i valori di x(t)x(t) e y(t)y(t) per ogni tempo nell'array definito implementando semplicemente le equazioni del moto

xt = vx*t
yt = h0+vy*t-0.5*g*t**2

Si noti che Python sa che t e un array, e quindi genera come risultato degli array contenenti i valori delle equazioni ad ogni elemento di t. Comodo, no?

A questo punto, possiamo finalmente plottare (dall'inglese plot, cioè disegnare su un grafico) i due array.

plot(xt,yt)

Codice completo

Qui sotto trovate il codice completo appena implementato

# -*- coding: utf-8 -*-
"""
Spyder Editor

This is a temporary script file.
"""

from pylab import *

g = 9.81        #m/s**2

v0 = 10.        #m/s
alpha = pi/3    #radianti
h0 = 10.        #m

vx = v0*cos(alpha)
vy = v0*sin(alpha)

tf = (vy + sqrt(vy**2+2*g*h0))/g
xf = vx*tf

t = arange(0,tf, 0.01)
xt = vx*t
yt = h0+vy*t-0.5*g*t**2

plot(xt,yt)

Lanciamo il programma

Una volta implementato il codice, possiamo lanciare il programma premento sulla freccina verde in alto all'editor Spyder. Una volta fatto, se non ci sono errori, vedremo apparire il grafico della simulazione sulla console del nostro programma.

lanciamo il programma in Spyder

Conclusioni

Come vedete, in pochissime linee di codice siamo riusciti a risolvere in moto automatico un classico problema di fisica meccanica di base. Essendo tutto calcolato dal programma, possiamo anche fare esperimenti cambiando l'angolo e il modulo della velocità iniziale e/o l'altezza h0h_0.

Buona sperimentazione a tutti!

Ringraziamenti

Alla stesura di questo documento hanno partecipato:

  • Prof. Basilio Bona

Ti è piaciuto questo post?

Registrati alla newsletter per rimanere sempre aggiornato!

Ci tengo alla tua privacy. Leggi di pi√Ļ sulla mia Privacy Policy.

Ti potrebbe anche interessare

HB Cloud Tutorial #1 - Uso dei Led
Iniziamo ad utilizzare la piattaforma di Cloud Robotics
HB Cloud Tutorial #2 - Uso dei Bottoni
Rieccomi con il secondo tutorial legato all'uso dei bottoni per il robot **DotBot-ROS**. In questo tutorial, vedremo come configurare ed utilizzare in Python un bottone attaccato ad un pin GPIO del Raspberry Pi 3.
HB Cloud Tutorial #3 - I Motori
I Motori sono una delle parti essenziali dei robot. In questo tutorial, vederemo come è possibile in modo semplice ed intuitivo implementare un programma in Python che controlla i motori in base a comandi inviati via Wifi al Robot.
Inviare Goals alla Navigation Stack - versione nodo ROS Python
Inviare un goal all ROS navigation stack utilizzando un nodo Python
Controllare siBOT dalla piattaforma HBR
Come controllare il manipolatore siBOT utilizzando la piattaforma HBR
Sviluppare un rilevatore di fiamma con la visione artificiale
Sviluppare un rilevatore di fiamma con la visione artificiale
Scriviamo un Blog in Python e Flask
Tutorial su come implementare, a partire da zero, un blog personale utilizzando Python e Flask! Prima parte!
Un laboratorio di Fisica con Arduino e Python
Primi esperimenti con Arduino e Python per realizzare un semplice laboratorio di fisica sfruttando la potenza di Python e la versatilità di Arduino
Canopy: una Pythonica alternativa a Matlab
Presento questo interessante tool python che può essere considerato una buona alternativa a Matlab per l'analisi dei dati!
Spyder, un'altra alternativa in Python a Matlab
Una velocissima prova del tool interattivo Spyder per l'analisi scientifica in Python
Python + Arduino = Nanpy
Programmare Arduino in Python con Nanpy
Utilizzo di Nanpy con il sensore di temperatura/umidità della famiglia DHT
Come utilizzare Nanpy col sensore DHT di temperatura e Umidità
Breve Introduzione all'utilizzo di Spyder per il Plot dei dati a livello scientifico
Una brevissima guida che mostra come utilizzare Spyder per il plot dei dati a livello scientifico
Accendere led con Arduino e Telegram
Un bot telegram in grado di controllare Arduino realizzato da 3 ragazzi del Liceo Stampacchia
Implementiamo un bot Telegram con Python
Una semplice guida per iniziare a muovere i primi passi nello sviluppo di chatbot Telegram con Python
Pillole di Python: pyscreenshot
Una semplice tutorial che mostra il funzionamento della libreria pyscreenshot
Python Decorators
Introduzione ai decoratori in Python
TDD con Flask e PyTest per lo sviluppo di API REST. Parte 1
Tutorial su come usare il Test Driver Development (TDD) con Flask e PyTest per sviluppare delle semplici API REST
Implementiamo un bot Telegram con Python - I Comandi
Vediamo come gestire i comandi del nostro bot in Telegram
4 (+1) Libri su Python (in Inglese) da cui imparare
Una lista di libri su Python (in Inglese) da cui ho imparato a programmare
Virtualenv: gestiamo meglio le dipendenze in Python
A cosa servono e come si utilizzano i virtualenv Python
Leggere i codici a barre con OpenCV e zbar in Python
Come usare Python per leggere i codici a barre degli alimenti e ricavarne alcune informazioni utili
TDD con Flask e PyTest per lo sviluppo di API REST. Parte 2
Tutorial su come usare il Test Driver Development (TDD) con Flask e PyTest per sviluppare delle semplici API REST
Sviluppiamo un bot Telegram che legge i codici a barre degli alimenti
Implementiamo un bot Telegram in grado di leggere ed analizzare le immagini per la lettura ed interpretazione dei codici a barre
TDD con Flask e PyTest per lo sviluppo di API REST. Parte 3
Tutorial su come usare il Test Driver Development (TDD) con Flask e PyTest per sviluppare delle semplici API REST
Divertiamoci sviluppando UI da terminale con ASCIIMATICS
Le UI da terminale fanno molto anni '80, però sono sempre diventerti da implementare. Oggi vi voglio introdurre ad una semplice libreria per creare questo tipo di applicazione.
Sviluppiamo un Robot con tecnologie Open Source
Inizio una serie di videoguide, in cui voglio introdurvi al mondo della robotica di servizio in modo pratico, facendo vedere come è possibilile, sfruttando tecnologie completamente Open Source, quali Arduino, Raspberry Pi, ROS e Docker, costruire un piccolo robot di Servizio.
Parliamo come GMaps: come creare file audio con gtts (Google Text to Speech) in Python
gtts è una libreria in Python per sfruttare le API di Google Text to Speech per generare file audio dal testo
Robot Open Source - Introduzione a Docker
√ą disponibile il video "Introduzione a Docker".
I chatbot possono Parlare? Sviluppiamo un bot telegram che manda messaggi vocali
Usiamo le API di sintesi vocale di google per creare un bot in grado di mandare messaggi vocali
Robot Open Source - Docker e Raspberry
√ą disponibile il video "Docker e Raspberry".