Mga eksperimento sa Advanced na Pag-log ng Data (Paggamit ng Python): 11 Mga Hakbang

2024 May -akda: John Day | [email protected]. Huling binago: 2024-01-30 13:11

Mayroong maraming mga instruksyon sa pag-log ng data, kaya't kapag nais kong bumuo ng isang proyekto ng aking pag-log ay tumingin ako sa paligid ng isang bungkos. Ang ilan ay mabuti, ang ilan ay hindi gaanong magkano, kaya't nagpasya akong kumuha ng ilan sa mga mas mahusay na ideya at gumawa ng sarili kong aplikasyon. Nagresulta ito sa isang proyekto na parehong mas advanced at mas kumplikado kaysa sa una kong inaasahan. Ang isang bahagi nito ay naging isang serye ng mga eksperimento sa pagproseso ng data ng sensor. Pinapayagan ka ng nagtuturo na ito na subukan ang pareho o katulad na mga eksperimento.

(Maaari mong tingnan ang lahat ng code at i-download ito sa: Code sa GitHub Maaari kang tumingin sa, marahil sa ibang window, na may 2 pag-click lamang)

Kadalasan ang pag-log sa data ay nagsasangkot ng mga sumusunod:

• Pagkuha ng data: Basahin ang ilang data mula sa isang sensor. Kadalasan ay binabasa lamang nito ang isang analog sa digital converter (ADC) sa isang aparato tulad ng isang Arduino.
• Pagproseso ng data: Kapag binabasa ang isang halaga ng ADC ang output ng mga converter ay karaniwang kailangang ma-scale sa tamang mga yunit. Maaaring kailanganin ding gumawa ng ilang pagsasaayos upang i-calibrate ang mga halaga upang maitama para sa mga error sa sensor.
• Pag-filter: Karaniwang naglalaman ang data ng ilang ingay, maaari itong ma-filter upang tumingin ka ng isang signal sa iyong data, hindi sa ingay.
• Imbakan ng data: Ang data ay nai-save, marahil sa isang text file, marahil sa cloud. Ang data ay dapat mabuhay kahit na ang kapangyarihan ay namatay. Madaling makatipid ng masyadong maraming data, mayroon kaming kaunting trick upang mabawasan ang espasyo ng imbakan ng data.
• Pagpapakita ng data: Mga pamamaraan upang tingnan ang iyong data, hindi talaga pag-log ng data, ngunit kung hindi ka gumawa ng isang uri ng pagpapakita ng data bakit mo ito kokolektahin?
• Remote Access: Hindi kinakailangan ngunit masarap magkaroon.

Karamihan sa mga itinuturo ay may kasamang ilan ngunit hindi lahat ng nasa itaas, o gawin ang mga ito sa isang napaka-simpleng paraan. Ang magtuturo na ito ay tutugon sa 2 sa mga madalas na laktaw na isyu sa pag-log at bilang isang bonus ay magbibigay sa iyo ng isang paraan ng pag-graphing ng iyong data nang hindi gumagamit ng isang serbisyong cloud. Maaari mong gamitin ang buong bagay o hilahin ang mga piraso at piraso at i-remix ang mga ito sa isang proyekto mo.

Hakbang 1: Mga Tool at Materyales

Ang halimbawang ito ay nasa Python kaya't tatakbo ito, at maaaring magamit ang mga bahagi, halos anumang OS kabilang ang Mac, PC, Linux at ang Raspberry Pi.

Kaya upang magamit ang itinuturo na ito na kailangan mo lamang ay isang tumatakbo na Python 3.6 na kapaligiran, at i-download ang nakalakip na code. Matapos patakbuhin ang code na na-set up ko, maaari mo itong baguhin para sa iyong sariling mga eksperimento. Tulad ng dati sa Python maaaring kailanganin mong magdagdag ng ilang mga pakete / modyul upang gumana ang lahat. Ang aking kapaligiran sa Spyder ay may halos lahat ng kinakailangang mga bahagi sa lugar (tingnan ang: Maaaring Masiyahan ang Mga Pagtingin sa Grap na may Python Screen Scraping). Kapag nagpatakbo ka muna ng relo para sa anumang mga mensahe ng error ipapaalam nila sa iyo ang tungkol sa anumang mga nawawalang bahagi sa iyong kapaligiran.

Sasabihin sa iyo ng susunod na dalawang mga hakbang kung paano bumuo at magpatakbo ng iyong sariling eksperimento, ngunit mas mahusay na maghintay hanggang sa patakbuhin mo ang kasama na mga eksperimento bago mo subukan ang iyong sarili.

Upang maunawaan ang code kakailanganin mong magkaroon ng kaunting karanasan sa oriented na object na Python, na nagpapaliwanag na lampas sa saklaw ng pagtuturo na ito, ngunit dapat bigyan ka ng Google ng anumang tulong na maaaring kailanganin mo.

Tandaan ang code: (Code sa GitHub Maaari kang makakuha ng pagtingin, marahil sa isa pang window, na may 2 pag-click lamang) ay nasa Python 3.6, kaya't ang pagkakaroon ng 3.6 ay magiging pinakamahusay. Ang mas lumang bersyon ng code ay narito sa mga link sa ibaba.

Hakbang 2: Pagbuo ng isang Eksperimento

Mayroong tatlong mga hakbang sa programa (at mga linya) sa pagbuo ng isang eksperimento. Ang bawat eksperimento ay isang pagpapaandar sa object ng LoggingSim sa file na simulate_logging.py. Hinahayaan nating tingnan ang eksperimento 1 (lamang ang unang grap) na tatakbo namin sa susunod na hakbang:

def experiment_with_sample_rates (sarili):

i-print ang "" "Eksperimento sa Mga Halimbawang Rate ng pagtingin sa iba't ibang mga rate ng sample sa pamamagitan ng pagbabago ng delta T" "" self.start_plot (plot_title = "Mga Sample Rate - Bahagi 1/3: Delta T = 1.0") self.add_sensor_data (pangalan = "dt = 1. ", amplitude = 1., noise_amp =.0, delta_t = 1., max_t = 10., run_ave = 0, trigger_value = 0) self.show_plot ()

Ang bawat eksperimento ay nakasulat bilang sariling pag-andar kaya't may linya kaming tumutukoy sa pagpapaandar (def eksperimento …..)

Ang susunod, hindi linya ng komento, (start_plot (….) Lumilikha ng bagay para sa eksperimento at binibigyan ito ng isang pangalan.

Ang susunod, linya ng linya na hindi puna, (add_sensor_data (…) ay nahahati sa maraming mga linya. Ginagaya nito ang isang sensor na sumusukat ng isang senyas na may potensyal na ingay at ilang pagproseso. Ang mga argumento ng pag-andar ay ang mga sumusunod:

• pangalan: isang pangalan na inilagay sa huling grap upang makilala ang data
• amplitude: kung gaano kalaki ang signal, palagi kaming gagamit ng isang amplitude na 1. sa itinuturo na ito.
• noise_amp: kung gaano kalaki ang ingay, 0. walang ingay, magsisimula kami dito.
• delta_t: ang oras sa pagitan ng mga sukat, kinokontrol ang rate ng sample.
• max_t: ang maximum na oras na nangongolekta kami ng data, palagi kaming gagamit ng 10 sa itinuturo na ito.
• run_ave: pagproseso gamit ang isang tumatakbo average, 0 ay nangangahulugang walang pagproseso.
• trigger_value: pagproseso gamit ang pag-trigger, 0 ay nangangahulugang walang pagproseso

ang pangwakas, hindi linya ng komento, (self.show_plot ……) ay nagpapakita ng grap.

Upang gawing mas kumplikado ang mga bagay maaari kang magkaroon ng maraming mga linya sa isang graph o maraming mga graphic sa isang eksperimento, dapat itong maging malinaw sa mga sumusunod na eksperimento.

Hakbang 3: Pagpapatakbo ng isang Eksperimento

Ito ang code para sa pagpapatakbo ng isang eksperimento. Tulad ng karaniwan sa Python inilalagay ito sa dulo ng file.

sim_logging = LoggingSim ()

sim_logging.experiment_with_sample_rates ()

Ito ay 2 linya lamang:

• Lumikha ng isang logging simulator (LoggingSim ())
• Patakbuhin ito (sim_logging.experiment_with_sample_rates ())

Sa na-download na code mayroon akong ilang mga linya at komento, dapat itong madaling malaman.

Hakbang 4: Eksperimento: Sample Rate

Ang simulator, tulad ng na-set up dito, ay palaging naglalabas ng isang magandang makinis na alon ng sine ng amplitude 1. Para sa eksperimento na ito magkagulo kami sa rate ng sample, na naayos ng delta_t, ang pagkakaiba ng oras sa pagitan ng mga sample. Wala kaming ingay o iba pang pagproseso. Gumagamit ang code ng 3 mga sample na rate (delta_t = 1.0, 0.1 at 0.01.) Dahil ang mga graph ay nahuhulog sa tuktok ng bawat isa ang eksperimento ay na-set up upang makabuo ng 3 magkakaibang mga graphic. Ang mga nagresultang grap ay ang mga imahe para sa hakbang na ito.

def experiment_with_sample_rates (sarili):

i-print ang "" "Eksperimento sa Mga Halimbawang Rate ng pagtingin sa iba't ibang mga rate ng sample sa pamamagitan ng pagbabago ng delta T" "" self.start_plot (plot_title = "Mga Rate ng Sample ng Eksperimento 1/3: Delta T = 1.0") self.add_sensor_data (name = "dt = 1. ", amplitude = 1., noise_amp =.0, delta_t = 1., max_t = 10., run_ave = 0, trigger_value = 0) self.show_plot () # ------------- ----------------------------------- self.start_plot (plot_title = "Mga Rate ng Sample ng Eksperimento 2/3: Delta T = 0.1 ") self.add_sensor_data (name =" dt = 1. ", amplitude = 1., noise_amp =.0, delta_t = 0.1, max_t = 10., run_ave = 0, trigger_value = 0) self.show_plot () # ---------------------------------------------- sarili.start_plot (plot_title = "Mga Rate ng Halimbawang Eksperimento 3/3: Delta T = 0.01") self.add_sensor_data (name = "dt = 1.", amplitude = 1., noise_amp =.0, delta_t = 0.01, max_t = 10., run_ave = 0, trigger_value = 0) self.show_plot ()

Upang patakbuhin ito gamitin ang linya: sim_logging.experiment_with_sample_rates ()

Posibleng mga konklusyon:

• Masyadong mababa ang isang rate ng sampling ay talagang masama.
• Ang mataas na rate ay madalas na mas mahusay.

(Python 3.6 Code sa GitHub na link sa ibaba sa mga itinuturo, 2.7)

Hakbang 5: Eksperimento: Nagpapakita ng Ingay

Sa eksperimentong ito pinapanatili namin ang parehong signal, gumagamit ng isang daluyan ng sample rate, at mayroong iba't ibang dami ng ingay (noise_amp =.0,.1, 1.0.) Patakbuhin ito gamit ang: sim_logging.experiment_showing_noise (). Ang output ay isang grap na may 3 mga linya.

Posibleng Konklusyon:

Pinahihirapan ang ingay na makita ang signal, bawasan ito kung maaari mo

Ang code:

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

def eksperimento_show_noise (sarili): i-print "" "Eksperimento na nagpapakita ng ingay Naghahanap ng iba't ibang mga ingay sa pamamagitan ng pagbabago ng lakas ng ingay." "" self.start_plot (plot_title = "Eksperimento na Nagpapakita ng Ingay") self.add_sensor_data (pangalan = "ingay = 0.0 ", amplitude = 1., noise_amp =.0, delta_t =.1, max_t = 10., run_ave = 0, trigger_value = 0) self.add_sensor_data (name =" ingay = 0.1 ", amplitude = 1., ingay_amp =. 1, delta_t =.1, max_t = 10., run_ave = 0, trigger_value = 0) self.add_sensor_data (name = "ingay = 1.0", amplitude = 1., noise_amp = 1., delta_t =.1, max_t = 10., run_ave = 0, trigger_value = 0) self.show_plot ()

Hakbang 6: Eksperimento: Bawasan ang Ingay Sa Isang Moving Average

Ang isang average na paglipat (halimbawa na may haba na 8) ay tumatagal ng huling 8 mga sukat at i-average ang mga ito. Kung ang ingay ay sapalaran inaasahan namin na ito ay average sa malapit sa 0. Patakbuhin ang eksperimento sa: sim_logging.experiment_showing_noise (). Output isang graph.

Mga Posibleng Konklusyon:

• Ang isang average na paglipat ay aalisin ang karamihan ng ingay
• Kung mas matagal ang average na paglipat mas maraming pagbabawas ng ingay
• Ang mas matagal na average na paglipat ay maaaring bawasan at ibaluktot ang signal

Ang code:

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

def experiment_with_moving_average (sarili): i-print ang "" "Eksperimento sa MovingAverage Tumingin sa iba't ibang MovingAverage sa pamamagitan ng pagbabago ng haba. Lahat ay may parehong ingay." "" # ---------------- ------------------------------ self.start_plot (plot_title = "MovingAverage-Part 1/2: Walang Moving Average") na sarili.add_sensor_data (name = "ave len = 0", amplitude = 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 at 32") self.add_sensor_data (name = "ave len = 8", amplitude = 1., noise_amp =.1, delta_t =.1, max_t = 10., run_ave = 8, trigger_value = 0) self.add_sensor_data (name = "ave len = 32", amplitude = 1., noise_amp =.1, delta_t =.1, max_t = 10., run_ave = 32, trigger_value = 0) self.show_plot ()

Hakbang 7: Eksperimento: Average na Paglilipat at Sample Rate

Sa eksperimentong ito ihinahambing namin ang hilaw na signal na may ingay at 2 magkakaibang pagkakaiba-iba sa pagbawas ng ingay.

1. Katamtamang rate ng sample at average na average na pagpapatakbo
2. Mataas na rate ng sample at average na mataas na haba ng pagpapatakbo

Patakbuhin ito gamit ang: sim_logging …… Output ay isang grap. Sa palagay ko malinaw na ang # 2 ay gumagawa ng isang mas mahusay na trabaho sa pagbawas ng ingay kaya maaari naming napagpasyahan na:

Ang mataas na rate ng sample at average ng pagtakbo ng haba ng haba ay mabuti

Ngunit dapat mong tandaan na may gastos. Ang # 2 ay tumatagal ng higit pang pagproseso at nagreresulta sa mas maraming data upang mai-save. Ang gastos ay maaaring o hindi maaaring sulit. Sa susunod na eksperimento magdagdag kami ng isang gatilyo, isang aparato upang mabawasan ang dami ng nakaimbak na data.

Ang code:

def experiment_with_moving_average_and_sample_rate (sarili):

i-print ang "" "Eksperimento sa Moving Average at Sample Rate, dt, magpatakbo ng average na magkakaiba-iba" "" # ---------------------------- ----------------- self.start_plot (plot_title = "Average na Paglipat at Sample Rate") self.add_sensor_data (pangalan = "dt =.1 ra = 0 trig = 0 ", amplitude = 1., noise_amp =.1, delta_t =.1, max_t = 10., run_ave = 0, trigger_value = 0) self.add_sensor_data (name =" dt =.1 ra = 10 trig = 0 ", amplitude = 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", amplitude = 1., noise_amp =.1, delta_t =.01, max_t = 10., run_ave = 100, trigger_value = 0) self.show_plot ()

Hakbang 8: Eksperimento: Pag-log With Trigger

Sa eksperimentong ito nagdagdag kami ng isang gatilyo. Una, ano ang ibig kong sabihin sa isang nag-uudyok? Ang isang gatilyo ay isang pamamaraan kung saan kinokolekta namin ang data ngunit nai-save lamang ito pagkatapos ng ilang variable na nabago ng isang makabuluhang halaga. Sa mga eksperimentong ito naglalagay ako ng isang gatilyo sa variable ng oras (x axis). Sa pamamagitan ng paggamit ng gatilyo maaari kong kunin ang mataas na halaga ng data mula sa mabilis na pag-sample at bawasan ito sa isang mas makatwirang dami ng data. Ito ay partikular na kapaki-pakinabang na may mataas na mga rate ng sample at isang mahabang tumatakbo average.

Kinuha ko ang linya na # 2 mula sa huling eksperimento na "mahusay" na nagdagdag ng isang gatilyo. Patakbuhin ito gamit ang: sim_logging …… Ang output ay isang grap, x mga linya.

Anong nangyayari Nakakakuha kami ng isang "mahusay" na balangkas na may isang makatwirang dami ng data (pareho sa # 1). Nagkaroon ng ilang gastos sa mas mataas na pagproseso. Gayunpaman, sa pangkalahatan, ang mga resulta ay halos kapareho ng # 1 ng mas mababang rate ng sample na may mas kaunting pagsala. Maaari kang magtapos:

• Ang matagal na average na tumatakbo sa pag-trigger ay maaaring magbigay ng mahusay na pagbabawas ng ingay na may makatuwirang halaga ng data.
• Ang labis na pagproseso ay maaaring hindi makapagbigay ng mas mahusay na mga resulta at may kasamang gastos.

Ang code:

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

def eksperimento_with_trigger (sarili): i-print ang "" "Eksperimento sa Pag-trigger, dt, pagpapatakbo ng average at pag-uudyok sa lahat ng iba-iba" "" # ----------------- ----------------- self.start_plot (plot_title = "Trigger 1/1 - Triggering On") self.add_sensor_data (name = "dt =.1 ra = 10, trig = 0 ", amplitude = 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 =.1 ", amplitude = 1., noise_amp =.1, delta_t =.01, max_t = 10., run_ave = 100, trigger_value =.1) self.show_plot ()

=

Hakbang 9: Eksperimento: Pag-log With Trigger - Louder Noise

Hinahayaan nating gawin ang parehong eksperimento tulad ng huling hakbang at dagdagan ang ingay. Patakbuhin ito gamit ang: sim_logging …… Ang output ay isang grap, 2 linya.

Ngayon ang sobrang pagpoproseso ay mukhang mas sulit habang. Ang isang makatuwirang konklusyon dito ay maaaring:

Ang pagpili ng dami at uri ng pagproseso para sa pagbawas ng ingay ay nakasalalay sa iyong signal at ingay

Ang code:

def eksperimento_with_trigger_louder_noise (sarili):

i-print ang "" "Mas malakas na ingay kaysa sa dating eksperimento" "" self.start_plot (plot_title = "Isang Eksperimento sa Trigger-Louder Noise") self.add_sensor_data (name = "… dt =.1 ra = 10", amplitude = 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", amplitude = 1., noise_amp =.5, delta_t =.01, max_t = 10., run_ave = 100, trigger_value =.1) self.show_plot ()

Hakbang 10: Gumawa ng Iyong Sariling Mga Eksperimento

Sa puntong ito inaasahan kong makita mo na ang mga diskarte sa itinuturo na ito ay maaaring maging kapaki-pakinabang sa pag-log ng data, ngunit kailangan din nilang magamit sa ilang pag-iisip. Ang pag-eksperimento sa kanila ay makakatulong sa prosesong iyon.

Ang ilang mga pangungusap sa mga eksperimento at bagay na maaari mong tingnan:

• Ang mga banayad na alon ay hindi lamang ang kagiliw-giliw na uri ng signal, subukan ang iba, iba pang mga alon o ramp o…..
• Gumamit ako ng isang normal na pamamahagi para sa ingay, maraming mga uri ng ingay; dapat isaalang-alang mo ang iba
• Ang pagpapatakbo ng mga average ay isang simple, ngunit hindi lamang ang paraan para sa pagtingin sa ingay

Tandaan: pag-log ng mga larawan mula sa Wikipedia.

Hakbang 11: Paggamit ng Mga Diskarte sa Iyong Pag-log Software

Ang aking code ay nakatuon sa object at ang pagproseso para sa average ng pagpapatakbo at pag-trigger ay maaaring makopya sa iyong kapaligiran sa Python at pagkatapos ay magamit. Ang mga bagay ay:

• DataTrigger sa data_trigger.py
• MovingAverage sa paglipat_average.py

Ang aking pangunahing object na LoggingSim sa simulate_logging.py ay dapat magbigay sa iyo ng isang magandang halimbawa ng kung paano ito gamitin. Kung gumagamit ka ng ibang wika maaari mong basahin ang aking code at ipatupad sa iyong wika.

Ang code na ito ay maaaring magbigay sa iyong proyekto ng mas mahusay na pag-log ng data, subukan ito.

Ang graph sa itaas ay mula sa Graph Your Solar Power ni russ_hensel na gumagamit ng parehong tumatakbo average na object.