Les fonctions mathématiques sont un outil essentiel pour les étudiants et les professionnels qui travaillent dans des domaines tels que la physique, l’ingénierie et les mathématiques. Le grapheur de fonction math sinus sur le PC est un outil pratique qui permet de tracer des courbes sinusoïdales et de les analyser. Il offre une variété de fonctionnalités qui peuvent être utilisées pour étudier et comprendre les propriétés des fonctions sinusoïdales. Dans cet article, nous examinerons en détail les fonctionnalités et les avantages du grapheur de fonction math sinus sur le PC.
Grapheur de fonction math sinus sur le PC

1. Présentation
Ce programme permet d’explorer les fonctions de calcul de la carte Arduino : on fait calculer à la carte Arduino les valeurs (600 pour être précis) de la fonction sinus qui sont envoyées par la liaison série USB vers le PC. La courbe des valeurs reçues est tracée dans une interface graphique Processing côté PC. Sur cette page, à la fois le programme Arduino et le programme Processing.
Ce programme utilise les fonctionnalités suivantes :
- la connexion série vers le PC
Voir également :
2. Matériel Nécessaire
2.1 L’espace de développement Arduino
- … pour éditer, compiler le programme et programmer la carte Arduino.

3. Instructions de montage
- Connexion série entre la carte Arduino et le PC (utilise les broches 0 et 1)
4. Le schéma théorique du montage

Le schéma théorique du montage
5. Le circuit du montage

Le schéma du montage à réaliser
6. Explication du programme Arduino
6.1 Structure globale du programme
Ce programme simple comprend :
- une entête déclarative
- une partie « configuration » qui ne sera exécutée qu’une fois (fonction setup( ) )
- une partie constituée d’une boucle sans fin que le programme répètera à l’infini ( fonction loop( ) ) : c’est le coeur du programme.
6.2 Déroulement du programme
Le programme se déroule de la façon suivante :
- Après avoir pris en compte les instructions de la partie déclarative,
- puis après avoir exécuté la partie configuration ( fonction setup( ) ),
- le programme bouclera sans fin ( fonction loop ( ) ), exécutant de façon répétée le code compris dans la boucle sans fin.

Le déroulement du programme
7. Détails du programme
- Le programme calcule 600 valeurs à l’aide de la fonction sinus. Les valeurs de sorties sont comprises entre 0 et 1023 et sont centrées sur la valeur médiane.
- Pour plus de précisions, se reporter aux commentaires présents dans le programme
8. Mise en oeuvre du programme
8.1 Fonctionnement
- Lancer l’exécution du programme processing
- Faire un reset sur la carte Arduino : le graphique apparaît.

9. Le programme complet en langage Arduino :
A copier/coller directement dans l’éditeur Arduino
// --- Programme Arduino --- // Copyright X. HINAULT - Créé le 21/08/2010 // www.mon-club-elec.fr // Code sous licence GNU GPL : // This program is free software: you can redistribute it and/or modify // it under the terms of the GNU General Public License as published by // the Free Software Foundation, either version 3 of the License, // or any later version. // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // You should have received a copy of the GNU General Public License // along with this program. If not, see <http://www.gnu.org/licenses/>. // // --- Que fait ce programme ? --- /* Envoie vers le PC des valeurs numériques issues de la fonction math sinus Affichage dans une interface graphique Processing des 600 premières valeurs reçues Valeur calculée dans une fourchette 0 / 1023 (10 bits de précision)*/ // --- Fonctionnalités utilisées --- // Utilise la connexion série vers le PC // --- Circuit à réaliser --- // Connexion série entre la carte Arduino et le PC (utilise les broches 0 et 1) //**************** Entête déclarative ******* // A ce niveau sont déclarées les librairies incluses, les constantes, les variables... // --- Inclusion des librairies utilisées --- // --- Déclaration des constantes --- const float pi=3.14159; // constante pi // --- Déclaration des variables globales --- float valeurf; // variable pour calcul du sinus int valeur; // variable pour envoi vers le PC float yf_min, yf_max, yf_base, yf; // variables pour les ordonnées float xf_min, xf_max, xf; // variables pour les abscisses float phasef; // variable de phase int y_min, y_max, y_base, y; // variables pour les ordonnées int x_min, x_max, x; // variable pour les abcisses // --- Déclaration des objets utiles pour les fonctionnalités utilisées --- //**************** FONCTION SETUP = Code d'initialisation ***** // La fonction setup() est exécutée en premier et 1 seule fois, au démarrage du programme void setup() { // debut de la fonction setup() // --- ici instructions à exécuter au démarrage --- Serial.begin(115200); // initialise connexion série à 115200 bauds // IMPORTANT : régler le terminal côté PC avec la même valeur de transmission // ------- Broches en sortie ------- // ------- Broches en entrée ------- // ------- Activation du rappel au + interne des broches en entrée si nécessaire ------- //------ initialisation des variables utilisées valeurf=0.0; valeur=0; xf_min=0.0, xf_max=600.0, xf=0.0; // pour 600 valeurs x_min=0, x_max=600, x=0; yf_min=0.0, yf_max=100.0, yf_base=yf_max/2.0, yf=0.0; // échelle des y y_min=0, y_max=100, y_base=y_max/2, y=0; //phasef=pi/2.0; phasef=0.0; } // fin de la fonction setup() // ******************************************************************************** //*************** FONCTION LOOP = Boucle sans fin = coeur du programme ************* // la fonction loop() s'exécute sans fin en boucle aussi longtemps que l'Arduino est sous tension void loop(){ // debut de la fonction loop() // --- ici instructions à exécuter par le programme principal --- for (x=x_min; x<x_max-1; x++) { // incrémente les abcisses de x_min à x_max //---- calcul de y=f(x) xf=x; // x au format float xf=xf*2.0*pi*3.0; // conversion en radians - 3 période sur toute la largeur xf=xf/xf_max; yf=sin(xf+phasef); // calcul de la fonction yf=yf*(yf_max-yf_min)/2; // adaptation à l'échelle des y yf=yf_base+yf; // centrage sur y_base yf=map(yf,yf_min,yf_max,0,1023); // renvoie valeur 0 - 1023 y=yf; // conversion au format int Serial.println(y); // envoi ordonnée vers Processing delay(10); // pause entre chaque valeur } // fin boucle for while(1); // stoppe loop } // fin de la fonction loop() - le programme recommence au début de la fonction loop sans fin // ******************************************************************************** //*************** Autres Fonctions du programme ************* // --- Fin programme ---
10. Le programme complet en langage Processing :
A copier/coller directement dans l’éditeur Processing
/* Processing code for this example // Graphing sketch // Ce programme reçoit des chaine de caractère ASCII // depuis le port Série à 115200 bauds et les affiche sous forme de courbe // dans une fourchette de 0 à 1023, // lorsque les données sont suivies d'un retour de ligne // Created 20 Apr 2005 // Updated 18 Jan 2008 // by Tom Igoe // // modifié par X. HINAULT - January 2010 - Aout 2010 // www.mon-club-elec.fr */ import processing.serial.*; Serial myPort; // Variable Port Série int xPos = 1; // variable abscisse - x int xPos0=1; // variable mémorisation xPos n-1 float yPos=1; // variable yPos - ordonnée float yPos0=1; // variable yPos n-1 void setup () { // initialise la fenêtre // size(int(screen.width*0.9), int(screen.height*0.9)); // 90% de l'écran par défaut - régler au besoin - // viser taille maxi en hauteur - taille fenêtre (x,y) size(600,405); // initialise un fenetre 600x400 // Liste tous les ports disponible et affiche le résultat println(Serial.list()); // Le port COM3 est listé avec l'indice 1 // donc j'ouvre le port Serial.list()[1]. // A adapter si votre port est différent - cf liste qui s'affiche à l'exécution myPort = new Serial(this, Serial.list()[0], 115200); // ne génère aucun évènement Série tant qu'aucun caractère saut de ligne n'est reçu myPort.bufferUntil('\n'); // initialise le fond de la fenêtre background(255);// 0 = noir - 255 = blanc } void draw () { // tout se passe dans la fonction SerialEvent car le programme reçoit des données } void serialEvent (Serial myPort) { // mémorise la chaîne de caractères reçue String inString = myPort.readStringUntil('\n'); if (inString != null) { // enlève les espaces inString = trim(inString); // convertit la chaîne en valeur numérique float inByte = float(inString); // ré-échelonne la valeur pour affichage inByte = map(inByte, 0, 1023, 0, height-10); // -10 pour affichage du 0 yPos=inByte+5; // l'ordonnée est la valeur reçue par le port série // +5 pour affichage du zero // trace la ligne stroke(0,0,255); // fixe la couleur utilisée pour le tracé en RVB line (xPos0,height-yPos0,xPos,height-yPos); // trace une ligne en tenant compte valeur reçue xPos0=xPos; // mémorisation xPos n-1 yPos0=yPos; // mémorisation xPos n-1 // à la fin de l'écran revient au début if (xPos >= width) { xPos = 0; xPos0=0; // pour retour de la trace sans ligne background(255); // 0 pour noir - 255 pour blanc... } else { // incrémente la position horizontale (abscisse) xPos++; } } }
Articles similaires:
- Test de la fonction math pow()
- Test de l’affichage des float avec Serial.print
- Afficher des résultats de fonctions mathématiques dans la fenêtre Terminal du PC.
- Tracé d’un cercle calculé par une carte Arduino
- Tracé de la courbe de la déclinaison solaire calculée par une carte Arduino
Articles Liés
- Afficher le résultat brut d'une conversion analogique-numérique dans la fenêtre Terminal du PC
L'affichage du résultat brut d'une conversion analogique-numérique dans la fenêtre Terminal du PC est une…
- Recevoir une chaine de caractères depuis le PC via le port série USB
Le port série USB est un moyen pratique et fiable de transférer des données entre…
- Ethernet en mode serveur Arduino : faire un test ping depuis le PC vers la carte Arduino
L'Ethernet est un protocole de communication réseau très populaire et largement utilisé. Il est souvent…