Log in Register

Login to your account

Username
Password *
Remember Me

Create an account

Fields marked with an asterisk (*) are required.
Name
Username
Password *
Verify password *
Email *
Verify email *
Captcha *
Welcome, Guest
Username: Password: Remember me

TOPIC: teleinfo arduino

teleinfo arduino 22 Feb 2013 09:36 #1

bonjour,
je suis en cour de realisation d'un recepteur teleinfo avec une arduino ethernet pour envoie des données sur domogik par xpl.
j'ai bien mes info du compteur quand je suis en direct sur mon pc (en serie) mais par contre en reseau pas d'envoie de messages xpl.
je vous joint les fichiers pour une eventuelle aide.
merci
mael
  • mael22
  • Nophoto
  • OFFLINE
  • Fresh Boarder
  • Rank0
  • Posts: 9
  • Karma: 0
The administrator has disabled public write access.

teleinfo arduino 22 Feb 2013 09:41 #2

Hello,

ça va être difficile de t'aider, je ne vois pas les fichiers que tu évoques. Si je comprends bien ton arduino est censé envoyer du XPL, quelle est ta configuration matérielle, et d'où provient ton code de génération du XPL?
  • Frunk
  • Avatar 2013 01 08
  • OFFLINE
  • Administrateur
  • Administrateur
  • Posts: 70
  • Thank you received: 1
  • Karma: 1
The administrator has disabled public write access.

teleinfo arduino 22 Feb 2013 14:48 #3

desolé je n'avais pas vu qu'il manquait les fichiers.
ils viennent du blog de cquad que j'ai modifier pour mon installation.
voici le premier
 
#include <SPI.h>         // needed for Arduino versionslater than 0018
#include <Ethernet.h>
#include <EthernetUdp.h>
#include <SoftwareSerial.h>

// Arduino led
#define LEDPIN 9
/***************** Network configuration ********************/
 
/*
ADCO 020928712433 @
 
OPTARIF BASE <
 
ISOUSC 45 ?
 
BASE 012345678 4
 
PTEC TH S
 
IINST1 018 J
 
IINST2 018 J
 
IINST3 018 J
 
IMAX1 047 J
 
IMAX2 047 J
 
IMAX3 047 J
 
PMAX 01234 4
 
PAPP 04130 )
 
MOTDETAT 000000 B
 
PPOT 00 #
 
 
*/
 
 
// Mac address : a mac address must be unique
byte mac[] = {0x90, 0xA2, 0xDA, 0x0D, 0x9F, 0xA5};
// IP address : the value will depend on your network
IPAddress ip(192, 168, 0, 22);
char myIPAdress[]="192.168.0.22";
// Broadcat address's first three elements should be the same than ip. The last should be 255.
byte broadCastIp[] = {192, 168, 0, 255};
// Udp local port used (any value you want between 1024 and 65536)
unsigned int localPort = 3865;  
// xPL protocol port (keep default value unless you know what you are doing)
unsigned int xplPort = 3865;  
 
/***************** xPL configuration part *******************/
 
// Source. Format is <vendor id>-<device id>.<instance>
 
// Vendor id and device id should not be changed
// Instance should be the location of your arduino and RGB led strip : living, bedroom, etc
// Instance should only use letters or numbers! (no underscore, ...)
#define MY_SOURCE "arduino-teleinfo.compteur"

// Name of device in body of xpl message
// This should be the same as previously defined instance
#define MY_DEVICE "compteur"

// Maximal size of xPL messages that could be processed
// This size should not be reduce unless you are sure of what you are doing
#define MAX_XPL_MESSAGE_SIZE 200

// Heartbeat interval : time in minutes between 2 sends of a xpl hbeat message
#define HBEAT_INTERVAL 5

// Duration of a minute in seconds (to allow shorter delay in dev)
#define MINUTE 2

// Teleinfo interval : time in minutes between 2 sends of a xpl stat message
#define TELEINFO_INTERVAL 1

/***************** Teleinfo configuration part *******************/
char CaractereRecu ='\0';
char Checksum[32] = "";
char Ligne[32]="";
char Etiquette[9] = "";
char Donnee[13] = "";
char Trame[512] ="";
int i = 0;
int j = 0;
 
unsigned long Chrono = 0;
unsigned long LastChrono = 0;
 
char ADCO[12] ;      // Adresse du concentrateur de téléreport (numéro de série du compteur), 12 numériques + \0
char OPTARIF[4] ;    // Option tarifaire choisie, 4 alphanumériques (BASE => Option Base, HC.. => Option Heures Creuses, EJP. => Option EJP, BBRx => Option Tempo [x selon contacts auxiliaires])
int ISOUSC = 0;    // Intensité souscrite, 2 numériques, A
long BASE = 0;      // Index option tarif 8 numériques, Wh
char PTEC[4] ;      // Période Tarifaire en cours, 4 alphanumériques
int IINST1 = 0;     // Triphasé Phase1 - Intensité Instantanée, 3 numériques, A  (intensité efficace instantanée)
int IINST2 = 0;     // Triphasé Phase2 - Intensité Instantanée, 3 numériques, A  (intensité efficace instantanée)
int IINST3 = 0;     // Triphasé Phase3 - Intensité Instantanée, 3 numériques, A  (intensité efficace instantanée)
long PAPP = 0;      // Puissance apparente, 5 numérique, VA (arrondie à la dizaine la plus proche)
long PMAX = 0;      // Puissance max, 5 numérique, VA (arrondie à la dizaine la plus proche)
long IMAX1 = 0;      // Triphasé Phase1 - Intensité maximale appelée, 3 numériques, A
long IMAX2 = 0;      // Triphasé Phase2 - Intensité maximale appelée, 3 numériques, A
long IMAX3 = 0;      // Triphasé Phase3 - Intensité maximale appelée, 3 numériques, A
char MOTDETAT[10] = "";  // Mot d'état du compteur, 10 alphanumériques
long PPOT = 0;      // Presence des potentiels
 
int check[15];  // Checksum by etiquette 15
int trame_ok = 1; // global trame checksum flag
int finTrame=0;
/******************* END OF CONFIGURATION *******************/
 
 
/********************* time management **********************/
 
int second = 0;
int lastTimeHbeat = 0;
int lastTimeTeleinfo = 0;
 
/*********************** Global vars ************************/
 
// UDP related vars
EthernetUDP Udp;
SoftwareSerial cptSerial(2, 3);
 
int packetSize = 0;      // received packet's size
byte remoteIp[4];        // received packet's IP
unsigned int remotePort; // received packet's port
byte packetBuffer[MAX_XPL_MESSAGE_SIZE];   // place to store received packet
 
// status
int result;
 
/******************** Set up arduino ***********************/
void setup() {
 
 
    pinMode(LEDPIN, OUTPUT);     
 
    // Serial to EDF cpt
    cptSerial.begin(1200);
    Serial.begin(115200);
 
    // Ethernet initialisation
    Ethernet.begin(mac, ip);
    Udp.begin(localPort);
 
    // Send a hbeat message on startup
    sendHbeat();
    digitalWrite(LEDPIN, LOW);
}
 
void loop() {
  // pulse management 
  pulse();
 
  if (second == 1) {
 
       // Hbeat action
        lastTimeHbeat += 1;
        // Each N minute, send a hbeat xpl message
        if (lastTimeHbeat == (MINUTE*HBEAT_INTERVAL)) {
            sendHbeat();
            lastTimeHbeat = 0;
        } 
 
        // send teleinfo stat
        lastTimeTeleinfo += 1;
        // Each N minute, get teleinfo
        if (lastTimeTeleinfo == (MINUTE*TELEINFO_INTERVAL)) { 
            digitalWrite(LEDPIN, HIGH);
            getTeleinfo();
            digitalWrite(LEDPIN, LOW);
            sendTeleinfoBasic();
            lastTimeTeleinfo = 0;
        }        
   }
 
}
 
 
/*------------------------------------------------------------------------------*/
/* Test checksum d'un message (Return 1 si checkum ok)				*/
/*------------------------------------------------------------------------------*/
int checksum_ok(char *etiquette, char *valeur, char checksum) 
{
	unsigned char sum = 32 ;		// Somme des codes ASCII du message + un espace
	int i ;
 
	for (i=0; i < strlen(etiquette); i++) sum = sum + etiquette[i] ;
	for (i=0; i < strlen(valeur); i++) sum = sum + valeur[i] ;
	sum = (sum & 63) + 32 ;
        Serial.print(etiquette);Serial.print(" ");
        Serial.print(valeur);Serial.print(" ");
	Serial.println(checksum);
	Serial.print("Sum = "); Serial.println(sum);
	Serial.print("Cheksum = "); Serial.println(int(checksum));
	if ( sum == checksum) return 1 ;	// Return 1 si checkum ok.
	return 0 ;
}
 
/***********************************************
   getTeleinfo
   Decode Teleinfo from serial
   Input : n/a
   Output : n/a
***********************************************/
void getTeleinfo() {
 
  /* vider les infos de la dernière trame lue */
  memset(Ligne,'\0',32); 
  memset(Trame,'\0',512);
  int trameComplete=0;
 
  memset(ADCO,'\0',12);
  memset(OPTARIF,'\0',4);
  ISOUSC = 0;
  BASE = 0;
  memset(PTEC,'\0',4);
  IINST1 = 0; //en Triphasé phase1
  IINST2 = 0; //en Triphasé phase2
  IINST3 = 0; //en Triphasé phase3
  IMAX1 = 0; //en Triphasé phase1
  IMAX2 = 0; //en Triphasé phase2
  IMAX3 = 0; //en Triphasé phase3
  PMAX = 0;
  PAPP = 0;
  memset(MOTDETAT,'\0',10);
  PPOT = 0;
 
  while (!trameComplete){
    while(CaractereRecu != 0x02) // boucle jusqu'a "Start Text 002" début de la trame
    {
       if (cptSerial.available()) {
         CaractereRecu = cptSerial.read() & 0x7F;
       }
    }
 
    i=0; 
    while(CaractereRecu != 0x03) // || !trame_ok ) // Tant qu'on est pas arrivé à "EndText 003" Fin de trame ou que la trame est incomplète
    { 
      if (cptSerial.available()) {
          CaractereRecu = cptSerial.read() & 0x7F;
  	  Trame[i++]=CaractereRecu;
      }	
    }
    finTrame = i;
    Trame[i++]='\0';
 
    Serial.println(Trame);
 
    lireTrame(Trame);	
 
    // on vérifie si on a une trame complète ou non
    for (i=0; i<15; i++) {
      trameComplete+=check[i];
    }
    Serial.print("Nb lignes valides :"); Serial.println(trameComplete);
    if (trameComplete < 15) trameComplete=0; // on a pas les 15 valeurs, il faut lire la trame suivante
    else trameComplete = 1;
  }
}
 
void lireTrame(char *trame){
    int i;
    int j=0;
    for (i=0; i < strlen(trame); i++){
      if (trame[i] != 0x0D) { // Tant qu'on est pas au CR, c'est qu'on est sur une ligne du groupe
          Ligne[j++]=trame[i];
      }
      else { //On vient de finir de lire une ligne, on la décode (récupération de l'etiquette + valeur + controle checksum
          decodeLigne(Ligne);
          memset(Ligne,'\0',32); // on vide la ligne pour la lecture suivante
          j=0;
      }
 
   }
}
 
int decodeLigne(char *ligne){ 
 
 
 
  //Checksum='\0';
 
  int debutValeur; 
  int debutChecksum;
  // Décomposer en fonction pour lire l'étiquette etc ...  
  debutValeur=lireEtiquette(ligne);
  debutChecksum=lireValeur(ligne, debutValeur);
  lireChecksum(ligne,debutValeur + debutChecksum -1);
 
  if (checksum_ok(Etiquette, Donnee, Checksum[0])){ // si la ligne est correcte (checksum ok) on affecte la valeur à l'étiquette
    return affecteEtiquette(Etiquette,Donnee);
  } 
  else return 0;
 
}
 
 
int lireEtiquette(char *ligne){
    int i;
    int j=0;
    memset(Etiquette,'\0',9);
    for (i=1; i < strlen(ligne); i++){ 
      if (ligne[i] != 0x20) { // Tant qu'on est pas au SP, c'est qu'on est sur l'étiquette
          Etiquette[j++]=ligne[i];
      }
      else { //On vient de finir de lire une etiquette
	//  Serial.print("Etiquette : ");
        //  Serial.println(Etiquette);
          return j+2; // on est sur le dernier caractère de l'etiquette, il faut passer l'espace aussi (donc +2) pour arriver à la valeur
      }
 
   }
}
 
 
int lireValeur(char *ligne, int offset){
    int i;
    int j=0;
    memset(Donnee,'\0',13);
    for (i=offset; i < strlen(ligne); i++){ 
      if (ligne[i] != 0x20) { // Tant qu'on est pas au SP, c'est qu'on est sur l'étiquette
          Donnee[j++]=ligne[i];
      }
      else { //On vient de finir de lire une etiquette
	//  Serial.print("Valeur : ");
        //  Serial.println(Donnee);
          return j+2; // on est sur le dernier caractère de la valeur, il faut passer l'espace aussi (donc +2) pour arriver à la valeur
      }
 
   }
}
 
 
void lireChecksum(char *ligne, int offset){
    int i;
    int j=0;
    memset(Checksum,'\0',32);
    for (i=offset; i < strlen(ligne); i++){ 
          Checksum[j++]=ligne[i];
	//  Serial.print("Chekcsum : ");
        //  Serial.println(Checksum);
      }
 
}
 
 
 
 
int affecteEtiquette(char *etiquette, char *valeur){
 
 if(strcmp(etiquette,"ADCO") == 0) { memset(ADCO,'\0',12); memcpy(ADCO, valeur,strlen(valeur)); check[1]=1; 
   Serial.print("ADCO="); Serial.println(ADCO);
   Serial.print("valeur="); Serial.println(valeur);
 }
  else
 if(strcmp(Etiquette,"OPTARIF") == 0) { memset(OPTARIF,'\0',4); memcpy(OPTARIF, valeur,strlen(valeur)); check[2]=1;
   Serial.print("OPTARIF="); Serial.println(OPTARIF);
   Serial.print("valeur="); Serial.println(valeur); 
 }
 else
 if(strcmp(Etiquette,"ISOUSC") == 0) { ISOUSC = atoi(valeur); check[3]=1;
   Serial.print("ISOUSC="); Serial.println(ISOUSC);
   Serial.print("valeur="); Serial.println(valeur);
 }  
 else
 if(strcmp(etiquette,"BASE") == 0) { BASE = atol(valeur); check[4]=1;
   Serial.print("BASE="); Serial.println(BASE);
   Serial.print("valeur="); Serial.println(valeur);
 }
 else
 if(strcmp(etiquette,"PTEC") == 0) { memset(PTEC,'\0',4); memcpy(PTEC, valeur,strlen(valeur)); check[5]=1;
   Serial.print("PTEC="); Serial.println(PTEC);
   Serial.print("valeur="); Serial.println(valeur);
 }
 else //en Triphasé phase1
 if(strcmp(Etiquette,"IINST1") == 0) { IINST1 = atoi(valeur); check[6]=1;
   Serial.print("IINST1="); Serial.println(IINST1);
   Serial.print("valeur="); Serial.println(valeur);
 }
 else //en Triphasé phase2
  if(strcmp(Etiquette,"IINST2") == 0) { IINST2 = atoi(valeur); check[7]=1;
   Serial.print("IINST2="); Serial.println(IINST2);
   Serial.print("valeur="); Serial.println(valeur);
 }
 else //en Triphasé phase3
 if(strcmp(Etiquette,"IINST3") == 0) { IINST3 = atoi(valeur); check[8]=1;
   Serial.print("IINST3="); Serial.println(IINST3);
   Serial.print("valeur="); Serial.println(valeur);
 }
 else //en Triphasé phase1
 if(strcmp(Etiquette,"IMAX1") == 0) { IMAX1 = atol(valeur); check[9]=1;
   Serial.print("IMAX1="); Serial.println(IMAX1);
   Serial.print("valeur="); Serial.println(valeur);
 } 
   else //en Triphasé phase2
 if(strcmp(Etiquette,"IMAX2") == 0) { IMAX2 = atol(valeur); check[10]=1;
   Serial.print("IMAX2="); Serial.println(IMAX2);
   Serial.print("valeur="); Serial.println(valeur); 
 } 
   else //en Triphasé phase3
 if(strcmp(Etiquette,"IMAX3") == 0) { IMAX3 = atol(valeur); check[11]=1;
   Serial.print("IMAX3="); Serial.println(IMAX3);
   Serial.print("valeur="); Serial.println(valeur);
 }
 else
 if(strcmp(Etiquette,"PMAX") == 0) { PMAX = atol(valeur); check[12]=1;
   Serial.print("PMAX="); Serial.println(PMAX);
   Serial.print("valeur="); Serial.println(valeur);
 }
 else
 if(strcmp(Etiquette,"PAPP") == 0) { PAPP = atol(valeur); check[13]=1;
   Serial.print("PAPP="); Serial.println(PAPP);
   Serial.print("valeur="); Serial.println(valeur); 
 }
 else
 if(strcmp(Etiquette,"MOTDETAT") == 0) { memset(MOTDETAT,'\0',10); memcpy(MOTDETAT, valeur, strlen(valeur)); check[14]=1;
   Serial.print("MOTDETAT="); Serial.println(MOTDETAT);
   Serial.print("valeur="); Serial.println(valeur);  
 }
 else
 if(strcmp(Etiquette,"PPOT") == 0) { PPOT = atol(valeur); check[15]=1;
   Serial.print("PPOT="); Serial.println(PPOT);
   Serial.print("valeur="); Serial.println(valeur); 
 }
 else
 return 0;
 
 return 1;
}
 
le deuxieme
long previousSecond = 0;
 
/***********************************************
   pulse
   Set a var to 1 each second. 
   Input : n/a
   Output : n/a
   Note : you need to declare a "int second = 0" var in main pde file
***********************************************/
 
void pulse() {
    if (abs(millis() - previousSecond) > 1000) {
        second = 1;
        previousSecond = millis();
    }
    else {
        second = 0; 
    }
}
et le dernier
 
// caracter codes 
#define END_OF_LINE     10       // \n
#define OPEN_BRACKET    "{"
#define CLOSE_BRACKET   "}"

 
/***********************************************
sendHbeat
Send a xPL hbeat message
Input : n/a
Output : n/a
***********************************************/
void sendHbeat() {
Serial.println("Send hbeat message");
char buffer[200];
 
/**** header ****/
sprintf(buffer, "xpl-stat\n{\n");
sprintf(buffer, "%shop=1\n", buffer);
sprintf(buffer, "%ssource=%s\n", buffer, MY_SOURCE);
sprintf(buffer, "%starget=*\n}\n", buffer);
 
/**** body ****/
sprintf(buffer, "%shbeat.basic\n{\n", buffer);
sprintf(buffer, "%sinterval=%i\n", buffer, HBEAT_INTERVAL);
sprintf(buffer, "%sport=%u\n", buffer, localPort);
sprintf(buffer, "%sremote-ip=%s\n",buffer, myIPAdress);
sprintf(buffer, "%s}\n", buffer);
//Serial.println(buffer);
 
/**** Send it ****/
Udp.beginPacket(broadCastIp, xplPort);
Udp.write(buffer);
Udp.endPacket();
}
 
/***********************************************
   sendTeleinfoBasic
   Send a xPL teleinfo basic stat message
   Input : n/a
   Output : n/a
***********************************************/
void sendTeleinfoBasic() {
    Serial.println("Send Teleinfo stat");
    char buffer[512];
 
    /**** header ****/
    sprintf(buffer, "xpl-stat\n{\n");
    sprintf(buffer, "%shop=1\n", buffer);
    sprintf(buffer, "%ssource=%s\n", buffer, MY_SOURCE);
    sprintf(buffer, "%starget=*\n}\n", buffer);
 
    /**** body : specification part ****/
    sprintf(buffer, "%steleinfo.basic\n{\n", buffer);
    /**** body : developper part ***/
    // numéro de série du compteur
    sprintf(buffer, "%sadco=%s\n", buffer, ADCO);
    // Option tarifaire choisie
    sprintf(buffer, "%soptarif=%s\n", buffer, OPTARIF);
    // Intensité souscrite,
    sprintf(buffer, "%sisousc=%i\n", buffer, ISOUSC);
    // Index option tarif
    sprintf(buffer, "%sbase=%lu\n", buffer, BASE);
    // Période Tarifaire en cours
    sprintf(buffer, "%sptec=%s\n", buffer, PTEC);
    // Intensité Instantanée Triphasé Phase1
    sprintf(buffer, "%siinst1=%i\n", buffer, IINST1);
    // Intensité Instantanée Triphasé Phase2
    sprintf(buffer, "%siinst2=%i\n", buffer, IINST2);
    // Intensité Instantanée Triphasé Phase3
    sprintf(buffer, "%siinst3=%i\n", buffer, IINST3);
    // Intensité maximale appelée en Triphasé phase1
    sprintf(buffer, "%simax1=%i\n", buffer, IMAX1);
    // Intensité maximale appelée en Triphasé phase2
    sprintf(buffer, "%simax2=%i\n", buffer, IMAX2);
    // Intensité maximale appelée en Triphasé phase3
    sprintf(buffer, "%simax3=%i\n", buffer, IMAX3);
    // Puissance max
    sprintf(buffer, "%spmax=%i\n", buffer, PMAX);
    // Puissance apparente
    sprintf(buffer, "%spapp=%i\n", buffer, PAPP);
    // Mot d'état du compteur
    sprintf(buffer, "%smotdetat=%s\n", buffer, MOTDETAT);
    sprintf(buffer, "%sdevice=teleinfo\n", buffer);
    sprintf(buffer, "%s}\n", buffer);
    // Presence des potentiels
    sprintf(buffer, "%sppot=%i\n", buffer, PPOT);
 
    Serial.println(buffer);  
 
    /**** Send it ****/
    Udp.beginPacket(broadCastIp, xplPort);
    Udp.write(buffer);
    Udp.endPacket();
}
 

merci
maël
  • mael22
  • Nophoto
  • OFFLINE
  • Fresh Boarder
  • Rank0
  • Posts: 9
  • Karma: 0
Last Edit: 22 Feb 2013 14:55 by Frunk. Reason: réduction de la taille du message
The administrator has disabled public write access.

teleinfo arduino 22 Feb 2013 14:49 #4

le deuxieme et le troisieme sont a mettre dan le meme sketch que le premier

Maël
  • mael22
  • Nophoto
  • OFFLINE
  • Fresh Boarder
  • Rank0
  • Posts: 9
  • Karma: 0
The administrator has disabled public write access.

teleinfo arduino 23 Feb 2013 09:21 #5

j'ai isole le programme d'envoie de messages xpl pour domogik (hbeat) ça fonctionne, c'est au niveau du decodage des données teleinfo qu'il y a un hic?

voici le code d'envoie hbeat en xpl ok
#include <SPI.h>         // needed for Arduino versionslater than 0018
#include <Ethernet.h>
#include <EthernetUdp.h>
#include <SoftwareSerial.h>

// Arduino led
#define LEDPIN 9
/***************** Network configuration ********************/
 
// Mac address : a mac address must be unique
byte mac[] = {0x90, 0xA2, 0xDA, 0x0D, 0x9F, 0xA5};
// IP address : the value will depend on your network
IPAddress ip(192, 168, 0, 22);
char myIPAdress[]="192.168.0.22";
// Broadcat address's first three elements should be the same than ip. The last should be 255.
byte broadCastIp[] = {192, 168, 0, 255};
// Udp local port used (any value you want between 1024 and 65536)
unsigned int localPort = 3865;  
// xPL protocol port (keep default value unless you know what you are doing)
unsigned int xplPort = 3865;  
 
/***************** xPL configuration part *******************/
 
// Source. Format is <vendor id>-<device id>.<instance>
 
// Vendor id and device id should not be changed
// Instance should be the location of your arduino and RGB led strip : living, bedroom, etc
// Instance should only use letters or numbers! (no underscore, ...)
#define MY_SOURCE "arduino-teleinfo.compteur"

// Name of device in body of xpl message
// This should be the same as previously defined instance
#define MY_DEVICE "compteur"

// Maximal size of xPL messages that could be processed
// This size should not be reduce unless you are sure of what you are doing
#define MAX_XPL_MESSAGE_SIZE 200

// Heartbeat interval : time in minutes between 2 sends of a xpl hbeat message
#define HBEAT_INTERVAL 5

// Duration of a minute in seconds (to allow shorter delay in dev)
#define MINUTE 2

// Teleinfo interval : time in minutes between 2 sends of a xpl stat message
#define TELEINFO_INTERVAL 1

/********************* time management **********************/
 
int second = 0;
int lastTimeHbeat = 0;
int lastTimeTeleinfo = 0;
 
/*********************** Global vars ************************/
 
// UDP related vars
EthernetUDP Udp;
SoftwareSerial cptSerial(2, 3);
 
int packetSize = 0;      // received packet's size
byte remoteIp[4];        // received packet's IP
unsigned int remotePort; // received packet's port
byte packetBuffer[MAX_XPL_MESSAGE_SIZE];   // place to store received packet
 
// status
int result;
 
long previousSecond = 0;
 
/***********************************************
   pulse
   Set a var to 1 each second. 
   Input : n/a
   Output : n/a
   Note : you need to declare a "int second = 0" var in main pde file
***********************************************/
 
void pulse() {
    if (abs(millis() - previousSecond) > 1000) {
        second = 1;
        previousSecond = millis();
    }
    else {
        second = 0; 
    }
}
// caracter codes 
#define END_OF_LINE     10       // \n
#define OPEN_BRACKET    "{"
#define CLOSE_BRACKET   "}"

 
/***********************************************
sendHbeat
Send a xPL hbeat message
Input : n/a
Output : n/a
***********************************************/
void sendHbeat() {
Serial.println("Send hbeat message");
char buffer[200];
 
/**** header ****/
sprintf(buffer, "xpl-stat\n{\n");
sprintf(buffer, "%shop=1\n", buffer);
sprintf(buffer, "%ssource=%s\n", buffer, MY_SOURCE);
sprintf(buffer, "%starget=*\n}\n", buffer);
 
/**** body ****/
sprintf(buffer, "%shbeat.basic\n{\n", buffer);
sprintf(buffer, "%sinterval=%i\n", buffer, HBEAT_INTERVAL);
sprintf(buffer, "%sport=%u\n", buffer, localPort);
sprintf(buffer, "%sremote-ip=%s\n",buffer, myIPAdress);
sprintf(buffer, "%s}\n", buffer);
//Serial.println(buffer);
 
/**** Send it ****/
Udp.beginPacket(broadCastIp, xplPort);
Udp.write(buffer);
Udp.endPacket();
}
/***********************************************
   sendTeleinfoBasic
   Send a xPL teleinfo basic stat message
   Input : n/a
   Output : n/a
***********************************************/
void sendTeleinfoBasic() {
    Serial.println("Send Teleinfo stat");
    char buffer[512];
 
    /**** header ****/
    sprintf(buffer, "xpl-stat\n{\n");
    sprintf(buffer, "%shop=1\n", buffer);
    sprintf(buffer, "%ssource=%s\n", buffer, MY_SOURCE);
    sprintf(buffer, "%starget=*\n}\n", buffer);
 
    /**** body : specification part ****/
    sprintf(buffer, "%steleinfo.basic\n{\n", buffer);
 
     Serial.println(buffer);  
 
    /**** Send it ****/
    Udp.beginPacket(broadCastIp, xplPort);
    Udp.write(buffer);
    Udp.endPacket();
}   
/******************** Set up arduino ***********************/
void setup() {
 
 
    pinMode(LEDPIN, OUTPUT);     
 
    // Serial to EDF cpt
    cptSerial.begin(1200);
    Serial.begin(115200);
 
    // Ethernet initialisation
    Ethernet.begin(mac, ip);
    Udp.begin(localPort);
 
    // Send a hbeat message on startup
    sendHbeat();
    digitalWrite(LEDPIN, LOW);
}
 
void loop() {
  // pulse management 
  pulse();
 
  if (second == 1) {
 
       // Hbeat action
        lastTimeHbeat += 1;
        // Each N minute, send a hbeat xpl message
        if (lastTimeHbeat == (MINUTE*HBEAT_INTERVAL)) {
            sendHbeat();
            lastTimeHbeat = 0;
        } 
 
        // send teleinfo stat
        lastTimeTeleinfo += 1;
        // Each N minute, get teleinfo
        if (lastTimeTeleinfo == (MINUTE*TELEINFO_INTERVAL)) { 
            digitalWrite(LEDPIN, HIGH);
            getTeleinfo();
            digitalWrite(LEDPIN, LOW);
            sendTeleinfoBasic();
            lastTimeTeleinfo = 0;
        }        
   }
}
 
  /***********************************************
   getTeleinfo
   Decode Teleinfo from serial
   Input : n/a
   Output : n/a
***********************************************/
void getTeleinfo() {
 
  /* vider les infos de la dernière trame lue */
  int trameComplete=0;
 
 
}
  • mael22
  • Nophoto
  • OFFLINE
  • Fresh Boarder
  • Rank0
  • Posts: 9
  • Karma: 0
Last Edit: 23 Feb 2013 09:34 by gromain. Reason: mise en forme code
The administrator has disabled public write access.

teleinfo arduino 23 Feb 2013 09:40 #6

Salut Maël,

manu, qui traine ici, rencontre les mêmes soucis que toi, il a récupéré le code sur le blog de cquad.
Perso, je peux pas trop vous aider car je n'ai ni wiznet, ni compteur à téléinfo.
J'ai discuté un peu avec cquad hier soir sur IRC, il me confirme que son code fonctionnait à l'époque de la publication, il y a environ 1 an. Depuis, l'IDE arduino a un peu évolué, peut-être que le problème vient de là ?
Dans le cadre d'xplduino, on un code qui fonctionne bien pour la teleinfo, mais sur une base d'arduino + ethernet ENC28J60 :-/
As-tu essayé de voir directement avec cquad sur le chan IRC ? (freenode #xplduino ou #domogik)

Romain
  • gromain
  • Avatar 2013 01 07
  • OFFLINE
  • Administrateur
  • Administrateur
  • Posts: 153
  • Thank you received: 10
  • Karma: 3
Last Edit: 23 Feb 2013 09:40 by gromain.
The administrator has disabled public write access.

teleinfo arduino 23 Feb 2013 09:56 #7

ok merci je vais essayer de voir avec cquad.

Maël
  • mael22
  • Nophoto
  • OFFLINE
  • Fresh Boarder
  • Rank0
  • Posts: 9
  • Karma: 0
The administrator has disabled public write access.

teleinfo arduino 23 Feb 2013 10:04 #8

sinon il n'y as pas moyen de mettre des debug par endroit pour savoir ou ça plante?
ou sinon un message d'info a chaque commande realisées pour voir ou ça s'arrete?
Maël
  • mael22
  • Nophoto
  • OFFLINE
  • Fresh Boarder
  • Rank0
  • Posts: 9
  • Karma: 0
The administrator has disabled public write access.

teleinfo arduino 23 Feb 2013 10:08 #9

si, il y a la méthode du "Serial.println("passé par ici");"
  • gromain
  • Avatar 2013 01 07
  • OFFLINE
  • Administrateur
  • Administrateur
  • Posts: 153
  • Thank you received: 10
  • Karma: 3
The administrator has disabled public write access.

teleinfo arduino 23 Feb 2013 10:21 #10

tu le met dans la void setup ou void loop?
  • mael22
  • Nophoto
  • OFFLINE
  • Fresh Boarder
  • Rank0
  • Posts: 9
  • Karma: 0
The administrator has disabled public write access.
Backtotop