Studio Sperimentale del Moto Armonico Semplice: 5 Passi

2024 Autore: John Day | [email protected]. Ultima modifica: 2024-01-30 10:01

Di arrowlikeFollow Altro dell'autore:

In classe, usiamo spesso un cronometro per condurre l'esperimento del pendolo o un semplice esperimento di movimento armonico. Ecco una sfida, possiamo produrre un grafico reale del suo movimento e vedere qual è la posizione angolare istantanea e la velocità, sono molte più informazioni e divertimento.

Prima domanda, dobbiamo decidere che il corpo del pendolo è una corda senza peso o un'asta rigida e uniforme. L'approccio del cavo sembra essere più facile. Dalla pratica di costruirne uno, ho le seguenti considerazioni di compromesso: il modo più semplice per appendere un sistema a pendolo potrebbe essere appenderlo al bordo superiore della tua porta. Ciò fornisce una lunghezza del pendolo di ~ 2 m senza eseguire alcun lavoro di costruzione strutturale. Ma ha bisogno che l'oscillazione non tocchi la superficie della porta, il che semplicemente rovina l'intero esperimento. Quindi l'aereo su cui oscilla dovrebbe essere esattamente parallelo alla superficie della parete/della porta. Un cavo senza peso tende ad essere sottile, può girare facilmente e complicare la misurazione dell'angolo di oscillazione. Vogliamo usare una misura per rappresentare lo stato di oscillazione. La corda sottile, come la lenza, può essere elastica ed estensibile, il che influisce su una delle nostre costanti più importanti misurate da noi e utilizzate nell'equazione, che è la lunghezza del pendolo. Alcuni possono anche essere influenzati dalla temperatura. La massa del peso appesa all'estremità del cavo deve essere sufficientemente pesante in modo che il peso del cavo diventi trascurabile. Si prega di commentare se si è d'accordo o in disaccordo con loro, o se si hanno altre idee di compromesso sul design. Per studiare questo problema, abbiamo bisogno di un dispositivo che sia così leggero che il suo peso possa essere ignorato e trattiamo ancora il sistema del pendolo come un'asta rigida e uniforme. Sto usando un controller elettronico indossabile COTS, che ci fornisce il giroscopio, l'accelerometro e le informazioni sull'angolo tramite connessione bluetooth. Queste misurazioni verranno archiviate in un file di dati dell'app del telefono cellulare. Successivamente, analizzeremo i dati per il nostro semplice esperimento di moto armonico. L'analisi numerica si concentra sui seguenti argomenti: 1) Prevedere il periodo di oscillazione del pendolo 2) Raccogliere in modo programmabile i dati dell'esperimento di movimento armonico semplice del pendolo 3) Utilizzare kmean per raggruppare i dati e rimuovere i valori anomali nel processo di analisi 4) Utilizzare FFT a breve termine per stimare la frequenza di oscillazione del pendolo

Forniture

Apparecchio di misurazione Bluetooth

App per telefono Android: vai su Google Play Store, cerca M2ROBOTS e installa l'app di controllo. Nel caso in cui sia difficile accedere a Google playstore, visita la mia home page personale per un metodo di download alternativo dell'app

asta di legno

poche parti stampate in 3D

lame per seghe o materiale metallico simile

Passaggio 1: cosa sono i pendoli? Come modellarlo?

Ci sono molti articoli e libri che introducono la derivazione dell'equazione del pendolo, incluso il tuo libro di fisica del curriculum. Tale contenuto potrebbe essere meglio non essere ripetuto di nuovo qui. Qui viene elencata solo la conclusione finale riguardo al tema del "semplice moto armonico". Per conoscere il periodo di un pendolo, tutto ciò che dobbiamo sapere è la lunghezza del pendolo, indicata come "l", in metri.

Se siamo ragionevolmente sicuri che il peso si trova quasi completamente all'estremità di una corda senza peso appesa a un perno, e il pendolo oscilla di piccoli angoli, diciamo meno di 15°, il periodo T1 di tale pendolo è dato da:

T1 = 2*pi*(l/g)^0,5

g = accelerazione di gravità, circa 9,8 m/s^2

Se la corda senza peso è sostituita da un'asta rigida uniforme, sempre di lunghezza l, il suo periodo di moto armonico semplice T2 è dato da T1 = 2*pi*(2l/3g)^0.5

Effettivamente ha lo stesso periodo di un pendolo a corda senza peso essendo due terzi della lunghezza dell'asta rigida e uniforme.

Questo è lo sfondo e possiamo iniziare a preparare il nostro esperimento.

Passaggio 2: preparare le parti per la costruzione dell'hardware

Per costruire la struttura del pendolo, stampiamo in 3D alcune parti e ricicliamo qualcosa che abbiamo già. La struttura complessiva del pendolo è mostrata in Fig.1. È una miscela di parti stampate in 3D insieme ad alcune parti realizzate a mano e un lungo pezzo di asta di legno di Lowe's.

La parte stampata in 3D in Fig.2 è appesa al bordo superiore di una porta, perché la nostra porta è una superficie piana facile per noi per appendere qualcosa. Collegamento per il download del file STL:

xiapeiqing.github.io/doc/kits/pendulum/pen…

La parte verde in Fig.3 collega l'asta di legno a una lama e la lama si trova sopra due pezzi di binari montati sul precedente gancio per porta stampato in 3D. Link per il download del file STL:

I due pezzi di binario sono realizzati rompendo a metà una vecchia lama di sega, vedi Fig. 4. La parte in Fig.2 ha preparato per loro la giusta dimensione della fessura. Idealmente possiamo fare una tacca a forma di "V" in quelle due lame usando una lima. Un metallo dai bordi ragionevolmente affilati, come una lama di rasoio a bordo singolo, o qualsiasi pezzo di metallo fatto a mano, può sedersi all'interno delle tacche a forma di "V". Il motivo per cui abbiamo bisogno di un'area di contatto più piccola è ridurre l'energia cinetica persa durante l'oscillazione.

L'ultima parte stampata in 3D in Fig.5 è un piccolo vassoio per contenere l'apparato di misurazione elettronico.

Il link per il download:

L'apparato di misurazione bluetooth genera la stima dell'angolo, la misurazione del giroscopio e la misurazione dell'accelerometro. Tutti questi dati sono a nostra disposizione tramite collegamento wireless bluetooth.

Condurremo più esperimenti dispiegando questo apparato in diverse posizioni del braccio del pendolo e vedremo le differenze.

Passaggio 3: raccolta dei dati dell'esperimento

Ci sono due metodi fattibili per la raccolta dei dati sperimentali prima di analizzare il set di dati acquisito:

1) Utilizzare l'App per telefono Android specificata nella sezione dei requisiti per registrare tutte le misurazioni prodotte dall'apparato in un file di dati archiviato nella scheda SD del telefono. Possiamo copiare il file e post elaborare le informazioni.

2) Utilizzare un computer abilitato Bluetooth, un PC, un laptop o un mini-computer RaspberryPi per stabilire una connessione Bluetooth all'apparato e leggere i dati per l'analisi in tempo reale o offline.

Esistono sia pro che contro per ogni metodo, proveremo entrambi e diremo la differenza in questo istruibile.

Per il metodo (1) che utilizza l'app Android, una volta entrati nell'interfaccia di controllo dell'app Android, i dati di telemetria inviati dall'apparato di misurazione bluetooth al telefono Android verranno registrati in un file di registro dati denominato m2flightDatayyyymmdd_hhmmss.txt. Può essere trovato nella cartella Download/m2LogFiles del tuo telefono Android. La cartella "Download" è una cartella preesistente nel sistema operativo Android del telefono e "m2LogFiles" è una cartella creata dall'app. Il contenuto del nome del file aaaammgg_hhmmss è il modo per codificare l'ora di inizio dell'esperimento (anno, mese, giorno, ora, minuto e secondo) nel nome del file.

Ogni riga nel file di registro è un record. Inizia con il timestamp dell'evento, la stringa di preambolo "eam:", seguita da 4 dati di terzine, che sono:

Lettura dell'asse XYZ dell'accelerometro nei valori di rilettura del registro hardware del sensore grezzo

Lettura dell'asse XYZ del giroscopio nei valori di rilettura del registro hardware del sensore grezzo

Lettura dell'asse XYZ del magnetometro nei valori di rilettura del registro hardware del sensore grezzo

Roll/Pitch/Raw stimato a bordo in gradi

Il file di dati creato utilizzando il programma Python per computer utilizzerà lo stesso formato di file di dati, in modo che il programma che utilizziamo nella fase di analisi dei dati non venga disturbato dall'origine dati prodotta dal nostro programma Python o dall'app Android.

Iniziamo a codificare utilizzando il metodo (2).

Per interagire con l'apparato di misura bluetooth, sono forniti due tipi di SDK:

1) Python SDK, che può essere installato da "pip3 install m2controller", python3 è la lingua utilizzata. Gli esempi di codice dell'applicazione utente sono archiviati in https://github.com/xiapeiqing/m2robots/tree/maste… Per questo esperimento, utilizzeremo lo script python pendulum1.py

2) Java SDK, che non viene utilizzato in questo istruibile perché desideriamo la visualizzazione e l'analisi successive dei dati del pendolo acquisiti, che potrebbero richiedere un po' più di sforzo per noi per programmare in Java.

Il codice sorgente del programma di raccolta dati python3 contiene molti commenti per i dettagli della funzionalità del codice. Un'istantanea del codice sorgente è fornita qui.

#!/usr/bin/env python# -*- codifica: UTF-8 -*- from m2controller import m2controller da m2controller import m2Const import signal import time import datetime import usrCfg import pedulum2

requestExit = False

################################################################

# vogliamo utilizzare la stessa convenzione di denominazione del file di registro in modo che il modulo di analisi dei dati, pendulum2.py, possa essere indipendente da come otteniamo il file di dati di registro ################# ############################################## nomefile di registro = " m2flightData%s.txt"%(datetime.datetime.fromtimestamp(time.time()).strftime('%Y%m%d_%H%M%S')) dataLogfile = open(logfilename, "w")

def signal_handler(sig, frame):

global requestExit print('utente Ctrl-C per uscire dall'esecuzione del programma') requestExit = True signal.signal(signal. SIGINT, signal_handler)

################################################################

# ogni volta che i dati di misura diventano disponibili a una frequenza di 20Hz, questa funzione di "richiamata" verrà richiamata ############################## ################################# def callbackfunc (telemetria): strTimeStamp = datetime.datetime.fromtimestamp(time.time ()).strftime('%H:%M:%S.%f')[:-3] dataStr = "%s, eam:%d, %d, %d, %d, %d, %d, %d, %d, %d, %2.1f, %2.1f, %2.1f\n"%(strTimeStamp, telemetry['m_fAccelHwUnit'][0], telemetry['m_fAccelHwUnit'][1], telemetry['m_fAccelHwUnit'][2], telemetria['m_fGyroHwUnit'][0], telemetria['m_fGyroHwUnit'][1], telemetria['m_fGyroHwUnit'][2], telemetria['m_fMagHwUnit'][0], telemetria['m_fMagHwUnit'][1], telemetria['m_fMagHwUnit'][2], telemetria['m_fRPYdeg'][0], telemetria['m_fRPYdeg'][1], telemetria['m_fRPYdeg'][2]) ## ################################################# ############ # stampiamo la stringa di dati sullo schermo e li salviamo nel file di registro ##################### ######################################### print(dataStr) dataLogfile.writelines(dataStr)

################################################################

# inizializza il controller, ricordati di impostare il campo BleMACaddress come indirizzo MAC del tuo dispositivo ################################ ############################### # DA FARE: inizializziamo il BleMACaddress se non è impostato dall'utente. controller = m2controller. BleCtrller(m2Const.etDebian, callbackfunc, usrCfg. BleMACaddress) controller.connect() while True: ######################### ###################################### # attendi i dati di misura creati e inviati dalla misura del pendolo apparato ################################################ ############### controller.m_CommsTunnel.waitForNotifications(1.0) if requestExit: ######################## ######################################## # Le pulizie funzionano qui quando finiamo la registrazione dei dati ################################################# ############## controller.stop() dataLogfile.close() break

################################################################

# raccolta dati completata, ora analizziamo i dati di registro ###################################### ######################### pendolo2.parseDataLogFile (nomefile di registro)

Per aggiornamenti a lungo termine, controlla

Ora spieghiamo il suo metodo di funzionamento. Questo programma Python è scritto sopra un pacchetto installabile pip, chiamato m2controller. Il pacchetto di livello inferiore offre un meccanismo di callback, in modo che ogni aggiornamento di misurazione ricevuto attiverà la funzione di callback che abbiamo scritto e salverà i dati in un file di registro locale. Il formato del contenuto dei dati del file di registro è identico a quello prodotto dall'app Android companion, in modo che il file di registro dati creato dal programma Python o dall'app Android companion sia intercambiabile.

Il segnale dell'utente ctrl-C, catturato dal sistema operativo, viene passato al programma e interrompe il ciclo infinito in attesa del nuovo arrivo dei dati di misura.

Fino ad ora, il file di registro è stato creato con successo e questo programma chiamerà il programma di analisi per studiare i risultati dell'esperimento.

Ecco due esperimenti e il confronto mostra la differenza molto evidente collegando un dispositivo da 7 grammi in luoghi diversi.

In Fig.2, utilizziamo una bilancia per determinare il peso effettivo di questo apparato di misurazione bluetooth.

La Fig.3 illustra la configurazione del pendolo in cui il dispositivo da 7 grammi è attaccato all'estremità inferiore del pendolo. La configurazione di installazione in Fig.4 ha la massa di 7 grammi situata molto più vicino al perno oscillante.

La Fig.5 è una vista in primo piano della struttura del pendolo.

Passaggio 4: analisi dei dati

L'apparecchio di misurazione bluetooth pesa ~ 7 grammi, che pesa molto meno di un bastoncino di legno lungo ~ 1,6 metri. Usa l'ipotesi di "asta rigida uniforme" e abbiamo questa equazione del periodo del pendolo, T1 = 2*pi*(2l/3g)^0.5

Per ottenere la costante di gravità, possiamo usare 9,8 m/s^2. Ma una costante di gravità più accurata in una data geolocalizzazione può essere recuperata da questo servizio web:

www.wolframalpha.com/widgets/view.jsp?id=e…

Per san francisco, è 9,81278 m/s^2

La lunghezza del pendolo è misurata per essere 64.5''

2*pi*sqrt(2*64.5*0.0254/(3*9.81278)) fornisce il periodo del pendolo previsto di 2.0962(sec).

Vediamo se concorda con i nostri esperimenti.

Nel primo esperimento, la configurazione del pendolo ha il dispositivo da 7 grammi attaccato all'estremità inferiore del pendolo. Il mio file di registro può essere scaricato in:

xiapeiqing.github.io/doc/kits/pendulum/pen…

Rinominalo in "PendulumTestData.txt" e mettilo nella stessa cartella del programma di analisi Python. Un'istantanea del codice sorgente è fornita qui.

#!/usr/bin/env python# -*- codifica: UTF-8 -*- import csv import matplotlib.pyplot as plt plt.style.use('seaborn-whitegrid') import numpy as np from datetime import datetime, timedelta import seaborn as sns from sklearn.cluster import KMeans from collection import Counter ################################## ############################## # questa funzione esegue il lavoro di analisi dei file di dati ############ ################################################# ## def parseDataLogFile(datafilename): ########################################## ###################### # estrae i dati nel file di registro dati separato da virgole (CSV) e salva il contenuto in ogni colonna in una variabile di tipo float ## ################################################# ############ con open(datafilename) come csvfile: readCSV = csv.reader(csvfile, delimiter=', ') timestampS = fAccelHwUnit_x = fAccelHwUnit_y = fAccelHwUnit_z = fGyroHwUnit_x = fGyroHwUnit_y = fGyroHwUnit_z = fMagHwUnit_x = fMagHwUnit_y = fMagHwUni t_z = fRPYdeg_r = fRPYdeg_p = fRPYdeg_y = per la riga in readCSV: prova: x = datetime.strptime(row[0].split(', ')[0], '%H:%M:%S.%f') timestampS.append(timedelta(ore=x.ora, minuti=x.minuto, secondi=x.secondo, microsecondi=x.microsecondo).total_seconds()) fAccelHwUnit_x.append(float(row [1][4:])) fAccelHwUnit_y.append(float(row[2])) fAccelHwUnit_z.append(float(row[3])) fGyroHwUnit_x.append(float(row[4])) fGyroHwUnit_y.append(float (row[5])) fGyroHwUnit_z.append(float(row[6])) fMagHwUnit_x.append(float(row[7])) fMagHwUnit_y.append(float(row[8])) fMagHwUnit_z.append(float(row [9])) fRPYdeg_r.append(float(row[10])) fRPYdeg_p.append(float(row[11])) fRPYdeg_y.append(float(row[12])) tranne: pass timestampS = np.asarray(timestamp) timestamps = timestamps - timestamp [0] = fAccelHwUnit_x np.asarray (fAccelHwUnit_x) fAccelHwUnit_y = np.asarray (fAccelHwUnit_y) fAccelHwUnit_z = np.asarray (fAccelHwUnit_z) fGyroHwUnit_x = np.asarray (fGyroHwUnit_x) fGyroHwUnit_y = np.asarray (fGyroHwUnit_y) fGyroH wUnit_z = np.asarray (fGyroHwUnit_z) fMagHwUnit_x = np.asarray (fMagHwUnit_x) fMagHwUnit_y = np.asarray (fMagHwUnit_y) fMagHwUnit_z = np.asarray (fMagHwUnit_z) fRPYdeg_r = np.asarray (fRPYdeg_r) fRPYdeg_p = np.asarray (fRPYdeg_p) fRPYdeg_p = fRPYdeg_p - np.mean(fRPYdeg_p) fRPYdeg_y = np.asarray(fRPYdeg_y)

################################################################

# abbiamo bisogno di una stima accurata della frequenza di campionamento per una stima precisa del periodo di oscillazione ################################### ############################ FsHz = getSamplingIntervalS(timestampS) ################ ################################################ # utilizzo componente del beccheggio nell'output del sistema di riferimento della rotta di assetto per l'analisi del periodo del pendolo #################################### ###########################analys_timeSequence(timestampS, fRPYdeg_p, FsHz, 'pitch') ########### ################################################# ### # usa l'output della misurazione grezza dell'accelerometro per l'analisi del periodo del pendolo #################################### ###########################analys_timeSequence(timestampS, fAccelHwUnit_x, FsHz, 'accel') ########### ################################################# ### # usa l'uscita di misura grezza del giroscopio per l'analisi del periodo del pendolo #################################### ###########################analys_timeSequence(timestampS, fGyroHwUnit_y, FsHz, ' giroscopio') print('fatto, congratulazioni:-)') plt.show() ############################### ################################# # nel processo di comunicazione bluetooth, c'è una rara possibilità che il pacchetto di comunicazione dati possa essere perso # usiamo K-mean per isolare i dati di misurazione a 20Hz dai valori anomali, che sono causati dal pacchetto caduto # tuffati in "segnale e sistema per maggiori dettagli" ################ ############################################### def getSamplingIntervalS (timestampS): plt.figure() sampleIntervalS = np.diff(timestampS) sns.distplot(sampleIntervalS) plt.ylabel('histogram') plt.xlabel('measurement interval(s)') clusterCnt = 5 km = KMeans(n_clusters = clusterCnt) km.fit(sampleIntervalS.reshape(-1, 1)) centroids = km.cluster_centers_ elemCnt = Counter(km.labels_) occorrenzaCnt = for ii in range(clusterCnt): occorrenzaCnt.append(elemCnt[ii]) FsHz = 1/centroidi[occorrenzaCnt.index(max(occorrenzaCnt))] return FsHz

################################################################

# utilizzare lo spettrometro, ovvero FFT a breve termine per ottenere la componente di frequenza, il bin di picco è la nostra migliore stima dell'oscillazione del pendolo ########################## ###################################### def analysis_timeSequence(timestampS, timeSeqData, FsHz, strComment): fig, (ax1, ax2) = plt.subplots(nrows=2) ax1.plot(timestampS, timeSeqData, marker='o', markerfacecolor='blue', markersize=2, color='skyblue', linewidth=1) ax1.set_title("misurazione del dominio del tempo del pendolo -- %s"%strComment) ax1.set_xlabel("tempo di campionamento(secondo)") ax1.set_ylabel(strComment); NFFT = 2048 # la lunghezza dei segmenti di finestra

Pxx, freqs, bin, im = ax2.specgram(timeSeqData, NFFT=NFFT, Fs=FsHz, novellap=NFFT/2)

ax2.set_title("Spettrogramma") ax2.set_xlabel("campioni") ax2.set_ylabel("frequenza(Hz)");

# Il metodo `specgram` restituisce 4 oggetti. Loro sono:

# - Pxx: il periodogramma # - freqs: il vettore di frequenza # - bins: i centri degli intervalli temporali # - im: l'istanza matplotlib.image. AxesImage che rappresenta i dati nel grafico pkresult = np.where(Pxx == np.amax(Pxx)) oscFreqHz = freqs[pkresult[0][0] print('pendolo oscillazione Freq(Hz)=%f, Periodo(Sec)=%f, origine dati stima: %s'%(oscFreqHz, 1/oscFreqHz, strComment)) return 1/oscFreqHz

################################################################

# dovremmo eseguire questo programma in modo indipendente, cioè, non essendo chiamato da pendulum1.py, # definiamo un nome file di dati di registro predefinito da analizzare #################### ############################################ if _name_ == "_main_ ": defaultFilename = './PendulumTestData.txt' import os.path if os.path.isfile(defaultFilename): parseDataLogFile(defaultFilename) else: print ("file di registro predefinito %s non esistente"%defaultFilename)

Per aggiornamenti a lungo termine, controlla

Il codice sorgente contiene commenti dettagliati, diamo qui un riepilogo di alto livello della stima matematica.

1) Per prima cosa leggiamo il contenuto del file CSV nel computer, utilizzando un pacchetto Python chiamato "csv". Abbiamo misurazioni periodiche.

21:34:26,362, eam:0, -128, 14464, -8, 144, -96, 2112, -1280, 1664, -0,5, -5,5, 40,5

21:34:26,373, eam:128, 0, 14272, -8, 136, 40, 2112, -1280, 1664, -0,5, -6,5, 40,0

21:34:26.412, eam:448, -64, 14208, -8, 136, 24, 2176, -1280, 1664, -0,5, -7,5, 40,5

21:34:26.462, eam:448, -128, 14272, -8, 120, 16, 2176, -1280, 1664, -0,5, -8,0, 40,5

2) Poiché la velocità di misurazione è così critica e introduce direttamente l'errore di stima del periodo del pendolo, vogliamo stimarli. Il nostro intervallo di misurazione nominale è di 50 ms, ovvero 20 Hz. La media su tutte le misurazioni sembra OK, ma occasionalmente perdiamo il pacchetto di trasmissione dati, l'intervallo di aggiornamento diventa 100 ms o 150 ms, …

Se tracciamo l'occorrenza di questi dati, vedi Fig.1, come un essere umano, possiamo facilmente avere un valore di eyeballing di 0,05 sec. Tuttavia, possiamo fare di meglio?

Dobbiamo usare il metodo di classificazione per selezionare solo quelli buoni per il calcolo della media. Python ha un toolbox chiamato KMeans per aiutarci con il clustering, o diciamo la classificazione. Questi concetti sono utilizzati in molte aree dei big data e dell'intelligenza artificiale.

3) La Fig.2 contiene due immagini. Il grafico in alto è una sequenza nel dominio del tempo della nostra misurazione dell'angolo di oscillazione in gradi. Facendo riferimento al timestamp dell'asse x in Second, possiamo leggere circa 22,5 cicli in 50 secondi, che si traduce in un periodo di pendolo di 2,22 Sec. C'è un modo per automatizzare questo processo e avere una stima più accurata? Sì, possiamo usare uno strumento matematico chiamato spettrogramma, che utilizza una piccola porzione di dati di misurazione e ci dice la sua frequenza, vedi la figura sotto. La lettura dell'asse y per la linea più scura è la frequenza di oscillazione del pendolo. Essendo una linea orizzontale conferma che l'oscillazione del pendolo non è cambiata affatto durante l'esperimento. Il valore inverso della frequenza di oscillazione è il periodo di oscillazione del pendolo.

Il rapporto finale realizzato dal programma è un testo riassuntivo:

oscillazione del pendolo Freq(Hz)=0.449224, Period(Sec)=2.226059, fonte dati stima: pitch

Possiamo scoprire che il nostro precedente risultato del calcolo della mano oculare, 2,22 secondi, è abbastanza coerente con il valore calcolato dal programma.

Rispetto al valore calcolato teoricamente di 2.0962(sec), abbiamo un errore residuo di ~5%. Come sbarazzarsi di loro? Ricordi che il presupposto è "asta rigida e uniforme"? Anche un peso extra di 7 grammi sembra banale, è la causa principale dell'errore residuo.

Ora spostiamo il dispositivo, vicino al perno. Vedere il passaggio precedente per una foto in primo piano. Il file di registro che ho creato può essere scaricato qui:

xiapeiqing.github.io/doc/kits/pendulum/pen…

Esegui gli stessi passaggi di analisi e otteniamo Periodo di 2.089867 (Sec), vedi Fig.3, che è quasi identico alla previsione teorica. Grande!

Poiché abbiamo non solo la misurazione dell'angolo di oscillazione, ma anche la misurazione giroscopica e la misurazione dell'accelerometro alla stessa velocità. Esegui la stessa analisi per le altre due misurazioni, otteniamo risultati in Fig.4 e 5. Le stime da tutte e tre le fonti di misurazione concordano, il che ci rende più fiduciosi sul successo del nostro esperimento.

Ecco il risultato come output finale del programma Python in esecuzione:

oscillazione del pendolo Freq(Hz)=0.478499, Period(Sec)=2.089867, fonte dati stima: pitch

oscillazione del pendolo Freq(Hz)=0.478499, Periodo(Sec)=2.089867, fonte dati stima: accel

oscillazione del pendolo Freq(Hz)=0.478499, Period(Sec)=2.089867, fonte dati di stima: giroscopio

Ultima riflessione in questo passaggio, come possono i risultati della stima essere esattamente identici utilizzando un'origine dati di input diversa? Questa è contro-intuizione. Lascio questa domanda ai lettori. Ecco un suggerimento: ricordate che stiamo usando la FFT a breve termine per stimare la frequenza di oscillazione? Nel dominio digitale, la stima della frequenza viene fornita in bin di frequenza discreti invece di una stima in numero variabile.

Passaggio 5: raccomandazioni per il lavoro futuro

Ci sono poche categorie di raccomandazioni di lavoro futuro.

Nella fase precedente, riusciamo a ridurre il nostro errore dell'esperimento da ~5% a meno dell'1%, possiamo fare di meglio? Notando che l'ampiezza dell'oscillazione diminuisce in modo esponenziale, un fattore che contribuisce può essere la resistenza dell'aria causata dall'oscillazione del pendolo. Potrebbe essere necessario modificare la sezione trasversale del pendolo per essere di forma aerodinamica in modo da ridurre la resistenza aerodinamica.

Possiamo applicare un guadagno variabile nel tempo appreso utilizzando tecniche di filtro adattivo per emettere un segnale di ampiezza di picco costante. Nel frattempo, correla l'attenuazione della grandezza con le forze esterne.

Difficilmente possiamo trovare qualcosa di più semplice del "semplice movimento armonico". Possiamo usare le strutture che analizziamo il pendolo per analizzare qualcosa di più complicato, un'attività sportiva, una sequenza di lancio di razzi ad acqua, ecc?

Felice hacking