Experimentele studie van eenvoudige harmonische beweging: 5 stappen

2024 Auteur: John Day | [email protected]. Laatst gewijzigd: 2024-01-30 11:16

Door arrowlikeVolg meer door de auteur:

In de klas gebruiken we vaak een stopwatch om het slingerexperiment of een eenvoudig harmonisch bewegingsexperiment uit te voeren. Hier is een uitdaging, kunnen we een echte grafiek van zijn beweging maken en zien wat de momentane hoekpositie en snelheid is, dat is veel meer informatie en plezier.

Eerste vraag, we moeten beslissen of het slingerlichaam een gewichtloos koord of een stijve uniforme staaf is. De koordbenadering lijkt eenvoudiger. Uit de praktijk om er een te bouwen, heb ik de volgende afwegingen gemaakt: De gemakkelijkste manier om een slingersysteem op te hangen, kan zijn om het aan de bovenrand van uw deur te hangen. Dat geeft uw slingerlengte van ~ 2 m zonder enige structurele bouwwerkzaamheden. Maar het heeft wel nodig dat de schommel het deuroppervlak niet raakt, wat het hele experiment gewoon verpest. Het vlak dat het zwaait, moet dus nauwkeurig evenwijdig aan uw muur-/deuroppervlak zijn. Een gewichtloos snoer is meestal dun, het kan gemakkelijk ronddraaien en de meting van de zwaaihoek bemoeilijken. We willen één meting gebruiken om de zwaaitoestand weer te geven. Dun koord, zoals een vislijn, kan elastisch en rekbaar zijn, wat een van onze belangrijkste constanten beïnvloedt die door ons worden gemeten en in de vergelijking worden gebruikt, namelijk de lengte van de slinger. Sommige kunnen ook worden beïnvloed door de temperatuur. De gewichtsmassa die aan het uiteinde van het koord hangt, moet zwaar genoeg zijn zodat het gewicht van het koord verwaarloosbaar wordt. Geef een reactie als u het ermee eens of oneens bent, of als u andere ideeën heeft voor een compromis over het ontwerp. Om dit probleem te bestuderen, hebben we een apparaat nodig dat zo licht is dat het gewicht ervan kan worden genegeerd en we behandelen het slingersysteem nog steeds als een stijve uniforme staaf. Ik gebruik een draagbare elektronische controller van COTS, die de gyro, versnellingsmeter en hoekinformatie aan ons levert via een Bluetooth-verbinding. Deze metingen worden opgeslagen in een gegevensbestand van een app voor de mobiele telefoon. Daarna zullen we de gegevens analyseren voor ons eenvoudige harmonische bewegingsexperiment. De numerieke analyse richt zich op de volgende onderwerpen: 1) Voorspel de slingeroscillatieperiode 2) Verzamel programmeerbaar de eenvoudige harmonische bewegingsexperimentgegevens van de slinger 3) Gebruik kmean om gegevens te groeperen en uitbijters in het analyseproces te verwijderen 4) Gebruik korte FFT om te schatten de slinger oscillatie frequentie

Benodigdheden

Bluetooth-meetapparaat

Android-telefoon-app: ga naar Google Playstore, zoek M2ROBOTS en installeer de controle-app. Als het moeilijk is om toegang te krijgen tot Google Playstore, bezoek dan mijn persoonlijke startpagina voor een alternatieve app-downloadmethode

houten staaf

paar 3D-geprinte onderdelen

zaagbladen of soortgelijk metalen materiaal

Stap 1: Wat zijn slinger? Hoe het te modelleren?

Er zijn veel artikelen en boeken die de afleiding van de slingervergelijking introduceren, waaronder je natuurkundeboek. Dergelijke inhoud kan hier beter niet worden herhaald. Alleen de eindconclusie wordt hier vermeld met betrekking tot het onderwerp "eenvoudige harmonische beweging". Om de periode van een slinger te kennen, hoeven we alleen maar de lengte van de slinger te weten, aangeduid als "l", in meters.

Als we er redelijk zeker van zijn dat het gewicht bijna volledig aan het einde van een gewichtloos koord hangt dat in een spil hangt, en de slinger zwaait onder kleine hoeken θ, zeg minder dan 15°, wordt de periode T1 van zo'n slinger gegeven door:

T1 = 2*pi*(l/g)^0.5

g = zwaartekrachtversnelling, ongeveer 9,8 m/s^2

Als het gewichtloze koord wordt vervangen door een stijve uniforme staaf, opnieuw met lengte l, wordt de eenvoudige harmonische bewegingsperiode T2 gegeven door T1 = 2*pi*(2l/3g)^0.5

In feite heeft het dezelfde periode als een gewichtloze koordslinger die tweederde is van de stijve uniforme staaflengte.

Dit is de achtergrond en we kunnen beginnen met het voorbereiden van ons experiment.

Stap 2: Bereid de onderdelen voor op het bouwen van hardware

Om de slingerstructuur te bouwen, printen we sommige onderdelen in 3D en recyclen we iets dat we al hebben. De algemene slingerstructuur wordt getoond in Fig.1. Het is een mix van 3D-printonderdelen samen met enkele handgemaakte onderdelen en een lang stuk houten staaf van Lowe's.

Het 3D-geprinte deel in Fig.2 hangt aan de bovenrand van een deur, omdat onze deur een gemakkelijk plat oppervlak is om iets op te hangen. STL-bestand downloadlink:

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

Het groene deel in Fig. 3 verbindt de houten staaf met een blad en het blad zit bovenop twee stukken rail die op de eerdere 3D-geprinte deurhanger zijn gemonteerd. STL-bestand downloadlink:

De twee stukken rail worden gemaakt door een oud zaagblad doormidden te breken, zie Fig. 4. Het onderdeel in Fig.2 heeft de juiste sleufmaat voor hen voorbereid. Idealiter kunnen we met een vijl een "V"-vormige inkeping in die twee zaagbladen maken. Een redelijk scherp metaal, zoals een scheermesje met één rand, of een met de hand gemaakt metalen stuk, kan in de "V"-vormige inkepingen zitten. De reden dat we een kleiner contactoppervlak nodig hebben, is om de kinetische energie die verloren gaat tijdens het slingeren te verminderen.

Het laatste 3D-geprinte onderdeel in Fig.5 is een klein bakje voor het elektronische meetapparaat.

De downloadlink:

Het bluetooth-meetapparaat genereert hoekschatting, gyrometing en accelerometermeting. Al deze gegevens zijn voor ons beschikbaar via een draadloze Bluetooth-verbinding.

We gaan meerdere experimenten uitvoeren door dit apparaat op verschillende posities van de slingerarm in te zetten en de verschillen te zien.

Stap 3: Experimentgegevens verzamelen

Er zijn twee uitvoerbare methoden voor het verzamelen van experimentele gegevens voordat we de verkregen dataset analyseren:

1) Gebruik de Android-telefoon-app die is gespecificeerd in het gedeelte met vereisten om alle metingen die door het apparaat zijn geproduceerd, in een gegevensbestand op te slaan dat is opgeslagen op de SD-kaart van uw telefoon. We kunnen het bestand kopiëren en de informatie nabewerken.

2) Gebruik een bluetooth-computer, een pc, een laptop of een RaspberryPi-minicomputer om een bluetooth-verbinding met het apparaat tot stand te brengen en de gegevens te lezen voor realtime of offline analyse.

Er zijn zowel voor- als nadelen voor elke methode, we gaan beide proberen en het verschil in deze instructable vertellen.

Voor methode (1) met behulp van de Android-app, zodra we in de Android App-besturingsinterface zijn, worden de telemetriegegevens die van het Bluetooth-meetapparaat naar de Android-telefoon worden verzonden, opgenomen in een datalogbestand met de naam m2flightDatayyyymmdd_hhmmss.txt. Het is te vinden in de map Download/m2LogFiles van uw Android-telefoon. De map "Download" is een reeds bestaande map in het Android-besturingssysteem van uw telefoon en "m2LogFiles" is een map die de app heeft gemaakt. De inhoud van de bestandsnaam yyyymmdd_uummss is de manier om de starttijd van het experiment (jaar, maand, dag, uur, minuut en sec) in de bestandsnaam te coderen.

Elke regel in het logbestand is één record. Het begint met het tijdstempel van de gebeurtenis, preambule string "eam:", gevolgd door 4 triplet-gegevens, die zijn:

Versnellingsmeter XYZ-asaflezing in onbewerkte sensorhardwareregister terugleeswaarden

Gyroscoop XYZ-as aflezing in onbewerkte sensor hardware register terugleeswaarden

Magnetometer XYZ-asaflezing in onbewerkte sensorhardwareregister terugleeswaarden

aan boord geschatte Roll/Pitch/Raw in graad

Het gegevensbestand dat is gemaakt met het computerpython-programma, gebruikt een identiek gegevensbestandsformaat, zodat het programma dat we gebruiken in de gegevensanalysestap geen last heeft van de gegevensbron die wordt geproduceerd door ons python-programma of onze Android-app.

Laten we beginnen met coderen met methode (2).

Om te communiceren met het Bluetooth-meetapparaat, zijn er twee soorten SDK beschikbaar:

1) Python SDK, die kan worden geïnstalleerd door "pip3 install m2controller", python3 is de gebruikte taal. De voorbeelden van gebruikerstoepassingscode zijn opgeslagen in https://github.com/xiapeiqing/m2robots/tree/maste… Voor dit experiment gebruiken we het python-script pendulum1.py

2) Java SDK, die niet wordt gebruikt in deze instructable omdat we latere visualisatie en analyse van de verkregen slingergegevens willen, wat misschien wat meer moeite kost om in Java te programmeren.

De broncode van het python3-programma voor het verzamelen van gegevens bevat veel opmerkingen over de details van de codefunctionaliteit. Een momentopname van de broncode vindt u hier.

#!/usr/bin/env python# -*- codering: UTF-8 -*- van m2controller import m2controller van m2controller import m2Const import signaal import tijd import datetime import usrCfg import pendulum2

requestExit = False

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

# we willen dezelfde naamgevingsconventie voor logbestanden gebruiken, zodat de data-analysemodule, pendulum2.py, agnostisch kan zijn voor hoe we het loggegevensbestand krijgen ################# ############################################### logbestandsnaam = " 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('gebruiker Ctrl-C om programma-uitvoering af te sluiten') requestExit = True signal.signal(signal. SIGINT, signal_handler)

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

# zodra alle meetgegevens beschikbaar komen met een snelheid van 20 Hz, wordt deze "callback"-functie opgeroepen ############################### ################################# def 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], telemetrie['m_fMagHwUnit'][1], telemetrie['m_fMagHwUnit'][2], telemetrie['m_fRPYdeg'][0], telemetrie['m_fRPYdeg'][1], telemetrie['m_fRPYdeg'][2]) ## ################################################## ############ # we printen de datastring naar het scherm en slaan ze op in het logbestand ###################### ########################################## print(dataStr) dataLogfile.writelines(dataStr)

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

# initialiseer de controller, vergeet niet om het veld BleMACaddress in te stellen als het MAC-adres van uw apparaat ################################# ############################### # TODO: laten we het BleMACaddress initialiseren als het niet door de gebruiker is ingesteld. controller = m2controller. BleCtrller(m2Const.etDebian, callbackfunc, usrCfg. BleMACaddress) controller.connect() terwijl True: ########################## ###################################### # wacht op meetgegevens die zijn gemaakt en verzonden vanaf de slingermeting apparaat ################################################# ############### controller.m_CommsTunnel.waitForNotifications(1.0) if requestExit: ######################## ######################################## # het huishouden werkt hier als we klaar zijn met datalogging ################################################## ############## controller.stop() dataLogfile.close() break

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

# gegevensverzameling voltooid, laten we nu de loggegevens analyseren ####################################### ######################### pendulum2.parseDataLogFile(logbestandnaam)

Ga voor een update op lange termijn naar

Laten we nu de werkingsmethode uitleggen. Dit python-programma is geschreven bovenop een pip installeerbaar pakket, genaamd m2controller. Het pakket op een lager niveau biedt een callback-mechanisme, zodat elke ontvangen meetupdate de callback-functie activeert die we hebben geschreven en de gegevens opslaat in een lokaal logbestand. Het formaat van de inhoud van de logbestandgegevens is identiek aan wat wordt geproduceerd door de Android Companion-app, zodat het datalogbestand dat is gemaakt door het Python-programma of de Andriod Companion-app uitwisselbaar is.

Het Ctrl-C-signaal van de gebruiker, vastgelegd door het besturingssysteem, wordt doorgegeven aan het programma en stopt de oneindige lus die wacht op de nieuwe aankomst van meetgegevens.

Tot nu toe is het logbestand met succes gemaakt en dit programma zal het analyseprogramma aanroepen om onze experimentresultaten te bestuderen.

Hier zijn twee experimenten, en de vergelijking toont het zeer opvallende verschil door een apparaat van 7 gram op verschillende locaties te bevestigen.

In figuur 2 gebruiken we een weegschaal om het werkelijke gewicht van dit bluetooth-meetapparaat te bepalen.

Fig.3 toont de slingeropstelling waarbij het 7gram-apparaat aan het onderste uiteinde van de slinger is bevestigd. Opstellingsconfiguratie in Fig. 4 heeft de 7 gram massa veel dichter bij het zwaaiende draaipunt.

Fig.5 is een close-up van de slingerstructuur.

Stap 4: Gegevensanalyse

Het bluetooth-meetapparaat weegt ~7 gram, wat veel minder weegt dan een ~1.6 meter lange houten stok. Gebruik de aanname van "stijve uniforme staaf", en we hebben deze slingerperiodevergelijking, T1 = 2 * pi * (2l / 3g) ^ 0,5

Om de zwaartekracht constant te krijgen, kunnen we 9,8m/s^2 gebruiken. Maar een nauwkeuriger zwaartekrachtconstante op een bepaalde geolocatie kan worden opgehaald uit deze webservice:

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

Voor San Francisco is dit 9,81278m/s^2

De slingerlengte wordt gemeten als 64,5''

2*pi*sqrt(2*64.5*0.0254/(3*9.81278)) geeft de verwachte slingertijd van 2.0962(sec).

Eens kijken of het overeenkomt met onze experimenten.

In het eerste experiment heeft de slingeropstelling het 7gram-apparaat bevestigd aan het onderste uiteinde van de slinger. Mijn logbestand kan worden gedownload in:

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

Hernoem het naar "PendulumTestData.txt" en plaats het in dezelfde map van het python-analyseprogramma. Een momentopname van de broncode vindt u hier.

#!/usr/bin/env python# -*- codering: UTF-8 -*- import csv import matplotlib.pyplot as plt plt.style.use('seaborn-whitegrid') import numpy als np van datetime import datetime, timedelta importeer zeegeboren als sns uit sklearn.cluster import KMeans uit collecties import Teller ################################### ############################# # deze functie voert de analyse van gegevensbestanden uit ############ ################################################## ## def parseDataLogFile(gegevensbestandsnaam): ########################################## ###################### # extraheer gegevens in het door komma's gescheiden datalogbestand (CSV) en sla de inhoud in elke kolom op in één variabele van het type float ## ################################################## ############ met open(datafilename) als 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 = voor rij in readCSV: try: x = datetime.strptime(row[0].split(', ')[0], '%H:%M:%S.%f') timestampS.append(timedelta(hours=x.hour, minutes=x.minute, seconds=x.second, microseconds=x.microseconds).total_seconds()) fAccelHwUnit_x.append(float(rij [1][4:])) fAccelHwUnit_y.append(float(rij[2])) fAccelHwUnit_z.append(float(rij[3])) fGyroHwUnit_x.append(float(rij[4])) fGyroHwUnit_y.append(float (rij[5])) fGyroHwUnit_z.append(float(rij[6])) fMagHwUnit_x.append(float(rij[7])) fMagHwUnit_y.append(float(rij[8])) fMagHwUnit_z.append(float(rij [9])) fRPYdeg_r.append(float(rij[10])) fRPYdeg_p.append(float(rij[11])) fRPYdeg_y.append(float(rij[12])) behalve: pass timestampS = np.asarray(tijdstempels) tijdstempels = tijdstempels - tijdstempels [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)

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

# we hebben een nauwkeurige schatting van de bemonsteringsfrequentie nodig voor een nauwkeurige schatting van de oscillatieperiode #################################### ############################ FsHz = getSamplingIntervalS(timestampS) ################ ################################################ # gebruik maken van toonhoogte component in de stand koers referentiesysteem output voor slingerperiode analyse ###################################### ########################### analysis_timeSequence(timestampS, fRPYdeg_p, FsHz, 'pitch') ########### ################################################## ### # gebruik de ruwe meetoutput van de versnellingsmeter voor de analyse van de slingerperiode ##################################### ########################### analysis_timeSequence(timestampS, fAccelHwUnit_x, FsHz, 'accel') ########### ################################################## ### # gebruik de ruwe meetoutput van de gyro voor de analyse van de slingerperiode ##################################### ########################### analysis_timeSequence(timestampS, fGyroHwUnit_y, FsHz, ' gyro') print('klaar, gefeliciteerd:-)') plt.show() ############################### ################################# # in het Bluetooth-communicatieproces is er een zeldzame kans dat het datacommunicatiepakket verloren gaan # we gebruiken K-mean om de meetgegevens van 20 Hz te isoleren van uitschieters, die worden veroorzaakt door een gevallen pakket # duik in "signaal en systeem voor meer details" ################ ################################################ def getSamplingIntervalS (timestampS): plt.figure() sampleIntervalS = np.diff(timestampS) sns.distplot(sampleIntervalS) plt.ylabel('histogram') plt.xlabel('meetinterval(s)') clusterCnt = 5 km = KMeans(n_clusters = clusterCnt) km.fit(sampleIntervalS.reshape(-1, 1)) centroids = km.cluster_centers_ elemCnt = Teller(km.labels_) occurrenceCnt = for ii in range(clusterCnt): occurrenceCnt.append(elemCnt[ii]) FsHz = 1/centroïden[occurrenceCnt.index(max(occurrenceCnt))] return FsHz

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

# gebruik spectrometer, dwz korte tijd FFT om de frequentiecomponent te krijgen, peak bin is onze beste schatting van slingeroscillatie ########################## ###################################### def analysis_timeSequence(timestampS, timeSeqData, FsHz, strCommentaar): fig, (ax1, ax2) = plt.subplots(nrows=2) ax1.plot(timestampS, timeSeqData, marker='o', markerfacecolor='blue', markersize=2, color='skyblue', linewidth=1) ax1.set_title("slingertijddomeinmeting -- %s"%strComment) ax1.set_xlabel("sampling time(second)") ax1.set_ylabel(strComment); NFFT = 2048 # de lengte van de venstersegmenten

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("frequentie(Hz)");

# De `specgram` methode retourneert 4 objecten. Zij zijn:

# - Pxx: het periodogram # - freqs: de frequentievector # - bins: de middelpunten van de tijd bins # - im: de instantie matplotlib.image. AxesImage die de gegevens in de plot vertegenwoordigt pkresult = np.where(Pxx == np.amax(Pxx)) oscFreqHz = freqs[pkresult[0][0] print('pendulum oscillation Freq(Hz)=%f, Period(Sec)=%f, schattingsgegevensbron: %s'%(oscFreqHz, 1/oscFreqHz, strComment)) retour 1/oscFreqHz

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

# moeten we dit programma onafhankelijk uitvoeren, dwz niet worden aangeroepen door pendulum1.py, # definiëren we een standaard loggegevensbestandsnaam die moet worden geanalyseerd #################### ############################################ if _name_ == "_main_ ": defaultFilename = './PendulumTestData.txt' import os.path if os.path.isfile(defaultFilename): parseDataLogFile(defaultFilename) else: print ("standaard logbestand %s niet aanwezig"%defaultFilename)

Ga voor een update op lange termijn naar

De broncode bevat gedetailleerde opmerkingen, laten we hier een samenvatting op hoog niveau van de wiskundige schatting geven.

1) We lezen eerst de inhoud van het CSV-bestand in de computer, met behulp van een python-pakket genaamd "csv". We hebben een periodieke meting.

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) Omdat de meetsnelheid zo kritisch is en direct een schattingsfout van de slingerperiode introduceert, willen we ze schatten. Ons nominale meetinterval is 50 ms, d.w.z. 20 Hz. Het gemiddelde over alle metingen lijkt in orde, maar we verliezen af en toe een datatransmissiepakket, het update-interval wordt 100ms of 150ms, …

Als we het voorkomen van deze gegevens plotten, zie figuur 1, als mens, kunnen we gemakkelijk een eyeballing-waarde van 0,05sec hebben. Kunnen we echter beter doen dan dat?

We moeten de classificatiemethode gebruiken om alleen de goede te selecteren voor berekening van het gemiddelde. Python heeft een toolbox genaamd KMeans om ons te helpen met clustering, of zeg maar classificatie. Deze concepten worden gebruikt in veel big data en AI-gebieden.

3) Fig.2 bevat twee afbeeldingen. De bovenste plot is een tijdsdomeinsequentie van onze zwaaihoekmeting in graden. Door te verwijzen naar de tijdstempel van de x-as in Second, kunnen we ongeveer 22,5 cycli in 50 seconden lezen, wat zich vertaalt naar een slingerperiode van 2,22 seconden. Is er een manier om dit proces te automatiseren en een nauwkeurigere schatting te krijgen? Ja, we kunnen een wiskundig hulpmiddel genaamd spectrogram gebruiken, dat een klein stukje meetgegevens gebruikt en ons de frequentie vertelt, zie de onderstaande afbeelding. De y-asaflezing voor de donkerste lijn is de slingeroscillatiefrequentie. Omdat het een horizontale lijn is, bevestigt dit dat de slingeroscillatie tijdens het experiment helemaal niet veranderde. De inverse waarde van de oscillatiefrequentie is de slingeroscillatieperiode.

Het eindrapport van het programma is een tekstsamenvatting:

slinger oscillatie Freq(Hz)=0.449224, Periode(Sec)=2.226059, schatting gegevensbron: toonhoogte

We kunnen zien dat ons eerdere resultaat van de oogverblindende handberekening, 2,22sec, redelijk consistent is met de door het programma berekende waarde.

Vergeleken met de theoretisch berekende waarde van 2.0962 (sec), hebben we een resterende fout van ~ 5%. Hoe kom je van ze af? Weet je nog dat de aanname "stijve uniforme staaf" is? Zelfs 7 gram extra gewicht lijkt triviaal, het is de grootste oorzaak van de resterende fout.

We verplaatsen het apparaat nu, dicht bij de spil. Zie vorige stap voor een close-up foto. Het logbestand dat ik heb gemaakt, kan hier worden gedownload:

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

Voer dezelfde analysestappen uit en we krijgen een periode van 2,089867 (sec), zie Fig. 3, die bijna identiek is aan de theoretische voorspelling. Super goed!

Omdat we niet alleen zwaaihoekmeting hebben, maar ook gyroscopische meting en accelerometermeting in hetzelfde tempo. Voer dezelfde analyse uit voor de andere twee metingen, we krijgen resultaten in Fig. 4 en 5. De schattingen van alle drie de meetbronnen komen overeen, waardoor we meer vertrouwen hebben in het succes van ons experiment.

Hier is het resultaat als de uiteindelijke uitvoer van het python-programma dat wordt uitgevoerd:

slinger oscillatie Freq (Hz) = 0,478499, Periode (Sec) = 2,089867, schatting gegevensbron: toonhoogte

slinger oscillatie Freq(Hz)=0,478499, Periode(Sec)=2,089867, schatting gegevensbron: accel

slinger oscillatie Freq(Hz)=0,478499, Periode(Sec)=2,089867, schatting gegevensbron: gyro

Als laatste gedachte in deze stap, hoe kunnen de schattingsresultaten precies identiek zijn met behulp van verschillende invoergegevensbronnen? Dit is contra-intuïtie. Deze vraag laat ik aan de lezers over. Hier is een hint: weet je nog dat we de korte-tijd FFT gebruiken om de oscillatiefrequentie te schatten? In het digitale domein wordt de frequentieschatting gegeven in discrete frequentiebakken in plaats van een zwevende getalschatting.

Stap 5: Toekomstige werkaanbevelingen

Er zijn weinig categorieën van toekomstige werkaanbevelingen.

In een eerdere stap slagen we erin om onze experimentfout te verminderen van ~ 5% tot minder dan 1%, kunnen we het beter doen dan dat? Als je merkt dat de grootte van de oscillatie exponentieel afneemt, kan een bijdragende factor de luchtweerstand zijn die wordt veroorzaakt bij het slingeren van de slinger. De dwarsdoorsnede van de slinger moet mogelijk worden aangepast om een gestroomlijnde vorm te krijgen om de aerodynamische weerstand te verminderen.

Kunnen we een in de tijd variërende versterking toepassen die is geleerd met behulp van adaptieve filtertechnieken om een constant piek-magnitude-signaal uit te voeren. In de tussentijd, correleer de grootteverzwakking met externe krachten.

We kunnen bijna niets eenvoudiger vinden dan de "eenvoudige harmonische beweging". Kunnen we de faciliteiten die we de slinger analyseren gebruiken om iets ingewikkelders te analyseren, een sportactiviteit, een waterraketlancering, enz.?

Gelukkig hacken