// — Programme Arduino —
// Trame de code générée par le générateur de code Arduino
// du site www.mon-club-elec.fr

// Auteur du Programme : X. HINAULT – Tous droits réservés
// Programme écrit le : 15/3/2011.

// ——- Licence du code de ce programme —–
//  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/>.

// ////////////////////  PRESENTATION DU PROGRAMME ////////////////////

// ——– Que fait ce programme ? ———
 /* La carte Arduino reçoit sur le port Série les valeurs respectives
 pour les couleurs Rouge Vert Bleu à utiliser pour le ruban RGB.
Le ruban RGB est directement controlé via 3 broches PWM  via un simple
CI ULN2803 pour assurer l’amplification de puissance et l’adaptation en tension.  */

// — Fonctionnalités utilisées —

// Utilise la connexion série vers le PC
// Utilise / fonctionne avec une interface Processing coté PC
// Utilise un ruban à LED RGB

// ——– Circuit à réaliser ———

// La connexion série vers le PC utilise les broches 0 et 1 (via le câble USB)

// Broche 3 : La broche Vert du ruban LED RGB via ULN 2803 ou équiv
// Broche 5 : La broche Rouge du ruban LED RGB via ULN 2803 ou équiv
// Broche 6 : La broche Bleu du ruban LED RGB via ULN 2803 ou équiv

// /////////////////////////////// 1. Entête déclarative ///////////////////////
// A ce niveau sont déclarées les librairies incluses, les constantes, les variables, les objets utiles…

// — Déclaration des constantes —

// — Inclusion des librairies —

// — Déclaration des constantes utiles —

const int R=1;
const int V=1;
const int B=1;

// — Déclaration des constantes des broches E/S numériques —

const int ledVert=3; // Constante pour la broche 3
const int ledRouge=5; // Constante pour la broche 5
const int ledBleu=6; // Constante pour la broche 6

// — Déclaration des constantes des broches analogiques —

// — Déclaration des variables globales —

int octetReception=0; // variable de stockage des valeurs reçues sur le port Série
long nombreReception=0; // variable de stockage du nombre  reçu sur le port Série
long nombreReception0=0; // variable de stockage du dernier nombre  reçu sur le port Série
String chaineReception=«  »; // déclare un objet String vide pour reception chaine

int impulsionRouge=0; // variable pour impulsion ROuge
int impulsionVert=0; // variable pour impulsion ROuge
int impulsionBleu=0; // variable pour impulsion ROuge

// — Déclaration des objets utiles pour les fonctionnalités utilisées —

// ////////////////////////// 2. 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 1 seule fois au démarrage du programme —

// ——- Initialisation fonctionnalités utilisées ——-  

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 sorties numériques ——-  
 pinMode (ledVert,OUTPUT); // Broche ledVert configurée en sortie
 pinMode (ledRouge,OUTPUT); // Broche ledRouge configurée en sortie
 pinMode (ledBleu,OUTPUT); // Broche ledBleu configurée en sortie

// ——- Broches en entrées numériques ——-  

// ——- Activation si besoin du rappel au + (pullup) des broches en entrées numériques ——-  

// ——- Initialisation des variables utilisées ——-  

} // fin de la fonction setup()
// ********************************************************************************

////////////////////////////////// 3. 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 —

//—- code type réception chaine sur le port série —
while (Serial.available()>0) { // tant qu’un octet en réception

        octetReception=Serial.read(); // Lit le 1er octet reçu et le met dans la variable

        if (octetReception==10) { // si Octet reçu est le saut de ligne
                Serial.println (« Chaine recue= »+chaineReception); // affiche la chaine recue

                chaineReception.trim(); // enlève espaces
                analyseChaine(chaineReception); // appelle la fonction d’analyse de la chaine en réception

                break; // sort de la boucle while
        }
        else { // si le caractère reçu n’est pas un saut de ligne
                chaineReception=chaineReception+char(octetReception); // ajoute le caratère au String
        }

} // fin tant que  octet réception

//—– une fois que le saut de ligne est reçu, on sort du While et on se positionne ici

chaineReception=«  »; //RAZ le String de réception

} // fin de la fonction loop() – le programme recommence au début de la fonction loop sans fin
// ********************************************************************************

// ////////////////////////// FONCTIONS DE GESTION DES INTERRUPTIONS ////////////////////

// ////////////////////////// AUTRES FONCTIONS DU PROGRAMME ////////////////////

//————- fonction d’analyse de la chaine reçue sur le port série —-

void analyseChaine(String chaineRecue) { // fonction d’analyse de la chaine recue

        //— variables locales
        int valeur=0; // variable utile
        String chaineTest=«  »; // objet STring pour analyse chaine recue

  // >>>>>>>>>>>>>>>>>>>>>>>>>>>> si débute par Rouge <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<

  if (chaineRecue.startsWith(« Rouge »)) { // si la chaine débute par « chaine »

   chaineTest=chaineRecue.substring(String(« Rouge »).length(),chaineRecue.length()); // extraction des derniers caractères – le 1er est à index=0
   Serial.println(chaineTest); // debug

   // récupération du nombre à partir chaine caractère
   impulsionRouge=stringToLong(chaineTest); // récupère valeur numérique chaine

   impulsionRouge=constrain(impulsionRouge,0,255); // oblige valeur entre 0 et 255

   Serial.print (« Rouge = « ), Serial.println(impulsionRouge); //debug

   ledRVBpwm(impulsionRouge,impulsionVert,impulsionBleu); // génère impulsion largeur voulue pour les couleurs

  } // fin débute avec « Rouge »

  // >>>>>>>>>>>>>>>>>>>>>> si débute par Vert <<<<<<<<<<<<<<<<<<<<<<<<<<<<<

  if (chaineRecue.startsWith(« Vert »)) { // si la chaine débute par « chaine »

   chaineTest=chaineRecue.substring(String(« Vert »).length(),chaineRecue.length()); // extraction des derniers caractères – le 1er est à index=0
   Serial.println(chaineTest); // debug

   // récupération du nombre à partir chaine caractère
   impulsionVert=stringToLong(chaineTest); // récupère valeur numérique chaine

   impulsionVert=constrain(impulsionVert,0,255); // oblige valeur entre 0 et 255

   Serial.print (« Vert = « ), Serial.println(impulsionVert); //debug

   ledRVBpwm(impulsionRouge,impulsionVert,impulsionBleu); // génère impulsion largeur voulue pour les couleurs

  } // fin débute avec « Vert »

  // >>>>>>>>>>>>>>>>>>>>>>>>>>> si débute par Rouge <<<<<<<<<<<<<<<<<<<<<<<<<

  if (chaineRecue.startsWith(« Bleu »)) { // si la chaine débute par « chaine »

   chaineTest=chaineRecue.substring(String(« Bleu »).length(),chaineRecue.length()); // extraction des derniers caractères – le 1er est à index=0
   Serial.println(chaineTest); // debug

   // récupération du nombre à partir chaine caractère
   impulsionBleu=stringToLong(chaineTest); // récupère valeur numérique chaine

   impulsionBleu=constrain(impulsionBleu,0,255); // oblige valeur entre 0 et 255

   Serial.print (« Bleu = « ), Serial.println(impulsionBleu); //debug

   ledRVBpwm(impulsionRouge,impulsionVert,impulsionBleu); // génère impulsion largeur voulue pour la couleur

  } // fin débute avec « Rouge »

} // fin fonction analyse chaine

// ———- fonction de conversion d’un String numérique en long

long stringToLong(String chaineLong) { // fonction conversion valeur numérique String en int

    long nombreLong=0; // variable locale
    int valeurInt=0; // variable locale

    for (int i=0; i<chaineLong.length(); i++) { // défile caractères de la chaine numérique

      valeurInt=chaineLong.charAt(i); // extrait le caractère ASCII à la position voulue – index 0 est le 1er caractère
      valeurInt=valeurInt–48; // obtient la valeur décimale à partir de la valeur ASCII  

     // Serial.println (valeurInt); // debug

     if (valeurInt>=0 && valeurInt<=9) { // si caractère est entre 0 et 9
       nombreLong=(nombreLong*10)+valeurInt;
     } // fin si caractère est entre 0 et 9

    } // fin for défile caractères

 return (nombreLong); // renvoie valeur numérique

} // fin stringToLong

//—- fonction pour variation progressive des couleurs sur ruban Leds RGB —-

void ledRVBpwm(int pwmRouge, int pwmVert, int pwmBleu) { // reçoit valeur 0-255 par couleur

 analogWrite(ledRouge, pwmRouge); // impulsion largeur voulue sur la broche 0 = 0% et 255 = 100% haut
 analogWrite(ledVert, pwmVert); // impulsion largeur voulue sur la broche 0 = 0% et 255 = 100% haut
 analogWrite(ledBleu, pwmBleu); // impulsion largeur voulue sur la broche 0 = 0% et 255 = 100% haut

} // fin fonction RGB pwm

// ////////////////////////// Fin du programme ////////////////////