Le Shield Téléinfo est un dispositif innovant qui permet une acquisition simple et rapide d’une trame de téléinformation en provenance d’un compteur EDF. Il s’agit d’un outil pratique et intuitif qui permet aux utilisateurs de collecter des données à partir de leur compteur EDF et de les analyser pour en tirer des informations utiles. Ce dispositif est particulièrement utile pour les professionnels qui souhaitent surveiller leurs consommations d’énergie et optimiser leurs performances. Dans cet article, nous allons examiner en détail le Shield Téléinfo et ses avantages pour les utilisateurs.
Shield Téléinfo : Acquisition simple d’une trame de téléinformation en provenance d’un compteur EDF.
(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 :
- La librairie Serial – pour les communications séries entre la carte Arduino et l’ordinateur ou d’autres composants
- Shield Arduino « TéléInfo » pour Monitoring et datalogging de 1 à 2 compteurs EDF, par www.carteletronic.fr
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é
- Un shield Arduino « TéléInfo » pour Monitoring et datalogging de 1 à 2 compteurs EDF, par www.carteletronic.fr
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
// 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 ////////////////////
Articles similaires:
- http://web.archive.org/web/20210804223007/http://www.mon-club-elec.fr/pmwiki_mon_club_elec/pmwiki.php?n=MAIN.ATELIERSSerieEnvoiPCVersArduino
- http://web.archive.org/web/20210804223007/http://www.mon-club-elec.fr/pmwiki_mon_club_elec/pmwiki.php?n=MAIN.ATELIERSSerieAfficheMessageTerminal
- http://web.archive.org/web/20210804223007/http://www.mon-club-elec.fr/pmwiki_mon_club_elec/pmwiki.php?n=MAIN.ATELIERSSerieEnvoiPCVersArduinoProcessing
- Allumer une LED à partir d’une chaine avec paramètre reçue sur le port Série
- Afficher du texte dans la fenêtre Terminal du PC
Articles Liés
- Mesure analogique à distance (télémétrie) multivoies à partir d'une carte Arduino "serveur" via deux interfaces Processing Client/Serveur sur 2 PC connectés en réseau wifi.
La télémétrie est une technologie qui permet de mesurer des données à distance. Elle est…
- Mesure d'une intensité à l'aide du capteur de courant +/-5A ACS714 (affichage graphique Processing)
La mesure d'une intensité est une tâche importante pour de nombreuses applications industrielles et domestiques.…
- Réaliser la mesure angulaire de la réponse d'un capteur analogique
La mesure angulaire de la réponse d'un capteur analogique est une tâche complexe qui nécessite…