Experimente de înregistrare avansată a datelor (folosind Python): 11 pași

2024 Autor: John Day | [email protected]. Modificat ultima dată: 2024-01-30 11:41

Există o mulțime de instrumente de înregistrare a datelor, așa că atunci când am vrut să construiesc un proiect propriu de înregistrare, m-am uitat în jur la o grămadă. Unele au fost bune, altele nu atât de multe, așa că am decis să iau unele dintre ideile mai bune și să îmi fac propria cerere. Acest lucru a dus la un proiect mai avansat și mai complicat decât mă așteptam la început. O parte a acestuia a devenit o serie de experimente în prelucrarea datelor senzorilor. Acest instructable vă permite să încercați aceleași experimente sau similare.

(Puteți vizualiza tot codul și îl puteți descărca de la: Cod la GitHub Puteți intra în vizualizare, poate într-o altă fereastră, cu doar 2 clicuri)

În mod obișnuit, înregistrarea datelor implică următoarele:

• Achiziționarea datelor: citiți câteva date de la un senzor. Adesea, aceasta este doar citirea unui convertor analogic digital (ADC) pe un dispozitiv precum un Arduino.
• Prelucrarea datelor: Când citiți o valoare ADC, ieșirea convertorilor trebuie să fie în mod normal scalată la unitățile potrivite. De asemenea, ar putea fi necesară efectuarea unor ajustări pentru a calibra valorile pentru a corecta erorile senzorului.
• Filtrare: datele conțin de obicei un anumit zgomot, acesta poate fi filtrat, astfel încât să căutați un semnal în datele dvs., nu zgomotul.
• Stocarea datelor: datele sunt salvate, poate într-un fișier text, poate în cloud. Datele ar trebui să supraviețuiască chiar dacă alimentarea se oprește. Este ușor să economisiți prea multe date, avem un mic truc pentru a reduce spațiul de stocare a datelor.
• Afișarea datelor: metode pentru a vă analiza datele, nu chiar înregistrarea datelor, dar dacă nu faceți un fel de afișare a datelor, de ce să le colectați?
• Acces de la distanță: nu este necesar, dar este plăcut.

Cele mai multe instructabile includ unele, dar nu toate cele de mai sus, sau le fac într-un mod foarte simplu. Această instrucțiune va aborda 2 dintre problemele de înregistrare deseori omise și, ca bonus, vă va oferi un mijloc de a grafica datele fără a utiliza un serviciu cloud. Puteți folosi totul sau puteți scoate bucăți și remixați-le într-un proiect propriu.

Pasul 1: Instrumente și materiale

Acest exemplu este totul în Python, deci va rula și componentele pot fi utilizate pe aproape orice sistem de operare, inclusiv Mac, PC, Linux și Raspberry Pi.

Deci, pentru a utiliza acest lucru instructiv, tot ce aveți nevoie este un mediu Python 3.6 care rulează și descărcați codul atașat. După rularea codului pe care l-am configurat, îl puteți modifica pentru propriile experimente. Așa cum este obișnuit cu Python, poate fi necesar să adăugați câteva pachete / module pentru ca totul să funcționeze. Mediul meu Spyder vine cu aproape toate piesele necesare în loc (a se vedea: Graficul Vizionări instructabile cu Python Screen Scraping). Când rulați pentru prima dată pentru orice mesaje de eroare, vă vor informa despre orice părți lipsă din mediul dvs.

Următorii doi pași vă vor spune cum să construiți și să rulați un experiment propriu, dar este mai bine să așteptați până când rulați experimentele incluse înainte de a încerca propriul dvs. experiment.

Pentru a înțelege codul, va trebui să aveți un pic de experiență cu Python orientat pe obiecte, explicând că acest lucru depășește sfera acestui instructiv, dar Google ar trebui să vă ofere orice ajutor de care aveți nevoie.

Rețineți codul: (Codul la GitHub Puteți intra în vizualizare, poate într-o altă fereastră, cu doar 2 clicuri) este acum în Python 3.6, deci să aveți 3.6 ar fi cel mai bine. Versiunea mai veche a codului este aici în linkurile de mai jos.

Pasul 2: Construirea unui experiment

Există trei pași (și linii) de programare în construirea unui experiment. Fiecare experiment este o funcție din obiectul LoggingSim din fișierul simulate_logging.py. Să vedem experimentul 1 (doar primul grafic) pe care îl vom executa în pasul următor:

def experiment_with_sample_rates (auto):

print "" "Experimentați cu rate de eșantionare Privind diferite rate de eșantionare prin modificarea deltei T" "" self.start_plot (plot_title = "Eșantion rate - Partea 1/3: Delta T = 1.0") self.add_sensor_data (nume = "dt = 1. ", amplitudine = 1., noise_amp =.0, delta_t = 1., max_t = 10., run_ave = 0, trigger_value = 0) self.show_plot ()

Fiecare experiment este scris ca funcție proprie, așa că avem o linie care definește funcția (def experiment …)

Următoarea linie, fără comentarii, (start_plot (….) creează obiectul pentru experiment și îi dă un nume.

Următoarea linie fără comentariu, (add_sensor_data (…) este împărțită în mai multe linii. Simulează un senzor care măsoară un semnal cu potențial zgomot și o anumită procesare. Argumentele funcției sunt următoarele:

• nume: un nume pus pe graficul final pentru a identifica datele
• amplitudine: cât de mare este semnalul, vom folosi întotdeauna o amplitudine de 1. în acest instructable.
• noise_amp: cât de mare este zgomotul, 0. nu există zgomot, vom începe de aici.
• delta_t: timpul dintre măsurători, controlează rata de eșantionare.
• max_t: timpul maxim de colectare a datelor, vom folosi întotdeauna 10 în acest instructable.
• run_ave: procesare folosind o medie de rulare, 0 înseamnă lipsă de procesare.
• trigger_value: procesare folosind triggering, 0 înseamnă lipsă de procesare

ultima linie, fără comentarii, (self.show_plot …….) afișează graficul.

Pentru a face lucrurile puțin mai complicate, puteți avea mai multe linii pe un grafic sau mai multe grafice într-un experiment, acest lucru ar trebui să fie clar din experimentele care urmează.

Pasul 3: Rularea unui experiment

Acesta este codul pentru rularea unui experiment. Ca în mod obișnuit în Python, este plasat la sfârșitul fișierului.

sim_logging = LoggingSim ()

sim_logging.experiment_with_sample_rates ()

Acesta este doar 2 rânduri:

• Creați un simulator de înregistrare (LoggingSim ())
• Rulați-l (sim_logging.experiment_with_sample_rates ())

În codul descărcat mai am câteva rânduri și comentarii, ar trebui să fie ușor de dat seama.

Pasul 4: Experiment: rata de eșantionare

Simulatorul, așa cum este configurat aici, produce întotdeauna o undă sinusoidală netedă de amplitudine 1. Pentru acest experiment, ne vom amesteca cu rata de eșantionare, ajustată de delta_t, diferența de timp dintre eșantioane. Nu vom avea niciun zgomot sau alte prelucrări. Codul folosește 3 rate de eșantionare (delta_t = 1,0, 0,1 și 0,01.) Deoarece graficele cad una peste alta, experimentul este configurat pentru a produce 3 grafice diferite. Graficele rezultate sunt imaginile pentru acest pas.

def experiment_with_sample_rates (auto):

print "" "Experimentare cu rate de eșantionare Uită-te la rate de eșantionare diferite prin modificarea deltei T" "" self.start_plot (plot_title = "Experimentare eșantionare 1/3: Delta T = 1.0") self.add_sensor_data (nume = "dt = 1. ", amplitudine = 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 rate de eșantionare 2/3: Delta T = 0.1 ") self.add_sensor_data (nume =" dt = 1. ", amplitudine = 1., noise_amp =.0, delta_t = 0.1, max_t = 10., run_ave = 0, trigger_value = 0) self.show_plot () # ------------------------------------------------ de sine.start_plot (plot_title = "Experiment Sample Rate 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 ()

Pentru al rula utilizați linia: sim_logging.experiment_with_sample_rates ()

Concluzii posibile:

• O rată de eșantionare prea mică este foarte proastă.
• Tarifele mari sunt adesea mai bune.

(Codul Python 3.6 la linkul GitHub de mai jos la instructables, 2.7)

Pasul 5: Experiment: Afișarea zgomotului

În acest experiment păstrăm același semnal, folosim o rată de eșantionare medie și avem cantități diferite de zgomot (noise_amp =.0,.1, 1.0.) Rulați-l cu: sim_logging.experiment_showing_noise (). Ieșirea este un grafic cu 3 linii.

Posibile concluzii:

Zgomotul face dificil de văzut semnalul, reduceți-l dacă puteți

Codul:

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

def experiment_showing_noise (self): print "" "Experiment care arată zgomot Uită-te la diferite cantități de zgomot prin schimbarea amplitudinii zgomotului." "" self.start_plot (plot_title = "Experimentarea zgomotului") self.add_sensor_data (name = "noise = 0.0 ", amplitudine = 1., noise_amp =.0, delta_t =.1, max_t = 10., run_ave = 0, trigger_value = 0) self.add_sensor_data (nume =" noise = 0.1 ", amplitudine = 1., noise_amp =. 1, delta_t =.1, max_t = 10., run_ave = 0, trigger_value = 0) self.add_sensor_data (nume = "noise = 1.0", amplitudine = 1., noise_amp = 1., delta_t =.1, max_t = 10., run_ave = 0, trigger_value = 0) self.show_plot ()

Pasul 6: Experiment: reduceți zgomotul cu o medie mobilă

O medie mobilă (de exemplu, cu lungimea 8) ia ultimele 8 măsurători și le medieză. Dacă zgomotul este aleator, sperăm că va ajunge la aproximativ 0. Executați experimentul cu: sim_logging.experiment_showing_noise (). Efectuați un grafic.

Posibile concluzii:

• O medie mobilă elimină o mare parte din zgomot
• Cu cât media mobilă este mai lungă, cu atât este mai redusă zgomotul
• Media mobilă mai lungă poate reduce și distorsiona semnalul

Codul:

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

def experiment_with_moving_average (self): print "" "Experiment cu MovingAverage Privind la MovingAverage diferit schimbând lungimea. Toate au același zgomot." "" # ------------------ ------------------------------ self.start_plot (plot_title = "MovingAverage-Part 1/2: No Moving Average") self.add_sensor_data (nume = "ave len = 0", amplitudine = 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 (nume = "ave len = 32", amplitudine = 1., noise_amp =.1, delta_t =.1, max_t = 10., run_ave = 32, trigger_value = 0) self.show_plot ()

Pasul 7: Experiment: Media mobilă și rata de eșantionare

În acest experiment, comparăm semnalul brut cu zgomotul și 2 variații diferite privind reducerea zgomotului.

1. Rată medie de eșantionare și medie medie de funcționare
2. Rată de eșantionare ridicată și medie de rulare de lungime mare

Rulați-l cu: sim_logging …… Ieșirea este un grafic. Cred că este clar că # 2 face o treabă mai bună la reducerea zgomotului, așa că am putea concluziona că:

Rata de eșantionare ridicată și media de rulare de lungime mare sunt bune

Dar trebuie să rețineți că există un cost. # 2 necesită mult mai multă procesare și are ca rezultat salvarea multor date. Costul poate merita sau nu. În experimentul următor vom adăuga un declanșator, un dispozitiv pentru a reduce cantitatea de date stocate.

Codul:

def experiment_with_moving_average_and_sample_rate (auto):

print "" "Experiment cu media mobilă și rata de eșantionare, dt, media de rulare fiind variată" "" # ---------------------------- -------------------- self.start_plot (plot_title = "Moving Average and Sample Rate") self.add_sensor_data (name = "dt =.1 ra = 0 trig = 0 ", amplitudine = 1., noise_amp =.1, delta_t =.1, max_t = 10., run_ave = 0, trigger_value = 0) self.add_sensor_data (nume =" dt =.1 ra = 10 trig = 0 ", amplitudine = 1., noise_amp =.1, delta_t =.1, max_t = 10., run_ave = 10, trigger_value = 0) self.add_sensor_data (nume = "dt =.01 ra = 100 trig = 0", amplitudine = 1., noise_amp =.1, delta_t =.01, max_t = 10., run_ave = 100, trigger_value = 0) self.show_plot ()

Pasul 8: Experiment: Logare cu Trigger

În acest experiment adăugăm un declanșator. În primul rând, ce vreau să spun prin declanșator? Un declanșator este o tehnică în care colectăm date, dar le salvăm numai după ce o variabilă s-a modificat cu o cantitate semnificativă. În aceste experimente am pus un declanșator pe variabila timp (axa x). Prin utilizarea declanșatorului, pot prelua cantitatea mare de date din eșantionarea rapidă și o pot reduce la o cantitate mai rezonabilă de date. Este deosebit de util cu rate de eșantionare ridicate și o medie de funcționare pe termen lung.

Am luat linia # 2 din ultimul experiment, care a fost „bun” și a adăugat un declanșator. Rulați-l cu: sim_logging …… Ieșirea este un grafic, x linii.

Ce se întâmplă? Obținem un complot „bun” cu o cantitate rezonabilă de date (la fel ca numărul 1). Au existat unele costuri în procesarea mai mare. În general, totuși, rezultatele sunt aproximativ aceleași cu numărul 1, rata de eșantionare mai mică, cu mai puține filtrări. Ați putea concluziona:

• Media de funcționare lungă cu declanșare poate oferi o reducere bună a zgomotului cu cantități rezonabile de date.
• Este posibil ca procesarea suplimentară să nu dea rezultate mult mai bune și să vină cu un cost.

Codul:

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

def experiment_with_trigger (self): print "" "Experiment cu Triggering, dt, run mediu și declanșare toate fiind variate" "" # ----------------------- ------------------------- self.start_plot (plot_title = "Trigger 1/1 - Triggering On") self.add_sensor_data (name = "dt =.1 ra = 10, trig = 0 ", amplitudine = 1., noise_amp =.1, delta_t =.1, max_t = 10., run_ave = 10, trigger_value = 0) self.add_sensor_data (nume =" dt =.01 ra = 100, trig =.1 ", amplitudine = 1., noise_amp =.1, delta_t =.01, max_t = 10., run_ave = 100, trigger_value =.1) self.show_plot ()

=

Pasul 9: Experiment: Înregistrare cu declanșator - Zgomot mai puternic

Să facem același experiment ca ultimul pas și să intensificăm zgomotul. Rulați-l cu: sim_logging …… Ieșirea este un grafic, 2 linii.

Acum, procesarea suplimentară pare mai utilă. O concluzie rezonabilă aici ar putea fi:

Alegerea cantității și tipului de procesare pentru reducerea zgomotului depinde de semnal și zgomot

Codul:

def experiment_with_trigger_louder_noise (self):

print "" "Zgomot mai puternic decât experimentul anterior" "" self.start_plot (plot_title = "Un experiment cu declanșator-zgomot mai puternic") 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 ()

Pasul 10: Faceți propriile experimente

În acest moment, sper să vedeți că tehnicile din acest instructable pot fi utile în înregistrarea datelor, dar că trebuie să fie folosite și cu ceva gând. Experimentarea cu ei poate ajuta acest proces.

Câteva observații cu privire la experimente și lucruri pe care ați putea să le analizați:

• Undele sinusoidale nu sunt singurul tip de semnal interesant, încercați altele, alte valuri sau rampe sau …..
• Am folosit o distribuție normală pentru zgomot, există atât de multe tipuri de zgomot; ar trebui să-i iei în considerare pe ceilalți
• Mediile de rulare sunt simple, dar nu singura metodă de a privi zgomotul

Notă: înregistrarea imaginilor din Wikipedia.

Pasul 11: Utilizarea tehnicilor din software-ul dvs. de înregistrare

Codul meu este orientat pe obiecte, iar procesarea pentru rulare medie și declanșator poate fi doar copiată în mediul dvs. Python și apoi utilizată. Obiectele sunt:

• DataTrigger în data_trigger.py
• MovingAverage în moving_average.py

Obiectul meu principal LoggingSim din simulate_logging.py ar trebui să vă ofere un bun exemplu de utilizare. Dacă utilizați o altă limbă, puteți citi codul meu și implementa în limba dvs.

Acest cod poate oferi proiectului dvs. o înregistrare mai bună a datelor, încercați.

Graficul de mai sus este din Graph Your Solar Power de către russ_hensel care folosește același obiect mediu de rulare.