Experimenty s pokročilým zaznamenávaním údajov (pomocou Pythonu): 11 krokov

2024 Autor: John Day | [email protected]. Naposledy zmenené: 2024-01-30 11:56

Existuje veľa inštrukcií k protokolovaniu údajov, takže keď som chcel vytvoriť vlastný projekt protokolovania, poobzeral som sa okolo. Niektoré boli dobré, niektoré nie až také, a tak som sa rozhodol vziať niekoľko lepších nápadov a vytvoriť si vlastnú aplikáciu. Výsledkom bol projekt pokročilejší a komplikovanejší, ako som pôvodne očakával. Jednou z jej častí sa stala séria experimentov pri spracovaní údajov zo senzorov. Tento návod vám umožní vyskúšať si rovnaké alebo podobné experimenty.

(Celý kód si môžete stiahnuť a stiahnuť na adrese: Kód na GitHub Do prezerania sa dostanete, možno v inom okne, iba 2 kliknutia)

Protokolovanie údajov zvyčajne zahŕňa nasledujúce:

• Zber údajov: Prečítajte si niektoré údaje zo senzora. Často je to len čítanie analógovo -digitálneho prevodníka (ADC) na zariadení, akým je Arduino.
• Spracovanie údajov: Pri čítaní hodnoty ADC je obvykle potrebné, aby bol výstup prevodníka zmenšený na správne jednotky. Tiež môže byť potrebné vykonať určité úpravy na kalibráciu hodnôt na opravu chýb snímača.
• Filtrovanie: Údaje bežne obsahujú určitý šum, ktorý je možné filtrovať, aby ste vo svojich údajoch hľadali signál, nie šum.
• Ukladanie údajov: Údaje sa ukladajú možno do textového súboru, možno do cloudu. Dáta by mali prežiť, aj keď sa vypne napájanie. Je ľahké uložiť príliš veľa dát, máme malý trik na zníženie priestoru v úložisku dát.
• Zobrazenie údajov: Metódy na prezeranie vašich údajov, nie v skutočnosti zaznamenávanie údajov, ale ak údaje nezobrazujete, prečo ich zhromažďovať?
• Vzdialený prístup: Nie je to potrebné, ale je pekné to mať.

Väčšina pokynov obsahuje niektoré, ale nie všetky vyššie uvedené, alebo ich urobte veľmi jednoduchým spôsobom. Tento návod sa bude zaoberať 2 často vynechávanými problémami s protokolovaním a ako bonus vám poskytne spôsob, ako vykresliť údaje bez použitia cloudovej služby. Môžete to použiť celé alebo vytiahnuť kúsky a remixovať ich do vlastného projektu.

Krok 1: Nástroje a materiály

Tento príklad je v Pythone, takže bude fungovať a komponenty je možné použiť v takmer každom operačnom systéme vrátane počítačov Mac, PC, Linux a Raspberry Pi.

Aby ste teda mohli použiť tento návod, potrebujete iba spustené prostredie Python 3.6 a stiahnite si priložený kód. Po spustení kódu, ktorý som nastavil, ho môžete upraviť pre svoje vlastné experimenty. Ako je to obvyklé v Pythone, možno budete musieť pridať niektoré balíky/moduly, aby všetko fungovalo. Moje prostredie Spyder je vybavené takmer všetkými požadovanými časťami (pozri: Graficky upraviteľné zobrazenia so škrabaním obrazovky v Pythone). Pri prvom spustení sledujte všetky chybové správy, ktoré vás informujú o chýbajúcich častiach vo vašom prostredí.

Nasledujúce dva kroky vám povedia, ako zostaviť a spustiť vlastný experiment, ale pred vyskúšaním vlastného experimentu je pravdepodobne lepšie počkať, kým spustíte zahrnuté experimenty.

Na pochopenie kódu budete potrebovať určité skúsenosti s objektovo orientovaným Pythonom s vysvetlením, že to presahuje rámec tohto návodu, ale spoločnosť Google by vám mala poskytnúť akúkoľvek pomoc, ktorú by ste mohli potrebovať.

Všimnite si kód: (Kód na GitHub K prezeraniu sa môžete dostať, možno v inom okne, iba dvoma kliknutiami) je teraz v Pythone 3.6, takže najlepšie bude mať 3.6. Staršia verzia kódu je tu v odkazoch nižšie.

Krok 2: Vytvorenie experimentu

Pri vytváraní experimentu existujú tri programovacie kroky (a čiary). Každý experiment je funkciou v objekte LoggingSim v súbore simulate_logging.py. Pozrime sa na experiment 1 (len prvý graf), ktorý spustíme v nasledujúcom kroku:

def experiment_s_vzorkovym_ratom (vlastny):

print "" "Experiment so vzorkovacími rýchlosťami Pri pohľade na rôzne vzorkovacie frekvencie zmenou delta T" "" self.start_plot (plot_title = "Sample Rates - Part 1/3: Delta T = 1.0") self.add_sensor_data (name = "dt = 1. ", amplitúda = 1., noise_amp =.0, delta_t = 1., max_t = 10., run_ave = 0, trigger_value = 0) self.show_plot ()

Každý experiment je zapísaný ako vlastná funkcia, takže máme riadok definujúci funkciu (definícia experimentu …..)

Ďalší riadok bez komentárov (start_plot (….)) Vytvorí objekt experimentu a pomenuje ho.

Ďalší riadok riadka bez komentárov (add_sensor_data (…) je rozdelený do niekoľkých riadkov. Simuluje senzor merajúci signál s potenciálnym šumom a určitým spracovaním. Argumenty funkcie sú nasledujúce:

• name: názov uvedený v konečnom grafe na identifikáciu údajov
• amplitúda: aký veľký je signál, v tomto návode vždy použijeme amplitúdu 1.
• noise_amp: aký veľký je hluk, 0. nie je žiadny hluk, začneme tu.
• delta_t: čas medzi meraniami, riadi vzorkovaciu frekvenciu.
• max_t: maximálny čas, kedy zhromažďujeme údaje, vždy použijeme 10 v tomto návode.
• run_ave: spracovanie pomocou bežiaceho priemeru, 0 znamená žiadne spracovanie.
• trigger_value: spracovanie pomocou spustenia, 0 znamená žiadne spracovanie

posledný riadok bez komentárov (self.show_plot ……) zobrazuje graf.

Aby to bolo ešte komplikovanejšie, môžete mať v experimente viacero riadkov na grafe alebo viacero grafov, to by malo byť zrejmé z experimentov, ktoré nasledujú.

Krok 3: Spustenie experimentu

Toto je kód na spustenie experimentu. Ako je v Pythone bežné, je umiestnený na konci súboru.

sim_logging = LoggingSim ()

sim_logging.experiment_w_sample_rates ()

Toto sú iba 2 riadky:

• Vytvorte simulátor protokolovania (LoggingSim ())
• Spustite ho (sim_logging.experiment_with_sample_rates ())

V stiahnutom kóde mám ešte niekoľko riadkov a komentárov, malo by to byť ľahké prísť na to.

Krok 4: Experiment: Vzorkovacia frekvencia

Simulátor, ako je tu nastavený, vždy produkuje peknú plynulú sínusovú vlnu amplitúdy 1. V tomto experimente sa budeme zaoberať vzorkovacou frekvenciou, upravenou o delta_t, časovým rozdielom medzi vzorkami. Nebudeme mať žiadny hluk ani iné spracovanie. Kód používa 3 vzorkovacie frekvencie (delta_t = 1,0, 0,1 a 0,01.) Pretože grafy ležia na sebe, experiment je vytvorený tak, aby produkoval 3 rôzne grafy. Výsledné grafy sú obrázky pre tento krok.

def experiment_s_vzorkovym_ratom (vlastny):

vytlačiť "" "Experiment so vzorkovacími rýchlosťami Pri pohľade na rôzne vzorkovacie frekvencie zmenou delta T" "" self.start_plot (plot_title = "Experimentálne vzorové rýchlosti 1/3: Delta T = 1,0") self.add_sensor_data (názov = "dt = 1. ", amplitúda = 1., noise_amp =.0, delta_t = 1., max_t = 10., run_ave = 0, trigger_value = 0) self.show_plot () # ------------- ----------------------------------- self.start_plot (plot_title = "Experimentálne vzorky 2/3: Delta T = 0,1 ") self.add_sensor_data (názov =" dt = 1. ", amplitúda = 1., noise_amp =.0, delta_t = 0.1, max_t = 10., run_ave = 0, trigger_value = 0) self.show_plot () # ------------------------------------------------ sám.start_plot (plot_title = "Vzorky experimentu 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 ()

Na jeho spustenie použite riadok: sim_logging.experiment_with_sample_rates ()

Možné závery:

• Príliš nízka vzorkovacia frekvencia je skutočne zlá.
• Vysoké ceny sú často lepšie.

(Kód Python 3.6 na odkaze GitHub nižšie v pokynoch, 2.7)

Krok 5: Experiment: Zobrazuje sa šum

V tomto experimente udržujeme rovnaký signál, používame strednú vzorkovaciu frekvenciu a máme tam rôzne množstvo šumu (noise_amp =.0,.1, 1.0.) Spustite ho pomocou: sim_logging.experiment_showing_noise (). Výstupom je jeden graf s 3 riadkami.

Možný záver:

Hluk sťažuje videnie signálu, pokiaľ je to možné, znížte ho

Kód:

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

def experiment_showing_noise (self): print "" "Experiment ukazujúci hluk Pri pohľade na rôzne množstvo hluku zmenou amplitúdy hluku." "" self.start_plot (plot_title = "Experiment Showing Noise") self.add_sensor_data (name = "noise = 0,0 ", amplitúda = 1., noise_amp =.0, delta_t =.1, max_t = 10., run_ave = 0, trigger_value = 0) self.add_sensor_data (name =" noise = 0.1 ", amplitude = 1., noise_amp =. 1, delta_t =.1, max_t = 10., run_ave = 0, trigger_value = 0) self.add_sensor_data (name = "noise = 1.0", amplitude = 1., noise_amp = 1., delta_t =.1, max_t = 10., run_ave = 0, trigger_value = 0) self.show_plot ()

Krok 6: Experiment: Znížte hluk kĺzavým priemerom

Kĺzavý priemer (napríklad s dĺžkou 8) vykoná posledných 8 meraní a spriemeruje ich. Ak je hluk náhodný, dúfame, že bude v priemere blízky 0. Spustite experiment s: sim_logging.experiment_showing_noise (). Vytvorte jeden graf.

Možné závery:

• Kĺzavý priemer eliminuje veľkú časť hluku
• Čím dlhší je kĺzavý priemer, tým väčšia je redukcia šumu
• Dlhší kĺzavý priemer môže znížiť a skresliť signál

Kód:

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

def experiment_with_moving_average (self): print "" "Experiment with MovingAverage Pohľad na rôzne MovingAverage zmenou dĺžky. Všetky majú rovnaký hluk." "" # ------------------ ------------------------------ self.start_plot (plot_title = "MovingAverage-Part 1/2: No Moving Average") self.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 and 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 ()

Krok 7: Experiment: kĺzavý priemer a vzorkovacia frekvencia

V tomto experimente porovnávame surový signál s hlukom a 2 rôzne variácie na zníženie šumu.

1. Stredná vzorkovacia frekvencia a stredný bežiaci priemer
2. Vysoká vzorkovacia frekvencia a dlhý priemer

Spustite ho pomocou: sim_logging …… Výstupom je jeden graf. Myslím si, že je zrejmé, že #2 robí lepšiu prácu pri znižovaní hluku, takže by sme mohli dospieť k záveru, že:

Dobrá je vysoká vzorkovacia frekvencia a dlhý priemer

Musíte však mať na pamäti, že existujú náklady. #2 vyžaduje oveľa viac spracovania a má za následok uloženie oveľa viac údajov. Náklady môžu, ale nemusia stáť za to. V ďalšom experimente pridáme spúšť, zariadenie na zníženie množstva uložených údajov.

Kód:

def experiment_s_moving_average_and_sample_rate (self):

vytlačiť "" "Experiment s kĺzavým priemerom a vzorkovacou frekvenciou, dt, bežný priemer sa líši" "" # ---------------------------- -------------------- self.start_plot (plot_title = "kĺzavý priemer a vzorkovacia frekvencia") self.add_sensor_data (name = "dt =.1 ra = 0 trig = 0 ", amplitúda = 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 ", amplitúda = 1., noise_amp =.1, delta_t =.1, max_t = 10., run_ave = 10, trigger_value = 0) self.add_sensor_data (názov = "dt = 0,01 ra = 100 trig = 0", amplitúda = 1., noise_amp =.1, delta_t =.01, max_t = 10., run_ave = 100, trigger_value = 0) self.show_plot ()

Krok 8: Experiment: Protokolovanie pomocou spúšťača

V tomto experimente pridávame spúšťač. Po prvé, čo mám rozumieť pod spúšťou? Spúšťač je technika, pri ktorej zhromažďujeme údaje, ale ukladáme ich iba vtedy, ak sa nejaká premenná výrazne zmení. V týchto experimentoch som dal spúšť na premennú času (os x). Použitím spúšte môžem odobrať veľké množstvo údajov z rýchleho vzorkovania a redukovať ich na rozumnejšie množstvo údajov. Je to obzvlášť užitočné pri vysokých vzorkovacích frekvenciách a dlhom kĺzavom priemere.

Prevzal som riadok č. 2 z posledného experimentu, ktorý bol „dobrý“, a pridal spúšť. Spustite ho pomocou: sim_logging …… Výstupom je jeden graf, x riadkov.

Čo sa stane? Získame „dobrú“zápletku s primeraným množstvom údajov (rovnakých ako č. 1). Vyššie spracovanie prinieslo určité náklady. Celkovo sú však výsledky približne rovnaké ako #1, nižšia vzorkovacia frekvencia s menším filtrovaním. Môžete dospieť k záveru:

• Dlhodobý priemer so spustením môže poskytnúť dobrú redukciu šumu s primeraným množstvom údajov.
• Extra spracovanie nemusí poskytnúť oveľa lepšie výsledky a je spojené s cenou.

Kód:

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

def experiment_with_trigger (self): print "" "Experiment so spúšťaním, dt, spustenie priemeru a spustenie zmeny všetkých" "" # ----------------------- ------------------------- self.start_plot (plot_title = "Spúšťač 1/1-spustenie zapnuté") self.add_sensor_data (názov = "dt =.1 ra = 10, trig = 0 ", amplitúda = 1., noise_amp =.1, delta_t =.1, max_t = 10., run_ave = 10, trigger_value = 0) self.add_sensor_data (názov =" dt =.01 ra = 100, trig =.1 ", amplitúda = 1., noise_amp =.1, delta_t =.01, max_t = 10., run_ave = 100, trigger_value =.1) self.show_plot ()

=

Krok 9: Experiment: Zaznamenávanie so spúšťou - hlasnejší hluk

Vykonajme rovnaký experiment ako posledný krok a zosilnite hluk. Spustite ho pomocou: sim_logging …… Výstupom je jeden graf, 2 riadky.

Teraz ďalšie spracovanie vyzerá hodnotnejšie. Rozumný záver tu môže byť:

Výber množstva a typu spracovania na zníženie šumu závisí od vášho signálu a šumu

Kód:

def experiment_with_trigger_louder_noise (self):

vytlačiť "" "Hlučnejší hluk ako v predchádzajúcom experimente" "" self.start_plot (plot_title = "Experiment so spúšťacím hlukom") self.add_sensor_data (name = "… dt =.1 ra = 10", amplitúda = 1., noise_amp =.5, delta_t =.1, max_t = 10., run_ave = 10, trigger_value = 0) self.add_sensor_data (názov = "..dt =.01 ra = 100 tv =.1", amplitúda = 1., noise_amp =.5, delta_t =.01, max_t = 10., run_ave = 100, trigger_value =.1) self.show_plot ()

Krok 10: Vytvorte si vlastné experimenty

V tomto bode dúfam, že vidíte, že techniky v tomto návode môžu byť užitočné pri zaznamenávaní údajov, ale musia byť tiež použité s trochou premýšľania. Experimentovanie s nimi môže tomuto procesu pomôcť.

Niekoľko poznámok k experimentom a veciam, ktoré by ste mohli zvážiť:

• Sinusové vlny nie sú jediným zaujímavým typom signálu, vyskúšajte iné, iné vlny alebo rampy alebo …..
• Na šum som použil normálne rozdelenie, existuje toľko druhov hluku; mali by ste brať ohľad na ostatných
• Bežné priemery sú jednoduchou, ale nie jedinou metódou na sledovanie hluku

Poznámka: protokolovanie obrázkov z Wikipédie.

Krok 11: Používanie techník vo vašom protokolovacom softvéri

Môj kód je objektovo orientovaný a spracovanie pre bežný priemer a spúšťač stačí skopírovať do vášho prostredia Python a potom použiť. Objektmi sú:

• DataTrigger v data_trigger.py
• MovingAverage v moving_average.py

Môj hlavný objekt LoggingSim na simulate_logging.py by vám mal poskytnúť dobrý príklad toho, ako ho používať. Ak používate iný jazyk, môžete si prečítať môj kód a implementovať ho vo svojom jazyku.

Tento kód môže vášmu projektu poskytnúť lepšie protokolovanie údajov, vyskúšajte to.

Vyššie uvedený graf je z grafu Graph Your Solar Power od russ_hensel, ktorý používa rovnaký priemerný objekt.