Eksperimen dalam Pencatatan Data Tingkat Lanjut (Menggunakan Python): 11 Langkah

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

Ada banyak instruksi logging data, jadi ketika saya ingin membangun proyek logging saya sendiri, saya melihat-lihat banyak. Beberapa bagus, beberapa tidak begitu banyak, jadi saya memutuskan untuk mengambil beberapa ide yang lebih baik dan membuat aplikasi saya sendiri. Ini menghasilkan proyek yang lebih maju dan lebih rumit daripada yang saya duga pada awalnya. Salah satu bagiannya menjadi rangkaian percobaan dalam mengolah data sensor. Instruksi ini memungkinkan Anda mencoba eksperimen yang sama atau serupa.

(Anda dapat melihat semua kode dan mengunduhnya di: Kode di GitHub Anda dapat melihat, mungkin di jendela lain, hanya dengan 2 klik)

Biasanya pencatatan data melibatkan hal-hal berikut:

• Akuisisi data: Membaca beberapa data dari sensor. Seringkali ini hanya membaca analog to digital converter (ADC) pada perangkat seperti Arduino.
• Pemrosesan data: Saat membaca nilai ADC, output konverter biasanya perlu diskalakan ke unit yang tepat. Mungkin juga perlu melakukan beberapa penyesuaian untuk mengkalibrasi nilai guna mengoreksi kesalahan sensor.
• Filtering: Data biasanya mengandung beberapa noise, ini dapat difilter sehingga Anda mencari sinyal dalam data Anda, bukan noise.
• Penyimpanan data: Data disimpan, mungkin ke file teks, mungkin ke cloud. Data harus bertahan bahkan jika listrik padam. Sangat mudah untuk menyimpan terlalu banyak data, kami memiliki sedikit trik untuk mengurangi ruang penyimpanan data.
• Tampilan data: Metode untuk melihat data Anda, bukan benar-benar pencatatan data, tetapi jika Anda tidak membuat semacam tampilan data mengapa mengumpulkannya?
• Akses Jarak Jauh: Tidak perlu tetapi menyenangkan untuk dimiliki.

Sebagian besar instruksi mencakup beberapa tetapi tidak semua hal di atas, atau melakukannya dengan cara yang sangat sederhana. Instruksi ini akan membahas 2 masalah logging yang sering dilewati dan sebagai bonus memberi Anda cara untuk membuat grafik data Anda tanpa menggunakan layanan cloud. Anda dapat menggunakan semuanya atau mengeluarkan potongan-potongan dan mencampurnya kembali menjadi proyek Anda sendiri.

Langkah 1: Alat dan Bahan

Contoh ini semuanya dalam Python sehingga akan berjalan, dan komponen dapat digunakan di, hampir semua OS termasuk Mac, PC, Linux dan Raspberry Pi.

Jadi untuk menggunakan instruksi ini, yang Anda butuhkan hanyalah lingkungan Python 3.6 yang berjalan, dan unduh kode terlampir. Setelah menjalankan kode yang telah saya siapkan, Anda dapat memodifikasinya untuk eksperimen Anda sendiri. Seperti biasa dengan Python, Anda mungkin perlu menambahkan beberapa paket/modul agar semuanya berfungsi. Lingkungan Spyder saya hadir dengan hampir semua bagian yang diperlukan (lihat: Grafik Tampilan yang Dapat Diinstruksikan dengan Penggoresan Layar Python). Saat pertama kali menjalankan watch untuk pesan kesalahan apa pun, mereka akan memberi tahu Anda tentang bagian yang hilang di lingkungan Anda.

Dua langkah berikutnya akan memberi tahu Anda cara membuat dan menjalankan eksperimen Anda sendiri, tetapi mungkin lebih baik menunggu hingga Anda menjalankan eksperimen yang disertakan sebelum Anda mencoba eksperimen Anda sendiri.

Untuk memahami kode, Anda perlu memiliki sedikit pengalaman dengan Python berorientasi objek, menjelaskan bahwa itu di luar cakupan instruksi ini, tetapi Google harus memberi Anda bantuan apa pun yang mungkin Anda perlukan.

Perhatikan kodenya: (Kode di GitHub Anda dapat melihat, mungkin di jendela lain, hanya dengan 2 klik) sekarang dalam Python 3.6, jadi memiliki 3.6 adalah yang terbaik. Versi kode yang lebih lama ada di sini di tautan di bawah ini.

Langkah 2: Membangun Eksperimen

Ada tiga langkah pemrograman (dan garis) dalam membangun eksperimen. Setiap eksperimen adalah fungsi dalam objek LoggingSim dalam file simulation_logging.py. Mari kita lihat percobaan 1 (hanya grafik pertama) yang akan kita jalankan pada langkah selanjutnya:

def eksperimen_with_sample_rates(sendiri):

print """ Bereksperimen dengan Sample Rate Melihat perbedaan sample rate dengan mengubah delta T """ self.start_plot(plot_title = "Sample Rate - Part 1/3: Delta T = 1.0") self.add_sensor_data(name = "dt = 1.", amplitudo = 1., noise_amp =.0, delta_t = 1., max_t = 10., run_ave = 0, trigger_value = 0) self.show_plot()

Setiap percobaan ditulis sebagai fungsinya sendiri sehingga kami memiliki garis yang mendefinisikan fungsi (percobaan def…..)

Selanjutnya, baris non-komentar, (start_plot(….) membuat objek untuk eksperimen dan memberinya nama.

Baris berikutnya, baris non komentar, (add_sensor_data(…) dibagi menjadi beberapa baris. Ini mensimulasikan sensor yang mengukur sinyal dengan potensi noise dan beberapa pemrosesan. Argumen fungsi adalah sebagai berikut:

• name: nama yang diletakkan pada grafik terakhir untuk mengidentifikasi data
• amplitudo: seberapa besar sinyalnya, kami akan selalu menggunakan amplitudo 1. dalam instruksi ini.
• noise_amp: seberapa besar noise, 0. tidak ada noise, kita akan mulai dari sini.
• delta_t: waktu antara pengukuran, mengontrol laju sampel.
• max_t: waktu maksimum kami mengumpulkan data, kami akan selalu menggunakan 10 dalam instruksi ini.
• run_ave: pemrosesan menggunakan rata-rata berjalan, 0 berarti tidak ada pemrosesan.
• trigger_value: pemrosesan menggunakan pemicu, 0 berarti tidak ada pemrosesan

baris terakhir, tanpa komentar, (self.show_plot……) menampilkan grafik.

Untuk membuat hal-hal sedikit lebih rumit Anda dapat memiliki beberapa garis pada grafik atau beberapa grafik dalam percobaan, ini harus jelas dari percobaan berikutnya.

Langkah 3: Menjalankan Eksperimen

Ini adalah kode untuk menjalankan eksperimen. Seperti pada umumnya di Python ditempatkan di akhir file.

sim_logging = LoggingSim()

sim_logging.experiment_with_sample_rates()

Ini hanya 2 baris:

• Buat simulator logging (LoggingSim())
• Jalankan (sim_logging.experiment_with_sample_rates())

Dalam kode yang diunduh, saya memiliki beberapa baris dan komentar lagi, seharusnya mudah untuk diketahui.

Langkah 4: Percobaan: Tingkat Sampel

Simulator, seperti yang diatur di sini, selalu mengeluarkan gelombang sinus halus yang bagus dengan amplitudo 1. Untuk percobaan ini kita akan mengacaukan laju sampel, yang disesuaikan dengan delta_t, perbedaan waktu antara sampel. Kami tidak akan memiliki kebisingan atau pemrosesan lainnya. Kode ini menggunakan 3 laju sampel (delta_t = 1,0, 0,1, dan 0,01.) Karena grafik berada di atas satu sama lain, eksperimen diatur untuk menghasilkan 3 grafik yang berbeda. Grafik yang dihasilkan adalah gambar untuk langkah ini.

def eksperimen_with_sample_rates(sendiri):

print """ Percobaan dengan Sample Rate Melihat sample rate yang berbeda dengan mengubah delta T """ self.start_plot(plot_title = "Experiment Sample Rates 1/3: Delta T = 1.0") self.add_sensor_data(name = "dt = 1.", amplitudo = 1., noise_amp =.0, delta_t = 1., max_t = 10., run_ave = 0, trigger_value = 0) self.show_plot() # ------------- ----------------------------------- self.start_plot(plot_title = "Laju Sampel Eksperimen 2/3: Delta T = 0.1") self.add_sensor_data(nama = "dt = 1.", amplitudo = 1., noise_amp =.0, delta_t = 0.1, max_t = 10., run_ave = 0, trigger_value = 0) self.show_plot() # ------------------------------------------------ diri sendiri.start_plot(plot_title = "Laju Sampel Eksperimen 3/3: Delta T = 0,01") self.add_sensor_data(nama = "dt = 1.", amplitudo = 1., noise_amp =.0, delta_t = 0,01, max_t = 10., run_ave = 0, trigger_value = 0) self.show_plot()

Untuk menjalankannya gunakan baris: sim_logging.experiment_with_sample_rates()

Kemungkinan kesimpulan:

• Tingkat pengambilan sampel yang terlalu rendah benar-benar buruk.
• Tarif tinggi seringkali lebih baik.

(Kode Python 3.6 di tautan GitHub di bawah di instruksi, 2.7)

Langkah 5: Percobaan: Menampilkan Kebisingan

Dalam percobaan ini kami menjaga sinyal yang sama, menggunakan sample rate yang sedang, dan memiliki jumlah noise yang berbeda (noise_amp =.0,.1, 1.0.) Jalankan dengan: sim_logging.experiment_showing_noise(). Outputnya adalah satu grafik dengan 3 garis.

Kemungkinan Kesimpulan:

Kebisingan membuat sulit untuk melihat sinyal, kurangi jika Anda bisa

Kode:

# ------------------------------------------------

def experiment_showing_noise(self): print """ Eksperimen menampilkan noise Melihat jumlah noise yang berbeda dengan mengubah amplitudo noise. """ self.start_plot(plot_title = "Eksperimen Menampilkan Noise") self.add_sensor_data(name = "noise = 0.0 ", amplitudo = 1., noise_amp =.0, delta_t =.1, max_t = 10., run_ave = 0, trigger_value = 0) self.add_sensor_data(name = "noise = 0.1", amplitudo = 1., noise_amp =. 1, delta_t =.1, max_t = 10., run_ave = 0, trigger_value = 0) self.add_sensor_data(nama = "noise = 1.0", amplitudo = 1., noise_amp = 1., delta_t =.1, max_t = 10., run_ave = 0, trigger_value = 0) self.show_plot()

Langkah 6:Eksperimen: Kurangi Kebisingan Dengan Rata-Rata Bergerak

Rata-rata bergerak (misalnya dengan panjang 8) mengambil 8 pengukuran terakhir dan membuat rata-ratanya. Jika noise acak, kami berharap rata-rata mendekati 0. Jalankan eksperimen dengan: sim_logging.experiment_showing_noise(). Keluarkan satu grafik.

Kemungkinan Kesimpulan:

• Rata-rata bergerak memang menghilangkan banyak kebisingan
• Semakin lama rata-rata bergerak semakin banyak pengurangan kebisingan
• Rata-rata pergerakan yang lebih panjang dapat mengurangi dan mendistorsi sinyal

Kode:

# ------------------------------------------------

def experiment_with_moving_average(self): print """ Percobaan dengan MovingAverage Melihat MovingAverage yang berbeda dengan mengubah panjangnya. Semua memiliki noise yang sama. """ # ------------------ ------------------------------ self.start_plot(plot_title = "MovingAverage-Part 1/2: No Moving Average") self.add_sensor_data(name = "ave len=0", amplitudo = 1., noise_amp =.1, delta_t =.1, max_t = 10., run_ave = 0, trigger_value = 0) self.show_plot() self.start_plot(plot_title = "MovingAverage-Part 2/2: Len 8 dan 32") self.add_sensor_data(name = "ave len=8", amplitudo = 1., noise_amp =.1, delta_t =.1, max_t = 10., run_ave = 8, trigger_value = 0) self.add_sensor_data(name = "ave len=32", amplitudo = 1., noise_amp =.1, delta_t =.1, max_t = 10., run_ave = 32, trigger_value = 0) self.show_plot ()

Langkah 7:Eksperimen: Rata-Rata Pergerakan dan Tingkat Sampel

Dalam percobaan ini kami membandingkan sinyal mentah dengan noise dan 2 variasi berbeda dalam mengurangi noise.

1. Tingkat sampel sedang dan rata-rata berjalan sedang
2. Tingkat sampel tinggi dan rata-rata lari panjang tinggi

Jalankan dengan: sim_logging…… Output adalah satu grafik. Saya pikir jelas bahwa #2 melakukan pekerjaan yang lebih baik dalam mengurangi kebisingan sehingga kami dapat menyimpulkan bahwa:

Tingkat sampel tinggi dan rata-rata lari panjang tinggi bagus

Tetapi Anda harus ingat bahwa ada biaya. #2 membutuhkan lebih banyak pemrosesan dan menghasilkan lebih banyak data untuk disimpan. Biaya mungkin atau mungkin tidak sepadan. Pada percobaan selanjutnya kita akan menambahkan trigger, alat untuk mengurangi jumlah data yang disimpan.

Kode:

def experiment_with_moving_average_and_sample_rate(self):

print """ Percobaan dengan Moving Average dan Sample Rate, dt, run average divariasikan """ # ---------------------------- -------------------- self.start_plot(plot_title = "Moving Average dan Sample Rate") self.add_sensor_data(name = "dt=.1 ra=0 trig= 0", amplitudo = 1., noise_amp =.1, delta_t =.1, max_t = 10., run_ave = 0, trigger_value = 0) self.add_sensor_data(nama = "dt=.1 ra=10 trig=0", amplitudo = 1., noise_amp =.1, delta_t =.1, max_t = 10., run_ave = 10, trigger_value = 0) self.add_sensor_data(name = "dt=.01 ra=100 trig=0", amplitudo = 1., noise_amp =.1, delta_t =.01, max_t = 10., run_ave = 100, trigger_value = 0) self.show_plot()

Langkah 8: Eksperimen: Masuk Dengan Pemicu

Dalam percobaan ini kami menambahkan pemicu. Pertama, apa yang saya maksud dengan pemicu? Pemicu adalah teknik di mana kami mengumpulkan data tetapi hanya menyimpannya setelah beberapa variabel berubah dalam jumlah yang signifikan. Dalam percobaan ini saya menempatkan pemicu pada variabel waktu (sumbu x). Dengan menggunakan pemicu, saya dapat mengambil sejumlah besar data dari pengambilan sampel cepat dan menguranginya menjadi jumlah data yang lebih masuk akal. Ini adalah kekhususan yang berguna dengan tingkat sampel yang tinggi dan rata-rata jangka panjang.

Saya telah mengambil baris # 2 dari percobaan terakhir yang "baik" dan menambahkan pemicu. Jalankan dengan: sim_logging…… Outputnya adalah satu grafik, x garis.

Apa yang terjadi? Kami mendapatkan plot "baik" dengan jumlah data yang masuk akal (sama dengan #1). Ada beberapa biaya dalam pemrosesan yang lebih tinggi. Namun, secara keseluruhan, hasilnya hampir sama dengan #1 tingkat sampel yang lebih rendah dengan lebih sedikit penyaringan. Anda mungkin menyimpulkan:

• Rata-rata berjalan lama dengan pemicu dapat memberikan pengurangan kebisingan yang baik dengan jumlah data yang masuk akal.
• Pemrosesan ekstra mungkin tidak memberikan hasil yang jauh lebih baik dan membutuhkan biaya.

Kode:

# ------------------------------------------------

def experiment_with_trigger(self): print """ Percobaan dengan Triggering, dt, run average dan trigger semuanya divariasikan """ # ----------------------- ------------------------- self.start_plot(plot_title = "Pemicu 1/1 - Pemicu Aktif") self.add_sensor_data(name = "dt=.1 ra=10, trigonometri =0", amplitudo = 1., noise_amp =.1, delta_t =.1, max_t = 10., run_ave = 10, trigger_value = 0) self.add_sensor_data(name = "dt=.01 ra=100, trigonometri =.1", amplitudo = 1., noise_amp =.1, delta_t =.01, max_t = 10., run_ave = 100, trigger_value =.1) self.show_plot()

=

Langkah 9: Eksperimen: Masuk Dengan Pemicu - Kebisingan Lebih Keras

Mari kita lakukan eksperimen yang sama seperti langkah terakhir dan tingkatkan noise. Jalankan dengan: sim_logging…… Outputnya adalah satu grafik, 2 baris.

Sekarang pemrosesan ekstra terlihat lebih berharga. Kesimpulan yang masuk akal di sini mungkin:

Memilih jumlah dan jenis pemrosesan untuk pengurangan kebisingan tergantung pada sinyal dan kebisingan Anda

Kode:

def eksperimen_with_trigger_louder_noise(mandiri):

print """ Suara lebih keras dari percobaan sebelumnya """ self.start_plot(plot_title = "Percobaan dengan Pemicu-Kebisingan Lebih Keras") self.add_sensor_data(name = "…dt=.1 ra=10", amplitudo = 1., noise_amp =.5, delta_t =.1, max_t = 10., run_ave = 10, trigger_value = 0) self.add_sensor_data(name = "..dt=.01 ra=100 tv =.1", amplitudo = 1., noise_amp =.5, delta_t =.01, max_t = 10., run_ave = 100, trigger_value =.1) self.show_plot()

Langkah 10: Buat Eksperimen Anda Sendiri

Pada titik ini saya harap Anda melihat bahwa teknik-teknik dalam instruksi ini dapat berguna dalam pencatatan data, tetapi mereka juga harus digunakan dengan beberapa pemikiran. Bereksperimen dengan mereka dapat membantu proses itu.

Beberapa komentar tentang eksperimen dan hal-hal yang mungkin Anda perhatikan:

• Gelombang sinus bukan satu-satunya jenis sinyal yang menarik, coba yang lain, gelombang lain atau landai atau …..
• Saya menggunakan distribusi normal untuk kebisingan, ada begitu banyak jenis kebisingan; Anda harus mempertimbangkan orang lain
• Rata-rata lari adalah cara yang sederhana, tetapi bukan satu-satunya metode untuk melihat kebisingan

Catatan: mencatat gambar dari Wikipedia.

Langkah 11: Menggunakan Teknik di Perangkat Lunak Logging Anda

Kode saya berorientasi objek dan pemrosesan untuk menjalankan rata-rata dan pemicu hanya dapat disalin ke lingkungan Python Anda dan kemudian digunakan. Objek-objek tersebut adalah:

• DataTrigger di data_trigger.py
• MovingAverage di moving_average.py

Objek utama saya LoggingSim di simulation_logging.py akan memberi Anda contoh yang baik tentang cara menggunakannya. Jika Anda menggunakan bahasa lain, Anda dapat membaca kode saya dan menerapkannya dalam bahasa Anda.

Kode ini dapat memberi proyek Anda pencatatan data yang lebih baik, cobalah.

Grafik di atas adalah dari Grafik Tenaga Surya Anda oleh russ_hensel yang menggunakan objek rata-rata berjalan yang sama.