Experimenten in geavanceerde datalogging (met behulp van Python): 11 stappen

2024 Auteur: John Day | [email protected]. Laatst gewijzigd: 2024-01-30 11:15

Er zijn veel instructables voor datalogging, dus toen ik een eigen logging-project wilde bouwen, keek ik naar een heleboel. Sommige waren goed, andere minder, dus besloot ik enkele van de betere ideeën te gebruiken en mijn eigen toepassing te maken. Dit resulteerde in een project dat zowel geavanceerder als gecompliceerder was dan ik in eerste instantie had verwacht. Een deel ervan werd een reeks experimenten in het verwerken van sensorgegevens. Met deze instructable kun je dezelfde of vergelijkbare experimenten uitproberen.

(Je kunt alle code bekijken en downloaden op: Code op GitHub Je kunt met slechts 2 klikken beginnen met bekijken, misschien in een ander venster)

Doorgaans omvat datalogging het volgende:

• Data-acquisitie: enkele gegevens van een sensor uitlezen. Vaak is dit gewoon het lezen van een analoog naar digitaal converter (ADC) op een apparaat zoals een Arduino.
• Gegevensverwerking: Bij het lezen van een ADC-waarde moet de uitvoer van de converter normaal gesproken worden geschaald naar de juiste eenheden. Het kan ook nodig zijn om enige aanpassingen te doen om de waarden te kalibreren om sensorfouten te corrigeren.
• Filteren: gegevens bevatten gewoonlijk wat ruis, dit kan worden gefilterd, zodat u naar het signaal in uw gegevens kijkt, niet naar de ruis.
• Gegevensopslag: de gegevens worden opgeslagen, misschien naar een tekstbestand, misschien naar de cloud. Gegevens moeten overleven, zelfs als de stroom uitvalt. Het is gemakkelijk om te veel gegevens op te slaan, we hebben een klein trucje om de gegevensopslagruimte te verkleinen.
• Gegevensweergave: methoden om naar uw gegevens te kijken, niet echt gegevensregistratie, maar als u de gegevens niet op een of andere manier weergeeft, waarom verzamelt u ze dan?
• Toegang op afstand: niet noodzakelijk, maar leuk om te hebben.

De meeste instructables bevatten enkele, maar niet alle bovenstaande, of doen ze op een heel eenvoudige manier. Deze instructable behandelt 2 van de vaak overgeslagen logproblemen en geeft u als bonus een manier om uw gegevens in kaart te brengen zonder een cloudservice te gebruiken. Je kunt het hele ding gebruiken of stukjes en beetjes eruit halen en ze remixen tot een eigen project.

Stap 1: Gereedschappen en materialen

Dit voorbeeld is allemaal in Python, dus het zal draaien op, en componenten kunnen worden gebruikt op, vrijwel elk besturingssysteem, inclusief Mac, pc, Linux en de Raspberry Pi.

Dus om deze instructable te gebruiken, heb je alleen een draaiende Python 3.6-omgeving nodig en de bijgevoegde code downloaden. Na het uitvoeren van de code die ik heb ingesteld, kunt u deze aanpassen voor uw eigen experimenten. Zoals gebruikelijk bij Python moet je misschien wat pakketten/modules toevoegen om alles werkend te krijgen. Mijn Spyder-omgeving wordt geleverd met vrijwel alle vereiste onderdelen (zie: Graph Instructable Views with Python Screen Scraping). Wanneer u Watch voor het eerst uitvoert op eventuele foutmeldingen, zullen ze u op de hoogte stellen van ontbrekende onderdelen in uw omgeving.

De volgende twee stappen zullen u vertellen hoe u uw eigen experiment kunt bouwen en uitvoeren, maar het is waarschijnlijk beter om te wachten tot u de meegeleverde experimenten uitvoert voordat u uw eigen experimenten probeert.

Om de code te begrijpen, moet je een beetje ervaring hebben met objectgeoriënteerde Python, uitleggen dat dit buiten het bestek van deze instructable valt, maar Google zou je alle hulp moeten geven die je nodig hebt.

Let op de code: (Code op GitHub Je kunt met slechts 2 klikken naar de weergave gaan, misschien in een ander venster) is nu in Python 3.6, dus 3.6 zou het beste zijn. Oudere versie van code is hier in onderstaande links.

Stap 2: Een experiment bouwen

Er zijn drie programmeerstappen (en lijnen) bij het bouwen van een experiment. Elk experiment is een functie in het LoggingSim-object in het bestand simul_logging.py. Laten we eens kijken naar experiment 1 (alleen de eerste grafiek) die we in de volgende stap zullen uitvoeren:

def experiment_with_sample_rates(zelf):

print """ Experimenteer met bemonsteringsfrequenties Verschillende bemonsteringsfrequenties bekijken door delta T te veranderen """ self.start_plot(plot_title = "Samplefrequenties - Deel 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()

Elk experiment is geschreven als zijn eigen functie, dus we hebben een regel die de functie definieert (def experiment…..)

De volgende regel, zonder commentaar, (start_plot(….) maakt het object voor het experiment aan en geeft het een naam.

De volgende regel, zonder commentaar, (add_sensor_data(…) is opgesplitst in verschillende regels. Het simuleert een sensor die een signaal meet met mogelijk ruis en enige verwerking. De functieargumenten zijn als volgt:

• naam: een naam op de laatste grafiek om de gegevens te identificeren
• amplitude: hoe groot het signaal ook is, we zullen altijd een amplitude van 1 gebruiken in deze instructable.
• noise_amp: hoe groot de ruis is, 0. is geen ruis, we beginnen hier.
• delta_t: de tijd tussen metingen, regelt de sample rate.
• max_t: de maximale tijd dat we gegevens verzamelen, zullen we altijd 10 gebruiken in deze instructable.
• run_ave: verwerking met een lopend gemiddelde, 0 betekent geen verwerking.
• trigger_value: verwerking met behulp van triggering, 0 betekent geen verwerking

de laatste regel zonder commentaar (self.show_plot……) geeft de grafiek weer.

Om het wat ingewikkelder te maken kun je meerdere lijnen op een grafiek hebben of meerdere grafieken in een experiment, dit zou duidelijk moeten zijn uit de experimenten die volgen.

Stap 3: Een experiment uitvoeren

Dit is de code voor het uitvoeren van een experiment. Zoals gebruikelijk in Python wordt het aan het einde van het bestand geplaatst.

sim_logging = LoggingSim()

sim_logging.experiment_with_sample_rates()

Dit zijn slechts 2 regels:

• Maak een logboeksimulator (LoggingSim())
• Voer het uit (sim_logging.experiment_with_sample_rates())

In de gedownloade code heb ik nog een paar regels en opmerkingen, het zou gemakkelijk moeten zijn om erachter te komen.

Stap 4: Experiment: Sample Rate

De simulator, zoals hier ingesteld, geeft altijd een mooie vloeiende sinusgolf van amplitude 1. Voor dit experiment zullen we knoeien met de samplefrequentie, zoals aangepast door delta_t, het tijdsverschil tussen samples. We zullen geen ruis of andere verwerking hebben. De code gebruikt 3 bemonsteringsfrequenties (delta_t = 1,0, 0,1 en 0,01.) Aangezien de grafieken op elkaar vallen, is het experiment opgezet om 3 verschillende grafieken te produceren. De resulterende grafieken zijn de afbeeldingen voor deze stap.

def experiment_with_sample_rates(zelf):

print """ Experimenteer met bemonsteringsfrequenties Verschillende bemonsteringsfrequenties bekijken door delta T te veranderen """ self.start_plot(plot_title = "Experimentbemonsteringsfrequenties 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 = "Experiment Sample Rates 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() # ------------------------------------------------ zelf.start_plot(plot_title = "Experiment Sample Rates 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()

Gebruik de regel om het uit te voeren: sim_logging.experiment_with_sample_rates()

Mogelijke conclusies:

• Een te lage bemonsteringsfrequentie is echt slecht.
• Hoge tarieven zijn vaak beter.

(Python 3.6-code op GitHub-link hieronder bij instructables, 2.7)

Stap 5: Experiment: ruis tonen

In dit experiment behouden we hetzelfde signaal, gebruiken we een gemiddelde samplefrequentie en hebben we verschillende hoeveelheden ruis (noise_amp =.0,.1, 1.0.) Voer het uit met: sim_logging.experiment_showing_noise(). De output is een grafiek met 3 lijnen.

Mogelijke conclusie:

Ruis maakt het moeilijk om het signaal te zien, verminder het indien mogelijk

De code:

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

def experiment_showing_noise(self): print """ Experiment met ruis Verschillende hoeveelheden ruis bekijken door de ruisamplitude te wijzigen. """ self.start_plot(plot_title = "Experiment met ruis") self.add_sensor_data(name = "noise = 0.0 ", amplitude = 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()

Stap 6: Experiment: ruis verminderen met een voortschrijdend gemiddelde

Een voortschrijdend gemiddelde (bijvoorbeeld met lengte 8) neemt de laatste 8 metingen en middelt deze. Als de ruis willekeurig is, hopen we dat het gemiddeld bijna 0 is. Voer het experiment uit met: sim_logging.experiment_showing_noise(). Voer één grafiek uit.

Mogelijke conclusies:

• Een voortschrijdend gemiddelde elimineert veel van de ruis
• Hoe langer het voortschrijdend gemiddelde, hoe meer ruisonderdrukking
• Het langere voortschrijdend gemiddelde kan het signaal verminderen en vervormen

De code:

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

def experiment_with_moving_average(self): print """ Experimenteer met MovingAverage Kijk naar verschillende MovingAverage door de lengte te veranderen. Ze hebben allemaal dezelfde ruis. """ # ------------------ ----------------------------- self.start_plot(plot_title = "MovingAverage-Part 1/2: No Moving Average") zelf.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 en 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 ()

Stap 7: Experiment: voortschrijdend gemiddelde en steekproeffrequentie

In dit experiment vergelijken we het ruwe signaal met ruis en 2 verschillende variaties op het verminderen van de ruis.

1. Gemiddelde samplefrequentie en gemiddeld lopend gemiddelde
2. Hoge samplefrequentie en hoog lopend gemiddelde

Voer het uit met: sim_logging … Uitvoer is één grafiek. Ik denk dat het duidelijk is dat # 2 het geluid beter doet verminderen, dus we zouden kunnen concluderen dat:

Hoge samplefrequentie en hoog lopend gemiddelde zijn goed

Maar je moet er rekening mee houden dat er kosten aan verbonden zijn. #2 vergt veel meer verwerking en resulteert in veel meer gegevens die moeten worden opgeslagen. De kosten kunnen het wel of niet waard zijn. In het volgende experiment zullen we een trigger toevoegen, een apparaat om de hoeveelheid opgeslagen gegevens te verminderen.

De code:

def experiment_with_moving_average_and_sample_rate(self):

print """ Experimenteer met voortschrijdend gemiddelde en bemonsteringsfrequentie, dt, loopgemiddelde wordt gevarieerd """ # ---------------------------- -------------------- self.start_plot(plot_title = "Moving Average and Sample Rate") self.add_sensor_data(name = "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()

Stap 8: Experiment: Loggen met Trigger

In dit experiment voegen we een trigger toe. Ten eerste, wat bedoel ik met een trigger? Een trigger is een techniek waarbij we gegevens verzamelen, maar deze pas opslaan nadat een variabele aanzienlijk is gewijzigd. In deze experimenten zette ik een trigger op de variabele tijd (x-as). Door de trigger te gebruiken, kan ik de grote hoeveelheid gegevens van snelle steekproeven nemen en deze terugbrengen tot een redelijkere hoeveelheid gegevens. Het is bijzonder handig bij hoge samplefrequenties en een langlopend gemiddelde.

Ik heb de #2-regel van het laatste experiment genomen dat "goed" was en een trigger heeft toegevoegd. Voer het uit met: sim_logging…… Uitvoer is één grafiek, x lijnen.

Wat gebeurt er? We krijgen een "goede" plot met een redelijke hoeveelheid gegevens (hetzelfde als #1). Er zijn enige kosten verbonden aan een hogere verwerking. Over het algemeen zijn de resultaten echter ongeveer hetzelfde als #1, de lagere samplefrequentie met minder filtering. Je zou kunnen concluderen:

• Langlopend gemiddelde met triggering kan een goede ruisonderdrukking geven met redelijke hoeveelheden gegevens.
• De extra verwerking geeft misschien niet zoveel betere resultaten en brengt kosten met zich mee.

De code:

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

def experiment_with_trigger(self): print """ Experimenteer met Triggering, dt, run average en trigger die allemaal worden gevarieerd """ # ----------------------- ------------------------- self.start_plot(plot_title = "Trigger 1/1 - Activering aan") 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()

=

Stap 9: Experiment: loggen met trigger - luider geluid

Laten we hetzelfde experiment als de laatste stap nemen en de ruis versterken. Voer het uit met: sim_logging…… Uitvoer is één grafiek, 2 lijnen.

Nu lijkt de extra verwerking meer de moeite waard. Een redelijke conclusie hier zou kunnen zijn:

Het kiezen van de hoeveelheid en het type verwerking voor ruisonderdrukking hangt af van uw signaal en ruis

De code:

def experiment_with_trigger_louder_noise(zelf):

print """ Luider geluid dan vorig experiment """ self.start_plot(plot_title = "Een experiment met trigger-luidere ruis") 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()

Stap 10: Maak je eigen experimenten

Op dit punt hoop ik dat je ziet dat de technieken in deze instructable nuttig kunnen zijn bij datalogging, maar dat ze ook met enig nadenken moeten worden gebruikt. Experimenteren met hen kan dat proces helpen.

Enkele opmerkingen over de experimenten en zaken waar u naar zou kunnen kijken:

• Sinusgolven zijn niet het enige interessante signaaltype, probeer andere, andere golven of hellingen of …..
• Ik heb een normale verdeling gebruikt voor het geluid, er zijn zoveel soorten geluid; je moet rekening houden met anderen
• Lopende gemiddelden zijn een eenvoudige, maar niet de enige methode om naar ruis te kijken

Let op: het loggen van afbeeldingen van Wikipedia.

Stap 11: De technieken in uw logboeksoftware gebruiken

Mijn code is objectgeoriënteerd en de verwerking voor lopend gemiddelde en trigger kan gewoon naar uw Python-omgeving worden gekopieerd en vervolgens worden gebruikt. De objecten zijn:

• DataTrigger in data_trigger.py
• MovingAverage in moving_average.py

Mijn hoofdobject LoggingSim in simul_logging.py zou je een goed voorbeeld moeten geven van hoe je het moet gebruiken. Als u een andere taal gebruikt, kunt u mijn code lezen en in uw taal implementeren.

Deze code kan uw project een betere datalogging geven, probeer het.

De bovenstaande grafiek is van Graph Your Solar Power van russ_hensel die hetzelfde lopende gemiddelde object gebruikt.