Mise à jour le 20/09/2020 : Le traceur série nous permet d’afficher une ou plusieurs courbes en même temps façon oscilloscope.Nous apprendrons aussi à réaliser un chronogramme temporel en créant un offset
Sommaire
- Description du traceur de courbe sur Arduino
- Documentation sur le matériel utilisé
- Carte Nano 3.0
- Shield E/S DFR0012 pour Nano
- Traçage d’un signal analogique sur le traceur série
- Traçage de 2 valeurs analogiques sur le traceur serie avec superposition des courbes
- Traçage avec offset de 2 valeurs analogiques sur le traceur serie
- Traçage de plusieurs signaux numériques sur le même axe
- Traçage de plusieurs signaux numériques avec offset
- Tutoriel Vidéo
- Arduino traceur serie pour courbe analogique
- Traceur série pour la creation d un chronogramme
- Pour tout problème
- Retour au menu Arduino .
.
Description du traceur de courbe sur Arduino |
.
Le traceur série est un nouvel outil intégrer dans l’interface de l’IDE Arduino, à partir de la version 1.8.9.
Le traceur série nous permet d’afficher une ou plusieurs courbes en même temps façon oscilloscope. Nous verrons dans cet article comment afficher plusieurs courbes en même temps et comment espacer les courbes en créant offset. Nous apprendrons aussi à réaliser un chronogramme temporel en créant un offset pour chaque valeur numérique, de façon que ces signaux ne soient pas sur le même axe .
Le système affecte une couleur différente pour chaque courbe qui est de l’ordre de quatre couleurs. Les courbes supplémentaires se trouvant ensuite dans une même couleur
On peut afficher toutes sortes de valeurs qu’elles soient entière,a virgule flottante .Le format d’affichage est normalisé en fonction de la courbe à visualiser.
Le système de courbes fonctionne sous le principe appelé FIFO ou la méthode du premier entré premier sorti. Quand la taille est atteinte, chaque nouveau point de la courbe supprime l’ancien point du début de celle-ci, l’affichage est donc dit glissant vers la gauche
.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 |
// // // Exemple de code pour le traceur série void loop() { Serial.print(valeur1); Serial.print(","); Serial.print(valeur2); Serial.print(","); Serial.print(valeur3); Serial.print(","); Serial.print(valeur4); Serial.println(); delay(100); } |
.
Retour au sommaire
Documentation sur le matériel utilisé |
.
Carte Nano 3.0
La carte Nano 3.0 est basée sur un ATMega328 cadencé à 16 MHz. Elle est fabriquée à partir du schéma de la carte ArduinoTM Nano, ce qui la rend compatible avec la plupart des programmes et de l’IDE ArduinoTM.
Sa mémoire de 32 kB et son grand nombre d’E/S font de ce circuit compatible DIL30 un élément idéal pour les systèmes embarqués ou pour des applications robotiques nécessitant du multitâches.
La Nano 3.0 peut se programmer avec le logiciel ArduinoTM. Le contrôleur ATMega328 contient un bootloader qui permet de modifier le programme sans passer par un programmateur.
.
Shield E/S DFR0012 pour Nano
Shield E/S DFR0012 pour Nano
Shield E/S DFR0012 pour Nano
Le shield Nano IO DFR0012 est un module d’interface conçu pour le microcontrôleur Arduino Nano ou DFRduino Nano. Le module Nano s’enfiche directement sur le shield et ses entrées-sorties sont rendues accessibles ainsi que les borniers d’alimentation.
.
Module bouton-poussoir Gravity DFR0029G
La sortie de ce module Gravity DFRobot commute lorsque l’on appuie sur le bouton-poussoir.Ce module se raccorde sur une entrée digitale d’une carte compatible Arduino ou directement sur les shield d’expansion E/S
Module bouton-poussoir Gravity DFR0029G
.
Capteur linéaire Gravity DFR0053
Ce capteur linéaire Gravity DFRobot est basé sur un potentiomètre à glissière et permet de connaître la position du curseur. Le capteur délivre une valeur analogique en fonction de la position.
Ce module se raccorde sur une entrée analogique d’une carte compatible Arduino ou directement sur le shield d’expansion E/S
Capteur linéaire Gravity DFR0053
.
Retour au sommaire
Traçage d’un signal analogique sur le traceur série |
.
Le but de ce programme est de mesurer une tension donnée par un potentiomètre sur la broche A0 de notre Arduino nano et d’en afficher le résultat sur le moniteur de l’IDE ou sur le traceur série. Dans ce programme , nous n’affichons qu’une seule courbe.
Matériel utile mais pas nécessaire
- 1 Arduino Nano
- Le shield Nano IO DFR0012
Schéma electrique de prinicpe
Schéma de prinicpe pour le cablage d’une entrée analogique
.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 |
// // //************************************************ // //RedOhm //le 11/01/2020 //H-Mazelin // //Tracage d'une courbe sur le traceur serie // //************************************************ // le potentiomètre, branché sur la broche analogique 0 int potentiometre1 = 0; // variable pour stocker la valeur int valeur1; // declaration de la variable en virgule flottante tension // c'est à dire des nombres à virgules. Ils sont souvent // utilisés pour la lecture des valeurs analogiques et continues float tension1; // Un programme Arduino doit impérativement contenir la fonction "setup" // Elle ne sera exécutée une seule fois au démarrage du microcontroleur // Elle sert à configurer globalement les entrées sorties void setup() { //ouvre le port série et fixe le debit de communication à 9600 bauds Serial.begin(9600); // on attent que le port de communication soit pret while(!Serial); } //Le programme principal s’exécute par une boucle infinie appelée Loop () void loop() { // conversion de la tension de la borne 0 et transfert de la valeur // numerique dans la variable valeur1 valeur1=analogRead(potentiometre1); // transformation de la valeur numerique en volts tension1 = valeur1 * 5.0 / 1023; /* //Affichage de la valeur obtenue sur le moniteur de l'IDE //si tel est le cas , supprimez le mode commentaire Serial.print("Tension mesurée => "); //On affiche la valeur de la tension a l'aide de la variable //tension et on specifie le nombre de decimale derriere la virgule Serial.print(tension1,2); Serial.println("Volt"); //On fait une pause pour pouvoir lire la valeur sur le moniteur delay(500); */ //Affichage de la valeur mesure sur le traceur serie //si tel est le cas , supprimez le mode commentaire Serial.print(tension1); Serial.println(); } |
.
Traçage d’une valeur analogique avec le traceur serie
.
Traçage de 2 valeurs analogiques sur le traceur serie
|
.
Le but de ce programme est de tracer deux valeurs analogiques avec le code recommandé. Vous pourrez donc vous apercevoir que les deux courbes démarrent de la même position en X. On s’aperçoit sur la figure en bas du programme que les deux courbes se superposent, sauf si les valeurs ne sont pas identiques. Si nous avions des oscillations cela deviendrait vite pénible à lire.
.
Schéma de principe pour le câblage sur 2 entrées analogiques
.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 |
// // //************************************************ // //RedOhm //le 11/01/2020 //H-Mazelin // //Traçage de 2 valeurs analogiques sur le traceur serie //avec superposition des courbes // //************************************************ // le potentiomètre, branché sur la broche analogique 0 int potentiometre1 = 0; // variable pour stocker la valeur int valeur1; // le potentiomètre, branché sur la broche analogique 1 int potentiometre2 = 1; // variable pour stocker la valeur int valeur2; // declaration de la variable en virgule flottante tension // c'est à dire des nombres à virgules. Ils sont souvent // utilisés pour la lecture des valeurs analogiques et continues float tension1; float tension2; // Un programme Arduino doit impérativement contenir la fonction "setup" // Elle ne sera exécutée une seule fois au démarrage du microcontroleur // Elle sert à configurer globalement les entrées sorties void setup() { //ouvre le port série et fixe le debit de communication à 9600 bauds Serial.begin(9600); // on attent que le port de communication soit pret while(!Serial); } //Le programme principal s’exécute par une boucle infinie appelée Loop () void loop() { // conversion de la tension de la borne 0 et transfert de la valeur // numerique dans la variable valeur1 valeur1=analogRead(potentiometre1); valeur2=analogRead(potentiometre2); // transformation de la valeur numerique en volts tension1 = valeur1 * 5.0 / 1023; tension2 = valeur2 * 5.0 / 1023; /* //Affichage de la valeur obtenue sur le moniteur de l'IDE //si tel est le cas , supprimez le mode commentaire Serial.print("Tension mesurée sur l'entrée A0 => "); //On affiche la valeur de la tension a l'aide de la variable //tension et on specifie le nombre de decimale derriere la virgule Serial.print(tension1,2); Serial.println("Volt"); //Meme manipulation pour l'entrée A1 Serial.print("Tension mesurée sur l'entrée A1 => "); Serial.print(tension2,2); Serial.println("Volt"); //Création d'un espace vide pour simplifier la lecture //sur l'ecran Serial.println(" "); //On fait une pause pour pouvoir lire la valeur sur le moniteur delay(500); */ //Affichage de la valeur mesure sur le traceur serie //si tel est le cas , supprimez le mode commentaire Serial.print(tension1); Serial.print(","); Serial.print(tension2); Serial.println(); } |
.
Traçage de 2 valeurs analogiques avec le traceur serie
.
Retour au sommaire
Traçage de 2 valeurs analogiques sur le traceur serie
|
.
Dans ce programme, on a intégré une valeur d’offset à une des variables, ce qui nous permet de pouvoir lire distinctement le résultat de chaque courbe. Cet offset à une valeur de 6. Pourquoi , et bien dans notre programme, nous avons défini la mise à l’échelle des valeurs mesurées à 5 V pour pouvoir décaler la courbe 2, il suffit de lui appliquer cinq unités ,plus une, pour la séparation et on obtient le graphique figure quatre
.
Schéma de principe pour le câblage sur 2 entrées analogiques
.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 |
// // //************************************************ // //RedOhm //le 11/01/2020 //H-Mazelin // //Traçage de 2 valeurs analogiques sur le traceur serie //avec integration d'un offset // //IDE Arduino 1.8.10 //************************************************ // le potentiomètre, branché sur la broche analogique 0 int potentiometre1 = 0; // variable pour stocker la valeur int valeur1; // le potentiomètre, branché sur la broche analogique 0 int potentiometre2 = 1; // variable pour stocker la valeur int valeur2; // declaration de la variable en virgule flottante tension // c'est à dire des nombres à virgules. Ils sont souvent // utilisés pour la lecture des valeurs analogiques et continues float tension1; float tension2; // Un programme Arduino doit impérativement contenir la fonction "setup" // Elle ne sera exécutée une seule fois au démarrage du microcontroleur // Elle sert à configurer globalement les entrées sorties void setup() { //ouvre le port série et fixe le debit de communication à 9600 bauds Serial.begin(9600); // on attent que le port de communication soit pret while(!Serial); } //Le programme principal s’exécute par une boucle infinie appelée Loop () void loop() { // conversion de la tension de la borne 0 et transfert de la valeur // numerique dans la variable valeur1 valeur1=analogRead(potentiometre1); valeur2=analogRead(potentiometre2); // transformation de la valeur numerique en volts tension1 = valeur1 * 5.0 / 1023; tension2 = valeur2 * 5.0 / 1023; /* //Affichage de la valeur obtenue sur le moniteur de l'IDE //si tel est le cas , supprimez le mode commentaire Serial.print("Tension mesurée sur l'entrée A0 => "); //On affiche la valeur de la tension a l'aide de la variable //tension et on specifie le nombre de decimale derriere la virgule Serial.print(tension1,2); Serial.println("Volt"); //Meme manipulation pour l'entrée A1 Serial.print("Tension mesurée sur l'entrée A1 => "); Serial.print(tension2,2); Serial.println("Volt"); //Création d'un espace vide pour simplifier la lecture //sur l'ecran Serial.println(" "); //On fait une pause pour pouvoir lire la valeur sur le moniteur delay(500); */ // Integration d'un offset dans la valeur de tension2 // Pourquoi la valeur d'offset de 6 // simplement car nous avons une tension de 5 Volts et on ajoute // un espace de 1 tension2 = tension2 +6; //Affichage de la valeur mesure sur le traceur serie //si tel est le cas , supprimez le mode commentaire Serial.print(tension1); Serial.print(","); Serial.print(tension2); Serial.println(); } |
.
Traçage de 2 valeurs analogiques avec création d’un offset ( figure 4)
.
Retour au sommaire
Traçage de plusieurs signaux numériques sur le même axe |
.
Schéma de principe pour le câblage sur 2 entrées numériques
.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 |
// // //************************************************ // //RedOhm //le 13/01/2020 //H-Mazelin // //Traçage de 3 valeurs numerique sur le traceur serie //avec le code par defaut //tracage sur le meme axe // //IDE Arduino 1.8.10 //************************************************ // déclaration de l'entrée du bouton2 branché sur la broche 2 // de votre carte Arduino int bouton2 = 2; // déclaration de l'entrée du bouton4 branché sur la broche 4 // de votre carte Arduino int bouton4 = 4; // variable du type int pour stocker la valeur de passage du bouton2 int bouton2v; // variable du type int pour stocker la valeur de passage du bouton4 int bouton4v; // creation d'une variable memoire_1 int memoire_1; // -------------------------------------------------------------------- // Un programme Arduino doit impérativement contenir la fonction "setup" // Elle ne sera exécutée une seule fois au démarrage du microcontroleur // Elle sert à configurer globalement les entrées sorties // -------------------------------------------------------------------- void setup() { //ouvre le port série et fixe le debit de communication à 9600 bauds Serial.begin(9600); // on attent que le port de communication soit pret while(!Serial); // Configure la broche spécifiée pour qu'elle se comporte soit en entrée, // soit en sortie.Dans notre cas en entrée pour le bouton2 pinMode(bouton2,INPUT); // Configure la broche spécifiée pour qu'elle se comporte soit en entrée, // soit en sortie.Dans notre cas en entrée pour le bouton4 pinMode(bouton4,INPUT); } // ---------------------------------------------------------------------- // Le programme principal s’exécute par une boucle infinie appelée Loop () // ---------------------------------------------------------------------- void loop() { // lit l'état de la broche en entrée bouton2 // et met le résultat dans la variable bouton2v bouton2v = digitalRead(bouton2); // lit l'état de la broche en entrée bouton4 // et met le résultat dans la variable bouton4v bouton4v = digitalRead(bouton4); // On realise le test suivant // si le bouton2 = 1 et si le bouton4 = 1 alors on execute l'operation // suivante active la memoire1== HIGH )) if ((bouton2v == HIGH )&& (bouton4v == HIGH )) { memoire_1=1; } // sinon on maintient la memoire1 au niveau bas else { memoire_1=0; } /* Serial.print(bouton2v); Serial.print(" "); Serial.print(bouton4v); Serial.print(" "); Serial.print(memoire_1); Serial.println(" "); */ //Affichage de la valeur mesure sur le traceur serie //si tel est le cas , supprimez le mode commentaire Serial.print(bouton2v); Serial.print(","); Serial.print(bouton4v); Serial.print(","); Serial.print(memoire_1); Serial.println(); } |
.
Traçage de plusieurs signaux numériques sur le même axe (figure 5)
.
Retour au sommaire
Traçage de plusieurs signaux numériques avec offset |
.
Schéma de principe pour le câblage sur 3 entrées numériques
.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 |
// // //************************************************ // //RedOhm //le 13/01/2020 //H-Mazelin // //Traçage de 3 valeurs numeriques sur le traceur serie //avec integration d'un offset a chaque mesure // // //IDE Arduino 1.8.10 //************************************************ // déclaration de l'entrée des boutons branchés sur les broches 2,4,6 // de votre carte Arduino int bouton2 = 2; int bouton4 = 4; int bouton6 = 6; // variable du type int pour stocker les valeurs de passage du bouton2,4,6 int bouton2v; int bouton4v; int bouton6v; // creation d'une variable memoire_1 et forçage a 0 de la variable int memoire_1=0; // creation d'une memoire_2 et forçage a 0 de la variable // etat du telerupteur int memoire_2=0; // etat precedent du bouton et forçage a 0 de la variable int etat_bouton6v=0 ; // creation de la memoire servant pour le traceur serie int memoire_3=0; // -------------------------------------------------------------------- // Un programme Arduino doit impérativement contenir la fonction "setup" // Elle ne sera exécutée une seule fois au démarrage du microcontroleur // Elle sert à configurer globalement les entrées sorties // -------------------------------------------------------------------- void setup() { //ouvre le port série et fixe le debit de communication à 9600 bauds Serial.begin(9600); // on attent que le port de communication soit pret while(!Serial); // Configure la broche spécifiée pour qu'elle se comporte soit en entrée, // soit en sortie.Dans notre cas en entrée pour les bouton2,4,6 pinMode(bouton2,INPUT); pinMode(bouton4,INPUT); pinMode(bouton6,INPUT); } // ---------------------------------------------------------------------- // Le programme principal s’exécute par une boucle infinie appelée Loop () // ---------------------------------------------------------------------- void loop() { // lit l'état de la broche en entrée bouton2 // et met le résultat dans la variable bouton2v // on repete la meme instruction pour les 2 autres boutons bouton2v = digitalRead(bouton2); bouton4v = digitalRead(bouton4); bouton6v = digitalRead(bouton6); // On realise le test suivant // si le bouton2 = 1 et si le bouton4 = 1 alors on execute l'operation // suivante active la memoire1== HIGH )) // cette operation s'apparente à un et logique if ((bouton2v == HIGH )&& (bouton4v == HIGH )) { memoire_1=1; } // sinon on maintient la memoire1 au niveau bas else { memoire_1=0; } // Creation un telerupteur // Compare la variable à gauche avec la valeur ou la variable // à droite . Renvoie l'information vrai lorsque les deux // variables ne sont pas égales. if (bouton6v!=etat_bouton6v) { if (!bouton6v) { //Inversion de la valeur de la variable memoire memoire_2=!memoire_2; } //Inversion de la valeur de la variable memoire memoire_2=!memoire_2; } // operation consitant a memoriser l'anciennne valeur de la // variable etat_bouton6v=bouton6v; //======= Creation des offset pour le chronogramme ======== // // affichage de la position du bouton 2 bouton4v=bouton4v+2; // affichage de la valeur de notre operation logique et memoire_1=memoire_1+4; // affichage de l'etat du bouton du telerupteur bouton6v=bouton6v+6; // Creation de l'offset pour l'affichage de l'etat du // telerupteur if(memoire_2 == HIGH) { // affichage de la memoire a 1 memoire_3=9; } else { // affichage de la memoire a 0 memoire_3=8; } //======================================================= //======================================================= // il faut imperativement respecter l'ordre d'ecriture // pour l'affichage sur le traceur serie // //Affichage de la valeur mesure sur le traceur serie //si tel est le cas , supprimez le mode commentaire Serial.print(bouton2v); Serial.print(","); Serial.print(bouton4v); Serial.print(","); Serial.print(memoire_1); Serial.print(","); Serial.print(bouton6v); Serial.print(","); Serial.print(memoire_3); Serial.println(); } |
.
Traceur serie Arduino – arduino series plotter
..
Retour au sommaire
Tutoriel sur le traceur série |
.
Arduino traceur serie pour courbe analogique
Tutoriel sur le traceur serie en 3 etapes.Le traçage d’un signal analogique sur le traceur serie ,traçage de 2 valeurs analogiques avec superposition des courbes et enfin le traçage de 2 valeurs analogiques avec integration d’un offset
.
.
Retour au sommaire.
.
Arduino traceur serie pour la creation d un chronogramme
Ce tutoriel nous apprend à utiliser le traceur série comme un chronogramme pour signaux numériques. La première partie de ce tuto vous explique comment coder les données pour qu’elles soient exploitables sur le traceur de courbes. On voit rapidement qu’avec ce type de programmation au-delà de deux tracés pour signaux numériques cela devient vite incompréhensible. La deuxième partie du programme nous explique comment créer un offset pour décaler chaque tracé pour que l’interprétation de ces signaux soit beaucoup plus confortable. Ce qui ressemble fort à un analyseur logique ou un chronogramme. Le chronogramme est une représentation graphique de l’évolution temporelle d’un signal électrique ou d’un état numérique .
.
.
Retour au sommaire
Pour tout problème |
Pour tout problème de téléchargement ou pour nous suivre sur les réseaux sociaux voici les plateformes sur lesquelles nous éditons.
Cliquez sur celle qui vous intéresse .
.
Retour au sommaire