Studi Eksperimental Gerak Harmonik Sederhana: 5 Langkah

2024 Pengarang: John Day | [email protected]. Terakhir diubah: 2024-01-30 09:55

Oleh arrowlikeIkuti Lainnya oleh penulis:

Di dalam kelas, kita sering menggunakan stopwatch untuk melakukan percobaan bandul, atau percobaan gerak harmonik sederhana. Inilah tantangannya, bisakah kita menghasilkan grafik nyata dari pergerakannya dan melihat apa posisi sudut dan kecepatan sesaat, itu lebih banyak informasi dan kesenangan.

Pertanyaan pertama, kita perlu memutuskan bahwa badan bandul adalah tali tanpa bobot atau batang seragam yang kaku. Pendekatan kabel tampaknya lebih mudah. Dari praktek membangun satu, saya memiliki pertimbangan tradeoff berikut: Cara termudah untuk menggantung sistem pendulum mungkin menggantungnya ke tepi atas pintu Anda. Itu memberikan panjang pendulum ~2m Anda tanpa melakukan pekerjaan bangunan struktural apa pun. Tapi itu perlu ayunan tidak akan menyentuh permukaan pintu, yang hanya merusak seluruh percobaan. Jadi bidang yang diayunkannya harus benar-benar sejajar dengan permukaan dinding/pintu Anda. Tali tanpa bobot cenderung tipis, mudah berputar, dan mempersulit pengukuran sudut ayun. Kami ingin menggunakan satu pengukuran untuk mewakili keadaan ayunan. Tali tipis, seperti tali pancing, dapat menjadi elastis dan dapat diregangkan, yang mempengaruhi salah satu konstanta terpenting yang diukur oleh kami dan digunakan dalam persamaan, yaitu panjang bandul. Beberapa mungkin juga terpengaruh oleh suhu. Massa berat yang tergantung di ujung tali harus cukup berat sehingga berat tali dapat diabaikan. Silakan berkomentar jika Anda setuju atau tidak setuju dengan mereka, atau Anda memiliki ide tradeoff desain lainnya. Untuk mempelajari masalah ini, kita membutuhkan alat yang sangat ringan sehingga beratnya dapat diabaikan dan kita masih memperlakukan sistem bandul sebagai batang seragam yang kaku. Saya menggunakan pengontrol elektronik COTS yang dapat dipakai, yang mengirimkan informasi gyro, akselerometer, dan sudut kepada kami melalui koneksi bluetooth. Pengukuran ini akan disimpan ke dalam file data aplikasi ponsel. Setelah itu, kami akan menganalisis data untuk percobaan gerak harmonik sederhana kami. Analisis numerik berfokus pada topik-topik berikut: 1) Memprediksi periode osilasi pendulum 2) Secara terprogram mengumpulkan data percobaan gerakan harmonik sederhana pendulum 3) Menggunakan kmean untuk mengelompokkan data dan menghilangkan outlier dalam proses analisis 4) Menggunakan FFT waktu singkat untuk memperkirakan frekuensi osilasi bandul

Perlengkapan

Alat pengukur Bluetooth

Aplikasi ponsel Android: Buka Google playstore, cari M2ROBOTS dan instal Aplikasi kontrol. Jika sulit mengakses Google playstore, kunjungi beranda pribadi saya untuk metode pengunduhan aplikasi alternatif

batang kayu

beberapa bagian cetak 3D

mata gergaji atau bahan logam serupa

Langkah 1: Apa Itu Pendulum? Bagaimana Memodelkannya?

Ada banyak artikel dan buku yang memperkenalkan turunan persamaan bandul, termasuk buku fisika kurikulum Anda. Konten seperti itu mungkin lebih baik tidak diulang di sini lagi. Hanya kesimpulan akhir yang tercantum di sini mengenai topik "gerakan harmonik sederhana". Untuk mengetahui periode bandul, yang perlu kita ketahui hanyalah panjang bandul, dilambangkan sebagai "l", dalam meter.

Jika kita cukup yakin bahwa beratnya terletak hampir seluruhnya pada ujung tali tanpa berat yang tergantung pada sebuah poros, dan bandul berayun pada sudut kecil, katakanlah kurang dari 15°, periode T1 dari bandul tersebut diberikan oleh:

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

g = percepatan gravitasi, kira-kira 9,8 m/s^2

Jika tali tanpa bobot diganti dengan batang kaku yang seragam, lagi-lagi dengan panjang l, periode gerak harmonik sederhana T2 diberikan oleh T1 = 2*pi*(2l/3g)^0,5

Secara efektif ia memiliki periode yang sama dengan bandul tali berat yang menjadi dua pertiga dari panjang batang seragam yang kaku.

Ini adalah latar belakang, dan kita dapat mulai mempersiapkan percobaan kita.

Langkah 2: Siapkan Suku Cadang untuk Bangunan Perangkat Keras

Untuk membangun struktur pendulum, kami mencetak 3D beberapa bagian, dan mendaur ulang sesuatu yang sudah kami miliki. Struktur pendulum keseluruhan ditunjukkan pada Gambar.1. Ini adalah campuran bagian cetak 3D bersama dengan beberapa bagian kerajinan tangan dan sepotong panjang batang kayu dari Lowe's.

Bagian cetakan 3D pada Gbr.2 digantung di tepi atas pintu, karena pintu kami adalah permukaan datar yang mudah untuk menggantung sesuatu. Tautan unduhan file STL:

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

Bagian hijau pada Gbr.3 menghubungkan batang kayu ke bilah, dan bilah berada di atas dua potong rel yang dipasang pada gantungan pintu cetak 3D sebelumnya. Tautan unduhan file STL:

Dua potong rel dibuat dengan membelah mata gergaji tua menjadi dua, lihat Gambar 4. Bagian pada Gambar 2 telah menyiapkan ukuran slot yang tepat untuk mereka. Idealnya kita bisa membuat lekukan berbentuk "V" di kedua mata gergaji itu menggunakan file. Logam bermata cukup tajam, seperti pisau cukur bermata tunggal, atau potongan logam buatan tangan lainnya, dapat ditempatkan di dalam takik berbentuk "V". Alasan kita membutuhkan area kontak yang lebih kecil adalah untuk mengurangi energi kinetik yang hilang saat berayun.

Bagian cetakan 3D terakhir pada Gbr.5 adalah baki kecil untuk menampung peralatan pengukuran elektronik.

Tautan unduhan:

Aparatus pengukuran bluetooth menghasilkan estimasi sudut, pengukuran gyro dan pengukuran accelerometer. Semua data ini tersedia bagi kami melalui tautan nirkabel bluetooth.

Kami akan melakukan beberapa percobaan dengan menempatkan peralatan ini pada posisi yang berbeda dari lengan pendulum, dan melihat perbedaannya.

Langkah 3: Pengumpulan Data Eksperimen

Ada dua metode yang dapat dilakukan untuk pengumpulan data eksperimen sebelum kami menganalisis dataset yang diperoleh:

1) Gunakan Aplikasi ponsel Android yang ditentukan di bagian persyaratan untuk mencatat semua pengukuran yang dihasilkan oleh peralatan ke dalam file data yang disimpan di kartu SD ponsel Anda. Kami dapat menyalin file dan memposting proses informasi.

2) Gunakan komputer berkemampuan bluetooth, PC, laptop atau komputer mini RaspberryPi untuk membuat koneksi bluetooth ke peralatan dan membaca data untuk analisis waktu nyata atau offline.

Ada pro dan kontra untuk setiap metode, kami akan mencoba keduanya dan membedakannya dalam instruksi ini.

Untuk metode (1) menggunakan aplikasi android, setelah kita berada di antarmuka kontrol Aplikasi android, data telemetri yang dikirim dari alat pengukur bluetooth ke ponsel android akan direkam ke dalam file datalog bernama m2flightDatayyyymmdd_hhmmss.txt. Itu dapat ditemukan di folder Download/m2LogFiles ponsel android Anda. Folder "Unduh" adalah folder yang sudah ada sebelumnya di OS Android ponsel Anda dan "m2LogFiles" adalah folder yang dibuat oleh Aplikasi. Konten nama file yyyymmdd_hhmmss adalah cara untuk mengkodekan waktu mulai eksperimen (tahun, bulan, hari, jam, menit, dan detik) dalam nama file.

Setiap baris dalam file log adalah satu record. Dimulai dengan timestamp event, preamble string "eam:", diikuti oleh 4 data triplet, yaitu:

Pembacaan sumbu akselerometer XYZ dalam perangkat keras sensor mentah mendaftarkan nilai pembacaan kembali

Pembacaan sumbu giroskop XYZ dalam perangkat keras sensor mentah mendaftarkan nilai pembacaan kembali

Pembacaan sumbu magnetometer XYZ dalam nilai pembacaan kembali register perangkat keras sensor mentah

onboard perkiraan Roll/Pitch/Raw dalam derajat

File data yang dibuat menggunakan program python komputer akan menggunakan format file data yang identik, sehingga program yang kita gunakan pada langkah analisis data tidak akan terganggu dengan sumber data yang dihasilkan oleh program python atau aplikasi android kita.

Mari kita mulai coding menggunakan metode (2).

Untuk berinteraksi dengan peralatan pengukuran bluetooth, tersedia dua varian SDK:

1) Python SDK, yang dapat diinstal dengan "pip3 install m2controller", python3 adalah bahasa yang digunakan. Contoh kode aplikasi pengguna disimpan di https://github.com/xiapeiqing/m2robots/tree/maste… Untuk percobaan kali ini kita akan menggunakan script python pendulum1.py

2) Java SDK, yang tidak digunakan dalam instruksi ini karena kami ingin visualisasi dan analisis data pendulum yang diperoleh nanti, yang mungkin memerlukan sedikit lebih banyak upaya bagi kami untuk memprogram di Java.

Kode sumber program pengumpulan data python3 berisi banyak komentar untuk detail fungsionalitas kode. Sebuah snapshot dari kode sumber disediakan di sini.

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

requestExit = Salah

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

# kami ingin menggunakan konvensi penamaan file log yang sama sehingga modul analisis data, pendulum2.py, dapat menjadi agnostik terhadap cara kami mendapatkan file data log ################ ############################################################### namafile log = " m2flightData%s.txt"%(datetime.datetime.fromtimestamp(time.time()).strftime('%Y%m%d_%H%M%S')) dataLogfile = open(logfilename, "w")

def signal_handler(sig, bingkai):

global requestExit print('user Ctrl-C untuk keluar dari eksekusi program') requestExit = True signal.signal(signal. SIGINT, signal_handler)

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

# pada setiap data pengukuran tersedia pada kecepatan 20Hz, fungsi "panggilan balik" ini akan dipanggil ############################# ################################ 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], telemetri['m_fMagHwUnit'][1], telemetri['m_fMagHwUnit'][2], telemetri['m_fRPYdeg'][0], telemetri['m_fRPYdeg'][1], telemetri['m_fRPYdeg'][2]) ## ############################################################# ############ # kita mencetak string data ke layar dan menyimpannya ke dalam file log ##################### ######################################## print(dataStr) dataLogfile.writelines(dataStr)

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

# inisialisasi pengontrol, ingatlah untuk mengatur bidang BleMACaddress menjadi alamat MAC perangkat Anda ################################ ############################## # TODO: mari inisialisasi BleMACaddress jika tidak disetel oleh pengguna. controller = m2controller. BleCtrller(m2Const.etDebian, callbackfunc, usrCfg. BleMACaddress) controller.connect() while True: ############################### ##################################### # menunggu data pengukuran dibuat dan dikirim dari pendulum pengukuran aparat ################################################################## ############### controller.m_CommsTunnel.waitForNotifications(1.0) jika requestExit: ############################## ###################################### # pekerjaan rumah tangga di sini saat kami menyelesaikan pencatatan data ############################################################# ############## controller.stop() dataLogfile.close() break

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

# pengumpulan data selesai, sekarang mari kita menganalisis data log ###################################################### ######################## pendulum2.parseDataLogFile(logfilename)

Untuk pembaruan jangka panjang, silakan checkout

Sekarang mari kita jelaskan metode operasinya. Program python ini ditulis di atas paket pip yang dapat diinstal, bernama m2controller. Paket tingkat yang lebih rendah menawarkan mekanisme panggilan balik, sehingga setiap pembaruan pengukuran yang diterima akan memicu fungsi panggilan balik yang kami tulis, dan menyimpan data ke dalam file log lokal. Format konten data file log identik dengan apa yang dihasilkan oleh aplikasi pendamping android, sehingga file log data yang dibuat oleh program python atau aplikasi pendamping android dapat ditukar.

Sinyal ctrl-C pengguna, ditangkap oleh sistem operasi, diteruskan ke program, dan menghentikan infinite loop menunggu kedatangan data pengukuran yang baru.

Sampai saat ini, file log telah berhasil dibuat, dan program ini akan memanggil program analisis untuk mempelajari hasil percobaan kami.

Berikut adalah dua percobaan, dan perbandingan menunjukkan perbedaan yang sangat mencolok dengan memasang perangkat 7gram di lokasi yang berbeda.

Pada Gbr.2, kami menggunakan skala untuk menentukan berat sebenarnya dari alat pengukur bluetooth ini.

Gbr.3 menggambarkan pengaturan pendulum di mana perangkat 7gram terpasang ke ujung bawah pendulum. Konfigurasi setup pada Gbr.4 memiliki massa 7gram yang terletak lebih dekat ke poros ayun.

Gbr.5 adalah tampilan closeup dari struktur pendulum.

Langkah 4: Analisis Data

Alat pengukur bluetooth memiliki berat ~7gram, yang beratnya jauh lebih ringan daripada tongkat kayu sepanjang ~1,6 meter. Gunakan asumsi "batang seragam kaku", dan kami memiliki persamaan periode pendulum ini, T1 = 2*pi*(2l/3g)^0,5

Untuk mendapatkan konstanta gravitasi, kita dapat menggunakan 9,8m/s^2. Tetapi konstanta gravitasi yang lebih akurat pada geolokasi tertentu dapat diambil dari layanan web ini:

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

Untuk san francisco, adalah 9,81278m/s^2

Panjang bandul diukur menjadi 64,5 ''

2*pi*sqrt(2*64.5*0.0254/(3*9.81278)) memberikan periode bandul yang diharapkan sebesar 2,0962(dtk).

Mari kita lihat apakah itu sesuai dengan eksperimen kita.

Pada percobaan pertama, pendulum setup memiliki perangkat 7 gram yang melekat pada ujung bawah bandul. File log saya dapat diunduh di:

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

Ubah namanya menjadi "PendulumTestData.txt" dan letakkan di folder yang sama dengan program analisis python. Sebuah snapshot dari kode sumber disediakan di sini.

#!/usr/bin/env python# -*- coding: 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 as sns from sklearn.cluster import KMeans from collections import Counter ######################################### ############################ # fungsi ini menjalankan pekerjaan analisis file data ############ ############################################################# ## def parseDataLogFile(namafiledata): ###################################################### ###################### # ekstrak data dalam file log data (CSV) yang dipisahkan koma dan simpan konten di setiap kolom ke dalam satu variabel tipe float ## ############################################################# ############ dengan open(datafilename) sebagai 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 = untuk baris dalam readCSV: try: x = datetime.strptime(row[0].split(', ')[0], '%H:%M:%S.%f') timestampS.append(timedelta(jam=x.jam, menit=x.menit, detik=x.detik, mikrodetik=x.mikrodetik).total_detik()) fAccelHwUnit_x.append(float(baris) [1][4:])) fAccelHwUnit_y.append(float(baris [2])) fAccelHwUnit_z.append(float(baris[3])) fGyroHwUnit_x.append(float(baris[4])) fGyroHwUnit_y.append(float (baris[5])) fGyroHwUnit_z.append(float(row[6])) fMagHwUnit_x.append(float(row[7])) fMagHwUnit_y.append(float(baris[8])) fMagHwUnit_z.append(float(baris [9])) fRPYdeg_r.append(float(row[10])) fRPYdeg_p.append(float(row[11])) fRPYdeg_y.append(float(row[12])) kecuali: lulus timestampS = np.asarray(cap) cap waktu = cap - cap [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)

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

# kita membutuhkan perkiraan frekuensi sampling yang akurat untuk perkiraan periode osilasi yang tepat ################################################ ########################## FsHz = getSamplingIntervalS(timestampS) ################ ################################################ # menggunakan komponen pitch dalam output sistem referensi heading sikap untuk analisis periode bandul ####################################################### ########################## analyze_timeSequence(timestampS, fRPYdeg_p, FsHz, 'pitch') ########### ############################################################# ### # gunakan keluaran pengukuran mentah acceleromter untuk analisis periode pendulum ######################################### ########################## analyze_timeSequence(timestampS, fAccelHwUnit_x, FsHz, 'accel') ########### ############################################################# ### # Gunakan keluaran pengukuran mentah gyro untuk analisis periode pendulum ######################################### ########################## analyze_timeSequence(timestampS, fGyroHwUnit_y, FsHz, ' gyro') print('selesai, selamat:-)') plt.show() ############################################ ################################ # Dalam proses komunikasi bluetooth, ada kemungkinan langka bahwa paket data comm bisa hilang # kami menggunakan K-mean untuk mengisolasi data pengukuran 20Hz dari outlier, yang disebabkan oleh paket yang jatuh # selami "sinyal dan sistem untuk lebih jelasnya" ############### ################################################### def getSamplingIntervalS (timestampS): plt.figure() sampleIntervalS = np.diff(timestampS) sns.distplot(sampleIntervalS) plt.ylabel('histogram') plt.xlabel('measurement interval(s)') clusterCnt = 5 km = KMeans(n_cluster = clusterCnt) km.fit(sampleIntervalS.reshape(-1, 1)) centroids = km.cluster_centers_ elemCnt = Penghitung(km.labels_) kejadianCnt = untuk ii dalam rentang(clusterCnt): kejadianCnt.append(elemCnt[ii]) FsHz = 1/centroids[occurrenceCnt.index(max(occurrenceCnt))] mengembalikan FsHz

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

# gunakan spektrometer, yaitu, FFT waktu singkat untuk mendapatkan komponen frekuensi, bin puncak adalah perkiraan terbaik kami untuk osilasi pendulum ######################### ##################################### def analyze_timeSequence(timestampS, timeSeqData, FsHz, strComment): ara, (ax1, ax2) = plt.subplots(nrows=2) ax1.plot(timestampS, timeSeqData, marker='o', markerfacecolor='blue', markersize=2, color='skyblue', linewidth=1) ax1.set_title("pengukuran domain waktu pendulum -- %s"%strComment) ax1.set_xlabel("waktu sampling(detik)") ax1.set_ylabel(strComment); NFFT = 2048 # panjang segmen windowing

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

ax2.set_title("Spektrogram") ax2.set_xlabel("sampel") ax2.set_ylabel("frequency(Hz)");

# Metode `specgram` mengembalikan 4 objek. Mereka:

# - Pxx: periodogram # - freqs: vektor frekuensi # - bin: pusat bin waktu # - im: instance matplotlib.image. AxesImage mewakili data dalam plot pkresult = np.where(Pxx == np.amax(Pxx)) oscFreqHz = freqs[pkresult[0][0] print('pendulum oscillation Freq(Hz)=%f, Period(Sec)=%f, sumber data estimasi: %s'%(oscFreqHz, 1/oscFreqHz, strComment)) mengembalikan 1/oscFreqHz

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

# haruskah kita menjalankan program ini secara mandiri, yaitu, tidak dipanggil oleh pendulum1.py, # kita menentukan nama file data log default yang akan dianalisis ################### ########################################## jika _name_ == "_main_ ": defaultFilename = './PendulumTestData.txt' import os.path jika os.path.isfile(defaultFilename): parseDataLogFile(defaultFilename) else: print ("file log default %s tidak ada"%defaultFilename)

Untuk pembaruan jangka panjang, silakan checkout

Kode sumber berisi komentar terperinci, mari berikan ringkasan tingkat tinggi dari estimasi matematis di sini.

1) Pertama-tama kita membaca konten file CSV ke komputer, menggunakan paket python yang disebut "csv". Kami memiliki pengukuran berkala.

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) Karena laju pengukuran sangat kritis dan secara langsung memperkenalkan kesalahan estimasi periode pendulum, kami ingin memperkirakannya. Interval pengukuran nominal kami adalah 50ms, yaitu 20Hz. Rata-rata di semua pengukuran tampaknya OK, tetapi kami kadang-kadang kehilangan paket transmisi data, interval pembaruan menjadi 100ms atau 150ms, …

Jika kita memplot kemunculan data ini, lihat Gbr.1, sebagai manusia, kita dapat dengan mudah memiliki nilai bola mata 0,05 detik. Namun, bisakah kita melakukan lebih baik dari itu?

Kita perlu menggunakan metode klasifikasi untuk hanya memilih yang baik untuk perhitungan rata-rata. Python memiliki kotak alat bernama KMeans untuk membantu kami dengan pengelompokan, atau katakanlah klasifikasi. Konsep-konsep ini digunakan di banyak data besar dan area AI.

3) Gbr.2 berisi dua gambar. Plot atas adalah urutan domain waktu dari pengukuran sudut ayun kami dalam derajat. Dengan mengacu pada stempel waktu sumbu x di Detik, kita dapat membaca sekitar 22,5 siklus dalam 50 detik, yang berarti periode pendulum 2,22 Detik. Apakah ada cara untuk mengotomatisasi proses ini dan memiliki perkiraan yang lebih akurat? Ya, kita dapat menggunakan alat matematika yang disebut spektogram, yang menggunakan sebagian kecil data pengukuran dan memberi tahu kita frekuensinya, lihat gambar di bawah ini. Pembacaan sumbu y untuk garis tergelap adalah frekuensi osilasi bandul. Menjadi garis horizontal menegaskan osilasi pendulum tidak berubah sama sekali selama percobaan. Nilai kebalikan dari frekuensi osilasi adalah periode osilasi bandul.

Laporan akhir yang dibuat oleh program adalah ringkasan teks:

osilasi bandul Freq(Hz)=0.449224, Periode(Sec)=2.226059, sumber data estimasi: pitch

Kami dapat menemukan hasil perhitungan tangan eyeballing kami sebelumnya, 2.22sec, cukup konsisten dengan nilai yang dihitung program.

Dibandingkan dengan 2,0962(sec) nilai yang dihitung secara teoritis, kami memiliki ~5% kesalahan yang tersisa. Bagaimana menyingkirkan mereka? Ingat asumsinya adalah "batang seragam kaku"? Bahkan berat ekstra 7 gram tampak sepele, itu adalah penyebab terbesar dari kesalahan yang tersisa.

Kami sekarang memindahkan perangkat, dekat dengan poros. Lihat langkah sebelumnya untuk foto close-up. File log yang saya buat dapat diunduh di sini:

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

Jalankan langkah analisis yang sama, dan kita mendapatkan Periode 2.089867(Sec), lihat Gbr.3, yang hampir identik dengan prediksi teoretis. Besar!

Karena kami tidak hanya memiliki pengukuran sudut ayun, tetapi juga pengukuran gyroscopic dan pengukuran accelerometer pada tingkat yang sama. Jalankan analisis yang sama untuk dua pengukuran lainnya, kami mendapatkan hasil pada Gambar.4 dan 5. Perkiraan dari ketiga sumber pengukuran setuju, yang membuat kami lebih percaya diri pada keberhasilan percobaan kami.

Berikut adalah hasil akhir dari program python yang sedang berjalan:

osilasi bandul Freq(Hz)=0.478499, Periode(Sec)=2.089867, sumber data estimasi: pitch

osilasi bandul Freq(Hz)=0.478499, Periode(Sec)=2.089867, sumber data estimasi: accel

osilasi bandul Freq(Hz)=0.478499, Periode(Sec)=2.089867, sumber data estimasi: gyro

Pemikiran terakhir dalam langkah ini, bagaimana hasil estimasi bisa persis sama dengan menggunakan sumber data input yang berbeda? Ini adalah kontra-intuisi. Saya akan menyerahkan pertanyaan ini kepada para pembaca. Berikut adalah petunjuknya: ingat kita menggunakan FFT waktu singkat untuk memperkirakan frekuensi osilasi? Dalam domain digital, perkiraan frekuensi diberikan dalam frekuensi diskrit bukan perkiraan angka mengambang.

Langkah 5: Rekomendasi Pekerjaan di Masa Depan

Ada beberapa kategori rekomendasi pekerjaan di masa depan.

Pada langkah sebelumnya, kami berhasil mengurangi kesalahan percobaan kami dari ~5% menjadi kurang dari 1%, dapatkah kami melakukan lebih baik dari itu? Melihat besarnya osilasi menurun secara eksponensial, salah satu faktor yang berkontribusi adalah hambatan udara yang disebabkan saat mengayunkan pendulum. Penampang bandul mungkin perlu dimodifikasi menjadi bentuk streamline untuk mengurangi hambatan aerodinamis.

Bisakah kita menerapkan keuntungan yang bervariasi terhadap waktu yang dipelajari menggunakan teknik filter adaptif untuk menghasilkan sinyal dengan magnitudo puncak yang konstan. Sementara itu, korelasikan besarnya redaman dengan gaya-gaya luar.

Kami hampir tidak dapat menemukan sesuatu yang lebih sederhana daripada "gerakan harmonik sederhana". Bisakah kita menggunakan fasilitas yang kita analisis bandul untuk menganalisis sesuatu yang lebih rumit, aktivitas olahraga, urutan peluncuran roket air, dll?

Selamat meretas