// Programme processing
// généré avec le générateur de code Processing
// www.mon-club-elec.fr
// par X. HINAULT – Mars 2011 – tous droits réservés

/////////////// Description du programme ////////////
// Utilise le port Serie
// Utilise la librairie GUI controlP5
// Utilise un/des bouton(s) simple(s) (Button)

/*
Tracé angulaire de la mesure analogique reçue par le port série depuis un capteur analogique placé sur un servomoteur.
*/

// XXXXXXXXXXXXXXXXXXXXXX ENTETE DECLARATIVE XXXXXXXXXXXXXXXXXXXXXX

// inclusion des librairies utilisées

import processing.serial.*; // importe la librairie série processing

import controlP5.*; // importe la librairie GUI controlP5
// cette librairie doit être présente dans le répertoire /libraries du répertoire Processing
// voir ici : http://www.sojamo.de/libraries/controlP5/

// déclaration objets

// — port Série —
Serial  myPort; // Création objet désignant le port série

ControlP5 controlP5; // déclare un objet principal de la librairie GUI controlP5

Button b1,b2, b3; // déclare un/des objets Button
// Button [] b= new Button[n]; // crée un tableau de n Button b[i] – 1er indice est 0

// déclaration variables globales

//—— déclaration des variables de couleur utiles —-
int jaune=color(255,255,0);
int vert=color(0,255,0);
int rouge=color(255,0,0);
int bleu=color(0,0,255);
int noir=color(0,0,0);
int blanc=color(255,255,255);
int bleuclair=color(0,255,255);
int violet=color(255,0,255);

//—- variables du programme
float xo, yo; // point référence graphique
float decalage,rayon;
float angle_radians;

float xpos, ypos, xpos0, ypos0;

boolean enCours=false; // variable témoin
int compt=0; // comptage

int mesure=0; // variable mesure

int coeff=1; // coeff tracé

// XXXXXXXXXXXXXXXXXXXXXX  Fonction SETUP XXXXXXXXXXXXXXXXXXXXXX

void setup(){ // fonction d’initialisation exécutée 1 fois au démarrage

        // —- initialisation paramètres graphiques utilisés
        colorMode(RGB, 255,255,255); // fixe format couleur R G B pour fill, stroke, etc…
        fill(0,0,255); // couleur remplissage RGB
        stroke (rouge); // couleur pourtour RGB
        rectMode(CORNER); // origine rectangle : CORNER = coin sup gauche | CENTER : centre
        imageMode(CORNER); // origine image : CORNER = coin sup gauche | CENTER : centre
        strokeWeight(0); // largeur pourtour
        frameRate(15);// Images par seconde
        smooth(); // activation lissage des formes

        // — initialisation fenêtre de base —
        size(800, 500); // ouvre une fenêtre xpixels  x ypixels
        background(0,0,0); // couleur fond fenetre

// — initialisation des objets et fonctionnalités utilisées —

        //————- initialisation port série —-
        println(Serial.list()); // affiche dans la console la liste des ports séries
        // Vérifier que le numéro du port série utilisé est le meme que celui utilisé avec  Serial.list()[index]
        myPort = new Serial(this, Serial.list()[0], 115200); // Initialise une nouvelle instance du port Série
        //myPort = new Serial(this, « /dev/ttyUSB0 », 115200); // Initialise une nouvelle instance du port Série
        myPort.bufferUntil(‘\n‘); // attendre arrivée d’un saut de ligne pour générer évènement série

        //======== Initialisation Objets GUI ControlP5 =========

        controlP5 = new ControlP5(this); // initialise l’objet principal de la librairie GUI controlP5

        // typeObjet nomObjet=controlP5.addObjet(paramètres); // pour info : déclaration / initialisation possible en 1 ligne
        // Textfield field = controlP5.addTextfield(« myWindowTextfield »,70,130,100,20); // exemple

        //======== Initialisation Objets Button =========

        //—- 1er bouton : bouton mesure —-
        // addButton(String theName, float theValue, int theX, int theY, int theW, int theH)
        b1=controlP5.addButton(« boutonMesure »,0,10,10,50,24); // initialise et ajoute un Button au ControlP5

        // méthodes propres à l’objet Button

        // méthodes communes à tous les controles (objet Controller)
        b1.setLabelVisible(true); // affichage des labels
        b1.setLabel(« Mesure »); // fixe label objet
        b1.setDecimalPrecision(2); // fixe la précision
        b1.setColorActive(color(255,0,0)); // fixe la couleur active
        b1.setColorBackground(color(255,0,255)); // fixe couleur fond  
        b1.setColorForeground(color(0,0,255)); // fixe couleur avant
        b1.setColorCaptionLabel(color(0,0,0)); // fixe couleur Label
        b1.setColorValueLabel(color(0,0,255)); // fixe la couleur valeur

        // setImages(PImage theImageDefault,PImage theImageOver, PImage theImageActive,PImage theImageHighlight)
        // les images doivent etre de la meme taille que bouton, dans rép prog, type .jpg .png ..
        // un toggle n’utilise que image Default, Over et Active
        //b1.setImages(loadImage(« imageDefault.png »),loadImage(« imageOver.png »), loadImage(« imageActive.png »),loadImage(« imageDefault.png »));

        //—— 2ème bouton – bouton Coeff —
        b2=controlP5.addButton(« boutonCoeff »,0,10,35,50,24); // initialise et ajoute un Button au ControlP5

        // méthodes communes à tous les controles (objet Controller)
        b2.setLabelVisible(true); // affichage des labels
        b2.setLabel(« Coeff x » + coeff); // fixe label objet

        //—— 3ème bouton – bouton RAZ —
        b3=controlP5.addButton(« boutonRAZ »,0,10,60,50,24); // initialise et ajoute un Button au ControlP5

        // méthodes communes à tous les controles (objet Controller)
        b3.setLabelVisible(true); // affichage des labels
        b3.setLabel(« RAZ »); // fixe label objet

    traceInitial();

} // fin fonction Setup

// XXXXXXXXXXXXXXXXXXXXXX Fonction Draw XXXXXXXXXXXXXXXXXXXX

void  draw() { // fonction exécutée en boucle

        //————- Code pour port série —-
        //  myPort.write(‘H’); // envoie le caractère sur le port Série
        // myPort.write(« chaine\n »); // envoie la chaine suivi saut ligne sur le port Série
        // Accès à la valeur des objets GUI controlP5

        //— accès à la valeur courante du Button —
        //println(« Valeur Button= « + b1.value());
        //delay(100);

        // while(true); // stoppe boucle draw

} // fin de la fonction draw()

// XXXXXXXXXXXXXXXXXXXXXX Autres Fonctions XXXXXXXXXXXXXXXXXXXXXX

        //————- Fonction de gestion des évènements série —-
         void serialEvent (Serial myPort) { // fonction appelée lors de la survenue d’un évènement série

        // ******** Gestion de la valeur reçue sur le port série : **********

                 String inString = myPort.readStringUntil(‘\n‘); // chaine stockant la chaîne reçue sur le port Série
        // saut de ligne en marque de fin

          if (inString != null) { // si la chaine recue n’est pas vide

                print(« Arduino envoie : « );
                print (inString); // affichage brut de la chaine recue
                inString = trim(inString); // enlève espace blancs de la chaine recue
                //int inByte_brut=int(inString); // conversion valeur reçue en valeur numérique entiere
                //float inByte = float(inString); // conversion valeur reçue en valeur numérique décimale

                //—- analyse chane reçue —

                if (match(inString,« resultatCan »)!=null) { // si la chaine reçue contient « mesure »

                  String testString[]=split(inString,« = »); // utilisé pour analyser string en réception
                  mesure=int(testString[1]);
                  println (« Valeur= »+mesure); // affiche valeur reçue

                if (enCours==true) { // si comptage en cours

                  compt=compt+1; // incrémente compt

                  if (compt<=9) { // de 0 à 9
                    // envoi angle 00compt
                    myPort.write(« servo(00 »+str(compt)+« )\n« ); // envoie la chaine suivi saut ligne sur le port Série
                    println(« Chaine envoyée : servo(00 »+str(compt)+« )\n« );
                  } // fin if compt <10

                 if ((compt>9) && (compt<100)) { // si compt entre 10 et 99
                    // envoi angle 0compt
                    myPort.write(« servo(0 »+str(compt)+« )\n« ); // envoie la chaine suivi saut ligne sur le port Série
                    println(« Chaine envoyée : servo(0 »+str(compt)+« )\n« );
                  } // fin if compt entre 10 et 100

                 if ((compt>99) && (compt<=180)) { // si compt entre 100 et 180
                    // envoi angle compt
                    myPort.write(« servo(« +str(compt)+« )\n« ); // envoie la chaine suivi saut ligne sur le port Série
                    println(« Chaine envoyée : servo(« +str(compt)+« )\n« );
                  } // fin if compt entre 100 et 180

                  //—– trace le point en cours
                  stroke (jaune); // couleur pourtour RGB

                  angle_radians=radians(compt);

                 //—- coordonnées point courant
                 xpos=xo+(cos(angle_radians)*rayon*mesure/1024*coeff);
                 ypos=yo–(sin(angle_radians)*rayon*mesure/1024*coeff);
                 line(xpos0, ypos0, xpos,ypos);  

          //— mémorise point courant
          xpos0=xpos;
          ypos0=ypos;

                  if (compt==180) {
                    enCours=false; // stoppe comptage

                     // envoi angle 000
                     myPort.write(« servo(000)\n« ); // envoie la chaine suivi saut ligne sur le port Série
                     println(« Chaine envoyée = » + « servo(000)\n« );

                  }// fin si compt==180

                }//fin si en cours  

         } // fin si match mesureCan

        } // fin condition chaine recue pas vide

} // fin de la fonction de gestion des évènements Série

// Gestion des évènements des objets GUI controlP5 —-

//—— fonction gestion globale des évènements GUI controlP5
public void controlEvent(ControlEvent theEvent) {
        //println(theEvent.controller().name());// affiche le nom de l’évènement
}

// —— gestion évènement Button ——
void boutonMesure(int theValue) { // fonction évènement Button de meme nom – reçoit la valeur
        println(« Evènement Bouton Mesure avec valeur = « +theValue);

        compt=0;
        enCours=true;

         // envoi angle 000
         myPort.write(« servo(000)\n« ); // envoie la chaine suivi saut ligne sur le port Série
         println(« Chaine envoyée = » + « servo(000)\n« );

} // fin bouton mesure

void boutonCoeff(int theValue) { // fonction évènement Button de meme nom – reçoit la valeur
        println(« Evènement Bouton Coeff avec valeur = « +theValue);

       coeff=coeff+1;
       if (coeff>5) coeff=1; // RAZ Coeff 1 à 5

       b2.setLabel(« Coeff x » + coeff); // fixe label objet

} // fin bouton mesure

void boutonRAZ(int theValue) { // fonction évènement Button de meme nom – reçoit la valeur
        println(« Evènement Bouton RAZ avec valeur = « +theValue);

       if (enCours==false)traceInitial(); // efface tracé en cours et retrace tracé initial si pas mesure en Cours

} // fin bouton mesure
void traceInitial() { // fonction de tracé initial

// tracé initial du graphe

        background(0,0,0); // couleur fond fenetre
        fill(noir); // couleur remplissage RGB
        stroke (vert); // couleur pourtour RGB
        strokeWeight(1); // largeur pourtour

        decalage=(width*0.1);
        rayon=((width–decalage)/2);
        xo=decalage+rayon–5; // point x de référence du graphique
        yo=height–5; // point y de référence du graphe

        rect(xo, yo, 1,1);

        // tracé des arcs de cercle voltage 0 à 5V

        for (int i=5; i>=1; i—) {

         //arc(x, y, width, height, start, stop)

        arc(xo,yo,rayon*2*0.2*i,rayon*2*0.2*i,PI,TWO_PI);          
        }

        // tracé des rayons angulaires tous les 10°
        for (int angle=0; angle<=18; angle++) { // défile de 0 à 180 degres

          angle_radians=radians(angle*10);
          line (xo,yo,xo+(cos(angle_radians)*rayon),yo–(sin(angle_radians)*rayon));  

        }

        // tracé de la courbe

        //— point n-1 initial
        xpos0=xo;
        ypos0=yo;

        /* code test trace – debug
        for (int angle=0; angle<=180; angle++) { // défile de 0 à 180 degres

          stroke (jaune); // couleur pourtour RGB

          angle_radians=radians(angle);
          //rect(xo+(cos(angle_radians)*rayon/2),yo-(sin(angle_radians)*rayon/2),1,1);  

          //—- coordonnées point courant
          xpos=xo+(cos(angle_radians)*rayon/2);
          ypos=yo-(sin(angle_radians)*rayon/2);
          line(xpos0, ypos0, xpos,ypos);  

          //— mémorise point courant
          xpos0=xpos;
          ypos0=ypos;

        }
       */
}

//XXXXXXXXXXXXXXXXXX Fin du programme XXXXXXXXXXXXXXXXX