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)
On this page... (hide) 1. Présentation
Ce programme utilise les fonctionnalités suivantes :
Ressources utiles associées à ce programme :
2. Matériel Nécessaire2.1 L'espace de développement Arduino
 2.2 Le matériel suivant pour réaliser le montage associé
 3. Instructions de montage
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 programme5.1 Structure globale du programmeCe programme simple comprend :
5.2 Déroulement du programmeLe programme se déroule de la façon suivante :
 Le déroulement du programme 6. Explication du programme
7. Mise en oeuvre du programme7.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.
7.2 Préparation du Terminal côté PC dans le logiciel Arduino
 7.3 Fonctionnement
8. Le programme complet en langage ArduinoA 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 //////////////////// |