Eksperimentell studie av enkel harmonisk bevegelse: 5 trinn

2024 Forfatter: John Day | [email protected]. Sist endret: 2024-01-30 11:22

Av arrowlikeFølg Mer av forfatteren:

I klasserommet bruker vi ofte en stoppeklokke for å gjennomføre pendeleksperimentet, eller et enkelt harmonisk bevegelseseksperiment. Her er en utfordring, kan vi lage en ekte graf over bevegelsen og se hva som er øyeblikkelig vinkelposisjon og hastighet, det er mye mer informasjon og moro.

Første spørsmål, vi må bestemme at pendelhuset er en vektløs ledning eller en stiv, ensartet stang. Ledningstilnærmingen ser ut til å være enklere. Fra praksisen med å bygge en, har jeg følgende avveininger: Den enkleste måten å henge et pendelsystem på er å henge den opp til dørkanten. Det gir ~ 2 m pendellengde uten å gjøre noen konstruksjonsbygging. Men den trenger at svingen ikke berører døroverflaten, noe som ganske enkelt ødelegger hele eksperimentet. Så flyet det skal svinge bør være nøyaktig parallelt med veggen/døroverflaten. En vektløs ledning har en tendens til å være tynn, den kan lett snurre og komplisere måling av svingvinkel. Vi ønsker å bruke en måling for å representere svingningstilstanden. Tynn snor, for eksempel fiskelinje, kan være elastisk og tøyelig, som påvirker en av våre viktigste konstanter målt av oss og brukt i ligningen, som er lengden på pendelen. Noen kan også påvirkes av temperaturen. Vektmassen som henger i enden av ledningen må være tung nok til at vekten av ledningen blir ubetydelig. Vennligst kommenter hvis du er enig eller uenig med dem, eller hvis du har andre design -kompromissideer. For å studere dette problemet trenger vi en enhet som er så lett at vekten kan ignoreres, og vi behandler fremdeles pendelsystemet som en stiv, ensartet stang. Jeg bruker en COTS bærbar elektronisk kontroller, som leverer gyro-, akselerometer- og vinkelinformasjon til oss via Bluetooth -tilkobling. Disse målingene lagres i en datafil for en mobiltelefonapp. Etter det vil vi analysere dataene for vårt enkle harmoniske bevegelseseksperiment. Den numeriske analysen fokuserer på følgende emner: 1) Forutsi pendeloscillasjonsperioden 2) Programmerbart samle pendelen enkle harmoniske bevegelseseksperimentdata 3) Bruk kmean til å gruppere data og fjerne ekstremer i analyseprosessen 4) Bruk korttids-FFT for å estimere pendelens svingningsfrekvens

Rekvisita

Bluetooth måleutstyr

Android -telefonapp: Gå til Google playstore, søk i M2ROBOTS og installer kontrollappen. I tilfelle det er vanskelig å få tilgang til Google playstore, kan du besøke min personlige hjemmeside for en alternativ nedlastingsmetode for apper

trestang

få 3D -trykte deler

sagblad eller lignende metallmateriale

Trinn 1: Hva er pendel? Hvordan modellere den?

Det er mange artikler og bøker som introduserer pendulligningsavledningen, inkludert læreplanens fysikkbok. Slikt innhold kan være bedre å ikke gjenta seg her igjen. Bare den endelige konklusjonen er oppført her angående temaet "enkel harmonisk bevegelse". For å kjenne perioden til en pendel, trenger vi bare vite lengden på pendelen, angitt som "l", i meter.

Hvis vi er rimelig sikre på at vekten er plassert nesten helt på enden av en vektløs ledning som henger i en sving, og pendelen svinger i små vinkler θ, si mindre enn 15 °, er perioden T1 for en slik pendel gitt av:

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

g = tyngdekraftakselerasjon, omtrent 9,8 m/s^2

Hvis den vektløse ledningen erstattes av en stiv, ensartet stang, igjen med lengde l, er dens enkle harmoniske bevegelsesperiode T2 gitt med T1 = 2*pi*(2l/3g)^0,5

Effektivt har den samme periode som en vektløs ledningspendel som er to tredjedeler av den stive jevne stanglengden.

Dette er bakgrunnen, og vi kan begynne å forberede vårt eksperiment.

Trinn 2: Forbered delene for maskinvarebygging

For å bygge pendelstrukturen, trykker vi noen deler i 3D og resirkulerer noe vi allerede har. Den generelle pendelstrukturen er vist i figur 1. Det er en blanding av 3D -printdeler sammen med noen håndlagde deler og et langt stykke trestang fra Lowe's.

Den 3D -trykte delen på figur 2 henger på den øvre kanten av en dør, fordi døren vår er en lett flat overflate for oss å henge noe på. Link til nedlasting av STL -fil:

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

Den grønne delen i figur 3 kobler trestangen til et blad, og bladet sitter på toppen av to skinner som er montert på den tidligere 3D -trykte dørhengeren. Link til nedlasting av STL -fil:

De to skinnestykkene lages ved å knekke et gammelt sagblad i to, se fig. 4. Delen i figur 2 har utarbeidet riktig spaltestørrelse for dem. Ideelt sett kan vi lage et "V" -formet hakk i de to sagbladene ved hjelp av en fil. Et rimelig skarpt kantmetall, som et barberblad med en kant, eller et håndlaget metallstykke, kan sitte inne i de "V" -formede hakkene. Grunnen til at vi trenger et mindre kontaktområde er å redusere den kinetiske energien som går tapt mens du svinger.

Den siste 3D -trykte delen i figur 5 er en liten skuff for å holde det elektroniske måleutstyret.

Nedlastingskoblingen:

Bluetooth -måleutstyret genererer vinkelestimat, gyro -måling og akselerometermåling. Alle disse dataene er tilgjengelige for oss via trådløs Bluetooth -lenke.

Vi skal utføre flere eksperimenter ved å distribuere dette apparatet på forskjellige posisjoner av pendelarmen, og se forskjellene.

Trinn 3: Datainnsamling av eksperimenter

Det er to gjennomførbare metoder for den eksperimentelle datainnsamlingen før vi analyserer det ervervede datasettet:

1) Bruk Android -telefonappen som er angitt i kravdelen for å logge alle målinger produsert av apparatet i en datafil som er lagret på telefonens SD -kort. Vi kan kopiere filen og deretter behandle informasjonen.

2) Bruk en Bluetooth-aktivert datamaskin, en PC, en bærbar datamaskin eller en RaspberryPi mini-datamaskin for å opprette en Bluetooth-tilkobling til apparatet og lese dataene for analyse i sanntid eller offline.

Det finnes både fordeler og ulemper for hver metode, vi skal prøve begge deler og fortelle forskjellen på denne instruerbare.

For metode (1) ved bruk av Android -appen, når vi er i Android App -kontrollgrensesnittet, blir telemetradataene som sendes fra bluetooth -måleutstyret til Android -telefonen, registrert i en datalogfil med navnet m2flightDatayyyymmdd_hhmmss.txt. Den finnes i Android -telefonens Download/m2LogFiles -mappe. Mappen "Last ned" er en eksisterende mappe i telefonens Android-operativsystem, og "m2LogFiles" er en mappe som appen opprettet. Filnavninnholdet yyyymmdd_hhmmss er måten å kode eksperimentets starttid (år, måned, dag, time, minutt og sek) i filnavnet.

Hver linje i loggfilen er én post. Det starter med hendelsens tidsstempel, innledningsstrengen "eam:", etterfulgt av 4 triplettdata, som er:

Akselerometer XYZ -akselavlesning i rå sensorhardware registrerer gjenopprettingsverdier

Gyroskop XYZ -akselavlesning i rå sensorhardware registrerer gjenopprettingsverdier

Magnetometer XYZ -akselavlesning i rå sensorhardware registrerer gjenopprettingsverdier

ombord estimert Roll/Pitch/Raw i grad

Datafilen som er opprettet ved hjelp av datamaskinens python -program vil bruke identiske datafilformater, slik at programmet vi bruker i dataanalysetrinnet ikke vil bli plaget med datakilden som produseres av vårt pythonprogram eller Android -appen.

La oss begynne å kode ved hjelp av metode (2).

For å samhandle med Bluetooth -måleinstrumentet, tilbys to smaker av SDK:

1) Python SDK, som kan installeres av "pip3 install m2controller", python3 er språket som brukes. Eksemplene på brukerapplikasjonskode er lagret i https://github.com/xiapeiqing/m2robots/tree/maste… For dette eksperimentet vil vi bruke python script pendulum1.py

2) Java SDK, som ikke brukes i denne instruerbare fordi vi ønsker senere visualisering og analyse av de ervervede pendeldataene, noe som kan ta litt mer innsats for oss å programmere i Java.

Kildekoden til python3 -dataindsamlingsprogrammet inneholder mange kommentarer for kodefunksjonalitetsdetaljer. Et øyeblikksbilde av kildekoden er gitt her.

#!/usr/bin/env python#-*-koding: UTF-8-*-fra m2controller import m2controller fra m2controller import m2Const import signal import time import datetime import usrCfg import pendulum2

requestExit = False

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

#vi ønsker å bruke den samme loggfilnavnkonvensjonen slik at dataanalysemodulen, pendulum2.py, kan være agnostisk for hvordan vi får loggdatafilen ################# ################################################# logfilename = " m2flightData%s.txt "%(datetime.datetime.fromtimestamp (time.time ()). strftime ('%Y%m%d_%H%M%S')) dataLogfile = open (loggfilnavn," w ")

def signal_handler (sig, frame):

global requestExit print ('bruker Ctrl-C for å avslutte programkjøring') requestExit = True signal.signal (signal. SIGINT, signal_handler)

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

#når hver måledata blir tilgjengelig med 20Hz -hastighet, vil denne "tilbakeringingsfunksjonen" bli innkalt ################################ ################################## def callbackfunc (telemetri): 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, telemetri ['m_fAccelHwUnit'] [0], telemetri ['m_fAccelHwUnit'] [1], telemetri ['m_fAccelHwUnit'] [2], telemetri ['m_fGyroHwUnit'] [0], telemetri ['m_fGyroHwUnit'] [1], telemetri ['m_fGyroHwUnit'] [2], telemetri ['m_fMagHwUnit'] ['m_fMagHwUnit'] [1], telemetri ['m_fMagHwUnit'] [2], telemetri ['m_fRPYdeg'] [0], telemetri ['m_fRPYdeg'] [1], telemetri ['m_fRPYdeg'] [2]) ## #################################################### ##############vi skriver ut datastrengen på skjermen og lagrer dem i loggfilen ####################### ########################################### print (dataStr) dataLogfile.writelines (dataStr)

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

#initialiser kontrolleren, husk å angi feltet BleMACaddress til å være enhetens MAC -adresse ################################## #################################TODO: la oss initialisere BleMACaddress hvis den ikke blir angitt av brukeren. controller = m2controller. BleCtrller (m2Const.etDebian, callbackfunc, usrCfg. BleMACaddress) controller.connect () while True: #################################### ########################################vent på måledata som er opprettet og sendt fra pendelmålingen apparat ################################################### ################ controller.m_CommsTunnel.waitForNotifications (1.0) if requestExit: ######################### ##########################################husholdning fungerer her når vi er ferdige med datalogging #################################################### ############### controller.stop () dataLogfile.close () break

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

#datainnsamling fullført, la oss nå analysere loggdata ######################################### ########################## pendulum2.parseDataLogFile (loggfilnavn)

For langsiktig oppdatering, vennligst sjekk

La oss nå forklare driftsmetoden. Dette python -programmet er skrevet på toppen av en pip installerbar pakke, kalt m2controller. Pakken på lavere nivå tilbyr tilbakeringingsmekanisme, slik at hver mottatt måleoppdatering vil utløse tilbakeringingsfunksjonen vi skrev, og lagre dataene i en lokal loggfil. Formatet på loggfilens datainnhold er identisk med det som produseres av android companion -appen, slik at datalogfilen som er opprettet av enten python -program eller andriod -companion -app, kan byttes ut.

Brukerens ctrl-C-signal, fanget opp av operativsystemet, sendes til programmet og stopper den uendelige sløyfen som venter på ny ankomst av måledata.

Til nå har loggfilen blitt opprettet, og dette programmet vil ringe analyseprogrammet for å studere våre eksperimentresultater.

Her er to eksperimenter, og sammenligningen viser den svært merkbare forskjellen ved å feste en 7gram enhet på forskjellige steder.

I figur 2 bruker vi en skala for å bestemme den faktiske vekten til dette måleinstrumentet for bluetooth.

Fig. 3 viser pendeloppsettet der 7gram -enheten er festet til den nedre enden av pendelen. Oppsettskonfigurasjon i figur 4 har 7gram -massen plassert mye nærmere den svingende pivoten.

Fig. 5 er et nærbilde av pendelstrukturen.

Trinn 4: Dataanalyse

Bluetooth -apparatet veier ~ 7 gram, som veier mye mindre enn en ~ 1,6 meter lang trepinne. Bruk forutsetningen om "stiv uniform stang", og vi har denne pendelperiode -ligningen, T1 = 2*pi*(2l/3g)^0,5

For å få tyngdekraften konstant kan vi bruke 9,8 m/s^2. Men en mer nøyaktig tyngdekraftskonstant ved en gitt geolokalisering kan hentes fra denne webtjenesten:

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

For san francisco er det 9,81278m/s^2

Pendellengden måles til 64,5 ''

2*pi*sqrt (2*64,5*0,0254/(3*9,81278)) gir den forventede pendelperioden på 2,0962 (sek).

La oss se om det stemmer med våre eksperimenter.

I det første eksperimentet har pendeloppsettet 7gram -enheten festet til nedre ende av pendelen. Loggfilen min kan lastes ned på:

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

Gi det nytt navn til "PendulumTestData.txt" og legg det i samme mappe i python -analyseprogrammet. Et øyeblikksbilde av kildekoden er gitt her.

#!/usr/bin/env python#-*-koding: UTF-8-*-import csv import matplotlib.pyplot som plt plt.style.use ('seaborn-whitegrid') import numpy som np fra datetime import datetime, timedelta import seaborn som sns fra sklearn.cluster import KMeans fra samlinger import Counter ################################### ###############################denne funksjonen kjører datafilanalysearbeidet ############# #################################################### ## def parseDataLogFile (datafilename): ########################################### ########################pakke ut data i komma-atskilt dataloggfil (CSV) og lagre innholdet i hver kolonne i en float-type variabel ## #################################################### ############# med åpent (datafilename) som 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 = for rad i readCSV: prøv: x = datetime.strptime (rad [0].split (',') [0], '%H:%M:%S.%f ') timestampS.append (timedelta (timer = x.time, minutter = x.minute, sekunder = x.second, microseconds = x.microsecond).total_seconds ()) fAccelHwUnit_x.append (float (rad) [1] [4:])) fAccelHwUnit_y.append (float (rad [2])) fAccelHwUnit_z.append (float (rad [3])) fGyroHwUnit_x.append (float (rad [4])) fGyroHwUnit_y.append (float (rad [5])) fGyroHwUnit_z.append (float (rad [6])) fMagHwUnit_x.append (float (rad [7])) fMagHwUnit_y.append (float (rad [8])) fMagHwUnit_z.append (float (rad) [9])) fRPYdeg_r.append (float (rad [10])) fRPYdeg_p.append (float (rad [11])) fRPYdeg_y.append (float (rad [12])) unntatt: pass tidsstempel = np.asarray (Tidsstempler) tidsstempler = tidsstempler - tidsstempler [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)

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

#vi trenger nøyaktig estimat av samplingsfrekvensen for nøyaktig estimering av oscillasjonsperioden ##################################### ############################ FsHz = getSamplingIntervalS (tidsstempel) ################# ################################################ # bruk tonehøydekomponent i holdningshodet referanse systemutgang for pendelperiode analyse ###################################### ############################ analyse_timeSequence (tidsstempler, fRPYdeg_p, FsHz, "tonehøyde") ########### #################################################### ####bruk acceleromter rå måleutgang for pendelperiode analyse ###################################### ############################ analyse_timeSequence (tidsstempler, fAccelHwUnit_x, FsHz, 'accel') ############ #################################################### ####bruk gyro råmåling for pendelperiode analyse ###################################### ############################ analys_timeSequence (tidsstempler, fGyroHwUnit_y, FsHz, ' gyro ') print (' done, gratulerer:-) ') plt.show () ################################# ###################################i Bluetooth kommunikasjonsprosess, er det en sjelden sjanse for at datakommepakken kan gå tapt#vi bruker K-mean til å isolere 20Hz måledata fra ekstremer, som er forårsaket av at pakke#dykker ned i "signal og system for flere detaljer" ################ ################################################# def getSamplingIntervalS (tidsstempel): plt.figure () sampleIntervalS = np.diff (timestampS) sns.distplot (sampleIntervalS) plt.ylabel ('histogram') plt.xlabel ('måleintervall (er)') 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/centroids [occurrenceCnt.index (max (occurrenceCnt))] return FsHz

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

#bruk spektrometer, dvs. kort tid FFT for å få frekvenskomponenten, toppbøtte er vårt beste estimat for pendeloscillasjon ########################### ###################################### def analyse_timeSequence (tidsstempler, 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 ("måling av pendeltidsdomene - %s" %strComment) ax1.set_xlabel ("sampling time (second)") ax1.set_ylabel (strComment); NFFT = 2048 # lengden på vindussegmentene

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

ax2.set_title ("Spectrogram") ax2.set_xlabel ("samples") ax2.set_ylabel ("frekvens (Hz)");

# Metoden `specgram` returnerer 4 objekter. De er:

# - Pxx: periodogrammet # - frekvenser: frekvensvektoren # - søppelbøtter: tidssentrene i tidene # - im: matplotlib.image. AxesImage -forekomsten som representerer dataene i plottet pkresult = np.where (Pxx == np.amax (Pxx)) oscFreqHz = frekvenser [pkresultat [0] [0] print ('pendeloscillasjonsfrekvens (Hz) =%f, periode (sek) =%f, estimatidatakilde:%s'%(oscFreqHz, 1/oscFreqHz, strComment)) returnerer 1/oscFreqHz

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

#skal vi kjøre dette programmet uavhengig, dvs. ikke bli kalt av pendulum1.py,#definerer vi et standard loggdatafilnavn som skal analyseres ##################### ############################################# hvis _name_ == "_main_ ": defaultFilename = './PendulumTestData.txt' import os.path if os.path.isfile (defaultFilename): parseDataLogFile (defaultFilename) else: print (" standard loggfil %s finnes ikke " %defaultFilename)

For langsiktig oppdatering, vennligst sjekk

Kildekoden inneholder detaljerte kommentarer, la oss gi et sammendrag på høyt nivå av den matematiske estimeringen her.

1) Vi leser først CSV -filinnholdet på datamaskinen ved hjelp av en python -pakke kalt "csv". Vi har periodiske målinger.

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) Siden målehastigheten er så kritisk og direkte introduserer en estimeringsfeil i pendelperioden, ønsker vi å estimere dem. Vårt nominelle måleintervall er 50 ms, dvs. 20 Hz. Gjennomsnitt over alle målinger virker OK, men vi mister av og til dataoverføringspakke, oppdateringsintervallet blir 100 ms eller 150 ms, …

Hvis vi plotter forekomsten av disse dataene, se figur 1, som et menneske, kan vi enkelt ha en øyebollingsverdi på 0,05 sekunder. Men kan vi gjøre det bedre enn det?

Vi trenger å bruke klassifiseringsmetoden for å bare velge de gode for gjennomsnittsberegning. Python har verktøykassen kalt KMeans for å hjelpe oss med gruppering, eller si klassifisering. Disse konseptene brukes i mange store data- og AI -områder.

3) Fig. 2 inneholder to bilder. Det øverste plottet er en tidsdomensekvens av vår svingende vinkelmåling i grader. Ved å referere til x-aksen tidsstempel i Second, kan vi lese omtrent 22,5 sykluser på 50 sekunder, som oversetter til 2,22 Sec pendelperiode. Er det en måte å automatisere denne prosessen og ha et mer nøyaktig estimat? Ja, vi kan bruke matematisk verktøy kalt spektrogram, som bruker en liten del måledata og forteller oss frekvensen, se figuren nedenfor. Y-aksens avlesning for den mørkeste linjen er pendeloscillasjonsfrekvensen. Å være en horisontal linje bekrefter at pendeloscillasjonen ikke endret seg i det hele tatt under eksperimentet. Den omvendte verdien av oscillasjonsfrekvensen er pendeloscillasjonsperioden.

Den siste rapporten laget av programmet er en tekstoppsummering:

pendeloscillasjonsfrekvens (Hz) = 0.449224, periode (sek) = 2.226059, estimeringsdatakilde: tonehøyde

Vi kan finne ut at vårt tidligere beregning av hånden på hånden, 2,22 sekunder, er ganske konsistent med programmets beregnede verdi.

Sammenlignet med 2.0962 (sek) teoretisk beregnet verdi, har vi ~ 5% gjenværende feil. Hvordan bli kvitt dem? Husker du at antagelsen er "stiv uniform stang"? Selv en 7 gram ekstra vekt virker triviell, det er den største årsaken til den gjenværende feilen.

Vi flytter nå enheten, nær svinget. Se forrige trinn for et nærbilde. Loggfilen jeg opprettet kan lastes ned her:

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

Kjør de samme analysetrinnene, og vi får Periode på 2.089867 (sek), se figur 3, som er nesten identisk med den teoretiske spådommen. Flott!

Siden vi ikke bare har svingende vinkelmåling, men også gyroskopisk måling og akselerometermåling i samme takt. Kjør den samme analysen for de to andre målingene, vi får resultater i figur 4 og 5. Estimater fra alle tre målekildene er enige, noe som gjør oss mer sikre på suksessen til eksperimentet vårt.

Her er resultatet som den siste utgangen av python -programmet som kjører:

pendel oscillasjon Freq (Hz) = 0.478499, periode (sek) = 2.089867, estimeringsdatakilde: tonehøyde

pendel oscillasjon Freq (Hz) = 0.478499, periode (sek) = 2.089867, estimeringsdatakilde: accel

pendel oscillasjon Freq (Hz) = 0.478499, Periode (sek) = 2.089867, estimeringsdatakilde: gyro

Siste tanke i dette trinnet, hvordan kan estimeringsresultatene være nøyaktig identiske ved hjelp av forskjellige inngangskilder? Dette er motintuisjon. Jeg vil overlate dette spørsmålet til leserne. Her er et hint: husker vi at vi bruker korttids-FFT til å estimere svingningsfrekvensen? I digitalt domene er frekvensestimatet gitt i diskrete frekvensbinger i stedet for et flytende tallestimat.

Trinn 5: Fremtidige arbeidsanbefalinger

Det er få kategorier av fremtidige arbeidsanbefalinger.

I tidligere trinn klarer vi å redusere eksperimentfeilen fra ~ 5% til mindre enn 1%, kan vi gjøre det bedre enn det? Når du merker at svingningsstørrelsen avtar eksponensielt, kan en medvirkende faktor være luftmotstanden forårsaket når du svinger pendelen. Tverrsnittet av pendelen må kanskje modifiseres for å ha en strømlinjeformet form for å redusere den aerodynamiske motstanden.

Kan vi bruke en tidsvarierende gevinst som er lært ved hjelp av adaptive filterteknikker for å sende et konstant toppstørrelsessignal. I mellomtiden, korrelere størrelsen demping vil eksterne krefter.

Vi kan knapt finne noe enklere enn den "enkle harmoniske bevegelsen". Kan vi bruke fasilitetene vi analyserer pendelen til å analysere noe mer komplisert, en sportsaktivitet, en vannrakettoppskytningssekvens osv?

Glad hacking