Nghiên cứu thực nghiệm về chuyển động điều hòa đơn giản: 5 bước

2024 Tác giả: John Day | [email protected]. Sửa đổi lần cuối: 2024-01-30 13:32

Theo arrowlikeFollow More của tác giả:

Trong lớp học, chúng ta thường sử dụng đồng hồ bấm giờ để tiến hành thí nghiệm con lắc, hoặc thí nghiệm chuyển động điều hòa đơn giản. Đây là một thách thức, chúng ta có thể tạo ra một đồ thị thực về chuyển động của nó và xem vị trí góc và vận tốc tức thời là gì, đó là rất nhiều thông tin và thú vị.

Câu hỏi đầu tiên, chúng ta cần xác định vật thể con lắc là một sợi dây không trọng lượng hay một thanh cứng đồng nhất. Cách tiếp cận dây có vẻ dễ dàng hơn. Từ thực tế xây dựng một hệ thống, tôi có những cân nhắc cân nhắc sau: Cách dễ nhất để treo một hệ thống con lắc có thể là treo nó vào mép trên của cửa nhà bạn. Điều đó mang lại chiều dài con lắc ~ 2m của bạn mà không cần thực hiện bất kỳ công việc xây dựng kết cấu nào. Nhưng nó cần xích đu sẽ không chạm vào bề mặt cửa, điều này chỉ đơn giản là làm hỏng toàn bộ thí nghiệm. Vì vậy, mặt phẳng mà nó xoay phải song song chính xác với bề mặt tường / cửa của bạn. Dây không trọng lượng có xu hướng mỏng, nó có thể quay dễ dàng và làm phức tạp việc đo góc xoay. Chúng tôi muốn sử dụng một phép đo để biểu thị trạng thái xoay. Dây mỏng, chẳng hạn như dây cá, có thể đàn hồi và co giãn được, ảnh hưởng đến một trong những hằng số quan trọng nhất được chúng tôi đo lường và sử dụng trong phương trình, đó là chiều dài của con lắc. Một số cũng có thể bị ảnh hưởng bởi nhiệt độ. Khối lượng treo ở đầu dây phải đủ nặng để khối lượng của dây không đáng kể. Vui lòng bình luận nếu bạn đồng ý hoặc không đồng ý với họ, hoặc bạn có ý tưởng đánh đổi thiết kế khác. Để nghiên cứu vấn đề này, chúng ta cần một thiết bị nhẹ đến mức có thể bỏ qua khối lượng của nó và chúng ta vẫn coi hệ thống con lắc như một thanh cứng đồng nhất. Tôi đang sử dụng bộ điều khiển điện tử có thể đeo được COTS, bộ điều khiển này cung cấp thông tin về con quay hồi chuyển, gia tốc kế và góc cho chúng tôi thông qua kết nối bluetooth. Các phép đo này sẽ được lưu trữ vào tệp dữ liệu ứng dụng điện thoại di động. Sau đó, chúng tôi sẽ phân tích dữ liệu cho thí nghiệm chuyển động điều hòa đơn giản của chúng tôi. Phân tích số tập trung vào các chủ đề sau: 1) Dự đoán chu kỳ dao động của con lắc 2) Lập trình thu thập dữ liệu thí nghiệm chuyển động điều hòa đơn giản của con lắc 3) Sử dụng kmean để nhóm dữ liệu và loại bỏ các giá trị ngoại lệ trong quá trình phân tích 4) Sử dụng FFT trong thời gian ngắn để ước lượng tần số dao động của con lắc

Quân nhu

Thiết bị đo lường Bluetooth

Ứng dụng điện thoại Android: Vào Google playstore, tìm kiếm M2ROBOTS và cài đặt Ứng dụng điều khiển. Trong trường hợp khó truy cập Google playstore, hãy truy cập trang chủ cá nhân của tôi để biết phương pháp tải xuống ứng dụng thay thế

thanh gỗ

một số bộ phận in 3D

lưỡi cưa hoặc vật liệu kim loại tương tự

Bước 1: Con lắc là gì? Làm thế nào để mô hình hóa nó?

Có rất nhiều bài báo và sách giới thiệu về phương trình con lắc, bao gồm cả sách vật lý chương trình của bạn. Nội dung như vậy có thể tốt hơn là không được lặp lại ở đây một lần nữa. Chỉ có kết luận cuối cùng được liệt kê ở đây liên quan đến chủ đề "chuyển động điều hòa đơn giản". Để biết chu kỳ của một con lắc, tất cả những gì chúng ta cần biết là chiều dài của con lắc, ký hiệu là "l", tính bằng mét.

Nếu chúng ta chắc chắn một cách hợp lý rằng quả nặng nằm gần như hoàn toàn ở đầu của một sợi dây không trọng lượng treo trên một trục quay và con lắc đang dao động với góc nhỏ θ, nhỏ hơn 15 ° thì chu kì T1 của con lắc đó là:

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

g = gia tốc trọng trường, xấp xỉ 9,8 m / s ^ 2

Nếu thay sợi dây không trọng lượng bằng một thanh đồng chất cứng, lại có chiều dài l thì chu kỳ chuyển động điều hòa đơn giản T2 của nó được cho bởi T1 = 2 * pi * (2l / 3g) ^ 0,5

Hiệu quả nó có cùng chu kỳ với con lắc dây treo không trọng lượng bằng 2/3 chiều dài thanh cứng đều.

Đây là thông tin cơ bản và chúng tôi có thể bắt đầu chuẩn bị thử nghiệm của mình.

Bước 2: Chuẩn bị các bộ phận để xây dựng phần cứng

Để xây dựng cấu trúc con lắc, chúng tôi in 3D một số bộ phận và tái chế một số thứ chúng tôi đã có. Cấu trúc tổng thể của con lắc được thể hiện trong Hình 1. Đó là hỗn hợp các bộ phận in 3D cùng với một số bộ phận được làm thủ công và một thanh gỗ dài của Lowe‘s.

Phần được in 3D trong Hình 2 được treo ở mép trên của cánh cửa, bởi vì cánh cửa của chúng ta là một bề mặt phẳng dễ dàng để chúng ta treo một thứ gì đó. Link tải tệp STL:

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

Phần màu xanh lá cây trong Hình 3 kết nối thanh gỗ với một lưỡi dao, và lưỡi dao nằm trên hai miếng thanh ray được gắn trên móc treo cửa in 3D trước đó. Link tải file STL:

Hai mảnh đường ray được tạo ra bằng cách bẻ đôi một lưỡi cưa cũ, xem Hình 4. Phần trong Hình 2 đã chuẩn bị kích thước rãnh phù hợp cho chúng. Lý tưởng nhất là chúng ta có thể tạo một rãnh hình chữ "V" trên hai lưỡi cưa đó bằng cách sử dụng một chiếc giũa. Một kim loại có cạnh sắc bén hợp lý, chẳng hạn như một lưỡi dao cạo một cạnh, hoặc bất kỳ mảnh kim loại làm bằng tay nào, có thể nằm bên trong các rãnh hình chữ "V". Lý do chúng ta cần một diện tích tiếp xúc nhỏ hơn là để giảm động năng bị mất khi lắc lư.

Phần cuối cùng được in 3D trong Hình 5 là một khay nhỏ để chứa thiết bị đo lường điện tử.

Liên kết tải xuống:

Thiết bị đo bluetooth tạo ra ước tính góc, đo con quay hồi chuyển và đo gia tốc. Tất cả những dữ liệu này có sẵn cho chúng tôi thông qua liên kết không dây bluetooth.

Chúng tôi sẽ tiến hành nhiều thí nghiệm bằng cách triển khai thiết bị này ở các vị trí khác nhau của cánh tay con lắc, và xem sự khác biệt.

Bước 3: Thu thập dữ liệu thử nghiệm

Có hai phương pháp khả thi để thu thập dữ liệu thử nghiệm trước khi chúng tôi phân tích tập dữ liệu thu được:

1) Sử dụng Ứng dụng điện thoại Android được chỉ định trong phần yêu cầu để ghi lại tất cả các phép đo do thiết bị tạo ra vào một tệp dữ liệu được lưu trữ trong thẻ SD của điện thoại của bạn. Chúng tôi có thể sao chép tệp và xử lý thông tin đăng.

2) Sử dụng máy tính hỗ trợ bluetooth, PC, máy tính xách tay hoặc máy tính mini RaspberryPi để thiết lập kết nối bluetooth với thiết bị và đọc dữ liệu để phân tích thời gian thực hoặc ngoại tuyến.

Có cả ưu và nhược điểm cho mỗi phương pháp, chúng tôi sẽ thử cả hai và cho biết sự khác biệt trong hướng dẫn này.

Đối với phương pháp (1) sử dụng ứng dụng android, khi chúng ta đang ở trong giao diện điều khiển Ứng dụng android, dữ liệu đo từ xa được gửi từ thiết bị đo bluetooth đến điện thoại android sẽ được ghi vào tệp dữ liệu có tên m2flightDatayyyymmdd_hhmmss.txt. Nó có thể được tìm thấy trong thư mục Tải xuống / m2LogFiles của điện thoại Android của bạn. Thư mục "Tải xuống" là thư mục có sẵn trong hệ điều hành Android của điện thoại của bạn và "m2LogFiles" là thư mục mà Ứng dụng đã tạo. Nội dung tên tệp yyyymmdd_hhmmss là cách để mã hóa thời gian bắt đầu thử nghiệm (năm, tháng, ngày, giờ, phút và giây) trong tên tệp.

Mỗi dòng trong tệp nhật ký là một bản ghi. Nó bắt đầu bằng dấu thời gian của sự kiện, chuỗi mở đầu "eam:", theo sau là 4 dữ liệu bộ ba, đó là:

Đọc trục XYZ của máy đo gia tốc trong giá trị đọc lại của thanh ghi phần cứng cảm biến thô

Đọc trục con quay hồi chuyển XYZ trong giá trị đọc lại thanh ghi phần cứng cảm biến thô

Đọc trục XYZ từ kế trong thanh ghi phần cứng cảm biến thô giá trị đọc lại

tích hợp sẵn Roll / Pitch / Raw theo mức độ

Tệp dữ liệu được tạo bằng chương trình python máy tính sẽ sử dụng định dạng tệp dữ liệu giống hệt nhau, do đó, chương trình chúng tôi sử dụng trong bước phân tích dữ liệu sẽ không bị làm phiền với nguồn dữ liệu do chương trình python hoặc ứng dụng android của chúng tôi tạo ra.

Hãy bắt đầu viết mã bằng phương pháp (2).

Để tương tác với thiết bị đo lường bluetooth, hai phiên bản SDK được cung cấp:

1) Python SDK, có thể được cài đặt bằng "pip3 install m2controller", python3 là ngôn ngữ được sử dụng. Các ví dụ về mã ứng dụng của người dùng được lưu trữ trong https://github.com/xiapeiqing/m2robots/tree/maste… Đối với thử nghiệm này, chúng tôi sẽ sử dụng tập lệnh python python1.py

2) Java SDK, không được sử dụng trong hướng dẫn này vì chúng tôi muốn hình ảnh hóa và phân tích dữ liệu con lắc thu được sau này, điều này có thể tốn nhiều công sức hơn một chút để chúng tôi lập trình bằng Java.

Mã nguồn chương trình thu thập dữ liệu python3 chứa nhiều nhận xét cho các chi tiết về chức năng mã. Ảnh chụp nhanh mã nguồn được cung cấp tại đây.

#! / usr / bin / env python # - * - coding: UTF-8 - * - from m2controller import m2controller from m2controller import m2Const import signal time import datetime import usrCfg import Con lắc2

requestExit = Sai

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

# chúng tôi muốn sử dụng cùng một quy ước đặt tên tệp nhật ký để mô-đun phân tích dữ liệu, bubble2.py, có thể không xác định được cách chúng tôi lấy tệp dữ liệu nhật ký ################## ################################################### logfilename = " 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 ('user Ctrl-C để thoát khỏi quá trình thực thi chương trình') requestExit = True signal.signal (signal. SIGINT, signal_handler)

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

# khi mọi dữ liệu đo lường khả dụng ở tốc độ 20Hz, chức năng "gọi lại" này sẽ được gọi lại ################################# ################################### def callbackfunc (đo từ xa): 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, đo từ xa ['m_fAccelHwUnit'] [0], đo từ xa ['m_fAccelHwUnit'] [1], đo từ xa ['m_fAccelHwUnit'] [2], đo từ xa ['m_fGyroHwUnit'] [0], đo xa ['m_fGyroHwUnit'] [1], đo xa ['m_fGyroHwUnit'] [2], đo xa ['m_fMagHwUnit'] 'm_fMagHwUnit'] [1], đo từ xa ['m_fMagHwUnit'] [2], đo từ xa ['m_fRPYdeg'] [0], đo từ xa ['m_fRPYdeg'] [1], đo từ xa ['m_fRPYdeg'] [2]) ## ##################################################### ############# # chúng tôi in chuỗi dữ liệu ra màn hình và lưu chúng vào tệp nhật ký ######################## ############################################# print (dataStr) dataLogfile.writelines (dataStr)

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

# khởi tạo bộ điều khiển, hãy nhớ đặt trường BleMACaddress thành địa chỉ MAC của thiết bị của bạn ################################### ################################ # TODO: hãy khởi tạo BleMACaddress nếu người dùng không đặt. controller = m2controller. BleCtrller (m2Const.etDebian, callbackfunc, usrCfg. BleMACaddress) controller.connect () trong khi True: ########################### ########################################## # đợi dữ liệu đo được tạo và gửi từ phép đo con lắc bộ máy ##################################################### ################ controller.m_CommsTunnel.waitForNotifications (1.0) if requestExit: ######################### ############################################ # lưu giữ nhà hoạt động ở đây khi chúng ta hoàn thành việc ghi dữ liệu ##################################################### ############## controller.stop () dataLogfile.close () break

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

# thu thập dữ liệu đã hoàn tất, bây giờ hãy phân tích dữ liệu nhật ký ######################################### ########################## Con lắc2.parseDataLogFile (logfilename)

Để cập nhật lâu dài, vui lòng kiểm tra

Bây giờ chúng ta hãy giải thích phương thức hoạt động của nó. Chương trình python này được viết trên đầu một gói có thể cài đặt được bằng pip, có tên là m2controller. Gói cấp thấp hơn cung cấp cơ chế gọi lại, để mọi cập nhật đo lường nhận được sẽ kích hoạt chức năng gọi lại mà chúng tôi đã viết và lưu dữ liệu vào tệp nhật ký cục bộ. Định dạng của nội dung dữ liệu tệp nhật ký giống với nội dung được tạo bởi ứng dụng đồng hành android, do đó, tệp nhật ký dữ liệu được tạo bởi chương trình python hoặc ứng dụng đồng hành andriod có thể trao đổi được.

Tín hiệu ctrl-C của người dùng, được hệ điều hành ghi lại, được chuyển tới chương trình và dừng vòng lặp vô hạn chờ dữ liệu đo mới xuất hiện.

Cho đến nay, tệp nhật ký đã được tạo thành công và chương trình này sẽ gọi chương trình phân tích để nghiên cứu kết quả thử nghiệm của chúng tôi.

Đây là hai thử nghiệm và so sánh cho thấy sự khác biệt rất đáng chú ý bằng cách gắn một thiết bị 7gram ở các vị trí khác nhau.

Trong hình 2, chúng tôi sử dụng một cân để xác định trọng lượng thực tế của thiết bị đo bluetooth này.

Hình 3 mô tả thiết lập con lắc trong đó thiết bị 7gram được gắn vào đầu dưới của con lắc. Cấu hình thiết lập trong Hình 4 có khối lượng 7gram nằm gần trục xoay hơn nhiều.

Hình 5 là hình ảnh cận cảnh của cấu trúc con lắc.

Bước 4: Phân tích dữ liệu

Thiết bị đo bluetooth nặng ~ 7gram, nặng hơn nhiều so với một thanh gỗ dài ~ 1,6m. Sử dụng giả thiết về "thanh đồng chất cứng", và chúng ta có phương trình chu kỳ của con lắc này, T1 = 2 * pi * (2l / 3g) ^ 0,5

Để có được hằng số trọng lực, chúng ta có thể sử dụng 9,8m / s ^ 2. Nhưng một hằng số trọng lực chính xác hơn tại bất kỳ vị trí địa lý nhất định nào có thể được truy xuất từ dịch vụ web này:

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

Đối với san francisco, nó là 9,81278m / s ^ 2

Người ta đo được chiều dài con lắc là 64,5 ''

2 * pi * sqrt (2 * 64,5 * 0,0254 / (3 * 9,81278)) cho chu kỳ con lắc dự kiến là 2,0962 (giây).

Hãy xem liệu nó có đồng ý với các thí nghiệm của chúng tôi hay không.

Trong thí nghiệm thứ nhất, cơ cấu con lắc có gắn thiết bị nặng 7gram vào đầu dưới của con lắc. Tệp nhật ký của tôi có thể được tải xuống trong:

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

Đổi tên nó thành "PendulumTestData.txt" và đặt nó vào cùng một thư mục của chương trình phân tích python. Ảnh chụp nhanh mã nguồn được cung cấp tại đây.

#! / 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 nhập seaborn dưới dạng sns từ sklearn.cluster nhập KMeans từ bộ sưu tập nhập Bộ đếm ##################################### ############################### # hàm này chạy công việc phân tích tệp dữ liệu ############ ##################################################### ## def parseDataLogFile (datafilename): ############################################# ####################### # trích xuất dữ liệu trong tệp nhật ký dữ liệu được phân tách bằng dấu phẩy (CSV) và lưu nội dung trong mỗi cột vào một biến kiểu float ## ##################################################### ############ với mở (datafilename) dưới dạng 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 = cho hàng trong readCSV: try: x = datetime.strptime (row [0].split (',') [0], '% H:% M:% S.% f ') timestampS.append (timedelta (giờ = x.giờ, phút = x.phút, giây = x.second, micro giây = x.microsecond).total_seconds ()) fAccelHwUnit_x.append (float (hàng [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])) ngoại trừ: pass timestampS = np.asarray (timestamps) timestamps = timestamps - timestamps [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)

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

# chúng tôi cần ước tính chính xác tần số lấy mẫu để ước tính chu kỳ dao động chính xác ###################################### ############################## FsHz = getSamplingIntervalS (dấu thời gian) ################# ################################################ # sử dụng thành phần cao độ trong đầu ra của hệ quy chiếu tiêu đề thái độ để phân tích chu kỳ con lắc ####################################### ############################ analyse_timeSequence (timestampS, fRPYdeg_p, FsHz, 'pitch') ############ ##################################################### ### # sử dụng đầu ra đo thô của máy gia tốc để phân tích chu kỳ con lắc ####################################### ############################ analyse_timeSequence (timestampS, fAccelHwUnit_x, FsHz, 'accel') ########### ##################################################### ### # sử dụng đầu ra đo thô con quay hồi chuyển để phân tích chu kỳ con lắc ####################################### ############################ analyse_timeSequence (timestampS, fGyroHwUnit_y, FsHz, ' con quay hồi chuyển ') print (' xong, xin chúc mừng:-) ') plt.show () ################################# ################################### # trong quá trình giao tiếp bluetooth, rất hiếm có khả năng gói dữ liệu comm bị mất # chúng tôi sử dụng K-mean để cách ly dữ liệu ít nhất 20Hz khỏi các dữ liệu ngoại lai do gói bị rơi ################################################### def getSamplingIntervalS (timestampS): plt.figure () sampleIntervalS = np.diff (timestampS) sns.distplot (sampleIntervalS) plt.ylabel ('histogram') plt.xlabel ('đo khoảng cách (s)') clusterCnt = 5 km = KMeans (n_clusters = clusterCnt) km.fit (sampleIntervalS.reshape (-1, 1)) centroids = km.cluster_centers_ elemCnt = Counter (km.labels_) domainsCnt = cho ii trong phạm vi (clusterCnt): certCnt.append (elemCnt [ii]) FsHz = 1 / centroids [xuất hiệnCnt.index (tối đa (lần xuất hiệnCnt))] trả về FsHz

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

# sử dụng quang phổ kế, tức là FFT trong thời gian ngắn để lấy thành phần tần số, đỉnh bin là ước tính tốt nhất của chúng tôi về dao động của con lắc ############################ ######################################## def analyse_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 ("đo miền thời gian con lắc -% s"% strComment) ax1.set_xlabel ("thời gian lấy mẫu (giây)") ax1.set_ylabel (strComment); NFFT = 2048 # độ dài của các phân đoạn cửa sổ

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

ax2.set_title ("Quang phổ") ax2.set_xlabel ("mẫu") ax2.set_ylabel ("tần số (Hz)");

# Phương thức `specgram` trả về 4 đối tượng. Họ đang:

# - Pxx: biểu đồ chu kỳ # - freqs: vectơ tần số # - bins: tâm của khoảng thời gian # - im: thể hiện matplotlib.image. AxesImage đại diện cho dữ liệu trong biểu đồ pkresult = np.where (Pxx == np.amax (Pxx)) oscFreqHz = freqs [pkresult [0] [0] print ('Dao động con lắc Freq (Hz) =% f, Thời gian (Sec) =% f, nguồn dữ liệu ước tính:% s'% (oscFreqHz, 1 / oscFreqHz, strComment)) trả về 1 / oscFreqHz

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

# chúng ta có nên chạy chương trình này một cách độc lập, tức là không được gọi bởi bubble1.py hay không, # chúng ta xác định tên tệp dữ liệu nhật ký mặc định để phân tích ###################### ############################################### nếu _name_ == "_main_ ": defaultFilename = './PendulumTestData.txt' nhập os.path if os.path.isfile (defaultFilename): parseDataLogFile (defaultFilename) else: print (" tệp nhật ký mặc định% s không tồn tại "% defaultFilename)

Để cập nhật lâu dài, vui lòng kiểm tra

Mã nguồn chứa các nhận xét chi tiết, hãy đưa ra bản tóm tắt cấp cao về ước lượng toán học ở đây.

1) Đầu tiên, chúng tôi đọc nội dung tệp CSV vào máy tính, sử dụng gói python có tên "csv". Chúng tôi có đo lường định kỳ.

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) Vì tốc độ đo rất quan trọng và trực tiếp đưa ra sai số ước lượng chu kỳ con lắc, chúng tôi muốn ước tính chúng. Khoảng đo danh nghĩa của chúng tôi là 50ms, tức là 20Hz. Mức trung bình trên tất cả các phép đo có vẻ ổn, nhưng đôi khi chúng tôi bị mất gói truyền dữ liệu, khoảng thời gian cập nhật trở thành 100ms hoặc 150ms,…

Nếu chúng ta vẽ biểu đồ sự xuất hiện của những dữ liệu này, xem Hình 1, với tư cách là một con người, chúng ta có thể dễ dàng có giá trị nhãn cầu là 0,05 giây. Tuy nhiên, liệu chúng ta có thể làm tốt hơn thế không?

Chúng ta cần sử dụng phương pháp phân loại để chỉ chọn những cái tốt để tính toán trung bình. Python có hộp công cụ tên là KMeans để giúp chúng ta phân nhóm, hay nói cách phân loại. Những khái niệm này được sử dụng trong nhiều lĩnh vực dữ liệu lớn và AI.

3) Hình 2 chứa hai hình ảnh. Biểu đồ trên cùng là chuỗi miền thời gian của phép đo góc xoay của chúng tôi tính bằng độ. Bằng cách tham chiếu đến dấu thời gian trục x trong Giây, chúng ta có thể đọc khoảng 22,5 chu kỳ trong 50 giây, tương đương với chu kỳ con lắc 2,22 giây. Có cách nào để tự động hóa quá trình này và ước tính chính xác hơn không? Có, chúng ta có thể sử dụng công cụ toán học được gọi là quang phổ, sử dụng một phần nhỏ dữ liệu đo lường và cho chúng ta biết tần số của nó, xem hình bên dưới. Đọc trục y cho vạch tối nhất là tần số dao động của con lắc. Là một đường nằm ngang khẳng định dao động của con lắc không thay đổi trong suốt thí nghiệm. Giá trị nghịch của tần số dao động là chu kì dao động của con lắc.

Báo cáo cuối cùng được thực hiện bởi chương trình là một bản tóm tắt văn bản:

dao động con lắc Freq (Hz) = 0,449224, Giai đoạn (Giây) = 2,226059, nguồn dữ liệu ước tính: cao độ

Chúng ta có thể thấy kết quả tính toán nhãn cầu trước đó của chúng ta, 2,22 giây, khá phù hợp với giá trị tính toán của chương trình.

So với giá trị tính toán theo lý thuyết là 2,0962 (giây), chúng tôi có ~ 5% lỗi còn lại. Làm thế nào để có được loại bỏ chúng? Hãy nhớ giả định là "thanh đồng nhất cứng nhắc"? Ngay cả một trọng lượng thêm 7 gram cũng có vẻ tầm thường, nó là nguyên nhân lớn nhất gây ra lỗi còn lại.

Bây giờ chúng tôi di chuyển thiết bị đến gần trục. Xem bước trước để có ảnh cận cảnh. Tệp nhật ký tôi đã tạo có thể được tải xuống tại đây:

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

Chạy các bước phân tích tương tự, và chúng tôi nhận được Khoảng thời gian là 2.089867 (Giây), xem Hình 3, gần giống với dự đoán lý thuyết. Tuyệt vời!

Vì chúng tôi không chỉ đo góc xoay mà còn đo con quay hồi chuyển và đo gia tốc với cùng một tốc độ. Chạy cùng một phân tích cho hai phép đo còn lại, chúng tôi nhận được kết quả trong Hình 4 và 5. Các ước tính từ cả ba nguồn đo lường đều đồng ý, điều này khiến chúng tôi tự tin hơn về sự thành công của thử nghiệm của mình.

Đây là kết quả cuối cùng của chương trình python đang chạy:

dao động con lắc Freq (Hz) = 0,478499, Thời gian (Giây) = 2,089867, nguồn dữ liệu ước tính: cao độ

dao động con lắc Freq (Hz) = 0,478499, Thời gian (Giây) = 2,089867, nguồn dữ liệu ước tính: accel

dao động con lắc Freq (Hz) = 0,478499, Thời gian (Giây) = 2,089867, nguồn dữ liệu ước tính: con quay hồi chuyển

Suy nghĩ cuối cùng trong bước này, làm thế nào để các kết quả ước tính có thể giống hệt nhau bằng cách sử dụng các nguồn dữ liệu đầu vào khác nhau? Đây là phản trực giác. Tôi sẽ để lại câu hỏi này cho độc giả. Đây là một gợi ý: hãy nhớ rằng chúng ta đang sử dụng FFT trong thời gian ngắn để ước tính tần số dao động? Trong miền kỹ thuật số, ước tính tần số được đưa ra trong các nhóm tần số rời rạc thay vì ước tính số thực.

Bước 5: Đề xuất công việc trong tương lai

Có một số loại đề xuất công việc trong tương lai.

Trong bước trước đó, chúng tôi quản lý để giảm lỗi thử nghiệm của mình từ ~ 5% xuống dưới 1%, liệu chúng tôi có thể làm tốt hơn thế không? Nhận thấy độ lớn dao động giảm dần theo cấp số nhân, một yếu tố góp phần có thể là lực cản không khí gây ra khi lắc con lắc. Tiết diện của con lắc có thể cần được sửa đổi để có hình dạng hợp lý để giảm lực cản khí động học.

Chúng ta có thể áp dụng độ lợi thay đổi theo thời gian đã học bằng cách sử dụng các kỹ thuật bộ lọc thích ứng để xuất ra tín hiệu có cường độ đỉnh không đổi. Trong khi đó, tương quan giữa sự suy giảm độ lớn sẽ ngoại lực.

Chúng ta khó có thể tìm thấy điều gì đơn giản hơn “chuyển động điều hòa đơn giản”. Chúng ta có thể sử dụng các phương tiện mà chúng ta phân tích con lắc để phân tích thứ gì đó phức tạp hơn, một hoạt động thể thao, một chuỗi phóng tên lửa nước, v.v. không?

Chúc bạn hack vui vẻ