L’oscilloscope est l’un des outils les plus importants que vous trouverez sur l’établi de tout ingénieur ou fabricant en é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 au fil du temps. Il est également utilisé par les développeurs de logiciels embarqués pour le débogage du code et par les techniciens pour dépanner les appareils électroniques lors de 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 les plus efficaces coûtent plus de 150 dollars. Aujourd’hui, je vais vous montrer comment utiliser le Arduino et 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’effectuer les tâches pour lesquelles certains oscilloscopes bon marché sont déployés, comme l’affichage des formes d’onde et la détermination des niveaux de tension pour les signaux.
[You can also check this similar project: DIY Mini Oscilloscope using Arduino nano and OLED]
Comment ça marche
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é à son canal d’entrée. Pour y parvenir, nous devons d’abord convertir le signal analogique en numérique, puis tracer les données. Pour la conversion, nous nous appuierons sur ADC (convertisseur analogique-numérique) sur le 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ù se trouve 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 liaison
Logiciels requis
- EDI Arduino
- Python
- Bibliothèques Python : Pyserial, Matplotlib, Drawnow
Schémas
Le schéma du Oscilloscope Arduino est simple. Tout ce que nous avons à 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 à examinerde telle sorte que la forme d’onde générée décrive 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 ressembler à l’image ci-dessous.
Une fois les connexions terminées, nous pouvons procéder à l’écriture du code.
Code de l’oscilloscope Arduino
Nous écrirons des codes pour chacune des deux sections. Pour le traceur comme mentionné précédemment, nous allons écrire un script python qui accepte les données de l’Arduino via UART et Plots, tandis que pour le convertisseurnous allons écrire un croquis Arduino qui récupère les données de l’ADC et les convertit en niveaux de tension qui sont envoyés au traceur.
Script Python (traceur)
Le code python étant plus complexe, nous allons commencer par celui-ci.
Nous utiliserons quelques bibliothèques, notamment : drawow, Matplotlib et Pyserial avec le script python comme mentionné précédemment. Pyserial nous permet de créer un script python capable de communiquer via le port série, Matplotlib nous donne la possibilité de générer des tracés à partir des données reçues via le port série et drawow nous permet 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 pépin. 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 saisissez ce qui suit :
pip install pyserial
Cela fait, installez matplotlib en utilisant ;
pip install matplotlib
Drawnow est parfois installé avec matplotlib mais juste pour être sûr, exécutez ;
pip install drawnow
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 que les données restent affichées sur l’oscilloscope.
val = [ ] cnt = 0
Ensuite, nous créer 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 en bauds de 115 200 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 faire l’intrigue utilisation interactive ;
plt.ion()
nous devons créer une fonction pour générer le tracé à partir des données reçuescréant les limites supérieure et minimale auxquelles nous nous attendons, qui dans ce cas est de 1023 en fonction de 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 de l’intrigue.
#create the figure function
def makeFig():
plt.ylim(-1023,1023)
plt.title('Osciloscope')
plt.grid(True)
plt.ylabel('ADC outputs')
plt.plot(val, 'ro-', label="Channel 0")
plt.legend(loc="lower right")
Cela fait, nous sommes maintenant prêts à écrire la boucle principale qui récupère les données du port série lorsqu’elles sont disponibles et les trace. Pour synchroniser avec l’Arduino, un les données de poignée de main sont envoyées à 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 with Arduino
if (port.inWaiting()):# if the arduino replies
value = port.readline()# read the reply
print(value)#print so we can monitor it
number = int(value) #convert received data to integer
print('Channel 0: {0}'.format(number))
# Sleep for half a second.
time.sleep(0.01)
val.append(int(number))
drawnow(makeFig)#update plot to reflect new data input
plt.pause(.000001)
cnt = cnt+1
if(cnt>50):
val.pop(0)#keep the plot fresh by deleting the data at position 0
Le code python complet pour oscilloscope arduino est donné à la fin de cet article ci-dessous.
Code Arduino
Le deuxième code est le croquis Arduino pour obtenir les données représentant le signal de l’ADC, puis attendez de recevoir le signal de prise de contact du logiciel de traceur. Dès qu’il reçoit le signal de prise de contact, il envoie les données acquises au logiciel traceur via UART.
Nous commencez par déclarer le pin de la broche Analogique de l’Arduino auquel le signal sera appliqué.
int sensorpin = A0;
Ensuite, nous initialisons et démarrons la communication série avec un débit en bauds de 115 200
void setup() {
// initialize serial communication at 115200 bits per second to match that of the python script:
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() {
// read the input on analog pin 0:
float sensorValue = analogRead(sensorpin);
byte data = Serial.read();
if (data == 's')
{
Serial.println(sensorValue);
delay(10); // delay in between reads for stability
}
}
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() {
// initialize serial communication at 115200 bits per second to match that of the python script:
Serial.begin(115200);
}
void loop() {
// read the input on analog pin 0:########################################################
float sensorValue = analogRead(sensorpin);
byte data = Serial.read();
if (data == 's')
{
Serial.println(sensorValue);
delay(10); // delay in between reads for stability
}
}
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 à circuler via la ligne de commande python et le tracé variant avec l’intensité lumineuse, comme indiqué dans l’image ci-dessous.
Voici donc comment Arduino peut être utilisé comme oscilloscope, il peut également être réalisé avec Raspberry Pi, consultez ici le tutoriel complet sur l’oscilloscope basé sur Raspberry Pi.
Retrouvez l’histoire de Raspberry Pi dans cette vidéo :
