View  Edit  Attributes  History  Attach  Print  Search

ACCUEIL | ARDUINO > S'INSTALLER > DEBUTER > APPROFONDIR | PROCESSING | MECATRONIQUE | MATERIEL | OUTILS | TESTS | Plus...|
Python > Shell > ATELIERS Python + Qt > PyQt apps > PyQt+Arduino | Mes Robots | RepRap | Mes lib'Arduino | Mes shields Arduino | Mes distros | Les Mini-PC |
ATELIERS ARDUINO| VIDEOS | COMPRENDRE | REFERENCES | CODER | TECHNIQUE | GNU/LINUX | LIENS | Rien à voir |

Shield Téléinfo : Acquisition simple d'une trame de téléinformation en provenance d'un compteur EDF.

Par X. HINAULT - Page créée le : 16/11/2011.

(cliquer sur l'image pour agrandir)

1.  Présentation

  • Ce programme réalise un 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).

Ce programme utilise les fonctionnalités suivantes :

  • Utilise la connexion série vers le PC

Ressources utiles associées à ce programme :

2.  Matériel Nécessaire

2.1  L'espace de développement Arduino

  • ... pour éditer, compiler le programme et programmer la carte Arduino.

2.2  Le matériel suivant pour réaliser le montage associé

3.  Instructions de montage

  • La connexion série vers le PC utilise les broches 0 et 1 (via le câble USB)
  • Enficher le shield téléinfo sur la carte Arduino, ce qui crée notamment les connexions :
    • Broche 0 : la sortie série de téléinformation en provenance du compteur
    • Broche 5 : Broche de sélection du compteur EDF 1
    • Broche 6 : Broche de sélection du compteur EDF 2

4.  Le circuit du montage

Le schéma du montage à réaliser (cliquer pour agrandir)

La connexion filaire entre le compteur et l'électronique de réception de la téléinformation peut aller jusqu'à 500m !

5.  Fonctionnement du programme

5.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.

5.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

6.  Explication du programme

  • Le point "clé" de ce programme consiste à configurer l'USART de la carte Arduino pour un fonctionnement en mode 1200 bauds,7bits, parité E, bit de stop pour l'acquisition de la trame de téléinformation.
  • Ensuite, pour pouvoir afficher l'information obtenue dans le Terminal Arduino, on reconfigure l'USART de la carte Arduino pour un fonctionnement en mode 115200 bauds, 8 bits, pas de parité, pas de bit de stop.
  • On recommence l'opération à chaque passage de la fonctin loop(), ce qui permet d'acquérir une trame toutes les n secondes et de l'afficher dans le Terminal Arduino.
  • A noter qu'il est également possible de récupérer les messages reçus dans un terminal série compatible avec le mode mode 1200 bauds,7bits, parité E, bit de stop, par exemple GtkTerm sous Ubuntu.

7.  Mise en oeuvre du programme

7.1  Préparation du montage et programmation de la carte Arduino :

Il faut retirer le cavalier du shield pour programmer la carte Arduino, le shield étant en place sur la carte et il faut remettre le cavalier en mode de fonctionnement.

  • Commencer par réaliser le montage indiqué sur plaque d'expérimentation
  • Ensuite, programmer la carte Arduino avec ce programme (en bas de page) selon la procédure habituelle

7.2  Préparation du Terminal côté PC dans le logiciel Arduino

  • Côté PC, il faut ouvrir la fenêtre terminal de l'IDE Arduino : pour ce faire, un simple clic sur le bouton « Sérial Monitor ».
  • La fenêtre « Terminal » s'ouvre alors :
  • Il faut alors régler le débit de communication sur la même valeur que celle utilisée par le programme avec lequel nous allons programmer la carte Arduino :
  • Si vous utilisez un terminal série en 1200 bauds, voici un exemple de configuration avec GtkTerm sous Ubuntu :

7.3  Fonctionnement

  • Une fois le programme lancé, toutes les 5 secondes la LED verte s'allume et la led bleue clignote ce qui indique que des données sont reçues.
  • Puis la trame est affichée dans le Terminal série.

8.  Le programme complet en langage Arduino

A copier/coller directement dans l'éditeur Arduino


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