// — 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 : 11/11/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 ? ———
 /*
    Test du shield téléinfo pour acquisition d’une trame de téléinformation
    en provenance d’un compteur EDF électronique.

    Les broches de téléinformation du compteur doivent etre connectées
    sur le bornier à vis du compteur 1 (CPT1) du shield téléinfo.
    Sens de connexion sans importance.

    Ce programme n’utilise que l’étage « téléinformation » du module,
    la carte micro-SD et le RTC ne sont pas utilisés ici.

    Note : Enlever le cavalier du shield pour programmer l’Arduino et le remettre lors exécution

    ATTENTION : ce programme envoie des messages sur le port série à différents moments selon 2 protocoles :
    > en 1200 bauds – 7 bits, parité E, bit de stop : utiliser GtkTerm (Ubuntu) ou équiv pour les visualiser
    (ces messages ne s’afficheront pas dans le Terminal Arduino)
    > en 115200 bauds, 8 bits, pas de parité, pas de bit de stop : utiliser Terminal Arduino pour les visualiser

    Selon ce que l’on veut visualiser, utiliser l’une ou l’autre solution (GtkTerm ou Terminal Arduino).

 */

// — Fonctionnalités utilisées —

// Utilise la connexion série logicielle

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

// Enficher le module téléinfo broche à broche sur la carte Arduino, ce qui donne :
// Broche 5 : Broche sélection compteur 1
// Broche 6 : Broche sélection compteur 2

// /////////////////////////////// 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 CPT1=5; // Constante pour la broche 5 – broche sélection compteur 1 du shield téléinfo
const int CPT2=6; // Constante pour la broche 6 – broche sélection compteur 2 du shield téléinfo

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

//const int Voie[6]={0,1,2,3,4,5}; //declaration constante de broche analogique

// — Déclaration des variables globales —

//– variables utiles pour la réception des trames de téléinformation
String chaineRecue=«  »; // déclare un string vide global
int comptChar=0; // variable de comptage des caractères reçus
char charIn=0; // variable de mémorisation du caractère courant en réception

int delayRecept=10; // delai en µs pour laisser temps réception caractères à 1200 bauds (débit lent…)
// on utilise delaymicroseconds dans ce programme pour les pauses afin d’éviter problème interruption avec delay()
// NB : à 1200 bauds, un caractère sur 10 bits mets théoriquement 1/120 = 8.33ms pour arriver…    

boolean debug=true; // drapeau activation messages debug

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

// ——- Broches en sorties numériques ——-  

//– compteur 1
 pinMode (CPT1,OUTPUT); // Broche CPT1 configurée en sortie
 digitalWrite (CPT1, HIGH); // sélectionne compteur 1 – LED verte s’allume

// compteur 2
pinMode (CPT2,OUTPUT); // Broche CPT2 configurée en sortie
digitalWrite (CPT2, LOW); // désélectionne compteur 2 – LED oragne éteinte

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

// ——- Codes d’initialisation utile ——-  

  initSerieTeleinfo(); // appelle fonction initialisation communication série pour téléinformation

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

   Serial.flush(); // vide le buffer série avant réception trame suivante…

   digitalWrite (CPT1,HIGH); // sélectionne CPT1 = téléinformation en provenance du compteur 1 active

   delayMicroseconds( delayRecept); // laisse caractères arriver

    //— initialisation variables réception téléinfo    
    chaineRecue=«  »; // vide le String de reception
    comptChar=0; // compteur de caractères en réception à 0
    charIn=0; // RAZ charIn

    if (debug) Serial.println(« Attente trame teleinfo »); // message debug 1200 Bauds

  //— attend caractère début de trame
  while (charIn!=0x02){ // tant que pas caractère 0x02 = attend le caractère de début de trame
    //le caractère « Start Text » STX (002 h) indique le début de la trame

      charIn = Serial.read(); // Serial.read() vide buffer au fur et à mesure  
      //Serial.print(charIn); // message debug – affiche un à un les caractères de la requete entiere reçue

      delayMicroseconds( delayRecept); // laisse caractères arriver

  } // fin while (tant que) pas caractère 0x02

  //— attente arrivée trame et messages debug —
  if (debug) Serial.println(« Caractere de debut de trame recu »); // message debug   1200 Bauds
    if (debug) Serial.println(« Suite trame en attente… »); // message debug 1200 Bauds  

  delayMicroseconds( delayRecept); // laisse caractères arriver

  while (!Serial.available()); // tant que pas donnée dispo = attend arrivée trame

  if (debug) Serial.println(« Reception de la trame en cours : »); // message debug  1200 Bauds

  delayMicroseconds( delayRecept); // laisse caractères arriver

  //— réception des caractères de la trame sur le port série —
  while (Serial.available()){ // tant que des octets sont disponibles en lecture : on lit les caractères

                char charIn = Serial.read(); // lit l’octet suivant reçu du client (pour vider le buffer au fur à mesure !)
                comptChar=comptChar+1; // incrémente le compteur de caractère reçus

                if (comptChar<=200) chaineRecue+=charIn; // ajoute le caractère reçu au String pour les N premiers caractères
                // on utilise une limite max pour éviter String trop long en cas erreur réception

                if (debug) Serial.print(charIn); // message debug 1200 Bauds – affiche la requete entiere reçue

                delayMicroseconds( delayRecept); // laisse caractères arriver

                if (charIn==0x03) break; // sort du while si le caractère de fin de trame reçu
                // le caractère « End Text » ETX (003 h) indique la fin de la trame

      } // — fin while Serial.available

     // si plus de caractères disponibles ou caractère fin reçu = la réception de la trame est terminée

     //— messages de debug
         if (debug) Serial.println(«  »); // message debug 1200 Bauds
         if (debug) Serial.println(« Reception trame teleinfo terminee « ); // message debug 1200 Bauds
         if (debug) Serial.println(«  »); // message debug 1200 Bauds

         if (debug) Serial.println(« Trame prise en compte = »); // message debug 1200 Bauds
         if (debug) Serial.println(chaineRecue); // message debug 1200 Bauds

      //—- désactivation de la réception téléinfo 1200 bauds et réinitialisation réception série Arduino 115200 bauds

      digitalWrite (CPT1,LOW); // ************ déselectionne le compteur 1 ************

      Serial.flush(); // vide le buffer série

      initSerieArduino(); // apppelle fonction qui initialise connexion série Arduino

      delay(100); // pause pour laisser temps réinitialisation

      //— messages pour Terminal Serie Arduino —

         Serial.println(«  »); // message debug Terminal Arduino
         Serial.println(« *** Reception trame teleinfo terminee *** »); // message debug Terminal Arduino
         Serial.println(«  »); // message debug Terminal Arduino

         Serial.println(« Trame prise en compte = »); // message debug Terminal Arduino
         Serial.println(chaineRecue); // message debug Terminal Arduino

     //—- réinitialise la communication série pour téléinfo

        delay(100); // pause avant initialisation

        Serial.flush(); // vide buffer série

        initSerieTeleinfo(); // appelle fonction initialisation communication série pour téléinformation

        delay(5000);   // pause entre 2 trames

//while(1); // stop loop

} // 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’initialisation de la communication série pour la téléinformation

void initSerieTeleinfo() {

   // initialisation du port série sur broches 0-1 : 1200,7,E,1 pour connexion téléinfo
        Serial.begin(1200);

        UCSR0C = B00100100; // configuration USART hardware
      // parité paire E
      // 7 bits data

    // NB : à 1200 bauds, un caractère sur 10 bits mets théoriquement 1/120 = 8.33ms pour arriver…    

} // fin initSerieTeleinfo

//— fonction d’initialisation de la communication série pour le Terminal Arduino e/o Processing

void initSerieArduino() {

      Serial.begin(115200); // réinitialise communication série
      UCSR0C = B00000110; // configuration USART hardware
      // pas parité pas bit stop
      // 8 bits data
}

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