Eksperimentel undersøgelse af enkel harmonisk bevægelse: 5 trin

2024 Forfatter: John Day | [email protected]. Sidst ændret: 2024-01-30 08:27

Af arrowlikeFølg mere af forfatteren:

I klasseværelset bruger vi ofte et stopur til at udføre pendulforsøget eller et simpelt harmonisk bevægelseseksperiment. Her er en udfordring, kan vi producere en reel graf over dens bevægelse og se, hvad der er den øjeblikkelige vinkelstilling og hastighed, det er meget mere information og sjov.

Første spørgsmål, vi skal beslutte, at pendullegemet er en vægtløs ledning eller en stiv ensartet stang. Ledningen tilgang synes at være lettere. Fra praksis med at bygge en har jeg følgende afvejningshensyn: Den nemmeste måde at hænge et pendelsystem på er at hænge det til den øverste kant af din dør. Det giver din ~ 2 m pendellængde uden at foretage strukturelle bygningsarbejde. Men det har brug for, at gyngen ikke rører døroverfladen, hvilket simpelthen ødelægger hele eksperimentet. Så det fly, det svinger, skal være præcist parallelt med din væg/døroverflade. En vægtløs ledning har en tendens til at være tynd, den kan let snurre og vanskeliggøre målingen af svingningsvinklen. Vi vil bruge en måling til at repræsentere svingningstilstanden. Tynd snor, såsom fiskelinje, kan være elastisk og strækbar, der påvirker en af vores vigtigste konstanter målt af os og brugt i ligningen, som er pendulets længde. Nogle kan også blive påvirket af temperaturen. Vægtmassen, der hænger for enden af snoren, skal være tung nok, så ledningens vægt bliver ubetydelig. Kommenter venligst, hvis du er enig eller uenig med dem, eller hvis du har andre idéer om designafvejninger. For at studere dette problem har vi brug for en enhed, der er så let, at dens vægt kan ignoreres, og vi behandler stadig pendulsystemet som en stiv ensartet stang. Jeg bruger en COTS bærbar elektronisk controller, som leverer gyro-, accelerometer- og vinkelinformation til os via bluetooth -forbindelse. Disse målinger gemmes i en datafil til en mobiltelefon -app. Derefter analyserer vi dataene for vores simple harmoniske bevægelseseksperiment. Den numeriske analyse fokuserer på følgende emner: 1) Forudsig penduloscillationsperioden 2) Indsaml programmerbart pendulets simple harmoniske bevægelseseksperimentdata 3) Brug kmean til at gruppere data og fjerne outliers i analyseprocessen 4) Brug korttids-FFT til at estimere pendulens svingningsfrekvens

Forbrugsvarer

Bluetooth måleudstyr

Android -telefon -app: Gå til Google playstore, søg i M2ROBOTS og installer kontrol -appen. Hvis det er svært at få adgang til Google playstore, kan du besøge min personlige hjemmeside for alternativ app -downloadmetode

træstang

få 3D -trykte dele

savklinger eller lignende metalmateriale

Trin 1: Hvad er pendul? Hvordan modelleres det?

Der er mange artikler og bøger, der introducerer pendulligningsafledningen, herunder din pensumfysikbog. Sådant indhold kan være bedre ikke at blive gentaget her igen. Kun den endelige konklusion er angivet her om emnet "simpel harmonisk bevægelse". For at kende et penduls periode er alt, hvad vi behøver at vide, længden af pendulet, angivet som "l", i meter.

Hvis vi er rimeligt sikre på, at vægten er placeret næsten fuldstændigt for enden af en vægtløs ledning, der hænger i en pivot, og pendulet svinger i små vinkler θ, siger mindre end 15 °, er perioden T1 for et sådant pendul givet ved:

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

g = tyngdekraftacceleration, cirka 9,8 m/s^2

Hvis den vægtløse ledning erstattes af en stiv ensartet stang, igen med længden l, er dens enkle harmoniske bevægelsesperiode T2 givet ved T1 = 2*pi*(2l/3g)^0,5

Den har effektivt samme periode som et vægtløst snorpendul, der er to tredjedele af den stive ensartede stanglængde.

Dette er baggrunden, og vi kan begynde at forberede vores eksperiment.

Trin 2: Forbered delene til hardwareopbygning

For at bygge pendulstrukturen udskriver vi nogle dele i 3D og genbruger noget, vi allerede har. Den samlede pendulstruktur er vist i figur 1. Det er en blanding af 3D -printdele sammen med nogle håndlavede dele og et langt stykke træstang fra Lowes.

Den 3D -trykte del i figur 2 er hængt på den øverste kant af en dør, fordi vores dør er en let flad overflade for os at hænge noget. Link til download af STL -fil:

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

Den grønne del i figur 3 forbinder træstangen til et blad, og bladet sidder oven på to skinner, der er monteret på den tidligere 3D -trykte dørbøjle. Link til download af STL -fil:

De to skinner er fremstillet ved at bryde et gammelt savblad i halve, se fig. 4. Delen i fig. 2 har forberedt den rigtige slidsestørrelse til dem. Ideelt set kan vi lave et "V" -formet hak i de to savklinger ved hjælp af en fil. Et rimeligt skarpt kantmetal, såsom et enkeltbladskniv, eller et håndlavet metalstykke, kan sidde inde i de "V" -formede hak. Grunden til, at vi har brug for et mindre kontaktområde, er at reducere den kinetiske energi, der går tabt under svingning.

Den sidste 3D -udskrevne del i figur 5 er en lille bakke til opbevaring af det elektroniske måleudstyr.

Downloadlinket:

Bluetooth -måleudstyret genererer vinkelestimat, gyro -måling og accelerometer -måling. Alle disse data er tilgængelige for os via et trådløst bluetooth -link.

Vi kommer til at udføre flere eksperimenter ved at implementere dette apparat på forskellige positioner af pendularmen og se forskellene.

Trin 3: Indsamling af eksperimentdata

Der er to anvendelige metoder til den eksperimentelle dataindsamling, før vi analyserer det erhvervede datasæt:

1) Brug den Android -telefonapp, der er angivet i afsnittet med krav, til at logge al den måling, som apparatet producerer, i en datafil, der er gemt på telefonens SD -kort. Vi kan kopiere filen og efterbehandle oplysningerne.

2) Brug en bluetooth-aktiveret computer, en pc, en bærbar computer eller en RaspberryPi mini-computer til at oprette en bluetooth-forbindelse til apparatet og læse dataene til enten realtids- eller offline-analyse.

Der findes både fordele og ulemper ved hver metode, vi vil prøve begge dele og fortælle forskellen i denne instruerbare.

For metode (1) ved brug af Android -appen, vil telemetri -data, der sendes fra bluetooth -måleudstyret til Android -telefonen, når vi er i android App -kontrolinterfacet, blive registreret i en datalogfil ved navn m2flightDatayyyymmdd_hhmmss.txt. Det kan findes i din Android -telefons download/m2LogFiles -mappe. Mappen "Download" er en eksisterende mappe i din telefons Android OS, og "m2LogFiles" er en mappe, som appen oprettede. Filnavnets indhold yyyymmdd_hhmmss er måden at kode eksperimentets starttid (år, måned, dag, time, minut og sek) i filnavnet på.

Hver linje i logfilen er en post. Det starter med begivenhedens tidsstempel, præamblestrengen "eam:", efterfulgt af 4 tripletdata, som er:

Accelerometer XYZ -akselavlæsning i rå sensorhardware -registreringsværdier

Gyroskop XYZ -akse -aflæsning i rå sensorhardware -registreringsværdier

Magnetometer XYZ -akselæsning i rå sensorhardware -registreringsværdier

ombord estimeret Roll/Pitch/Raw i grad

Datafilen, der er oprettet ved hjælp af computer -python -program, bruger identisk datafilformat, så det program, vi bruger i dataanalysetrinnet, ikke bliver generet af datakilden, der produceres af vores python -program eller Android -app.

Lad os begynde at kode ved hjælp af metode (2).

For at interagere med bluetooth -måleudstyret leveres der to varianter af SDK:

1) Python SDK, som kan installeres af "pip3 install m2controller", python3 er det sprog, der bruges. Eksemplerne på brugerapplikationskode gemmes i https://github.com/xiapeiqing/m2robots/tree/maste… Til dette eksperiment vil vi bruge python script pendulum1.py

2) Java SDK, som ikke bruges i denne instruerbare, fordi vi ønsker senere visualisering og analyse af de erhvervede penduldata, hvilket kan tage lidt mere indsats for os at programmere i Java.

Python3 -dataindsamlingsprogrammets kildekode indeholder mange kommentarer til kodefunktionalitetsdetaljer. Et øjebliksbillede af kildekoden findes her.

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

requestExit = Falsk

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

#vi ønsker at bruge den samme logfil -navngivningskonvention, så dataanalysemodulet, pendulum2.py, kan være agnostisk for, hvordan vi får logdatafilen ################# ################################################# logfilename = " m2flightData%s.txt "%(datetime.datetime.fromtimestamp (time.time ()). strftime ('%Y%m%d_%H%M%S')) dataLogfile = open (logfilnavn," w ")

def signal_handler (sig, frame):

global requestExit print ('bruger Ctrl-C for at afslutte programkørsel') requestExit = True signal.signal (signal. SIGINT, signal_handler)

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

#efter hver måledata bliver tilgængelig med 20Hz hastighed, vil denne "tilbagekaldsfunktion" blive indkaldt ################################ ################################## 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'] [0] 'm_fMagHwUnit'] [1], telemetri ['m_fMagHwUnit'] [2], telemetri ['m_fRPYdeg'] [0], telemetri ['m_fRPYdeg'] [1], telemetri ['m_fRPYdeg'] [2]) ## #################################################### ##############vi udskriver datastrengen på skærmen og gemmer dem i logfilen ####################### ########################################## print (dataStr) dataLogfile.writelines (dataStr)

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

#initialiser controlleren, husk at indstille feltet BleMACaddress til at være din enheds MAC -adresse ################################## #################################TODO: lad os initialisere BleMACaddress, hvis den ikke indstilles af brugeren. controller = m2controller. BleCtrller (m2Const.etDebian, callbackfunc, usrCfg. BleMACaddress) controller.connect () mens True: ########################### ########################################vent på måledata oprettet og sendt fra pendelmålingen apparat ################################################### ################ controller.m_CommsTunnel.waitForNotifications (1.0) if requestExit: ######################### ##########################################husholdning fungerer her, når vi er færdige med datalogning #################################################### ############### controller.stop () dataLogfile.close () pause

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

#dataindsamling afsluttet, lad os nu analysere logdata ######################################### ########################## pendulum2.parseDataLogFile (logfilnavn)

For langsigtet opdatering, bedes du tjekke

Lad os nu forklare dens driftsmetode. Dette python -program er skrevet oven på en pip -installerbar pakke, der hedder m2controller. Pakken på lavere niveau tilbyder tilbagekaldsmekanisme, så hver modtaget måleopdatering vil udløse den tilbagekaldsfunktion, vi skrev, og gemme dataene i en lokal logfil. Formatet på logfildataindhold er identisk med det, der produceres af android -ledsager -appen, så datalogfilen, der er oprettet af enten python -program eller andriod -ledsager -app, kan udskiftes.

Brugerens ctrl-C-signal, fanget af operativsystemet, sendes til programmet og stopper den uendelige sløjfe, der venter på den nye ankomst af måledata.

Indtil nu er logfilen oprettet med succes, og dette program vil kalde analyseprogrammet for at studere vores eksperimentresultater.

Her er to eksperimenter, og sammenligningen viser den meget mærkbare forskel ved at vedhæfte en 7gram enhed forskellige steder.

I figur 2 bruger vi en skala til at bestemme den faktiske vægt af dette bluetooth -måleudstyr.

Fig. 3 viser pendulopsætningen, hvor 7gram -enheden er fastgjort til den nedre ende af pendulet. Opsætningskonfiguration i fig. 4 har en masse på 7 gram placeret meget tættere på den svingende drejning.

Fig. 5 er et nærbillede af pendulstrukturen.

Trin 4: Dataanalyse

Bluetooth -måleapparatet vejer ~ 7 gram, hvilket vejer meget mindre end en ~ 1,6 meter lang træpind. Brug antagelsen om "stiv ensartet stang", og vi har denne pendulperiode ligning, T1 = 2*pi*(2l/3g)^0,5

For at få tyngdekraften konstant kan vi bruge 9,8 m/s^2. Men en mere præcis tyngdekraftskonstant ved enhver given geografisk placering kan hentes fra denne webtjeneste:

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

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

Pendellængden måles til 64,5 ''

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

Lad os se, om det stemmer overens med vores eksperimenter.

I det første eksperiment har pendulopsætningen 7gram -enheden fastgjort til den nedre ende af pendulet. Min logfil kunne downloades i:

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

Omdøb det til "PendulumTestData.txt" og læg det i den samme mappe i python -analyseprogrammet. Et øjebliksbillede af kildekoden findes her.

#!/usr/bin/env python#-*-kodning: 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 funktion kører datafil analyse arbejde ############# #################################################### ## def parseDataLogFile (datafilename): ########################################### ########################udtræk data i den kommaseparerede datalogfil (CSV) og gem indholdet i hver kolonne i en variabel af float-typen ## #################################################### ############ med åbent (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 række i readCSV: prøv: x = datetime.strptime (række [0].split (',') [0], '%H:%M:%S.%f ') timestampS.append (timedelta (timer = x.time, minutter = x.minut, sekunder = x.sekund, mikrosekunder = x.mikrosekund).total_seconds ()) fAccelHwUnit_x.append (float (række [1] [4:])) fAccelHwUnit_y.append (float (række [2])) fAccelHwUnit_z.append (float (række [3])) fGyroHwUnit_x.append (float (række [4])) fGyroHwUnit_y.append (float (række [5])) fGyroHwUnit_z.append (float (række [6])) fMagHwUnit_x.append (float (række [7])) fMagHwUnit_y.append (float (række [8])) fMagHwUnit_z.append (float (række) [9])) fRPYdeg_r.append (float (række [10])) fRPYdeg_p.append (float (række [11])) fRPYdeg_y.append (float (række [12])) undtagen: passér tidsstempler = 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 har brug for nøjagtigt estimat af prøveudtagningsfrekvensen for præcist estimat af oscillationsperioden ##################################### ############################# FsHz = getSamplingIntervalS (tidsstempler) ################# ################################################ # brug tonehøjdekomponent i holdningskursreferencesystemoutput til pendulperiodesanalyse ####################################### ############################ analyse_timeSequence (tidsstempler, fRPYdeg_p, FsHz, 'pitch') ########### #################################################### ####brug acceleromter rå måleoutput til pendulperiode analyse ###################################### ############################ analyse_timeSequence (tidsstempler, fAccelHwUnit_x, FsHz, 'accel') ############ #################################################### ####brug gyro rå måleoutput til pendulperiode analyse ###################################### ############################ analyse_timeSequence (tidsstempler, fGyroHwUnit_y, FsHz, ' gyro ') print (' klar, tillykke:-) ') plt.show () ################################# ###################################i bluetooth kommunikationsproces, er der en sjælden chance for at datakommepakken kan gå tabt#vi bruger K-mean til at isolere 20Hz-måledataene fra outliers, som er forårsaget af tabt pakke#dyk ned i "signal og system for flere detaljer" ################ ################################################# def getSamplingIntervalS (tidsstempler): plt.figure () sampleIntervalS = np.diff (timestampS) sns.distplot (sampleIntervalS) plt.ylabel ('histogram') plt.xlabel ('måleinterval (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))] returnerer FsHz

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

#brug spektrometer, dvs. kort tid FFT til at få frekvenskomponenten, spidsbakke er vores bedste estimat af penduloscillation ########################### ###################################### 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 af pendultiden domæne - %s" %strComment) ax1.set_xlabel ("sampling tid (anden)") ax1.set_ylabel (strComment); NFFT = 2048 # længden af vinduesegmenterne

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

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

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

# - Pxx: periodogrammet # - freqs: frekvensvektoren # - bakker: tidsrummernes centre # - im: matplotlib.image. AxesImage -forekomsten, der repræsenterer dataene i plottet pkresult = np.where (Pxx == np.amax (Pxx)) oscFreqHz = freqs [pkresult [0] [0] print ('penduloscillation Freq (Hz) =%f, Periode (Sec) =%f, estimationsdatakilde:%s'%(oscFreqHz, 1/oscFreqHz, strComment)) returnerer 1/oscFreqHz

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

#skal vi køre dette program uafhængigt, dvs. ikke kaldes af pendulum1.py,#definerer vi et standard logdatafilnavn, der skal analyseres ##################### ############################################## hvis _name_ == "_main_ ": defaultFilename = './PendulumTestData.txt' import os.path if os.path.isfile (defaultFilename): parseDataLogFile (defaultFilename) else: print (" standard logfil %s findes ikke " %defaultFilename)

For langsigtet opdatering, bedes du tjekke

Kildekoden indeholder detaljerede kommentarer, lad os give et resumé på højt niveau af det matematiske estimat her.

1) Vi læste først CSV -filens indhold ind på computeren ved hjælp af en python -pakke kaldet "csv". Vi har periodisk måling.

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) Da målehastigheden er så kritisk og direkte introducerer estimeringsfejl i pendulperioden, vil vi estimere dem. Vores nominelle måleinterval er 50 ms, dvs. 20Hz. Gennemsnit over alle målinger virker OK, men vi taber lejlighedsvis datatransmissionspakke, opdateringsintervallet bliver 100 ms eller 150 ms, …

Hvis vi plotter forekomsten af disse data, se figur 1, som et menneske, kan vi let have en øjeætsværdi på 0,05 sek. Men kan vi gøre det bedre end det?

Vi skal bruge klassificeringsmetoden til kun at vælge de gode til gennemsnitlig beregning. Python har værktøjskasse kaldet KMeans for at hjælpe os med klynger eller sige klassificering. Disse begreber bruges i mange big data- og AI -områder.

3) Fig. 2 indeholder to billeder. Det øverste plot er en tidsdomænesekvens af vores svingende vinkelmåling i grader. Ved at henvise til x-aksen tidsstempel i Second, kan vi læse cirka 22,5 cykler på 50 sekunder, hvilket oversætter til 2,22 Sec pendulperiode. Er der en måde at automatisere denne proces og få et mere præcist estimat? Ja, vi kan bruge matematisk værktøj kaldet spektrogram, som bruger en lille del af måledata og fortæller os dens frekvens, se figuren herunder. Y-aksens aflæsning for den mørkeste linje er penduloscillationsfrekvensen. At være en vandret linje bekræfter, at penduloscillationen slet ikke ændrede sig under hele forsøget. Den omvendte værdi af oscillationsfrekvensen er penduloscillationsperioden.

Den endelige rapport fra programmet er et tekstresumé:

penduloscillationsfrekvens (Hz) = 0.449224, periode (sek.) = 2.226059, estimeringsdatakilde: pitch

Vi kan finde vores tidligere øjeæblende håndberegningsresultat, 2.22sek, nogenlunde i overensstemmelse med programmets beregnede værdi.

Sammenlignet med 2.0962 (sek) teoretisk beregnet værdi har vi ~ 5% resterende fejl. Hvordan slippe af med dem? Kan du huske, at antagelsen er "stiv ensartet stang"? Selv en 7 gram ekstra vægt virker triviel, det er den største årsag til den resterende fejl.

Vi flytter nu enheden tæt på drejen. Se forrige trin for et nærbillede. Logfilen, jeg har oprettet, kan downloades her:

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

Kør de samme analysetrin, og vi får Periode på 2.089867 (sek), se figur 3, som er næsten identisk med den teoretiske forudsigelse. Store!

Da vi ikke kun har svingende vinkelmåling, men også gyroskopisk måling og accelerometermåling i samme hastighed. Kør den samme analyse for de to andre målinger, vi får resultater i figur 4 og 5. Estimater fra alle tre målekilder er enige, hvilket gør os mere sikre på succesen med vores eksperiment.

Her er resultatet som det sidste output af et python -program, der kører:

penduloscillationsfrekvens (Hz) = 0.478499, periode (sek) = 2.089867, estimeringsdatakilde: pitch

penduloscillation Freq (Hz) = 0.478499, Periode (sek) = 2.089867, estimeringsdatakilde: accel

penduloscillationsfrekvens (Hz) = 0.478499, periode (sek) = 2.089867, estimeringsdatakilde: gyro

Sidste tanke i dette trin, hvordan kan estimeringsresultaterne være nøjagtig identiske ved hjælp af forskellige inputdatakilder? Dette er modintuition. Jeg vil overlade dette spørgsmål til læserne. Her er et tip: husker vi, at vi bruger korttids-FFT til at estimere svingningsfrekvensen? I digitalt domæne er frekvensestimatet givet i diskrete frekvensbeholdere i stedet for et estimat med flydende antal.

Trin 5: Fremtidige arbejdsanbefalinger

Der er få kategorier af fremtidige arbejdsanbefalinger.

I tidligere trin formår vi at reducere vores eksperimentfejl fra ~ 5% til mindre end 1%, kan vi gøre det bedre end det? Bemærk at svingningsstørrelsen falder eksponentielt, en medvirkende faktor kan være luftmængden forårsaget ved svingning af pendulet. Tværsnittet af pendulet skal muligvis ændres for at have en strømlinet form for at reducere det aerodynamiske træk.

Kan vi anvende en tidsvarierende forstærkning lært ved hjælp af adaptive filterteknikker til at udsende et konstant spidsstyrkesignal. I mellemtiden, korrelere størrelsesdæmpningen vil eksterne kræfter.

Vi kan næsten ikke finde noget enklere end den "simple harmoniske bevægelse". Kan vi bruge de faciliteter, vi analyserer pendulet til at analysere noget mere kompliceret, en sportsaktivitet, en sekvens til opsendelse af vandraketter osv.?

Glad hacking