Expériences d'enregistrement de données avancé (à l'aide de Python) : 11 étapes

2024 Auteur: John Day | [email protected]. Dernière modifié: 2024-01-30 09:05

Il y a beaucoup d'instructables d'enregistrement de données, donc quand j'ai voulu créer mon propre projet d'enregistrement, j'ai regardé un tas. Certaines étaient bonnes, d'autres moins, alors j'ai décidé de prendre certaines des meilleures idées et de créer ma propre application. Cela a abouti à un projet à la fois plus avancé et plus compliqué que ce à quoi je m'attendais au départ. Une partie de celui-ci est devenue une série d'expériences de traitement des données de capteurs. Cette instructable vous permet d'essayer des expériences identiques ou similaires.

(Vous pouvez voir tout le code et le télécharger sur: Code sur GitHub Vous pouvez accéder à la visualisation, peut-être dans une autre fenêtre, en seulement 2 clics)

En règle générale, l'enregistrement des données implique les éléments suivants:

• Acquisition de données: Lire certaines données d'un capteur. Souvent, il s'agit simplement de lire un convertisseur analogique-numérique (ADC) sur un appareil comme un Arduino.
• Traitement des données: lors de la lecture d'une valeur ADC, la sortie des convertisseurs doit normalement être mise à l'échelle dans les bonnes unités. Il peut également être nécessaire de procéder à quelques ajustements pour calibrer les valeurs afin de corriger les erreurs de capteur.
• Filtrage: les données contiennent généralement du bruit, cela peut être filtré afin que vous recherchiez le signal dans vos données, pas le bruit.
• Stockage des données: les données sont enregistrées, peut-être dans un fichier texte, peut-être dans le cloud. Les données doivent survivre même en cas de coupure de courant. Il est facile de sauvegarder trop de données, nous avons une petite astuce pour réduire l'espace de stockage des données.
• Affichage des données: méthodes pour examiner vos données, pas vraiment l'enregistrement des données, mais si vous ne faites pas une sorte d'affichage des données, pourquoi les rassembler ?
• Accès à distance: Pas nécessaire mais agréable à avoir.

La plupart des instructables incluent certains mais pas tous les éléments ci-dessus, ou les font de manière très simple. Cette instructable abordera 2 des problèmes de journalisation souvent ignorés et, en prime, vous donnera un moyen de représenter graphiquement vos données sans utiliser un service cloud. Vous pouvez utiliser le tout ou extraire des morceaux et les remixer dans votre propre projet.

Étape 1: Outils et matériaux

Cet exemple est entièrement en Python, il fonctionnera donc et les composants peuvent être utilisés sur à peu près n'importe quel système d'exploitation, y compris Mac, PC, Linux et Raspberry Pi.

Donc, pour utiliser cette instructable, tout ce dont vous avez besoin est un environnement Python 3.6 en cours d'exécution et téléchargez le code ci-joint. Après avoir exécuté le code que j'ai configuré, vous pouvez le modifier pour vos propres expériences. Comme d'habitude avec Python, vous devrez peut-être ajouter des packages/modules pour que tout fonctionne. Mon environnement Spyder est livré avec à peu près toutes les pièces requises en place (voir: Graph Instructable Views with Python Screen Scraping). Lorsque vous exécutez pour la première fois, surveillez les messages d'erreur, ils vous informeront de toutes les pièces manquantes dans votre environnement.

Les deux étapes suivantes vous diront comment créer et exécuter votre propre expérience, mais il est probablement préférable d'attendre d'avoir exécuté les expériences incluses avant d'essayer la vôtre.

Pour comprendre le code, vous devrez avoir un peu d'expérience avec Python orienté objet, expliquant que cela dépasse le cadre de cette instruction, mais Google devrait vous donner toute l'aide dont vous pourriez avoir besoin.

Notez le code: (Code sur GitHub Vous pouvez accéder à la visualisation, peut-être dans une autre fenêtre, en seulement 2 clics) est maintenant en Python 3.6, donc avoir 3.6 serait le mieux. L'ancienne version du code est ici dans les liens ci-dessous.

Étape 2: Créer une expérience

Il y a trois étapes de programmation (et lignes) dans la construction d'une expérience. Chaque expérience est une fonction dans l'objet LoggingSim dans le fichier simulation_logging.py. Regardons l'expérience 1 (juste le premier graphique) que nous exécuterons à l'étape suivante:

def experiment_with_sample_rates(self):

print """ Expérimentez avec les taux d'échantillonnage En examinant différentes fréquences d'échantillonnage en modifiant le delta T """ self.start_plot(plot_title = "Taux d'échantillonnage - Partie 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()

Chaque expérience est écrite comme sa propre fonction, nous avons donc une ligne définissant la fonction (def experiment…..)

La ligne suivante, sans commentaire, (start_plot(….) crée l'objet pour l'expérience et lui donne un nom.

La ligne de ligne suivante, sans commentaire, (add_sensor_data(…) est divisée en plusieurs lignes. Elle simule un capteur mesurant un signal avec potentiellement du bruit et un certain traitement. Les arguments de la fonction sont les suivants:

• nom: un nom mis sur le graphique final pour identifier les données
• amplitude: quelle est la taille du signal, nous utiliserons toujours une amplitude de 1. dans cette instructable.
• noise_amp: quelle est la taille du bruit, 0. n'est pas du bruit, nous allons commencer ici.
• delta_t: le temps entre les mesures, contrôle la fréquence d'échantillonnage.
• max_t: le temps maximum que nous collectons des données, nous utiliserons toujours 10 dans cette instructable.
• run_ave: traitement à l'aide d'une moyenne courante, 0 signifie aucun traitement.
• trigger_value: traitement à l'aide du déclenchement, 0 signifie aucun traitement

la dernière ligne sans commentaire (self.show_plot……) affiche le graphique.

Pour rendre les choses un peu plus compliquées, vous pouvez avoir plusieurs lignes sur un graphique ou plusieurs graphiques dans une expérience, cela devrait être clair dans les expériences qui suivent.

Étape 3: Exécuter une expérience

C'est le code pour exécuter une expérience. Comme en commun en Python, il est placé à la fin du fichier.

sim_logging = LoggingSim()

sim_logging.experiment_with_sample_rates()

C'est juste 2 lignes:

• Créer un simulateur de journalisation (LoggingSim())
• Exécutez-le (sim_logging.experiment_with_sample_rates())

Dans le code téléchargé, j'ai quelques lignes et commentaires supplémentaires, cela devrait être facile à comprendre.

Étape 4: Expérience: Taux d'échantillonnage

Le simulateur, tel qu'il est configuré ici, produit toujours une belle onde sinusoïdale lisse d'amplitude 1. Pour cette expérience, nous allons jouer avec la fréquence d'échantillonnage, ajustée par delta_t, la différence de temps entre les échantillons. Nous n'aurons aucun bruit ou autre traitement. Le code utilise 3 taux d'échantillonnage (delta_t = 1,0, 0,1 et 0,01.) Étant donné que les graphiques se superposent, l'expérience est configurée pour produire 3 graphiques différents. Les graphiques résultants sont les images de cette étape.

def experiment_with_sample_rates(self):

print """ Expérimentez avec les taux d'échantillonnage En modifiant le delta T """ self.start_plot(plot_title = "Expérimentez les taux d'échantillonnage 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 = "Taux d'échantillonnage d'expérience 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() # ------------------------------------------------ soi.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()

Pour l'exécuter, utilisez la ligne: sim_logging.experiment_with_sample_rates()

Conclusions possibles:

• Un taux d'échantillonnage trop bas est vraiment mauvais.
• Les taux élevés sont souvent meilleurs.

(Python 3.6 Code au lien GitHub ci-dessous à instructables, 2.7)

Étape 5: Expérience: Montrer du bruit

Dans cette expérience, nous gardons le même signal, utilisons une fréquence d'échantillonnage moyenne et avons différentes quantités de bruit (noise_amp =.0,.1, 1.0.) Exécutez-le avec: sim_logging.experiment_showing_noise(). La sortie est un graphique avec 3 lignes.

Conclusion possible:

Le bruit rend difficile la perception du signal, réduisez-le si vous le pouvez

Le code:

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

def experiment_showing_noise(self): print """ Expérience montrant le bruit Examiner différentes quantités de bruit en modifiant l'amplitude du bruit. """ self.start_plot(plot_title = "Expériment montrant le bruit") 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()

Étape 6: Expérimentez: réduisez le bruit avec une moyenne mobile

Une moyenne mobile (par exemple de longueur 8) prend les 8 dernières mesures et en fait la moyenne. Si le bruit est aléatoire, nous espérons que sa moyenne sera proche de 0. Exécutez l'expérience avec: sim_logging.experiment_showing_noise(). Sortez un graphique.

Conclusions possibles:

• Une moyenne mobile élimine une grande partie du bruit
• Plus la moyenne mobile est longue, plus la réduction du bruit est importante
• La moyenne mobile plus longue peut réduire et déformer le signal

Le code:

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

def experiment_with_moving_average(self): print """ Expérimentez avec MovingAverage En regardant différentes MovingAverage en modifiant la longueur. Tous ont le même bruit. """ # ------------------ ------------------------------ 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 et 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 ()

Étape 7: Expérience: Moyenne mobile et fréquence d'échantillonnage

Dans cette expérience, nous comparons le signal brut avec du bruit et 2 variations différentes sur la réduction du bruit.

1. Taux d'échantillonnage moyen et moyenne courante moyenne
2. Taux d'échantillonnage élevé et moyenne glissante de longueur élevée

Exécutez-le avec: sim_logging…… La sortie est un graphique. Je pense qu'il est clair que #2 fait un meilleur travail pour réduire le bruit, nous pourrions donc conclure que:

Un taux d'échantillonnage élevé et une moyenne mobile de longueur élevée sont bons

Mais vous devez garder à l'esprit qu'il y a un coût. #2 prend beaucoup plus de traitement et entraîne beaucoup plus de données à sauvegarder. Le coût peut ou peut ne pas en valoir la peine. Dans la prochaine expérience, nous ajouterons un déclencheur, un dispositif pour réduire la quantité de données stockées.

Le code:

def experiment_with_moving_average_and_sample_rate(self):

print """ Expérimentez avec la moyenne mobile et la fréquence d'échantillonnage, dt, la moyenne d'exécution étant modifiée """ # --------------------------- -------------------- self.start_plot(plot_title = "Moyenne mobile et fréquence d'échantillonnage") 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()

Étape 8: Expérimentez: Connexion avec déclencheur

Dans cette expérience, nous ajoutons un déclencheur. Tout d'abord, qu'est-ce que j'entends par un déclencheur? Un déclencheur est une technique dans laquelle nous collectons des données mais ne les sauvegardons qu'après qu'une variable ait changé de manière significative. Dans ces expériences, j'ai mis un déclencheur sur la variable temps (axe x). En utilisant le déclencheur, je peux prendre la grande quantité de données d'un échantillonnage rapide et la réduire à une quantité de données plus raisonnable. Il est particulièrement utile avec des taux d'échantillonnage élevés et une longue moyenne en cours.

J'ai pris la ligne #2 de la dernière expérience qui était "bonne" et j'ai ajouté un déclencheur. Exécutez-le avec: sim_logging…… La sortie est un graphique, x lignes.

Ce qui se produit? Nous obtenons un "bon" tracé avec une quantité raisonnable de données (le même que #1). Il y a eu un certain coût dans le traitement plus élevé. Dans l'ensemble, cependant, les résultats sont à peu près les mêmes que #1 le taux d'échantillonnage inférieur avec moins de filtrage. Vous pourriez conclure:

• Une moyenne glissante longue avec déclenchement peut donner une bonne réduction du bruit avec des quantités raisonnables de données.
• Le traitement supplémentaire peut ne pas donner de bien meilleurs résultats et a un coût.

Le code:

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

def experiment_with_trigger(self): print """ Expérimentez avec Triggering, dt, run average et trigger all variant """ # ----------------------- ------------------------- self.start_plot(plot_title = "Trigger 1/1 - Déclenchement activé") 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()

=

Étape 9: Expérimentez: enregistrement avec déclencheur - bruit plus fort

Faisons la même expérience que la dernière étape et amplifions le bruit. Exécutez-le avec: sim_logging…… La sortie est un graphique, 2 lignes.

Maintenant, le traitement supplémentaire semble plus intéressant. Une conclusion raisonnable ici pourrait être:

Le choix de la quantité et du type de traitement pour la réduction du bruit dépend de votre signal et de votre bruit

Le code:

def experiment_with_trigger_louder_noise(self):

print """ Bruit plus fort que l'expérience précédente """ 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()

Étape 10: Faites vos propres expériences

À ce stade, j'espère que vous voyez que les techniques de cette instructable peuvent être utiles dans l'enregistrement de données, mais qu'elles doivent également être utilisées avec réflexion. Expérimenter avec eux peut aider ce processus.

Quelques remarques sur les expériences et les choses que vous pourriez examiner:

• Les ondes sinusoïdales ne sont pas le seul type de signal intéressant, essayez-en d'autres, d'autres ondes ou rampes ou …..
• J'ai utilisé une distribution normale pour le bruit, il y a tellement de types de bruit; tu devrais considérer les autres
• Les moyennes courantes sont une méthode simple, mais pas la seule, pour examiner le bruit

Remarque: enregistrement d'images à partir de Wikipédia.

Étape 11: Utilisation des techniques de votre logiciel de journalisation

Mon code est orienté objet et le traitement de la moyenne courante et du déclencheur peut simplement être copié dans votre environnement Python, puis utilisé. Les objets sont:

• DataTrigger dans data_trigger.py
• MovingAverage dans moving_average.py

Mon objet principal LoggingSim dans simulate_logging.py devrait vous donner un bon exemple de la façon de l'utiliser. Si vous utilisez une autre langue, vous pouvez lire mon code et l'implémenter dans votre langue.

Ce code peut donner à votre projet un meilleur enregistrement des données, essayez-le.

Le graphique ci-dessus provient de Graph Your Solar Power de russ_hensel qui utilise le même objet de moyenne courante.