Studiu experimental al mișcării armonice simple: 5 pași

2024 Autor: John Day | [email protected]. Modificat ultima dată: 2024-01-30 11:43

De arrowlike Urmărește mai multe de la autor:

În clasă, folosim adesea un cronometru pentru a efectua experimentul pendulului sau experimentul simplu de mișcare armonică. Iată o provocare, putem produce un grafic real al mișcării sale și să vedem care este poziția și viteza unghiulară instantanee, asta înseamnă mult mai multe informații și distracție.

Prima întrebare, trebuie să decidem că corpul pendulului este un cordon fără greutate sau o tijă uniformă rigidă. Abordarea prin cablu pare a fi mai ușoară. Din practica construirii unuia, am următoarele considerații de compromis: Cel mai simplu mod de a agăța un sistem pendul ar putea fi agățat-o de marginea superioară a ușii. Acest lucru vă oferă o lungime a pendulului de ~ 2m fără a face nicio lucrare de construcție structurală. Dar are nevoie ca leagănul să nu atingă suprafața ușii, ceea ce distruge pur și simplu întregul experiment. Deci, planul pe care îl leagănă ar trebui să fie exact paralel cu suprafața peretelui / ușii. Un cablu fără greutate tinde să fie subțire, se poate roti ușor și complică măsurarea unghiului de oscilație. Vrem să folosim o singură măsurătoare pentru a reprezenta starea de swing. Cablul subțire, cum ar fi linia de pește, poate fi elastic și extensibil, care afectează una dintre cele mai importante constante ale noastre măsurate de noi și utilizate în ecuație, care este lungimea pendulului. Unele pot fi, de asemenea, afectate de temperatură. Greutatea agățată la capătul cablului trebuie să fie suficient de grea, astfel încât greutatea cablului să devină neglijabilă. Vă rugăm să comentați dacă sunteți de acord sau nu cu ei sau dacă aveți alte idei de compromisuri de proiectare. Pentru a studia această problemă, avem nevoie de un dispozitiv atât de ușor încât greutatea sa poate fi ignorată și tratăm totuși sistemul pendulului ca o tijă uniformă rigidă. Folosesc un controler electronic portabil COTS, care ne furnizează informații despre giroscop, accelerometru și unghi prin conexiune bluetooth. Aceste măsurători vor fi stocate într-un fișier de date al aplicației de telefonie mobilă. După aceea, vom analiza datele pentru experimentul nostru simplu de mișcare armonică. Analiza numerică se concentrează pe următoarele subiecte: 1) Prezicerea perioadei de oscilare a pendulului 2) Colectarea programabilă a datelor experimentului de mișcare armonică simplă a pendulului 3) Utilizarea kmean pentru gruparea datelor și eliminarea valorilor aberante în procesul de analiză 4) Utilizarea FFT de scurtă durată pentru estimarea frecvența oscilației pendulului

Provizii

Aparat de măsurare Bluetooth

Aplicație pentru telefon Android: Accesați Google Playstore, căutați M2ROBOTS și instalați aplicația de control. În cazul în care este dificil să accesați Google Playstore, accesați pagina mea de pornire personală pentru metoda alternativă de descărcare a aplicației

tija de lemn

puține piese imprimate 3D

lame pentru ferăstrău sau material metalic similar

Pasul 1: Ce sunt pendulul? Cum să-l modelezi?

Există multe articole și cărți care introduc derivarea ecuației pendulului, inclusiv cartea dvs. de fizică a curriculumului. Este posibil ca un astfel de conținut să nu fie repetat aici din nou. Numai concluzia finală este listată aici cu privire la tema „mișcării armonice simple”. Pentru a cunoaște perioada unui pendul, tot ce trebuie să știm este lungimea pendulului, denumită „l”, în metri.

Dacă suntem destul de siguri că greutatea este situată aproape complet la capătul unui cablu fără greutate atârnat într-un pivot și pendulul se leagănă la unghiuri mici θ, să spunem mai puțin de 15 °, perioada T1 a unui astfel de pendul este dată de:

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

g = accelerația gravitațională, aproximativ 9,8 m / s ^ 2

Dacă cablul fără greutate este înlocuit cu o tijă uniformă rigidă, din nou de lungime l, perioada sa de mișcare armonică simplă T2 este dată de T1 = 2 * pi * (2l / 3g) ^ 0,5

În mod efectiv, are aceeași perioadă ca un pendul de cablu fără greutate, care este de două treimi din lungimea rigidă a tijei uniforme.

Acesta este fundalul și putem începe să ne pregătim experimentul.

Pasul 2: Pregătiți piesele pentru construcția hardware

Pentru a construi structura pendulului, imprimăm 3D unele părți și reciclăm ceva ce avem deja. Structura generală a pendulului este prezentată în Fig.1. Este un amestec de piese de imprimare 3D împreună cu unele piese lucrate manual și o bucată lungă de tijă de lemn de la Lowe.

Partea imprimată 3D din Fig.2 este atârnată pe marginea superioară a unei uși, deoarece ușa noastră este o suprafață plană ușoară pentru a putea agăța ceva. Link de descărcare a fișierului STL:

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

Partea verde din Fig.3 conectează tija de lemn la o lamă, iar lama se așează deasupra a două bucăți de șină montate pe umerașul de ușă imprimat anterior 3D. Link de descărcare fișier STL:

Cele două bucăți de șină sunt realizate prin ruperea unei lame vechi de ferăstrău în jumătate, vezi Fig. 4. Piesa din Fig.2 a pregătit dimensiunea fantei potrivită pentru ele. În mod ideal, putem face o crestătură în formă de "V" în cele două lame de ferăstrău folosind un fișier. Un metal ascuțit în mod rezonabil, cum ar fi o lamă de ras cu o singură margine, sau orice piesă de metal realizată manual, poate sta în interiorul crestăturilor în formă de "V". Motivul pentru care avem nevoie de o zonă de contact mai mică este reducerea energiei cinetice pierdute în timpul balansării.

Ultima parte imprimată 3D din Fig.5 este o tavă mică pentru a ține aparatul electronic de măsurare.

Link-ul de descărcare:

Aparatul de măsurare bluetooth generează estimarea unghiului, măsurarea giroscopului și măsurarea accelerometrului. Toate aceste date sunt disponibile pentru noi prin link wireless Bluetooth.

Vom efectua mai multe experimente prin desfășurarea acestui aparat în poziția diferită a brațului pendulului și vom vedea diferențele.

Pasul 3: Colectarea datelor din experiment

Există două metode realizabile pentru colectarea datelor experimentale înainte de a analiza setul de date achiziționat:

1) Utilizați aplicația pentru telefon Android specificată în secțiunea de cerințe pentru a înregistra toate măsurătorile produse de aparat într-un fișier de date stocat pe cardul SD al telefonului. Putem copia fișierul și putem procesa informațiile.

2) Utilizați un computer cu Bluetooth, un PC, un laptop sau un mini-computer RaspberryPi pentru a stabili o conexiune Bluetooth la aparat și pentru a citi datele pentru analize în timp real sau offline.

Există atât argumente pro, cât și contra pentru fiecare metodă, vom încerca ambele și vom face diferența în acest instructable.

Pentru metoda (1) de utilizare a aplicației Android, odată ce ne aflăm în interfața de control a aplicației Android, datele de telemetrie trimise de la aparatul de măsurare Bluetooth către telefonul Android vor fi înregistrate într-un fișier de date numit m2flightDatayyyymmdd_hhmmss.txt. Poate fi găsit în folderul Download / m2LogFiles al telefonului dvs. Android. Dosarul „Descărcare” este un folder preexistent în sistemul de operare Android al telefonului dvs. și „m2LogFiles” este un dosar creat de aplicație. Conținutul numelui de fișier yyyymmdd_hhmmss este modalitatea de a codifica ora de începere a experimentului (an, lună, zi, oră, minut și sec) în numele fișierului.

Fiecare linie din fișierul jurnal este o singură înregistrare. Începe cu marca de timp a evenimentului, șirul de preambul "eam:", urmat de 4 date de triplete, care sunt:

Citirea axei accelerometrului XYZ în valorile de reluare a registrului hardware al senzorului brut

Citirea axei giroscopului XYZ în valorile de reluare a registrului hardware al senzorului brut

Citirea axei magnetometrului XYZ în valorile de reluare a registrului hardware al senzorului brut

la bord estimat Roll / Pitch / Raw în grad

Fișierul de date creat folosind programul computer python va utiliza un format de fișier de date identic, astfel încât programul pe care îl folosim în etapa de analiză a datelor să nu fie deranjat de faptul că sursa de date este produsă de programul nostru Python sau de aplicația pentru Android.

Să începem codarea folosind metoda (2).

Pentru a interacționa cu aparatul de măsurare bluetooth, sunt furnizate două variante de SDK:

1) Python SDK, care poate fi instalat de „pip3 install m2controller”, python3 este limba utilizată. Exemplele codului aplicației utilizatorului sunt stocate în https://github.com/xiapeiqing/m2robots/tree/maste… Pentru acest experiment, vom folosi scriptul python pendulum1.py

2) Java SDK, care nu este utilizat în acest instructable, deoarece dorim vizualizarea și analiza ulterioară a datelor pendulului dobândit, ceea ce ar putea necesita un efort mai mare pentru ca noi să programăm în Java.

Codul sursă al programului de colectare a datelor python3 conține multe comentarii pentru detaliile funcționalității codului. Un instantaneu al codului sursă este oferit aici.

#! / usr / bin / env python # - * - codare: UTF-8 - * - din m2controller import m2controller din m2controller import m2Const import semnal import timp import datetime import usrCfg import pendulum2

requestExit = False

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

# vrem să folosim aceeași convenție de denumire a fișierului jurnal, astfel încât modulul de analiză a datelor, pendulum2.py, să poată fi agnostic la modul în care obținem fișierul de date jurnal ################### ################################################## logfilename = " m2flightData% s.txt "% (datetime.datetime.fromtimestamp (time.time ()). strftime ('% Y% m% d_% H% M% S')) dataLogfile = deschis (logfilename," w ")

def signal_handler (sig, frame):

global requestExit print („user Ctrl-C pentru a ieși din execuția programului”) requestExit = True signal.signal (signal. SIGINT, signal_handler)

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

# la fiecare dată de măsurare devine disponibilă la o rată de 20Hz, această funcție de „apel invers” va fi convocată ################################# ################################## callbackfunc (telemetrie): 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, telemetrie ['m_fAccelHwUnit'] [0], telemetrie ['m_fAccelHwUnit'] [1], telemetrie ['m_fAccelHwUnit'] [2], telemetrie ['m_fGyroHwUnit'] [0], telemetrie ['m_fGyroHwUnit'] [1], telemetrie ['m_fGyroHwUnit'] [2], telemetrie ['m_fMagHwUnit'] [0] 'm_fMagHwUnit'] [1], telemetrie ['m_fMagHwUnit'] [2], telemetrie ['m_fRPYdeg'] [0], telemetrie ['m_fRPYdeg'] [1], telemetrie ['m_fRPYdeg'] [2]) ## ###################################################### ############ # imprimăm șirul de date pe ecran și le salvăm în fișierul jurnal ######################### ########################################### print (dataStr) dataLogfile.writelines (dataStr)

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

# inițializați controlerul, nu uitați să setați câmpul Adresă BleMAC pentru a fi adresa MAC a dispozitivului dvs. #################################### ################################ # TODO: să inițializăm adresa BleMAC dacă nu este setată de utilizator. controller = m2controller. BleCtrller (m2Const.etDebian, callbackfunc, usrCfg. BleMACaddress) controller.connect () în timp ce True: ############################ ###################################### # # așteptați datele de măsurare create și trimise de la măsurarea pendulului aparat ################################################# ################ controller.m_CommsTunnel.waitForNotifications (1.0) if requestExit: ######################### ######################################## # păstrarea funcționează aici când terminăm înregistrarea datelor ###################################################### ############### controller.stop () dataLogfile.close () break

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

# colectarea datelor finalizată, acum să analizăm datele jurnalului ########################################### ########################## pendulum2.parseDataLogFile (logfilename)

Pentru actualizarea pe termen lung, vă rugăm să verificați

Acum să explicăm metoda de funcționare a acestuia. Acest program python este scris deasupra unui pachet instalabil pip, numit m2controller. Pachetul de nivel inferior oferă mecanism de apelare, astfel încât fiecare actualizare de măsurare primită să declanșeze funcția de apelare pe care am scris-o și să salveze datele într-un fișier jurnal local. Formatul conținutului datelor din fișierul jurnal este identic cu ceea ce este produs de aplicația însoțitoare Android, astfel încât fișierul jurnal de date creat fie de programul python, fie de aplicația însoțitoare andriod este schimbabil.

Semnalul ctrl-C al utilizatorului, captat de sistemul de operare, este transmis către program și oprește bucla infinită în așteptarea noii sosiri a datelor de măsurare.

Până acum, fișierul jurnal a fost creat cu succes, iar acest program va apela programul de analiză pentru a studia rezultatele experimentului nostru.

Iată două experimente, iar comparația arată diferența foarte notabilă prin atașarea unui dispozitiv de 7 grame în locații diferite.

În Fig.2, folosim o scală pentru a determina greutatea reală a acestui aparat de măsurare bluetooth.

Fig.3 ilustrează configurarea pendulului în care dispozitivul de 7 grame este atașat la capătul inferior al pendulului. Configurația de configurare din Fig.4 are masa de 7 grame situată mult mai aproape de pivotul oscilant.

Fig.5 este o vedere de ansamblu a structurii pendulului.

Pasul 4: Analiza datelor

Aparatul de măsurare Bluetooth cântărește ~ 7 grame, care cântărește mult mai puțin decât un stick de lemn lung de ~ 1,6 metri. Folosiți ipoteza „tijei uniforme rigide” și avem această ecuație a perioadei pendulului, T1 = 2 * pi * (2l / 3g) ^ 0,5

Pentru a obține constanta gravitațională, putem folosi 9.8m / s ^ 2. Dar o constantă de greutate mai precisă la o anumită geolocalizare poate fi preluată din acest serviciu web:

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

Pentru San Francisco, acesta este de 9.81278m / s ^ 2

Lungimea pendulului este măsurată la 64,5"

2 * pi * sqrt (2 * 64,5 * 0,0254 / (3 * 9,81278)) dă perioada pendulului așteptat de 2,0962 (sec).

Să vedem dacă este de acord cu experimentele noastre.

În primul experiment, configurarea pendulului are dispozitivul de 7 grame atașat la capătul inferior al pendulului. Fișierul meu jurnal ar putea fi descărcat în:

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

Redenumiți-l în „PendulumTestData.txt” și puneți-l în același folder al programului de analiză python. Un instantaneu al codului sursă este oferit aici.

#! / usr / bin / env python # - * - codare: UTF-8 - * - import csv import matplotlib.pyplot ca plt plt.style.use ('seaborn-whitegrid') import numpy ca np din datetime import datetime, timedelta import seaborn as sns from sklearn.cluster import KMeans from collections collections Counter ####################################### ############################## # această funcție execută analiza fișierului de date ############# ####################################################### ## def parseDataLogFile (datafilename): ############################################## ####################### # extrageți datele din fișierul jurnal de date separat (CSV) și salvați conținutul din fiecare coloană într-o singură variabilă de tip float ## ####################################################### ############ cu open (datafilename) ca fișier csv: 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 = pentru rând în readCSV: încercați: x = datetime.strptime (rând [0].split (',') [0], '% H:% M:% S.% f ') timestampS.append (timedelta (hours = x.hour, minutes = x.minute, seconds = x.second, microseconds = x.microsecond).total_seconds ()) fAccelHwUnit_x.append (float (rând) [1] [4:])) fAccelHwUnit_y.append (float (rând [2])) fAccelHwUnit_z.append (float (rând [3])) fGyroHwUnit_x.append (float (rând [4])) fGyroHwUnit_y.append (float (rând [5])) fGyroHwUnit_z.append (float (rând [6])) fMagHwUnit_x.append (float (rând [7])) fMagHwUnit_y.append (float (rând [8])) fMagHwUnit_z.append (float (rând) [9])) fRPYdeg_r.append (float (rând [10])) fRPYdeg_p.append (float (rând [11])) fRPYdeg_y.append (float (rând [12])) cu excepția: pass timestampS = np.asarray (timestamps) timestamps = timestamps - timestamps [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)

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

# avem nevoie de o estimare exactă a frecvenței de eșantionare pentru o estimare precisă a perioadei de oscilare ####################################### ############################# FsHz = getSamplingIntervalS (timestampS) ################# ################################################ # utilizare componenta pitch în ieșirea sistemului de referință a poziției de atitudine pentru analiza perioadei pendulului ######################################### ############################ analiza_timp_secuvență (timestampS, fRPYdeg_p, FsHz, 'pitch') ############ ###################################################### ### # utilizați ieșirea de măsurare brută accelerometru pentru analiza perioadei pendulului ######################################### ########################### analyse_tempaSecuvență (timestampS, fAccelHwUnit_x, FsHz, 'accel') ########### ###################################################### ### # utilizați ieșirea de măsurare brută giroscopică pentru analiza perioadei pendulului ######################################### ############################ analysis_timeSequence (timestampS, fGyroHwUnit_y, FsHz, ' gyro ') print (' gata, felicitări:-) ') plt.show () ################################## ################################## # în procesul de comunicare bluetooth, există o șansă rară ca pachetul de comunicare de date să poată să ne pierdem # folosim K-mean pentru a izola datele de măsurare de 20Hz din valori anormale, care sunt cauzate de scăderea pachetului # scufundare în „semnal și sistem pentru mai multe detalii” ################# ################################################### def getSamplingIntervalS (timestampS): plt.figure () sampleIntervalS = np.diff (timestampS) sns.distplot (sampleIntervalS) plt.ylabel ('histogramă') plt.xlabel ('interval de măsurare (s)') clusterCnt = 5 km = KMeans (n_clusters = clusterCnt) km.fit (sampleIntervalS.reshape (-1, 1)) centroids = km.cluster_centers_ elemCnt = Counter (km.labels_) occurrenceCnt = for ii in range (clusterCnt): occurrenceCnt.append (elemCnt [ii]) FsHz = 1 / centroizi [occurrenceCnt.index (max (occurrenceCnt))] returnează FsHz

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

# folosiți spectrometrul, adică FFT de scurtă durată pentru a obține componenta de frecvență, vârful bin este cea mai bună estimare a oscilației pendulului ############################# ####################################### analize_timeSequence (timestampS, timeSeqData, FsHz, strComment): fig, (ax1, ax2) = plt.subplots (nrows = 2) ax1.plot (timestampS, timeSeqData, marker = 'o', markerfacecolor = 'blue', markersize = 2, color = 'skyblue', lățime de linie = 1) ax1.set_title ("măsurare domeniu timp pendul -% s"% strComment) ax1.set_xlabel ("timp de eșantionare (al doilea)") ax1.set_ylabel (strComment); NFFT = 2048 # lungimea segmentelor de fereastră

Pxx, frecvente, bins, im = ax2.specgram (timeSeqData, NFFT = NFFT, Fs = FsHz, noverlap = NFFT / 2)

ax2.set_title ("Spectrogram") ax2.set_xlabel ("mostre") ax2.set_ylabel ("frecvența (Hz)");

# Metoda `specgram` returnează 4 obiecte. Sunt:

# - Pxx: periodograma # - frecvente: vectorul de frecvență # - bins: centrele binsurilor de timp # - im: matplotlib.image. AxesImage instance reprezentând datele din grafic pkresult = np.where (Pxx == np.amax (Pxx)) oscFreqHz = freqs [pkresult [0] [0] print ('pendulare oscilație Freq (Hz) =% f, Perioada (Sec) =% f, sursa de date de estimare:% s'% (oscFreqHz, 1 / oscFreqHz, strComment)) returnează 1 / oscFreqHz

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

# ar trebui să rulăm acest program independent, adică nefiind chemat de pendulum1.py, # definim un nume implicit de fișier de date jurnal care urmează să fie analizat ###################### ############################################## dacă _name_ == "_main_ ": defaultFilename = './PendulumTestData.txt' import os.path if os.path.isfile (defaultFilename): parseDataLogFile (defaultFilename) else: print (" fișierul jurnal implicit% s nu există "% defaultFilename)

Pentru actualizarea pe termen lung, vă rugăm să verificați

Codul sursă conține comentarii detaliate, să prezentăm aici un rezumat la nivel înalt al estimării matematice.

1) Mai întâi citim conținutul fișierului CSV în computer, folosind un pachet python numit „csv”. Avem măsurători periodice.

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) Deoarece rata de măsurare este atât de critică și introduce direct eroarea de estimare a perioadei pendulului, dorim să le estimăm. Intervalul nostru nominal de măsurare este de 50 ms, adică 20Hz. Media pentru toate măsurătorile pare OK, dar ocazional pierdem pachetul de transmisie a datelor, intervalul de actualizare devine 100ms sau 150ms, …

Dacă trasăm apariția acestor date, vezi Fig.1, ca om, putem avea cu ușurință o valoare globală a ochilor de 0,05sec. Cu toate acestea, putem face mai bine decât atât?

Trebuie să folosim metoda de clasificare pentru a selecta numai cele bune pentru calculul mediu. Python are o cutie de instrumente denumită KMeans pentru a ne ajuta cu clusterizarea sau pentru a spune clasificarea. Aceste concepte sunt utilizate în multe domenii de date mari și AI.

3) Fig.2 conține două imagini. Graficul de sus este o secvență de domeniu în timp a măsurării unghiului de oscilare în deg. Referindu-ne la marca temporală a axei x în secunda, putem citi aproximativ 22,5 cicluri în 50 de secunde, ceea ce se traduce în perioada de pendul de 2,22 sec. Există o modalitate de a automatiza acest proces și de a avea o estimare mai precisă? Da, putem folosi un instrument matematic numit spectrogramă, care folosește o mică parte din datele de măsurare și ne spune frecvența, vezi figura de mai jos. Citirea axei y pentru cea mai întunecată linie este frecvența de oscilare a pendulului. Fiind o linie orizontală confirmă că oscilația pendulului nu sa schimbat deloc pe tot parcursul experimentului. Valoarea inversă a frecvenței de oscilație este perioada de oscilație a pendulului.

Raportul final realizat de program este un rezumat text:

oscilația pendulului Freq (Hz) = 0.449224, Perioada (Sec) = 2.226059, sursa datelor de estimare: pitch

Putem găsi rezultatul nostru anterior de calcul al mâinii globului ocular, 2.22sec, este destul de consistent cu valoarea calculată a programului.

Comparativ cu valoarea calculată teoretic de 2.0962 (sec), avem o eroare rămasă de ~ 5%. Cum să scapi de ele? Vă amintiți presupunerea că este „tija uniformă rigidă”? Chiar și o greutate suplimentară de 7 grame pare banală, este cea mai mare cauză a erorii rămase.

Acum mutăm dispozitivul, aproape de pivot. Vedeți pasul anterior pentru o fotografie în prim plan. Fișierul jurnal creat de mine poate fi descărcat de aici:

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

Rulați aceiași pași de analiză și obținem Perioada de 2.089867 (Sec), vezi Fig.3, care este aproape identică cu predicția teoretică. Grozav!

Deoarece avem nu numai măsurarea unghiului oscilant, ci și măsurarea giroscopică și măsurarea accelerometrului în același ritm. Rulați aceeași analiză pentru celelalte două măsurători, obținem rezultate în figurile 4 și 5. Estimările din toate cele trei surse de măsurare sunt de acord, ceea ce ne face mai încrezători în succesul experimentului nostru.

Iată rezultatul ca rezultat final al programului python care rulează:

oscilația pendulului Frecvență (Hz) = 0,478499, Perioada (Sec) = 2,089867, sursa datelor de estimare: pas

oscilația pendulului Frecvență (Hz) = 0,478499, Perioada (Sec) = 2,089867, sursa de date de estimare: accel

oscilația pendulului Freq (Hz) = 0.478499, Perioada (Sec) = 2.089867, sursa de date de estimare: giroscop

Ultimul gând din acest pas, cum pot rezultatele estimării să fie exact identice folosind diferite surse de date de intrare? Aceasta este contra-intuiție. Voi lăsa această întrebare în seama cititorilor. Iată un indiciu: vă amintiți că folosim FFT de scurtă durată pentru a estima frecvența oscilației? În domeniul digital, estimarea frecvenței este dată în pubele de frecvență discrete în loc de o estimare a numărului flotant.

Pasul 5: Recomandări de muncă viitoare

Există puține categorii de recomandări de muncă viitoare.

În etapa anterioară, reușim să reducem eroarea experimentului de la ~ 5% la mai puțin de 1%, putem face mai bine decât atât? Observând că magnitudinea oscilației scade exponențial, un factor care poate contribui poate fi tragerea aerului cauzată de balansarea pendulului. Secțiunea transversală a pendulului ar trebui să fie modificată pentru a avea o formă raționalizată, astfel încât să se reducă rezistența aerodinamică.

Putem aplica un câștig variabil în timp învățat folosind tehnici de filtrare adaptive pentru a emite un semnal constant de mărime de vârf. Între timp, corelați atenuarea magnitudinii cu forțele externe.

Cu greu putem găsi ceva mai simplu decât „simpla mișcare armonică”. Putem folosi facilitățile pe care le analizăm pendulul pentru a analiza ceva mai complicat, o activitate sportivă, o secvență de lansare a rachetelor de apă etc.?

Hacking fericit