Arduino Le traceur série

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

//
//
// 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);
}

// 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 Arduino^TM Nano, ce qui la rend compatible avec la plupart des programmes et de l’IDE Arduino^TM.

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 Arduino^TM. Le contrôleur ATMega328 contient un bootloader qui permet de modifier le programme sans passer par un programmateur.

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

//
//
//************************************************
//
//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();

}

//************************************************

//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

Retour au sommaire

Traçage de 2 valeurs analogiques sur le traceur serie
avec superposition des courbes

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

//
//
//************************************************
//
//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();




}

//************************************************

//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
avec integration d’un offset

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

//
//
//************************************************
//
//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();

}

//************************************************

//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

//
//
//************************************************
//
//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();
  
}

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

//
//
//************************************************
//
//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();


}

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 .

Facebook Twitter Youtube

Retour au sommaire