Cet instructable va vous montrer comment construire un écran tactile portable

Oscilloscope pour moins de 40 U $!

L’oscilloscope est l’un des instruments électroniques les plus puissants qui

est disponible pour les amateurs d'électronique, les expérimentateurs et les ingénieurs. Il est

principalement utilisé pour mesurer des signaux variant dans le temps. Chaque fois que vous avez un signal

qui varie avec le temps (lentement, rapidement et / ou périodiquement), vous pouvez utiliser

un oscilloscope pour le mesurer, le visualiser et détecter les imprévus

caractéristiques en elle.

Nous pouvons utiliser un oscilloscope pour observer et étudier les caractéristiques du signal

que nous ne pourrions pas voir autrement.

Vous en apprendrez davantage sur le convertisseur analogique-numérique méga (ADC) Arduino.

Nous utiliserons l'entrée analogique A0 Arduino pour échantillonner et capturer le temps

faire varier les signaux en écrivant un programme qui affichera également ces signaux

dans un écran tactile TFT LCD de 3,8 ", et nous saisirons des données pour modifier

comportement de l’oscilloscope, en utilisant les capacités tactiles de l’affichage à l’écran.

Avant de commencer à construire et à programmer, passons en revue quelques bases

caractéristiques d'un oscilloscope.

Voici des fonctions que vous pouvez contrôler sur la plupart des oscilloscopes:

Vitesse de balayage. La vitesse de balayage est généralement mesurée en unités de temps par distance, millisecondes / centimètre ou millisecondes par division.Cela pourrait également

être appelé sensibilité horizontale.

Sensibilité verticale. C'est la mesure de la sensibilité du point d'affichage

est à la tension appliquée aux bornes d'entrée. Il est généralement mesuré en

volts / centimètre ou volts par division.

UNE signal de déclenchement peut être généré lorsque la valeur du signal atteint

niveau particulier - le niveau de déclenchement. Dans la plupart des cas, vous pouvez définir le déclencheur

niveau à une valeur de tension de votre choix. Un déclencheur est utilisé pour capturer et

stabiliser la forme d'onde à l'écran ou d'attendre un événement avant

capturer les données

L’oscilloscope, comme mon DVM DC à 4 canaux, ne sera pas aussi précis que

une unité commerciale, mais cela fonctionne assez bien pour la basse tension et les basses fréquences.

Provisions:

Étape 1: MISE À JOUR: Esquisse pour convertir Oscope en DVM à 3 canaux avec écran graphique + boîtier Lego

Merci à tous ceux qui ont voté pour moi! Ce Instructable a remporté le 3ème prix du concours Arduino et le premier prix du concours Gadget …

Vous y trouverez des images et du code permettant de convertir votre oscope en un DVM à 3 canaux et d’afficher la sortie de chaque canal individuellement sur l’écran de l’appareil en appuyant sur une touche programmable de l’affichage. (le troisième bouton du haut)

vous aurez besoin d'un connecteur à broches femelles en forme de L si vous voulez avoir la possibilité d'insérer des cavaliers. Sinon, il vous suffit de plier les broches d'un côté des cavaliers pour les insérer dans les canaux analogiques (A0-A3) afin de les utiliser comme sondes..

Il suffit de télécharger le croquis et de le télécharger sur l’Arduino.

Vous pouvez nommer chaque canal individuellement, il suffit de changer le libellé de l'esquisse.

J'ai également fabriqué un boîtier Lego pour le scope. Vérifiez les images.

Étape 2: Liste de pièces

Tu auras besoin de:

• Carte Sainsmart mega2560 avec écran de module tactile 3.5 "et écran de protection
• Un PC avec l'IDE arduino et un port USB libre.
• Un cable usb
• Câbles de démarrage
• La bibliothèque UTFT et la bibliothèque UTouch de Henning Karlsen. site web:

Étape 3: Construisez le matériel.

La construction de l'oscilloscope est assez simple. Vous devez juste assembler les pièces du kit Sainsmart. Tout ce que vous avez à faire est d’ajouter deux cavaliers; l’un pour la terre et l’autre comme sonde de test pour l’oscilloscope.

Vous devrez plier les broches d’un côté des cavaliers et les insérer dans les broches A0 et GND de l’Arduino (voir les illustrations ci-dessous), avant d’installer le bouclier d’affichage, car celui-ci couvrira les ports une fois. c'est en place.

Branchez le bouclier sur l’Arduino, puis branchez l’écran sur le bouclier, et vous avez terminé !!!

Maintenant, testons l'affichage avant de le transformer en oscilloscope.

Étape 4: Le logiciel: Test de la bibliothèque UTFT.

Si vous avez fini de assembler votre kit, branchez-le sur le câble USB qui le connecte à votre PC exécutant l'IDE Arduino.

Si vous ne l'avez pas encore fait, téléchargez les bibliothèques UTFT et UTouch, puis copiez-les dans le dossier des bibliothèques dans lequel vous avez installé l'EDI arduino.

Si les bibliothèques sont correctement installées, vous verrez les options UTFT et UTouch lorsque vous cliquez sur l’option Fichiers et faites défiler jusqu’à des exemples.

Si l'option UTFT figure dans votre liste de menus, sélectionnez-la, puis sélectionnez arduino et, enfin, UTFT_Demo_320x240. Cela chargera le programme de démonstration cool.

Avec le programme chargé dans l'EDI, faites défiler vers le bas pour afficher le code suivant:

// Décommenter la prochaine ligne pour Arduino 2009 / Uno

// UTFT myGLCD (ITDB32S, 19,18,17,16); // N'oubliez pas de modifier le paramètre de modèle en fonction de votre module d'affichage!

// Décommenter la prochaine ligne pour Arduino Mega

UTFT myGLCD (ITDB32S, 38,39,40,41); // N'oubliez pas de modifier le paramètre de modèle en fonction de votre module d'affichage!

Commentez le commandement pour l'ONU et décommentez le commandement pour le Mega, comme je l'ai fait.

Maintenant, allez dans le menu Outils, cliquez sur Conseil et sélectionnez Arduino Mega 2560 ou Mega ADK, si ce n'est déjà fait.

Cliquez sur vérifier pour compiler le programme. S'il n'y a pas d'erreur, cliquez sur télécharger pour charger et exécuter le programme.

Si tout va bien, vous verrez un programme de démonstration en marche. Les images de cette étape montrent des captures d'écran de la démo en cours d'exécution.

Étape 5: Le logiciel: Test de la bibliothèque UTouch.

Maintenant, nous devons tester la bibliothèque Utouch

Allez dans le menu des fichiers et sélectionnez; Exemples> UTouch> Arduino> Utouch_ButtonTest et chargez le programme dans l'IDE.

Vérifiez et exécutez le programme.

Un clavier devrait apparaître à l'écran et, au fur et à mesure que vous appuyez sur les touches numériques, elles doivent apparaître en bas de l'écran.

Si tout s'est bien passé, nous sommes prêts à charger le logiciel Oscilloscope.

Étape 6: l'oscilloscope

Vous trouverez ci-dessous l'esquisse de l'oscilloscope. Avant de copier et coller le programme, passons en revue certaines limitations et expliquons le programme.

J'ai dû faire pas mal de recherches pour trouver le code, et de nombreux extraits ont été "empruntés" à plusieurs sources.

J'ai divisé le programme en plusieurs sous-programmes pour le rendre plus facile à comprendre. Le code est bien documenté, mais si vous avez du mal à le comprendre, laissez un commentaire et je tenterai de l'expliquer.

La bande passante de l'oscilloscope est limitée à environ 1 khz, mais des améliorations sont possibles.

L'entrée est limitée à une forme d'onde pic à pic de 5 volts, sauf si vous utilisez un diviseur de tension à l'entrée, et également aux formes d'onde positives de 0 à 5 volts.

J'ai utilisé du code trouvé à l'adresse suivante: http://www.microsmart.co.za/technical/2014/03/01/advanced-arduino-adc/ pour ajuster le temps d'échantillonnage de l'ADC.

Les fonctions graphiques et tactiles ont été modifiées et empruntées aux exemples de Henning Karlsen fournis dans ses bibliothèques.

J'ai utilisé un régulateur de tension LM 317 et un minuteur IC 555 comme ocillateur astable pour créer les signaux utilisés pour tester l'entrée de l'oscilloscope.

J'espère que vous avez apprécié la lecture et la construction de cet instructable. Si vous le trouvez utile, votez pour moi dans les concours.

Remarque: J'ai inclus les bibliothèques sKetch, UTFT et UTouch dans le fichier libraries.zip pour ceux qui ont des problèmes.

Copiez et collez l'esquisse dans votre IDE Arduino

// ---------------------- START PROGRAM

/*--------------------------------------------------------------

Programme: OscopetouchLCDmega

Description: Oscilloscope numérique avec données affichées

sur écran LCD TFT couleur avec écran tactile

Matériel: Carte sainsmart mega2560 avec écran de module tactile 3.5 "et écran blindé

http: //www.sainsmart.com/home-page-view/sainsmart …

Logiciel: développé à l'aide du logiciel Arduino 1.0.3

Ce programme nécessite la bibliothèque UTFT et la

Bibliothèque UTouch de Henning Karlsen.

site web:

Version 1.00

Date: 5 avril 2014

Auteur: johnag

--------------------------------------------------------------*/

#comprendre

#comprendre

// Déclarer les polices que nous utiliserons

extern uint8_t SmallFont;

// Initialiser l'écran et les fonctions tactiles

UTFT myGLCD (ITDB32S, 38,39,40,41);

UTouch myTouch (6,5,4,3,2);

// Déclarer des variables

char buf 12;

int x, y;

int Input = 0;

octet échantillon 320;

octet OldSample 320;

int StartSample = 0;

int EndSample = 0;

int max = 100;

int Min = 100;

mode int = 0;

int dTime = 1;

int tmode = 0;

int déclencheur = 0;

int SampleSize = 0;

int SampleTime = 0;

int dgvh;

int hpos = 50; // place 0v sur la grille horizontale

int vsens = 4; // sensibilité verticale

// Définir divers prescaler ADC

const unsigned char PS_16 = (1 << ADPS2);

const unsigned char PS_32 = (1 << ADPS2) | (1 << ADPS0);

const unsigned char PS_64 = (1 << ADPS2) | (1 << ADPS1);

const unsigned char PS_128 = (1 << ADPS2) | (1 << ADPS1) | (1 << ADPS0);

// ------------ Lancer les sous-tâches ---------------------------------- -

// -------- dessine des boutons sous

boutons d'annulation () {

myGLCD.setColor (0, 0, 255);

myGLCD.fillRoundRect (250, 1, 310, 50);

myGLCD.fillRoundRect (250, 55, 310, 105);

myGLCD.fillRoundRect (250, 110, 310, 160);

myGLCD.fillRoundRect (250, 165, 310, 215);

}

// ------- sous position de l'écran tactile

void touch () {

while (myTouch.dataAvailable ())

{

myTouch.read ();

x = myTouch.getX ();

y = myTouch.getY ();

retard (500);

if ((y> = 1) && (y <= 50)) // Ligne de délai

{

if ((x> = 250) && (x <= 300)) // Bouton de retard

waitForIt (250, 1, 310, 50);

mode = mode ++;

{

myGLCD.setColor (255, 0, 0);

myGLCD.drawRoundRect (250, 1, 310, 50);

// Sélection des délais

if (mode == 0) dTime = 0;

if (mode == 1) dTime = 1;

if (mode == 2) dTime = 2;

if (mode == 3) dTime = 5;

if (mode == 4) dTime = 10;

if (mode == 5) dTime = 20;

if (mode == 6) dTime = 30;

if (mode == 7) dTime = 50;

if (mode == 8) dTime = 100;

if (mode == 9) dTime = 200;

if (mode == 10) dTime = 500;

si (mode> 10) mode = 0;

}}

if ((y> = 70) && (y <= 120)) // Ligne de déclenchement

{

if ((x> = 250) && (x <= 300)) // Bouton de déclenchement

waitForIt (250, 55, 310, 105);

tmode = tmode ++;

{

myGLCD.setColor (255, 0, 0);

// Sélection du déclencheur logiciel

myGLCD.drawRoundRect (250, 55, 310, 105);

if (tmode == 1) Déclencheur = 0;

if (tmode == 2) Déclencheur = 10;

if (tmode == 3) Déclencheur = 20;

if (tmode == 4) Déclencheur = 30;

if (tmode == 5) Déclencheur = 50;

si (tmode> 5) tmode = 0;

}}

if ((y> = 130) && (y <= 180)) // rangée de position H

{

if ((x> = 250) && (x <= 300)) // Bouton de position H

waitForIt (250, 110, 310, 160);

hpos = hpos ++;

{

myGLCD.setColor (255, 0, 0);

myGLCD.drawRoundRect (250, 110, 310, 160);

myGLCD.clrScr ();

boutons();

si (hpos> 60) hpos = 50;

}}}}

// ---------- wait for touch sub

void waitForIt (int x1, int y1, int x2, int y2)

{

while (myTouch.dataAvailable ())

myTouch.read ();

}

// ---------- dessine une grille

void DrawGrid () {

myGLCD.setColor (0, 200, 0);

pour (dgvh = 0; dgvh <5; dgvh ++) {

myGLCD.drawLine (dgvh * 50, 0, dgvh * 50, 240);

myGLCD.drawLine (0, dgvh * 50, 245, dgvh * 50);

}

myGLCD.drawLine (245, 0, 245, 240);

myGLCD.drawLine (0, 239, 245, 239);

myGLCD.setColor (255, 255, 255);

myGLCD.drawRoundRect (250, 1, 310, 50);

myGLCD.drawRoundRect (250, 55, 310, 105);

myGLCD.drawRoundRect (250, 110, 310, 160);

myGLCD.drawRoundRect (250, 165, 310, 215);

}

// ------ Attend que l'entrée soit plus grande que le déclencheur secondaire

void trigger () {

while (Input <Trigger) {Entrée = analogRead (A0) * 5/100;

}}

// --------------- End Subrutines ----------------------

void setup()

myGLCD.InitLCD ();

myGLCD.clrScr ();

myTouch.InitTouch ();

myTouch.setPrecision (PREC_MEDIUM);

boutons();

pinMode (0, INPUT);

// mettre en place l'ADC

ADCSRA & = ~ PS_128; // supprime les bits définis par la bibliothèque Arduino

// vous pouvez choisir un prescaler en dessous.

// PS_16, PS_32, PS_64 ou PS_128

ADCSRA

boucle vide () {

tandis que (1) {

DrawGrid ();

toucher();

déclencheur();

// Collecte les données analogiques dans un tableau

StartSample = micros ();

pour (int xpos = 0;

xpos <240; xpos ++) {échantillon xpos = analogRead (A0) * 5/102;

delayMicroseconds (dTime);

}

EndSample = micros ();

// Affiche les données analogiques collectées du tableau

pour (int xpos = 0; xpos <239;

xpos ++)

{

// Effacer l'affichage précédent

myGLCD.setColor (0, 0, 0);

myGLCD.drawLine (xpos + 1, 255-OldSample xpos + 1 * vsens-hpos, xpos + 2, 255-OldSample xpos + 2 * vsens-hpos);

if (xpos == 0) myGLCD.drawLine (xpos + 1, 1, xpos + 1, 239);

// Dessine les nouvelles données

myGLCD.setColor (255, 255, 255);

myGLCD.drawLine (xpos, 255-échantillon xpos * vsens-hpos, xpos + 1, 255-échantillon xpos + 1 * vsens-hpos);

}

// Détermine le pic de tension d'échantillon à pic

Max = échantillon 100;

Min = échantillon 100;

pour (int xpos = 0;

xpos <240; xpos ++)

{

OldSample xpos = Sample xpos;

if (Sample xpos> Max) Max = Sample xpos;

if (Sample xpos <Min) Min = Sample xpos;

}

// affiche le temps d'échantillonnage, le temps de retard et le niveau de déclenchement

myGLCD.setBackColor (0, 0, 255);

myGLCD.setFont (SmallFont);

myGLCD.setBackColor (0, 0, 255);

myGLCD.print ("Delay", 260, 5);

myGLCD.print ("", 270, 20);

myGLCD.print (itoa (dTime, buf, 10), 270, 20);

myGLCD.print ("Trig.", 260, 60);

myGLCD.print ("", 270, 75);

myGLCD.print (itoa (Trigger, buf, 10), 270, 75);

myGLCD.print ("H Pos.", 260, 120);

myGLCD.print (itoa (hpos, buf, 10), 270, 135);

//myGLCD.setBackColor (0, 0, 0);

SampleTime = (EndSample-StartSample) / 1000;

myGLCD.print ("Sec.", 205, 210);

myGLCD.print ("", 280, 30);

myGLCD.print (itoa (SampleTime, buf, 10), 205, 220);

// Plage de 0 à 64 * 78 = 4992 mV

SampleSize = (Max-Min) * 78;

myGLCD.print ("mVolt", 5, 210);

myGLCD.print (itoa (SampleSize, buf, 10), 5, 220);

myGLCD.print (itoa (analogRead (A0) * 4.15 / 10.23, buf, 10), 110, 220);

}}

// ------------------------- FIN DU PROGRAMME

Étape 7: Vidéo de l'Oscope en action

Étape 8: une autre vidéo

Runner Up dans le

Concours Arduino

Deuxième prix au

Concours de piratage de gadgets et d'accessoires

4 personnes ont réalisé ce projet!

• 

  scottm214 l'a fait!

• 

  e.ma.niak l'a fait!

• 

  Whitmore12 l'a fait!

• 

  grumpyboots l'a fait!

Avez-vous réalisé ce projet? Partagez le avec nous!

Recommandations

• 

  Réduire les échantillons de code Arduino

• 

  Prototype d'ornithoptère Opensource. Actionné par Arduino et contrôlé à distance.

• 

  

  Classe Internet des objets

• Défi de fête

  

• Concours Arduino 2019

  

• Défi IoT

  

84 discussions

0

David Patterson

Il y a 4 ans sur l'introduction

Un excellent article!

Je vais chercher un tft pour mon méga!

Quel type de taux de rafraîchissement pensez-vous que votre tft a?

Avez-vous envisagé de lire le port analogique en interrompant

J'ai une conception d'oscilloscope 153K utilisant un méga avec un déclenchement matériel et logiciel.

http: //www.instructables.com/id/Arduino-High-speed …

Il serait intéressant de réunir les deux concepts.

7 réponses 0

johnag David Patterson

Répondre il y a 4 années sur Introduction

Désolé pour avoir mis du temps pour répondre. Merci pour votre commentaire. Je ne connais pas le taux de rafraîchissement de l'écran, je n'ai pas vérifié les spécifications en détail. Si vous pouviez augmenter la bande passante en utilisant votre conception, cela améliorerait certainement la portée. Si vous avez le kit et essayez vos concepts, partagez-le s'il vous plaît.. Si j'ai le temps, je pourrais l'essayer moi-même.. Encore merci.

0

David Patterson johnag

Répondre il y a 4 années sur Introduction

L'écran de 3,2 pouces et le bouclier sont enfin arrivés. J'ai utilisé mon Mega plutôt que le Sainsmart.

L'assemblage était facile - j'ai ajouté des connecteurs pour le port analogique, pwm10, zéro et 5V. La programmation n'a pas été difficile - Henning, l'auteur de la bibliothèque dispose d'une excellente documentation. J'ai trouvé aucun problème dans la mise en œuvre de ses protocoles.

Mon champ d'action va jusqu'à 237-238 kHz.

Le lecteur de carte SD qui se trouve sur le bouclier fonctionne et offre la possibilité de sauvegarder des données. (Sans parler de l'ajout de photos)

Cela a produit un très bel oscilloscope autonome.

Merci pour votre travail.

0

waqasbadarwb David Patterson

Répondre il y a 4 années sur Introduction

Pouvez-vous donner le code?

0

hemal1 waqasbadarwb

Répondre il y a 4 années sur Introduction

Bonjour, quelle bibliothèque utilisez-vous pour cela?

0

Hamzaikky David Patterson

Répondre il y a 4 années sur Introduction

Comment avez-vous ajouté des images?

0

David Patterson Hamzaikky

Répondre il y a 4 années sur Introduction

Salut, Pour cette application j'ai utilisé

Fonction loadBitmap de Henning - décrite dans les exemples

fourni avec sa bibliothèque. Cela nécessite que vous convertissiez une taille d'écran

(ou moins) image au format brut. Il fournit un programme avec sa bibliothèque

télécharger pour cela. Ou vous pouvez utiliser son convertisseur en ligne sur:

http: //www.henningkarlsen.com/electronics/t_imagec …

J'ai utilisé un fichier de taille d'écran (320 x 240).

#comprendre

#comprendre

#comprendre

#comprendre

// Initialiser l'écran et les fonctions tactiles

UTFT myGLCD (ITDB32S, 38,39,40,41);

UTFT_tinyFAT myFiles (& myGLCD);

UTouch myTouch (6,5,4,3,2);

logo booléen = vrai;

mot res;

const int chipSelect = 53; // sd select pin

void setup(){

pinMode (chipSelect, OUTPUT);

myGLCD.InitLCD ();

myGLCD.clrScr ();

int picsize_x = myGLCD.getDisplayXSize ();

int picsize_y = myGLCD.getDisplayYSize ();

si (logo) {

if (file.initFAT () == 0) {

commutateur (picsize_x);

res = myFiles.loadBitmap (0, 0, picsize_x, picsize_y, "LOGO.RAW");

si (res == 0) {

retarder (5000);

myGLCD.clrScr ();

}

}

}

// plus de choses d'installation

}

L'utilisation du fichier brut pour un affichage unique est acceptable.

toutefois

Devoir convertir plusieurs fichiers me semblait prendre un peu de temps.

Alors j'ai écrit un ajout à la bibliothèque utft de Henning pour traiter 24 bits

fichiers bmp directement. Cela fonctionne très bien et ne nécessite pas UTFT_tinyFat

et tinyFat. La sdcard est accessible à l’aide du standard arduino sd

bibliothèque. Mon patch chargera une image bitmap d’écran dans 1.79S, qui est une

peu plus vite que le système de Henning.

J'ai également utilisé le SD pour l'enregistrement de données.

Dans l'ensemble, John a détaillé un bouclier et un écran LCD très utiles!

0

David Patterson johnag

Répondre il y a 4 années sur Introduction

Salut, J'ai commandé le lcd il y a un mois - apparemment c'est quelque part entre la Chine et le Royaume-Uni.

En même temps, j'ai développé un code qui fonctionne à

237,3 kHz, avec déclenchement logiciel configurable.

http: //forum.arduino.cc/index.php? PHPSESSID = 3e1pvs …

J'ai également écrit un logiciel fonctionnant à 1,2 MHz à l'aide d'un TLV571, également avec déclenchement logiciel.

0

ValtherN

il y a 1 an

Quelqu'un at-il créé par hasard une boîte imprimable en 3D pour cela?

0

hackerh

il y a 1 an

Bonjour

J'ai une requête pour rendre possible la création d'un oscilloscope par Arduino UNO et disposer d'une lecture analogique rapide capable de lire le signal à haute vitesse pour 200KHZ.

Si possible, cela m'aide à l'accomplir

Est-il possible de me donner un exemple? Ceci est un petit programme montrant l’action d’ADC rapide pour prélever l’échantillon de 200KHZ

Cet email est [email protected]

Remercier

0

pipern8536d

il y a 1 an

Cet appareil peut-il être installé à l'aide du nouvel écran flexible oled?

0

AMSR1

il y a 1 an

Il semble que le code fonctionne, mais les boutons (délai, déclenchement, etc.) ne fonctionnent pas. Est-ce que quelqu'un a le même problème?

0

kevinmaker2018

il y a 1 an

Projet cool. Je l'ai fait avec mon Mega 2560 et l'écran TFT de 3,2 pouces. Cela fonctionne bien. Merci d'avoir partagé.

0

Jwzumwalt

il y a 1 an

Que signifie "fonctionne assez bien pour les basses tensions et les basses fréquences"? Veuillez inclure quelques spécifications pertinentes dans le premier ou les deux premiers paragraphes afin que nous puissions voir si le projet est applicable à nos besoins …

2 réponses 0

PatrickT90 Jwzumwalt

Répondre il y a 1 année

Il explique la question dans son autre instructable, qui est liée à la phrase en question.

0

Jwzumwalt PatrickT90

Répondre il y a 1 année

Oh … Alors, c'est un appât au clic et pas pour être vraiment informatif?

0

système laser

il y a 1 an

Salut, Comment utiliser Arduino DUE avec TFT LCD Sheild with touch.

Merci beaucoup

0

Harry N4HBM

il y a 2 ans

J'ai utilisé les planches SainSmart et cela fonctionne comme un charme.

0

Non camionneur

il y a 2 ans

Enfin trouvé un beau projet, vous avez mis du temps à mettre la sienne ici, merci de prendre le temps.

0

bagarres01

il y a 2 ans

Comment modifieriez-vous le code pour afficher un signal compris entre 0,2 et -0,2 volts?