Réel basé sur Arduino

L'oscilloscope est l'un des outils les plus importants que vous trouverez sur l'établi de tout ingénieur ou fabricant d'électronique. Il est principalement utilisé pour visualiser la forme d'onde et déterminer les niveaux de tension, la fréquence, le bruit et d'autres paramètres des signaux appliqués à son entrée qui peuvent changer avec le temps. Il est également utilisé par les développeurs de logiciels embarqués pour le débogage de code et les techniciens pour le dépannage des appareils électroniques pendant la réparation. Ces raisons font de l'oscilloscope un outil indispensable pour tout ingénieur. Le seul problème est qu'ils peuvent être très coûteux, les oscilloscopes qui exécutent les fonctions les plus élémentaires avec le moins de précision peuvent coûter entre 45 et 100 dollars, tandis que les plus avancés et efficaces coûtent plus de 150 dollars. Aujourd'hui, je vais démontrer comment utiliser l' Arduinoet un logiciel, qui sera développé avec mon langage de programmation préféré Python, pour construire un oscilloscope Arduino 4 canaux à faible coût capable d'exécuter les tâches pour lesquelles certains des oscilloscopes bon marché sont déployés comme l'affichage de formes d'onde et la détermination des niveaux de tension pour les signaux.

Comment ça fonctionne

Il y a deux parties pour ce projet;

Le convertisseur de données
Le traceur

Les oscilloscopes impliquent généralement la représentation visuelle d'un signal analogique appliqué à sa voie d'entrée. Pour y parvenir, nous devons d'abord convertir le signal d'analogique en numérique, puis tracer les données. Pour la conversion, nous tirerons parti du convertisseur analogique-numérique (ADC) du microcontrôleur atmega328p utilisé par l'Arduino pour convertir les données analogiques à l'entrée du signal en un signal numérique. Après la conversion, la valeur par heure est envoyée via UART de l'Arduino au PC où le logiciel de traceur qui sera développé en utilisant python convertira le flux de données entrant en forme d'onde en traçant chaque donnée en fonction du temps.

Composants requis

Les composants suivants sont requis pour construire ce projet;

Arduino Uno (n'importe laquelle des autres cartes peut être utilisée)
Planche à pain
Résistance 10k (1)
LDR (1)
Fils de cavalier

Logiciels requis

IDE Arduino
Python
Bibliothèques Python: Pyserial, Matplotlib, Drawnow

Schémas

Le schéma de l' oscilloscope Arduino est simple. Tout ce que nous devons faire est de connecter le signal à examiner à la broche analogique spécifiée de l'Arduino. Cependant, nous utiliserons le LDR dans une configuration simple de diviseur de tension pour générer le signal à examiner, de sorte que la forme d'onde générée décrira le niveau de tension, en fonction de l'intensité de la lumière autour du LDR.

Connectez les composants comme indiqué dans les schémas ci-dessous;

Après la connexion, la configuration devrait aimer l'image ci-dessous.

Une fois les connexions terminées, nous pouvons continuer à écrire le code.

Code de l'oscilloscope Arduino

Nous écrirons des codes pour chacune des deux sections. Pour le traceur comme mentionné précédemment, nous écrirons un script python qui accepte les données de l'Arduino via UART et Plots, tandis que pour le convertisseur, nous allons écrire un croquis Arduino qui prend les données de l'ADC et les convertit en les niveaux de tension qui sont envoyés au traceur.

Script Python (traceur)

Comme le code python est plus complexe, nous allons commencer par lui.

Nous utiliserons quelques bibliothèques dont; drawnow, Matplotlib et Pyserial avec le script python comme mentionné précédemment. Pyserial nous permet de créer un script python qui peut communiquer sur le port série, Matplotlib nous donne la possibilité de générer des tracés à partir des données reçues sur le port série et drawow nous fournit un moyen de mettre à jour le tracé en temps réel.

Il existe plusieurs façons d'installer ces packages sur votre PC, la plus simple étant via pip . Pip peut être installé via la ligne de commande sur une machine Windows ou Linux. PIP est fourni avec python3, je vous conseillerai donc d'installer python3 et de cocher la case concernant l'ajout de python au chemin. Si vous rencontrez des problèmes lors de l'installation de pip, consultez le site Web officiel de Python pour obtenir des conseils.

Avec pip installé, nous pouvons maintenant installer les autres bibliothèques dont nous avons besoin.

Ouvrez l'invite de commande pour les utilisateurs Windows, le terminal pour les utilisateurs Linux et entrez ce qui suit;

pip installer pyserial

Ceci fait, installez matplotlib en utilisant;

pip installer matplotlib

Drawnow est parfois installé avec matplotlib, mais pour être sûr, exécutez;

pip installer dessiné

Une fois l'installation terminée, nous sommes maintenant prêts à écrire le script python.

Le script python de ce projet est similaire à celui que j'ai écrit pour l'oscilloscope basé sur Raspberry Pi.

Nous commençons par importer toutes les bibliothèques nécessaires au code;

import time import matplotlib.pyplot as plt from drawnow import * import pyserial

Ensuite, nous créons et initialisons les variables qui seront utilisées lors du code. Le tableau val sera utilisé pour stocker les données reçues du port série et cnt sera utilisé pour compter. Les données à l'emplacement 0 seront supprimées tous les 50 comptages de données. Ceci est fait pour garder les données affichées sur l'oscilloscope.

val = cnt = 0

Ensuite, nous créons l'objet port série à travers lequel l'Arduino communiquera avec notre script python. Assurez-vous que le port com spécifié ci-dessous est le même port com via lequel votre carte Arduino communique avec l'IDE. Le débit de 115200 bauds utilisé ci-dessus a été utilisé pour assurer une communication à haut débit avec l'Arduino. Pour éviter les erreurs, le port série Arduino doit également être activé pour communiquer avec ce débit en bauds.

port = serial.Serial ('COM4', 115200, timeout = 0.5)

Ensuite, nous rendons le graphique interactif en utilisant;

plt.ion ()

nous devons créer une fonction pour générer le tracé à partir des données reçues, créant la limite supérieure et minimale que nous attendons, qui dans ce cas est 1023 basée sur la résolution de l'ADC de l'Arduino. Nous définissons également le titre, étiquetons chaque axe et ajoutons une légende pour faciliter l'identification du tracé.

#create the figure function def makeFig (): plt.ylim (-1023,1023) plt.title ('Osciloscope') plt.grid (True) plt.ylabel ('ADC output') plt.plot (val, 'ro - ', label =' Canal 0 ') plt.legend (loc =' en bas à droite ')

Cela fait, nous sommes maintenant prêts à écrire la boucle principale qui prend les données du port série lorsqu'elles sont disponibles et les trace. Pour se synchroniser avec l'Arduino, une donnée de prise de contact est envoyée à l'Arduino par le script python pour indiquer qu'il est prêt à lire les données. Lorsque l'Arduino reçoit les données de prise de contact, il répond avec les données de l'ADC. Sans cette poignée de main, nous ne pourrons pas tracer les données en temps réel.

while (True): port.write (b's ') #handshake avec Arduino if (port.inWaiting ()): # si l'arduino répond value = port.readline () # lire la réponse print (value) #print afin que nous puissions monitor it number = int (value) #convertir les données reçues en nombre entier print ('Channel 0: {0}'. format (number)) # Sleep pendant une demi-seconde. time.sleep (0.01) val.append (int (number)) drawnow (makeFig) #update plot pour refléter la nouvelle entrée de données plt.pause (.000001) cnt = cnt + 1 if (cnt> 50): val.pop (0) # garder le tracé frais en supprimant les données à la position 0

Le code Python complet pour l'oscilloscope Arduino est donné à la fin de cet article ci-dessous.

Code Arduino

Le deuxième code est l'esquisse Arduino pour obtenir les données représentant le signal du CAN, puis attendez de recevoir le signal de prise de contact du logiciel du traceur. Dès qu'il reçoit le signal de prise de contact, il envoie les données acquises au logiciel du traceur via UART.

Nous commençons par déclarer la broche de la broche analogique de l'Arduino à laquelle le signal sera appliqué.

int sensorpin = A0;

Ensuite, nous initialisons et commençons la communication série avec une vitesse de transmission de 115200

void setup () { // initialise la communication série à 115200 bits par seconde pour correspondre à celle du script python: Serial.begin (115200); }

Enfin, la fonction voidloop () qui gère la lecture des données, et envoie les données en série au traceur.

void loop () { // lire l'entrée sur la broche analogique 0: float sensorValue = analogRead (sensorpin); données d'octet = Serial.read (); if (data == 's') { Serial.println (sensorValue); retard (10); // délai entre les lectures pour la stabilité } }

Le code complet de l'oscilloscope Arduino est donné ci-dessous ainsi qu'à la fin de cet article ci-dessous.

int sensorpin = A0; void setup () { // initialise la communication série à 115200 bits par seconde pour correspondre à celle du script python: Serial.begin (115200); } void loop () { // lire l'entrée sur la broche analogique 0: ################################# ##################### float sensorValue = analogRead (sensorpin); données d'octet = Serial.read (); if (data == 's') { Serial.println (sensorValue); retard (10); // délai entre les lectures pour la stabilité } }

Oscilloscope Arduino en action

Téléchargez le code dans la configuration Arduino et exécutez le script python. Vous devriez voir les données commencer à être diffusées via la ligne de commande python et le tracé variant avec l'intensité lumineuse, comme indiqué dans l'image ci-dessous.

C'est donc ainsi qu'Arduino peut être utilisé comme oscilloscope, il peut également être réalisé à l'aide de Raspberry pi, consultez ici le tutoriel complet sur l'oscilloscope basé sur Raspberry Pi.