Experimente in der erweiterten Datenprotokollierung (mit Python): 11 Schritte

2024 Autor: John Day | [email protected]. Zuletzt bearbeitet: 2024-01-30 07:16

Es gibt viele Instructables für die Datenprotokollierung. Als ich also ein eigenes Protokollierungsprojekt erstellen wollte, schaute ich mich bei einem Haufen um. Einige waren gut, andere nicht so sehr, also beschloss ich, einige der besseren Ideen aufzunehmen und meine eigene Bewerbung zu machen. Dies führte zu einem Projekt, das sowohl fortgeschrittener als auch komplizierter war, als ich zunächst erwartet hatte. Ein Teil davon wurde zu einer Reihe von Experimenten zur Verarbeitung von Sensordaten. Mit diesem anweisbaren können Sie die gleichen oder ähnliche Experimente ausprobieren.

(Sie können den gesamten Code anzeigen und herunterladen unter: Code at GitHub Sie können mit nur 2 Klicks in die Ansicht gelangen, möglicherweise in einem anderen Fenster.)

Typischerweise umfasst die Datenprotokollierung Folgendes:

• Datenerfassung: Lesen Sie einige Daten von einem Sensor. Oft ist dies nur das Lesen eines Analog-Digital-Wandlers (ADC) auf einem Gerät wie einem Arduino.
• Datenverarbeitung: Beim Lesen eines ADC-Wertes muss der Ausgang des Wandlers normalerweise auf die richtigen Einheiten skaliert werden. Möglicherweise müssen auch einige Anpassungen vorgenommen werden, um die Werte zu kalibrieren, um Sensorfehler zu korrigieren.
• Filterung: Daten enthalten häufig Rauschen. Dies kann gefiltert werden, sodass Sie das Signal in Ihren Daten und nicht das Rauschen betrachten.
• Datenspeicherung: Die Daten werden gespeichert, vielleicht in einer Textdatei, vielleicht in der Cloud. Daten sollten überleben, auch wenn der Strom ausfällt. Es ist leicht, zu viele Daten zu speichern, wir haben einen kleinen Trick, um den Datenspeicherplatz zu reduzieren.
• Datenanzeige: Methoden zum Betrachten Ihrer Daten, nicht wirklich Datenprotokollierung, aber wenn Sie die Daten nicht anzeigen, warum sollten Sie sie sammeln?
• Fernzugriff: Nicht notwendig, aber nett zu haben.

Die meisten instructables enthalten einige, aber nicht alle der oben genannten oder tun sie auf sehr einfache Weise. Dieses anweisbare behandelt 2 der oft übersprungenen Protokollierungsprobleme und gibt Ihnen als Bonus die Möglichkeit, Ihre Daten grafisch darzustellen, ohne einen Cloud-Dienst zu verwenden. Sie können das Ganze verwenden oder kleine Teile herausziehen und zu einem eigenen Projekt remixen.

Schritt 1: Werkzeuge und Materialien

Dieses Beispiel ist vollständig in Python, sodass es auf so ziemlich jedem Betriebssystem ausgeführt werden kann und Komponenten verwendet werden können, einschließlich Mac, PC, Linux und Raspberry Pi.

Um dieses instructable zu verwenden, brauchen Sie nur eine laufende Python 3.6-Umgebung und laden Sie den beigefügten Code herunter. Nachdem Sie den von mir eingerichteten Code ausgeführt haben, können Sie ihn für Ihre eigenen Experimente ändern. Wie bei Python üblich, müssen Sie möglicherweise einige Pakete/Module hinzufügen, damit alles funktioniert. Meine Spyder-Umgebung enthält so ziemlich alle erforderlichen Teile (siehe: Graph Instructable Views with Python Screen Scraping). Wenn Sie zum ersten Mal auf Fehlermeldungen achten, werden Sie über fehlende Teile in Ihrer Umgebung informiert.

In den nächsten beiden Schritten erfahren Sie, wie Sie ein eigenes Experiment erstellen und ausführen. Es ist jedoch wahrscheinlich besser, zu warten, bis Sie die enthaltenen Experimente ausgeführt haben, bevor Sie es selbst ausprobieren.

Um den Code zu verstehen, müssen Sie ein wenig Erfahrung mit objektorientiertem Python haben, was den Rahmen dieses instructable sprengt, aber Google sollte Ihnen jede Hilfe geben, die Sie benötigen.

Beachten Sie den Code: (Code auf GitHub Sie können mit nur 2 Klicks in die Ansicht gelangen, vielleicht in einem anderen Fenster) ist jetzt in Python 3.6, daher wäre 3.6 am besten. Ältere Versionen des Codes finden Sie hier in den Links unten.

Schritt 2: Erstellen eines Experiments

Es gibt drei Programmierschritte (und Zeilen) beim Erstellen eines Experiments. Jedes Experiment ist eine Funktion im LoggingSim-Objekt in der Datei simulieren_logging.py. Schauen wir uns Experiment 1 (nur das erste Diagramm) an, das wir im nächsten Schritt ausführen werden:

def experiment_with_sample_rates(self):

print """ Experiment mit Abtastraten Betrachten verschiedener Abtastraten durch Ändern von Delta T """ self.start_plot(plot_title = "Sample Rates - Part 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()

Jedes Experiment wird als eigene Funktion geschrieben, also haben wir eine Zeile, die die Funktion definiert (def experiment…..)

Die nächste Zeile ohne Kommentar (start_plot(….) erstellt das Objekt für das Experiment und gibt ihm einen Namen.

Die nächste Zeile ohne Kommentar (add_sensor_data(…) ist in mehrere Zeilen aufgeteilt. Sie simuliert einen Sensor, der ein Signal mit potenziellem Rauschen und etwas Verarbeitung misst. Die Funktionsargumente lauten wie folgt:

• name: ein Name, der in das letzte Diagramm eingefügt wird, um die Daten zu identifizieren
• Amplitude: Wie groß das Signal ist, verwenden wir immer eine Amplitude von 1. in diesem anweisbaren.
• noise_amp: wie groß das Rauschen ist, 0. ist kein Rauschen, wir fangen hier an.
• delta_t: die Zeit zwischen den Messungen, steuert die Abtastrate.
• max_t: Die maximale Zeit, in der wir Daten sammeln, verwenden wir immer 10 in diesem anweisbaren.
• run_ave: Verarbeitung mit einem laufenden Durchschnitt, 0 bedeutet keine Verarbeitung.
• trigger_value: Verarbeitung mit Triggering, 0 bedeutet keine Verarbeitung

die letzte Zeile ohne Kommentar (self.show_plot……) zeigt den Graphen an.

Um die Sache etwas komplizierter zu machen, können Sie mehrere Linien in einem Diagramm oder mehrere Diagramme in einem Experiment haben, dies sollte aus den folgenden Experimenten klar werden.

Schritt 3: Ausführen eines Experiments

Dies ist der Code zum Ausführen eines Experiments. Wie in Python üblich, wird es am Ende der Datei platziert.

sim_logging = LoggingSim()

sim_logging.experiment_with_sample_rates()

Das sind nur 2 Zeilen:

• Erstellen eines Protokollierungssimulators (LoggingSim())
• Führen Sie es aus (sim_logging.experiment_with_sample_rates())

Im heruntergeladenen Code habe ich noch ein paar Zeilen und Kommentare, es sollte einfach sein, herauszufinden.

Schritt 4: Experiment: Abtastrate

Der Simulator, wie er hier eingerichtet ist, gibt immer eine schöne glatte Sinuswelle der Amplitude 1 aus. Für dieses Experiment werden wir mit der Abtastrate herumspielen, die durch delta_t, die Zeitdifferenz zwischen den Abtastwerten, eingestellt wird. Wir werden keine Geräusche oder andere Verarbeitung haben. Der Code verwendet 3 Abtastraten (delta_t = 1,0, 0,1 und 0,01). Da die Diagramme übereinander liegen, wird das Experiment so eingerichtet, dass 3 verschiedene Diagramme erstellt werden. Die resultierenden Grafiken sind die Bilder für diesen Schritt.

def experiment_with_sample_rates(self):

print """ Experiment mit Abtastraten Betrachten verschiedener Abtastraten durch Ändern von Delta T """ self.start_plot(plot_title = "Experiment Sample Rates 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() # ------------------------------------------------ selbst.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()

Um es auszuführen, verwenden Sie die Zeile: sim_logging.experiment_with_sample_rates()

Mögliche Schlussfolgerungen:

• Eine zu niedrige Abtastrate ist wirklich schlecht.
• Hohe Zinsen sind oft besser.

(Python 3.6 Code bei GitHub Link unten bei instructables, 2.7)

Schritt 5: Experiment: Rauschen anzeigen

In diesem Experiment behalten wir das gleiche Signal bei, verwenden eine mittlere Abtastrate und haben dort unterschiedliche Mengen an Rauschen (noise_amp =.0,.1, 1.0.) Führen Sie es aus mit: sim_logging.experiment_showing_noise(). Die Ausgabe ist ein Diagramm mit 3 Linien.

Mögliches Fazit:

Rauschen macht es schwer, das Signal zu sehen, reduzieren Sie es, wenn Sie können

Der Code:

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

def experiment_showing_noise(self): print """ Experiment mit Rauschen Betrachten verschiedener Rauschstärken durch Ändern der Rauschamplitude. """ self.start_plot(plot_title = "Experiment Showing Noise") 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()

Schritt 6: Experiment: Rauschen mit einem gleitenden Durchschnitt reduzieren

Ein gleitender Durchschnitt (zum Beispiel mit Länge 8) nimmt die letzten 8 Messungen und mittelt sie. Wenn das Rauschen zufällig ist, hoffen wir, dass es nahe 0 liegt. Führen Sie das Experiment aus mit: sim_logging.experiment_showing_noise(). Ausgabe eines Diagramms.

Mögliche Schlussfolgerungen:

• Ein gleitender Durchschnitt eliminiert einen Großteil des Rauschens
• Je länger der gleitende Durchschnitt, desto mehr Rauschunterdrückung
• Der längere gleitende Durchschnitt kann das Signal reduzieren und verzerren

Der Code:

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

def experiment_with_moving_average(self): print """ Experimentieren mit MovingAverage Betrachten Sie verschiedene MovingAverages, indem Sie die Länge ändern. Alle haben das gleiche Rauschen. """ # ------------------ ------------------------------------------ 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 und 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 ()

Schritt 7: Experiment: Gleitender Durchschnitt und Abtastrate

In diesem Experiment vergleichen wir das Rohsignal mit Rauschen und 2 verschiedenen Variationen zur Reduzierung des Rauschens.

1. Mittlere Abtastrate und mittlerer laufender Durchschnitt
2. Hohe Abtastrate und langer laufender Durchschnitt

Führen Sie es aus mit: sim_logging…… Die Ausgabe ist ein Graph. Ich denke, es ist klar, dass #2 das Rauschen besser reduziert, sodass wir zu dem Schluss kommen könnten, dass:

Hohe Abtastrate und langer laufender Durchschnitt sind gut

Aber Sie müssen bedenken, dass es Kosten gibt. #2 erfordert viel mehr Verarbeitung und führt dazu, dass viel mehr Daten gespeichert werden müssen. Die Kosten können sich lohnen oder auch nicht. Im nächsten Experiment werden wir einen Trigger hinzufügen, ein Gerät, um die gespeicherte Datenmenge zu reduzieren.

Der Code:

def experiment_with_moving_average_and_sample_rate(self):

print """ Experiment mit gleitendem Durchschnitt und Abtastrate, dt, Laufmittelwert wird variiert """ # ---------------------------------------- -------------------- self.start_plot(plot_title = "Gleitender Durchschnitt und Abtastrate") 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()

Schritt 8: Experiment: Logging mit Trigger

In diesem Experiment fügen wir einen Trigger hinzu. Erstens, was meine ich mit einem Auslöser? Ein Trigger ist eine Technik, bei der wir Daten sammeln, aber erst speichern, nachdem sich eine Variable erheblich geändert hat. In diesen Experimenten habe ich einen Trigger auf die Variable Zeit (x-Achse) gesetzt. Durch die Verwendung des Triggers kann ich die hohe Datenmenge aus dem Rapid Sampling nehmen und auf eine vernünftigere Datenmenge reduzieren. Es ist besonders nützlich bei hohen Abtastraten und einem langen laufenden Durchschnitt.

Ich habe die #2-Zeile aus dem letzten Experiment genommen, die "gut" war, und einen Trigger hinzugefügt. Führen Sie es aus mit: sim_logging…… Die Ausgabe ist ein Graph, x Linien.

Was geschieht? Wir erhalten einen "guten" Plot mit einer vernünftigen Datenmenge (wie bei Nr. 1). Es gab einige Kosten in der höheren Verarbeitung. Insgesamt sind die Ergebnisse jedoch ungefähr die gleichen wie bei #1, der niedrigeren Abtastrate mit weniger Filterung. Sie könnten schlussfolgern:

• Langfristiger Durchschnitt mit Triggerung kann eine gute Rauschunterdrückung mit angemessenen Datenmengen ergeben.
• Die zusätzliche Verarbeitung liefert möglicherweise nicht so viel bessere Ergebnisse und ist mit Kosten verbunden.

Der Code:

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

def experiment_with_trigger(self): print """ Experiment mit Triggering, dt, run Average und Trigger alle werden variiert """ # -------------------------- ------------------------- 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()

=

Schritt 9: Experiment: Logging mit Trigger - lauteres Rauschen

Machen wir das gleiche Experiment wie im letzten Schritt und verstärken das Rauschen. Führen Sie es aus mit: sim_logging…… Die Ausgabe ist ein Graph, 2 Linien.

Jetzt sieht die zusätzliche Verarbeitung lohnenswerter aus. Eine vernünftige Schlussfolgerung könnte hier lauten:

Die Auswahl des Umfangs und der Art der Verarbeitung zur Rauschunterdrückung hängt von Ihrem Signal und Rauschen ab

Der Code:

def experiment_with_trigger_louder_noise(self):

print """ Lauteres Rauschen als vorheriges Experiment """ self.start_plot(plot_title = "An Experiment with 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()

Schritt 10: Machen Sie Ihre eigenen Experimente

An dieser Stelle hoffe ich, dass Sie sehen, dass die Techniken in diesem instructable bei der Datenprotokollierung nützlich sein können, aber auch mit etwas Nachdenken verwendet werden müssen. Das Experimentieren mit ihnen kann diesen Prozess unterstützen.

Einige Bemerkungen zu den Experimenten und Dingen, die Sie untersuchen könnten:

• Sinuswellen sind nicht die einzige interessante Signalart, versuchen Sie es mit anderen, anderen Wellen oder Rampen oder …..
• Ich habe eine Normalverteilung für das Rauschen verwendet, es gibt so viele Arten von Rauschen; du solltest andere berücksichtigen
• Laufende Durchschnitte sind eine einfache, aber nicht die einzige Methode, um Rauschen zu untersuchen

Hinweis: Bilder von Wikipedia protokollieren.

Schritt 11: Verwenden der Techniken in Ihrer Protokollierungssoftware

Mein Code ist objektorientiert und die Verarbeitung für den laufenden Durchschnitt und Trigger kann einfach in Ihre Python-Umgebung kopiert und dann verwendet werden. Die Objekte sind:

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

Mein Hauptobjekt LoggingSim in simulation_logging.py sollte Ihnen ein gutes Beispiel für die Verwendung geben. Wenn Sie eine andere Sprache verwenden, können Sie meinen Code lesen und in Ihrer Sprache implementieren.

Dieser Code kann Ihrem Projekt eine bessere Datenprotokollierung ermöglichen, probieren Sie es aus.

Die obige Grafik stammt von Graph Your Solar Power von russ_hensel, das dasselbe Objekt für den laufenden Durchschnitt verwendet.