Experimentelle Untersuchung einfacher harmonischer Bewegungen - Gunook

2024 Autor: John Day | [email protected]. Zuletzt bearbeitet: 2024-01-30 07:17

Von arrowlikeFollow More vom Autor:

Im Klassenzimmer verwenden wir oft eine Stoppuhr, um das Pendelexperiment oder das einfache harmonische Bewegungsexperiment durchzuführen. Hier ist eine Herausforderung, können wir einen echten Graphen seiner Bewegung erstellen und sehen, was die momentane Winkelposition und Geschwindigkeit ist, das ist viel mehr Informationen und Spaß.

Erste Frage, wir müssen entscheiden, dass der Pendelkörper eine schwerelose Schnur oder ein starrer, einheitlicher Stab ist. Der Schnuransatz scheint einfacher zu sein. Aus der Praxis des Bauens habe ich die folgenden Kompromissüberlegungen: Der einfachste Weg, ein Pendelsystem aufzuhängen, könnte darin bestehen, es an die obere Kante Ihrer Tür zu hängen. Das ergibt Ihre Pendellänge von ~2m ohne bauliche Maßnahmen. Aber die Schaukel muss die Türoberfläche nicht berühren, was das ganze Experiment einfach ruiniert. Die Ebene, die es schwingt, sollte also genau parallel zu Ihrer Wand- / Türoberfläche sein. Ein schwereloses Seil ist in der Regel dünn, kann sich leicht drehen und erschwert die Messung des Schwungwinkels. Wir möchten eine Messung verwenden, um den Swing-Zustand darzustellen. Dünne Schnüre, wie Angelschnur, können elastisch und dehnbar sein, was eine unserer wichtigsten Konstanten beeinflusst, die von uns gemessen und in der Gleichung verwendet werden, nämlich die Länge des Pendels. Einige können auch von der Temperatur beeinflusst werden. Die am Ende der Schnur hängende Gewichtsmasse muss so schwer sein, dass das Gewicht der Schnur vernachlässigbar wird. Bitte kommentieren Sie, wenn Sie ihnen zustimmen oder nicht zustimmen oder andere Design-Kompromiss-Ideen haben. Um dieses Problem zu untersuchen, brauchen wir ein Gerät, das so leicht ist, dass sein Gewicht vernachlässigt werden kann und wir das Pendelsystem immer noch als starren, einheitlichen Stab behandeln. Ich verwende einen tragbaren elektronischen Controller von COTS, der uns die Kreisel-, Beschleunigungs- und Winkelinformationen über eine Bluetooth-Verbindung liefert. Diese Messungen werden in einer Handy-App-Datendatei gespeichert. Danach werden wir die Daten für unser einfaches harmonisches Bewegungsexperiment analysieren. Die numerische Analyse konzentriert sich auf die folgenden Themen: 1) Vorhersage der Pendelschwingungsperiode 2) Programmierbares Sammeln der einfachen harmonischen Pendelbewegungsexperimentdaten 3) Verwenden Sie kmean, um Daten zu gruppieren und Ausreißer im Analyseprozess zu entfernen 4) Verwenden Sie Kurzzeit-FFT zur Schätzung die Pendelschwingungsfrequenz

Lieferungen

Bluetooth-Messgerät

Android-Telefon-App: Gehen Sie zum Google Playstore, suchen Sie nach M2ROBOTS und installieren Sie die Steuerungs-App. Falls es schwierig ist, auf den Google Playstore zuzugreifen, besuchen Sie meine persönliche Homepage für eine alternative App-Download-Methode

Holzstab

wenige 3D-gedruckte Teile

Sägeblätter oder ähnliches Metallmaterial

Schritt 1: Was sind Pendel? Wie modelliert man es?

Es gibt viele Artikel und Bücher, die die Ableitung von Pendelgleichungen vorstellen, einschließlich Ihres Lehrplans für Physik. Solche Inhalte sollten hier besser nicht noch einmal wiederholt werden. Zum Thema "einfache harmonische Bewegung" sei hier nur das abschließende Fazit aufgeführt. Um die Periode eines Pendels zu kennen, müssen wir nur die Länge des Pendels, bezeichnet mit "l", in Metern kennen.

Wenn wir uns einigermaßen sicher sind, dass sich das Gewicht fast vollständig am Ende einer schwerelosen Schnur befindet, die in einem Drehpunkt hängt, und das Pendel in kleinen Winkeln θ schwingt, sagen wir weniger als 15°, ist die Periode T1 eines solchen Pendels gegeben durch:

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

g = Erdbeschleunigung, ca. 9,8 m/s^2

Ersetzt man die schwerelose Schnur durch einen starren gleichförmigen Stab, wiederum der Länge l, so ist seine einfache harmonische Bewegungsperiode T2 gegeben durch T1 = 2*pi*(2l/3g)^0.5

Effektiv hat es die gleiche Periode wie ein schwereloses Schnurpendel, das zwei Drittel der starren einheitlichen Stablänge beträgt.

Dies ist der Hintergrund, und wir können mit der Vorbereitung unseres Experiments beginnen.

Schritt 2: Bereiten Sie die Teile für den Hardwarebau vor

Um die Pendelstruktur zu bauen, drucken wir einige Teile in 3D und recyceln etwas, das wir bereits haben. Die Gesamtstruktur des Pendels ist in Abb. 1 dargestellt. Es ist eine Mischung aus 3D-Druckteilen zusammen mit einigen handgefertigten Teilen und einem langen Stück Holzstab von Lowe.

Das 3D-gedruckte Teil in Abb. 2 hängt an der Oberkante einer Tür, da unsere Tür eine einfache flache Oberfläche für uns ist, um etwas aufzuhängen. Downloadlink für STL-Datei:

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

Der grüne Teil in Abb. 3 verbindet die Holzstange mit einer Klinge, und die Klinge sitzt auf zwei Schienenstücken, die am früheren 3D-gedruckten Türhänger montiert waren. Download-Link für STL-Datei:

Die beiden Schienenstücke werden hergestellt, indem ein altes Sägeblatt in zwei Hälften gebrochen wird, siehe Abb. 4. Das Teil in Abb. 2 hat die richtige Schlitzgröße dafür vorbereitet. Idealerweise können wir mit einer Feile eine "V" -förmige Kerbe in diesen beiden Sägeblättern machen. Ein einigermaßen scharfkantiges Metall, wie eine einschneidige Rasierklinge oder jedes handgefertigte Metallstück, kann in den "V" -förmigen Kerben sitzen. Der Grund, warum wir eine kleinere Kontaktfläche benötigen, ist die Reduzierung der kinetischen Energie, die beim Schwingen verloren geht.

Das letzte 3D-gedruckte Teil in Abb. 5 ist ein kleines Tablett zur Aufnahme des elektronischen Messgeräts.

Der Download-Link:

Das Bluetooth-Messgerät erzeugt eine Winkelschätzung, eine Kreiselmessung und eine Beschleunigungsmessermessung. Alle diese Daten stehen uns über eine drahtlose Bluetooth-Verbindung zur Verfügung.

Wir werden mehrere Experimente durchführen, indem wir dieses Gerät an verschiedenen Positionen des Pendelarms einsetzen, und die Unterschiede sehen.

Schritt 3: Datensammlung experimentieren

Es gibt zwei praktikable Methoden für die experimentelle Datenerhebung, bevor wir den erfassten Datensatz analysieren:

1) Verwenden Sie die im Abschnitt "Anforderungen" angegebene Android-Telefon-App, um alle vom Gerät erzeugten Messungen in einer Datendatei zu protokollieren, die auf der SD-Karte Ihres Telefons gespeichert ist. Wir können die Datei kopieren und die Informationen nachbearbeiten.

2) Verwenden Sie einen Bluetooth-fähigen Computer, einen PC, einen Laptop oder einen RaspberryPi-Minicomputer, um eine Bluetooth-Verbindung zum Gerät herzustellen und die Daten entweder für die Echtzeit- oder Offline-Analyse auszulesen.

Es gibt sowohl Vor- als auch Nachteile für jede Methode, wir werden beide versuchen und den Unterschied in diesem anweisbaren sagen.

Bei Methode (1) mit der Android-App werden die vom Bluetooth-Messgerät an das Android-Telefon gesendeten Telemetriedaten, sobald wir uns in der Android-App-Steuerungsschnittstelle befinden, in einer Datenprotokolldatei namens m2flightDatayyyymmdd_hhmmss.txt aufgezeichnet. Es befindet sich im Ordner Download/m2LogFiles Ihres Android-Telefons. Der Ordner "Download" ist ein bereits vorhandener Ordner im Android-Betriebssystem Ihres Telefons und "m2LogFiles" ist ein Ordner, den die App erstellt hat. Der Inhalt des Dateinamens yyyymmdd_hhmmss dient dazu, die Startzeit des Experiments (Jahr, Monat, Tag, Stunde, Minute und Sekunde) im Dateinamen zu kodieren.

Jede Zeile in der Protokolldatei ist ein Datensatz. Es beginnt mit dem Ereigniszeitstempel, Präambelzeichenfolge "eam:", gefolgt von 4 Triplettdaten, die sind:

Beschleunigungsmesser-XYZ-Achsenablesung in den Rohdaten des Sensor-Hardwareregisters

Gyroskop-XYZ-Achsen-Lesen in den rohen Sensor-Hardware-Register-Lesewerten

XYZ-Achsenablesung des Magnetometers in den Rohdaten des Sensor-Hardwareregisters

Onboard geschätzte Roll/Pitch/Raw in Grad

Die mit dem Computer-Python-Programm erstellte Datendatei verwendet das identische Datendateiformat, sodass das Programm, das wir im Datenanalyseschritt verwenden, nicht mit der Datenquelle belästigt wird, die von unserem Python-Programm oder Android-App erstellt wird.

Beginnen wir mit der Codierung mit Methode (2).

Um mit dem Bluetooth-Messgerät zu interagieren, werden zwei SDK-Varianten bereitgestellt:

1) Python SDK, das mit "pip3 install m2controller" installiert werden kann, python3 ist die verwendete Sprache. Die Beispiele des Benutzeranwendungscodes sind in https://github.com/xiapeiqing/m2robots/tree/maste… gespeichert. Für dieses Experiment verwenden wir das Python-Skript pendulum1.py

2) Java SDK, das in diesem instructable nicht verwendet wird, weil wir eine spätere Visualisierung und Analyse der erfassten Pendeldaten wünschen, was für uns möglicherweise etwas mehr Aufwand erfordert, um in Java zu programmieren.

Der Quellcode des Python3-Datenerfassungsprogramms enthält viele Kommentare zu den Details der Codefunktionalität. Eine Momentaufnahme des Quellcodes wird hier bereitgestellt.

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

requestExit = False

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

# wir möchten die gleiche Namenskonvention für Protokolldateien verwenden, damit das Datenanalysemodul pendulum2.py unabhängig davon sein kann, wie wir die Protokolldatendatei erhalten ################# ############################################### Logdateiname = " 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('Benutzer Strg-C zum Beenden der Programmausführung') requestExit = True signal.signal(signal. SIGINT, signal_handler)

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

# Sobald Messdaten mit 20 Hz verfügbar sind, wird diese "Callback"-Funktion aufgerufen ############################### ################################# def callbackfunc(telemetry): strTimeStamp = datetime.datetime.fromtimestamp(time.time ()).strftime('%H:%M:%S.%f')[:-3] dataStr = "%s, eam:%d, %d, %d, %d, %d, %d, %d, %d, %d, %2.1f, %2.1f, %2.1f\n"%(strTimeStamp, telemetry['m_fAccelHwUnit'][0], telemetry['m_fAccelHwUnit'][1], telemetry['m_fAccelHwUnit'][2], 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]) ## ################################################ ############ # wir drucken den Datenstring auf den Bildschirm und speichern ihn in der Protokolldatei ###################### ########################################## print(dataStr) dataLogfile.writelines(dataStr)

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

# Initialisieren Sie den Controller, denken Sie daran, das Feld BleMACaddress auf die MAC-Adresse Ihres Geräts einzustellen ################################# ############################### # TODO: Lassen Sie uns die BleMAC-Adresse initialisieren, wenn sie nicht vom Benutzer festgelegt wurde. controller = m2controller. BleCtrller(m2Const.etDebian, callbackfunc, usrCfg. BleMACaddress) controller.connect() während True: ########################## ###################################### # auf Messdaten warten, die von der Pendelmessung erstellt und gesendet werden Gerät ################################################# ############### controller.m_CommsTunnel.waitForNotifications(1.0) falls angefordertExit: ######################## ######################################## # Hauswirtschaft arbeitet hier, wenn wir mit der Datenprotokollierung fertig sind ################################################ ############## controller.stop() dataLogfile.close() break

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

# Datensammlung abgeschlossen, jetzt analysieren wir die Protokolldaten ####################################### ######################### pendulum2.parseDataLogFile(logfilename)

Für ein langfristiges Update besuchen Sie bitte

Lassen Sie uns nun seine Betriebsmethode erklären. Dieses Python-Programm ist auf einem installierbaren Pip-Paket namens m2controller geschrieben. Das untergeordnete Paket bietet einen Callback-Mechanismus, sodass jedes empfangene Messupdate die von uns geschriebene Callback-Funktion auslöst und die Daten in einer lokalen Protokolldatei speichert. Das Format des Dateninhalts der Protokolldatei ist identisch mit dem, was von der Android-Begleit-App erstellt wird, sodass die Datenprotokolldatei, die entweder vom Python-Programm oder der Android-Begleit-App erstellt wurde, ausgetauscht werden kann.

Das vom Betriebssystem erfasste Benutzer-Strg-C-Signal wird an das Programm weitergegeben und stoppt die Endlosschleife, die auf den neuen Eingang von Messdaten wartet.

Bis jetzt wurde die Protokolldatei erfolgreich erstellt und dieses Programm ruft das Analyseprogramm auf, um unsere Experimentergebnisse zu studieren.

Hier sind zwei Experimente, und der Vergleich zeigt den sehr deutlichen Unterschied, indem ein 7-Gramm-Gerät an verschiedenen Orten angebracht wird.

In Abb.2 verwenden wir eine Waage, um das tatsächliche Gewicht dieses Bluetooth-Messgeräts zu bestimmen.

Abb. 3 zeigt den Pendelaufbau, bei dem das 7-Gramm-Gerät am unteren Ende des Pendels befestigt ist. Bei der Setup-Konfiguration in Abb. 4 befindet sich die 7-Gramm-Masse viel näher am schwingenden Drehpunkt.

Fig. 5 ist eine Nahaufnahme der Pendelstruktur.

Schritt 4: Datenanalyse

Das Bluetooth-Messgerät wiegt ~7 Gramm, was viel weniger wiegt als ein ~1,6 Meter langer Holzstab. Verwenden Sie die Annahme "starrer gleichförmiger Stab", und wir haben diese Pendelperiodengleichung T1 = 2*pi*(2l/3g)^0.5

Um die Gravitationskonstante zu erhalten, können wir 9,8 m/s^2 verwenden. Eine genauere Gravitationskonstante an einem bestimmten Standort kann jedoch von diesem Webservice abgerufen werden:

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

Für San Francisco sind es 9,81278 m/s^2

Die Pendellänge wird mit 64,5'' gemessen.

2*pi*sqrt(2*64,5*0,0254/(3*9.81278)) ergibt die erwartete Pendelperiode von 2,0962(s).

Mal sehen, ob es mit unseren Experimenten übereinstimmt.

Im ersten Experiment ist beim Pendelaufbau das 7-Gramm-Gerät am unteren Ende des Pendels befestigt. Meine Log-Datei kann heruntergeladen werden in:

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

Benennen Sie es in "PendulumTestData.txt" um und legen Sie es in den gleichen Ordner des Python-Analyseprogramms. Eine Momentaufnahme des Quellcodes wird hier bereitgestellt.

#!/usr/bin/env python# -*- Kodierung: UTF-8 -*- import csv import matplotlib.pyplot as plt plt.style.use('seaborn-whitegrid') import numpy as np from datetime import datetime, timedelta import seaborn als sns aus sklearn.cluster KMean aus Sammlungen importieren Zähler importieren ################################### ############################# # diese Funktion führt die Dateianalyse aus ############ ################################################ ## def parseDataLogFile(datafilename): ########################################## ###################### # Daten aus der kommagetrennten Datenprotokolldatei (CSV) extrahieren und den Inhalt jeder Spalte in einer Float-Variablen speichern ## ################################################## ############ mit 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 = für Zeile in readCSV: try: x = datetime.strptime(row[0].split(', ')[0], '%H:%M:%S.%f') timestampS.append(timedelta(hours=x.hour, minutes=x.minute, second=x.second, microseconds=x.microsecond).total_seconds()) fAccelHwUnit_x.append(float(row [1][4:])) fAccelHwUnit_y.append(float(row[2])) fAccelHwUnit_z.append(float(row[3])) fGyroHwUnit_x.append(float(row[4])) fGyroHwUnit_y.append(float (row[5])) fGyroHwUnit_z.append(float(row[6])) fMagHwUnit_x.append(float(row[7])) fMagHwUnit_y.append(float(row[8])) fMagHwUnit_z.append(float(row.) [9])) fRPYdeg_r.append(float(row[10])) fRPYdeg_p.append(float(row[11])) fRPYdeg_y.append(float(row[12])) außer: pass timestampS = np.asarray(Zeitstempel) Zeitstempel = Zeitstempel - Zeitstempel [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)

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

# wir benötigen eine genaue Schätzung der Abtastfrequenz für eine genaue Schätzung der Schwingungsperiode #################################### ############################ FsHz = getSamplingIntervalS(timestampS) ################ ################################################ # verwenden Pitch-Komponente in der Lage-Kursbezugssystemausgabe für Pendelperiodenanalyse ##################################### ########################### analysis_timeSequence(timestampS, fRPYdeg_p, FsHz, 'pitch') ########### ################################################ ### # Beschleunigungsmesswertausgang für Pendelperiodenanalyse verwenden ##################################### ########################### analysis_timeSequence(timestampS, fAccelHwUnit_x, FsHz, 'accel') ########### ################################################## ### # Kreisel-Rohmessausgabe für Pendelperiodenanalyse verwenden ##################################### ########################### analysis_timeSequence(timestampS, fGyroHwUnit_y, FsHz, ' gyro') print('fertig, herzlichen Glückwunsch:-)') plt.show() ############################### ################################# # Beim Bluetooth-Kommunikationsprozess besteht die seltene Möglichkeit, dass das Datenkommunikationspaket be lost # wir verwenden K-mean, um die 20Hz-Messdaten von Ausreißern zu isolieren, die durch verworfene Pakete verursacht werden # Tauchen Sie ein in "Signal und System für weitere Details" ################ ################################################ def getSamplingIntervalS (timestampS): plt.figure() sampleIntervalS = np.diff(timestampS) sns.distplot(sampleIntervalS) plt.ylabel('histogram') plt.xlabel('messintervall(s)') clusterCnt = 5 km = KMeans(n_clusters = clusterCnt) km.fit(sampleIntervalS.reshape(-1, 1)) centroids = km.cluster_centers_ elemCnt = Counter(km.labels_) VorkommenCnt = für ii im Bereich(clusterCnt): VorkommenCnt.append(elemCnt[ii]) FsHz = 1/centroids[occurrenceCnt.index(max(occurrenceCnt))] Rückgabe FsHz

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

# Spektrometer verwenden, dh Kurzzeit-FFT, um die Frequenzkomponente zu erhalten, Peak Bin ist unsere beste Schätzung der Pendelschwingung ########################## ###################################### def analysis_timeSequence(timestampS, timeSeqData, FsHz, strComment): fig, (ax1, ax2) = plt.subplots(nrows=2) ax1.plot(timestampS, timeSeqData, marker='o', markerfacecolor='blue', markersize=2, color='skyblue', linewidth=1) ax1.set_title("Pendelzeitbereichsmessung -- %s"%strComment) ax1.set_xlabel("Abtastzeit(Sekunde)") ax1.set_ylabel(strComment); NFFT = 2048 # die Länge der Fenstersegmente

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

ax2.set_title("Spektrogramm") ax2.set_xlabel("Beispiele") ax2.set_ylabel("Frequenz(Hz)");

# Die Methode `specgram` gibt 4 Objekte zurück. Sie sind:

# - Pxx: das Periodogramm # - freqs: der Frequenzvektor # - Bins: die Mitten der Zeit-Bins # - im: die matplotlib.image. AxesImage-Instanz, die die Daten im Plot repräsentiert pkresult = np.where(Pxx == np.amax(Pxx)) oscFreqHz = freqs[pkresult[0][0] print('Pendelschwingung Freq(Hz)=%f, Period(Sec)=%f, Schätzdatenquelle: %s'%(oscFreqHz, 1/oscFreqHz, strComment)) zurück 1/oscFreqHz

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

# sollten wir dieses Programm unabhängig ausführen, dh nicht von pendulum1.py aufgerufen werden, # definieren wir einen Standardnamen für die zu analysierende Protokolldatei #################### ############################################ if _name_ == "_main_ ": defaultFilename = './PendulumTestData.txt' import os.path if os.path.isfile(defaultFilename): parseDataLogFile(defaultFilename) else: print ("default log file %s not existing"%defaultFilename)

Für ein langfristiges Update besuchen Sie bitte

Der Quellcode enthält detaillierte Kommentare, lassen Sie uns hier eine grobe Zusammenfassung der mathematischen Schätzung geben.

1) Wir lesen zuerst den Inhalt der CSV-Datei in den Computer ein, indem wir ein Python-Paket namens "csv" verwenden. Wir haben regelmäßige Messungen.

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 die Messrate so kritisch ist und direkt den Schätzfehler der Pendelperiode einführt, wollen wir sie schätzen. Unser nominelles Messintervall beträgt 50ms, also 20Hz. Durchschnitt über alle Messungen scheint in Ordnung zu sein, aber wir verlieren gelegentlich Datenübertragungspakete, das Aktualisierungsintervall wird 100 ms oder 150 ms, …

Wenn wir das Auftreten dieser Daten grafisch darstellen, siehe Abb. 1, können wir als Mensch leicht einen Augapfelwert von 0,05 Sekunden erhalten. Aber können wir es besser machen?

Wir müssen die Klassifizierungsmethode verwenden, um nur die guten für die Mittelwertberechnung auszuwählen. Python hat eine Toolbox namens KMeans, die uns beim Clustering oder Klassifizieren hilft. Diese Konzepte werden in vielen Big-Data- und KI-Bereichen verwendet.

3) Abb. 2 enthält zwei Bilder. Der obere Plot ist eine Zeitbereichssequenz unserer Schwingwinkelmessung in Grad. Durch Bezugnahme auf den x-Achsen-Zeitstempel in Sekunde können wir ungefähr 22,5 Zyklen in 50 Sekunden ablesen, was einer Pendelperiode von 2,22 Sekunden entspricht. Gibt es eine Möglichkeit, diesen Prozess zu automatisieren und eine genauere Schätzung zu erhalten? Ja, wir können ein mathematisches Werkzeug namens Spektrogramm verwenden, das einen kleinen Teil der Messdaten verwendet und uns seine Frequenz mitteilt, siehe Abbildung unten. Die Ablesung auf der y-Achse für die dunkelste Linie ist die Pendelschwingungsfrequenz. Die horizontale Linie bestätigt, dass sich die Pendelschwingung während des gesamten Experiments nicht verändert hat. Der Kehrwert der Schwingungsfrequenz ist die Pendelschwingungsperiode.

Der Abschlussbericht des Programms ist eine Textzusammenfassung:

Pendelschwingung Freq(Hz)=0.449224, Period(Sec)=2.226059, Schätzdatenquelle: Tonhöhe

Wir können feststellen, dass unser früheres Berechnungsergebnis für die Augapfelhand, 2,22 Sekunden, ziemlich konsistent mit dem vom Programm berechneten Wert ist.

Verglichen mit dem theoretisch berechneten Wert von 2,0962 (Sek.) haben wir einen verbleibenden Fehler von ~5%. Wie kann man sie loswerden? Denken Sie daran, dass die Annahme "starrer einheitlicher Stab" ist? Selbst 7 Gramm Mehrgewicht erscheinen trivial, es ist die größte Ursache für den verbleibenden Fehler.

Wir bewegen nun das Gerät in die Nähe des Drehpunkts. Siehe vorherigen Schritt für ein Nahaufnahmefoto. Die von mir erstellte Logdatei kann hier heruntergeladen werden:

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

Führen Sie die gleichen Analyseschritte aus, und wir erhalten eine Periode von 2,089867 (Sek.), siehe Abb. 3, die fast identisch mit der theoretischen Vorhersage ist. Groß!

Denn wir haben nicht nur Schwingwinkelmessung, sondern auch Kreiselmessung und Beschleunigungsmessung im gleichen Takt. Führen Sie die gleiche Analyse für die anderen beiden Messungen durch, wir erhalten die Ergebnisse in Abb. 4 und 5. Die Schätzungen aus allen drei Messquellen stimmen überein, was uns hinsichtlich des Erfolgs unseres Experiments zuversichtlicher macht.

Hier ist das Ergebnis als endgültige Ausgabe des ausgeführten Python-Programms:

Pendelschwingung Freq(Hz)=0.478499, Period(Sec)=2.089867, Schätzdatenquelle: Tonhöhe

Pendelschwingung Freq(Hz)=0.478499, Period(Sec)=2.089867, Schätzdatenquelle: accel

Pendelschwingung Freq(Hz)=0.478499, Period(Sec)=2.089867, Schätzdatenquelle: Kreisel

Letzter Gedanke in diesem Schritt, wie können die Schätzergebnisse mit unterschiedlichen Eingabedatenquellen exakt identisch sein? Das ist Gegenintuition. Diese Frage überlasse ich den Lesern. Hier ein Hinweis: Erinnern Sie sich, dass wir die Kurzzeit-FFT verwenden, um die Schwingungsfrequenz zu schätzen? Im digitalen Bereich wird die Frequenzschätzung in diskreten Frequenz-Bins anstelle einer Gleitzahlschätzung angegeben.

Schritt 5: Empfehlungen für die zukünftige Arbeit

Es gibt wenige Kategorien zukünftiger Arbeitsempfehlungen.

In einem früheren Schritt haben wir es geschafft, unseren Experimentfehler von ~ 5 % auf weniger als 1 % zu reduzieren. Können wir es besser machen? Da die Schwingungsgröße exponentiell abnimmt, kann ein beitragender Faktor der Luftwiderstand sein, der beim Schwingen des Pendels verursacht wird. Der Querschnitt des Pendels muss möglicherweise stromlinienförmig modifiziert werden, um den Luftwiderstand zu verringern.

Können wir eine zeitvariable Verstärkung anwenden, die unter Verwendung adaptiver Filtertechniken gelernt wurde, um ein Signal mit konstanter Spitzengröße auszugeben? In der Zwischenzeit korrelieren Sie die Größe der Dämpfung mit externen Kräften.

Wir können kaum etwas einfacheres finden als die "einfache harmonische Bewegung". Können wir die Einrichtungen, mit denen wir das Pendel analysieren, verwenden, um etwas Komplizierteres zu analysieren, eine sportliche Aktivität, eine Wasserraketenstartsequenz usw.?

Viel Spaß beim Hacken