// Auteur du Programme : X. HINAULT – Tous droits réservés
// Programme écrit le : 5/2/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 ? ———
 /* Ce programme fait varier l’intensité d’une LED à partir
 d’une valeur reçue sur le port Série comprise entre 0 et 255.  
 La valeur pourra être reçue depuis le Terminal Série
 ou d’un contrôle réglable (slider) depuis une interface Processing.  */

// — Fonctionnalités utilisées —

// Utilise la connexion série vers le PC

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

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

// Broche 3 : Une LED et sa résistance en série connectée au 0V

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

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

const int LED=3; // Constante pour la broche 3

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

// — 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 (LED,OUTPUT); // Broche LED 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 ——-  

//—– test LED —-
digitalWrite(LED,HIGH);
delay(500);
digitalWrite(LED,LOW);

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

//— réception valeur sur port Série par fonction dédiée —

        if (Serial.available()==true)nombreReception=recevoirNombre(); // appel de la fonction recevoirNombre

        if (nombreReception!=nombreReception0) { // si un nombre a été saisi

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

          //— renvoie la valeur reçue sur le port Série – debug
          Serial.print(« Arduino a recu : « );
          Serial.println(nombreReception);

          analogWrite(LED, nombreReception); // impulsion PWM sur la broche
          nombreReception0=nombreReception; // mémorise le sernier nombre saisi

        }

} // 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 de réception valeur entière sur le port série —

long recevoirNombre() { // fonction de reception d’un nombre sur le port série

        int octetRecu=0; // variable pour octet recu
        int compt=0; // variable locale comptage caractères reçus
        boolean signe=true; // variable locale signe nombre recu
        long nombreRecu=0; // variable locale nombre recu

        while (Serial.available()>0) { // tant qu’un octet en réception

                octetRecu=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
                        break; // sort de la boucle while
                }
                else { // si le caractère reçu n’est pas un saut de ligne

                        if ((octetRecu==‘-‘) && (compt==0))signe=false; // si Octet reçu est le – et si c’est le 1er caractère reçu – signe négatif
                        compt=compt+1; // incrémente compt

                        octetRecu=octetRecu–48; // transfo valeur ASCII en valeur décimale

                        // calcul du nombre à partir des valeurs reçues

                        if ((octetRecu>=0)&&(octetRecu<=9)) nombreRecu = (nombreRecu*10)+octetRecu;

                } // fin else if

                delay(1); // pause pour laisser le temps à la fonction available de recevoir octet suivant

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

        if (signe==false) nombreRecu=nombreRecu*(–1); // prise en compte signe négatif

        return(nombreRecu); // renvoie le nombre calculé – type long

} // fin fonction recevoirNombre

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