Télé Information Client (TIC)
La TéléInformation Client (TIC) est une spécification d'interface mise en place par EDF dans ses compteurs bleus électroniques (CBE). La BeagleBone Black (BBB) constitue une plate forme de choix pour exploiter ces informations de TIC mises à disposition par le CBE. Cet article propose de collecter à moindre frais, les informations de consommation électrique d'une habitation . Les données pourront servir à représenter graphiquement des habitudes de consommation.
On entend beaucoup parler d'économie d'énergie du fait de considérations écologiques, mais il existe assez peu d'information sur la manière d'évaluer simplement sa consommation énergétique. Une évidence devrait pourtant s'imposer: pour faire des économies, il faut avant toute chose savoir mesurer et identifier l'origine de cette consommation.
Compteur Bleu Electronique (CBE)
deux bus accessibles par l'exploitant ou l'usager.
L'exploitant possède un accès relatif aux données de comptage par un bus de télérelève au standard EURIDIS: une transaction par le bus de télérelève se réalise en 3 ou 4 secondes à l'initiative d'un équipement de relève à distance. Dans la pratique, l'équipement de l'exploitant possède un accès partagé à N compteurs qu'il doit interroger en séquence. Par conséquent, la fréquence des transactions sera limitée à la fois par leur durée et le nombre N de compteurs à relever.
L'usager dispose d'une sortie téléinfo spécifique d'EDF qui offre ses données en continu. Cette téléinformation est réalisée par une liaison série numérique modulée qui diffuse en permanence des données contenues dans les mémoires du compteur. La liaison TIC pourra être utilisée par l'usager afin de connecter des systèmes tels qu'un afficheur déporté, un terminal ou un gestionnaire d’énergie.
La TéléInformation Client (TIC) rend le compteur CBE communicant vers le consommateur pour lui permettre de réaliser et d'utiliser ses propres services:
- Le suivi de sa consommation instantanée en temps réel (environ 1Hz) depuis le web sur PC ou terminaux mobiles.
- La sauvegarde sous la forme d'historique de ses données de consommation.
- Une visualisation graphique de sa consommation.
Les grandeurs fournies par la sortie téléinfo sont classées en deux catégories:
- Information sur le client: tarif, puissance souscrite ...
- La consommation du client: puissance appelée, Index, Intensité instantanée ...
Accessoires
- Carte BeagleBone Black configurée avec une distribution Linux Debian.
- Démodulateur des trames TIC et circuit FTDI.
Il est possible de réaliser son propre démodulateur à partir de schémas disponibles sur Internet. Cependant, le matériel utlisé dans cet article est un TéléinfoStick v2 prêt à l'emploi. En plus du démodulateur de signal TIC, le TéléinfoStick comprend un adaptateur USB/TLL qui permet de le raccorder très facilement à la BeagleBone.
Montage
Une partie du TéléinfoStick v2 est raccordé aux bornes I1I2 du compteur bleu électronique.
L'autre partie du TéléinfoStick v2 correspond au connecteur USB/TTL. Elle sera connectée sur un port USB d'une BeagleBone Black ou d'une carte de même type.
Serveur LAMP
Les données sont sauvegardées dans une base MySQL et leur visualisation est assurée par un module PHP inclus dans un serveur Apache.
Il s'agit d'une architecture de type LAMP installée sur des cartes BeagleBone Black.
Archivage des données
Un abonnement EDF de type Tempo possède trois couleurs (Bleu/Blanc/Rouge) avec un traif Heures Creuses/Pleines pour chacune d'elles, soit 6 tarifs au total. Le changement de couleur du jour se fait à 6h du matin et la période d'heures creuses est de 22h a 6h.
Modèle de données d'un abonnement tempo
+----------+-------------+------+-----+---------+-------+| Field | Type | Null | Key | Default |
+----------+-------------+------+-----+---------+-------+
| DATE | datetime | YES | | NULL |
| ADCO | varchar(12) | YES | MUL | NULL |
| OPTARIF | varchar(4) | YES | | NULL |
| ISOUSC | varchar(2) | YES | | NULL |
| BASE | varchar(9) | YES | | NULL |
| HCHC | varchar(9) | YES | | NULL |
| HCHP | varchar(49) | YES | | NULL |
| EJPHN | varchar(9) | YES | | NULL |
| EJPHPM | varchar(9) | YES | | NULL |
| BBRHCJB | varchar(9) | YES | | NULL |
| BBRHPJB | varchar(9) | YES | | NULL |
| BBRHCJW | varchar(9) | YES | | NULL |
| BBRHPJW | varchar(9) | YES | | NULL |
| BBRHCJR | varchar(9) | YES | | NULL |
| BBRHPJR | varchar(9) | YES | | NULL |
| PEJP | varchar(2) | YES | | NULL |
| PTEC | varchar(4) | YES | | NULL |
| DEMAIN | varchar(4) | YES | | NULL |
| IINST | varchar(3) | YES | | NULL |
| ADPS | varchar(4) | YES | | NULL |
| IMAX | varchar(4) | YES | | NULL |
| IINST1 | varchar(3) | YES | | NULL |
| IINST2 | varchar(3) | YES | | NULL |
| IINST3 | varchar(3) | YES | | NULL |
| IMAX1 | varchar(3) | YES | | NULL |
| IMAX2 | varchar(3) | YES | | NULL |
| IMAX3 | varchar(3) | YES | | NULL |
| PMAX | varchar(5) | YES | | NULL |
| PAPP | varchar(5) | YES | | NULL |
| HHPHC | varchar(5) | YES | | NULL |
| MOTDETAT | varchar(6) | YES | | NULL |
| PPOT | varchar(2) | YES | | NULL |
+----------+-------------+------+-----+---------+-------+
Description
- DATE : date de la mesure au format MySQL (ex. 2015-02-18 08:51:27 pour 18 Février 2015)
- BBRHCJB : index compteur Heure Creuse Jour Bleu
- BBRHPJB : index compteur Heure Pleine Jour Bleu
- BBRHCJW : index compteur Heure Creuse Jour Blanc (w pour white en anglais)
- BBRHPJW : index compteur Heure Pleine Jour Blanc
- BBRHCJR : index compteur Heure Creuse Jour Rouge
- BBRHPJR : index compteur Heure Pleine Jour Rouge
- PTEC : tarification/couleur en cours qui contient:
- HPJB pour HeurePleineJourBleu
- ou HCJB pour HeureCreuseJourBleu
- ou HCJW pour HeureCreuseJourBlanc
- ou HPJW pour HeurePleineJourBlanc
- ou HCJR pour HeureCreuseJourRouge
- ou HPJR pour HeurePleineJourRouge
Programme C
Le programme C suivant lit les données fournies par le TeleinfoStick sur un port USB/série d'une carte BeagleBone. Les données sont ensuite enregistrées dans une base MySQL. Le programme vérifie les checksums des trames de téléinformation et peut réaliser plusieurs essais successifs lors d'erreurs de lecture.
Code soure
#include <limits.h>#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <stdint.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <syslog.h>
#include <time.h>
#include <errno.h>
#include <fcntl.h>
#include <unistd.h>
#include <termios.h>
#include <signal.h>
#include <mysql/mysql.h>
// Check windows
#if _WIN32 || _WIN64
#if _WIN64
#define ENV_64BIT
#else
#define ENV_32BIT
#endif
#endif
// Check GCC
#if __GNUC__
#if __x86_64__ || __ppc64__
#define ENV_64BIT
#else
#define ENV_32BIT
#endif
#endif
//#define DEBUG
const char *VERSION = "1.0.2 (2014-08-19)";
const char *SERIAL_DEVICE = "/dev/ttyUSB0";
const char *CSV_FILE_PATH = "/home/pi/teleinfo/log/edf_tli.csv";
const char *OPTARIF = "OPTARIF";
// MySQL settings
const char * MYSQL_HOST = "192.168.1.xxx";
const char * MYSQL_DB = "teleinfo";
const char * MYSQL_TABLE = "xxx";
const char * MYSQL_LOGIN = "yyy";
const char * MYSQL_PWD = "zzz";
const char *MYSQL_FIELDS[] =
{"ADCO","OPTARIF","ISOUSC","BASE","HCHC","HCHP","EJPHN","EJPHPM",
"BBRHCJB","BBRHPJB","BBRHCJW","BBRHPJW","BBRHCJR","BBRHPJR",
"PEJP","PTEC","DEMAIN","IINST","ADPS","IMAX",
"IINST1","IINST2","IINST3","IMAX1","IMAX2","IMAX3",
"PMAX","PAPP","HHPHC","MODETAT","PPOT",
NULL
};
const uint32_t BUFFER_SIZE = 512;
const uint32_t ITEM_COUNT = 64;
const uint32_t ITEM_LEN = 16;
const uint32_t MAX_RETRY = 3;
enum eStatus
{
success = 0,
failed,
/*! serial line is still open */
opened,
/*! serial line has been closed*/
closed,
/*! serial line interrupt occurred */
interrupt,
/*! check sum failed */
csFailed
};
typedef struct execStatus {
execStatus(): status(failed), idx(0), idxError(0), errorCount(0){}
eStatus status;
uint32_t idx;
uint32_t idxError;
uint32_t errorCount;
} execStatus_t;
typedef struct dateTime
{
char d[12];
char h[10];
char ts[11];
} dateTime_t;
typedef struct item
{
item(): id(NULL),
cs((unsigned char)'0') {}
enum {UNKNOWN= 0, ALPHA, NUM} type;
/*! item identifier */
char *id;
/*! id's checksum */
unsigned char cs;
union {
unsigned long long int nVal[ITEM_COUNT];
char sVal[ITEM_COUNT][ITEM_LEN];
} values;
} item_t;
typedef struct edf_teleinfo
{
edf_teleinfo(): device(NULL),
fd(-1),
status(failed) {}
/*! device is the device's name */
const char *device;
/*! fd is the file descriptor of this serial line */
int32_t fd;
/*! is the old termios settings */
struct termios oldOpt;
/*! is the current termios settings */
struct termios curOpt;
/*! status is the current state of this serial line */
eStatus status;
} edf_teleinfo_t;
// global types
item_t *gp_ids = NULL;
edf_teleinfo_t g_tli;
FILE *gp_csv = NULL;
// function declarations
/*!
* @brief INThandler() is designed to handle signal SIGINT.
* When the user press Ctrl-C, INThandler() is called with its only argument
* indicating the signal number.
*
* @param sig should contain SIGINT.
*/
void INThandler(int sig);
/*!
* \brief checksumCmp compares two checksum for equality
* \param c is a checksum to valuate
* \param cs is a checksum value the check against
*
* \return success if the two checksum are the same.
*/
eStatus checksumCmp(unsigned char c, unsigned char cs);
void getDateTime(dateTime_t *dt);
eStatus setOPTARIF(const char *s, item_t *ids);
eStatus setValue(const char *s, item_t *ids);
/*!
* @brief Open the serial line.
*
* @param t contains serial line info
* @param device is the device's name
* @param term is the current termios settings
*
*/
void openSerial(edf_teleinfo_t *t, const char *device);
/*!
* findFrame is looking for the start of a frame
*
* @param t contains serial line info
*
* @return true if start of frame is found
*/
void printSerialOptions(edf_teleinfo_t *t);
eStatus findFrame(edf_teleinfo_t *t);
/*!
* readFrame fills out a string buffer with the current frame content
*
* @param t contains serial line info
* @param buf is the frame content
*
* @return success if start of frame is found
*/
eStatus readFrame(edf_teleinfo_t *t, char *frameBuf, int size, int *count);
item_t *createIds(char *frameBuf, int size, int *count);
eStatus addValues(char *frameBuf, int size, item_t *ids, int count);
FILE *createCsvFile(item_t *ids, int count);
void appendCsvFile(FILE *csv, dateTime_t *dt, item_t *ids, int count);
item_t *findId(const char *s, item_t *ids, int count);
eStatus appendMySql(dateTime_t *dt, item_t *ids, int count);
// function definitions
/*!
* Retore the old settings for the serial line
*/
void INThandler(int sig)
{
(void)sig;
syslog(LOG_DEBUG, "=> INThandler");
if (NULL != g_tli.device)
{
free((void *)(g_tli.device));
}
if (opened == g_tli.status)
{
tcflush(g_tli.fd, TCIFLUSH);
tcsetattr(g_tli.fd, TCSANOW, &g_tli.oldOpt);
close(g_tli.fd);
}
if (NULL != gp_csv)
{
fclose(gp_csv);
}
if (NULL != gp_ids)
{
free((void *)gp_ids->id);
}
syslog(LOG_DEBUG, "<= INThandler");
closelog() ;
exit(0);
}
eStatus checksumCmp(unsigned char c,unsigned char cs)
{
eStatus status;
c = (c & 0x3F) + 0x20;
if (c == cs)
{
status = success;
}
else {
syslog(LOG_ERR, "Wrong checksum: c= %#x, cs= %#x", c, cs);
status = csFailed;
}
return status;
}
void getDateTime(dateTime_t *dt)
{
time_t t;
struct tm *ts;
time(&t);
// ts = gmtime(&t) ;
ts = localtime(&t) ;
strftime(dt->d, sizeof dt->d,"%Y-%m-%d", ts);
strftime(dt->h, sizeof dt->h,"%H:%M:%S", ts);
strftime(dt->ts, sizeof dt->ts,"%s", ts);
#ifdef DEBUG
printf("getDateTime: ts= [%s], dt= %s %s\n", dt->ts, dt->d, dt->h);
#endif
}
eStatus setValue(const char *s, item_t *ids)
{
char *endptr;
eStatus status= failed;
ids->type = item::UNKNOWN;
if (NULL != s && NULL != ids)
{
errno = 0;
*(ids->values.nVal) = strtoull(s, &endptr, 10);
if ((errno == ERANGE &&
*(ids->values.nVal) == ULLONG_MAX) ||
(errno != 0 && *(ids->values.nVal) == 0))
{
syslog(LOG_ERR, "strtoull: out of range");
}
else {
if (endptr == s)
{
char *p= *(ids->values.sVal);
for (uint32_t i=0; i<ITEM_LEN; i++, p++, s++)
{
*p = *s;
if ('\0' == *p ) break;
}
ids->type = item::ALPHA;
}
else {
ids->type = item::NUM;
}
status = success;
}
}
return status;
}
/*!
* 9600 bps, 8 bits, pas de parité, 1 stop
*
*/
void openSerial(edf_teleinfo_t *t, const char *device)
{
syslog(LOG_DEBUG, "=> openSerial");
t->fd = open (device, O_RDWR|O_NOCTTY);
if (0 > t->fd)
{
syslog(LOG_ERR, "cannot open device %s: %s",
device,
strerror(errno));
}
else if (!isatty(t->fd)) {
syslog(LOG_ERR, "device [%s] is not a tty", device);
close(t->fd);
}
else {
if (NULL == (t->device = strdup(device)))
{
syslog(LOG_ERR, "memory alloc failed");
close(t->fd);
}
else {
tcgetattr(t->fd, &t->oldOpt);
tcgetattr(t->fd, &t->curOpt);
t->curOpt.c_iflag = IGNBRK|IGNPAR;
t->curOpt.c_oflag = 0;
t->curOpt.c_cflag = B9600|CS8|CREAD|CLOCAL;
t->curOpt.c_lflag = 0;
t->curOpt.c_cc[VTIME] = 80;
t->curOpt.c_cc[VMIN] = 1;
tcflush(t->fd, TCIFLUSH);
tcsetattr(t->fd, TCSANOW, &t->curOpt);
syslog(LOG_DEBUG,"Teleinfo serial line %s opened", t->device);
t->status= opened;
}
}
syslog(LOG_DEBUG, "<= openSerial");
}
void printSerialOptions(edf_teleinfo_t *t)
{
syslog(LOG_DEBUG, "=> serialOptions");
syslog(LOG_DEBUG, "old termios settings");
syslog(LOG_DEBUG,"c_iflag= %u", t->oldOpt.c_iflag);
syslog(LOG_DEBUG,"c_oflag= %u", t->oldOpt.c_oflag);
syslog(LOG_DEBUG,"c_lflag= %u", t->oldOpt.c_lflag);
for(unsigned int i=0; i<NCCS; i++)
{
syslog(LOG_DEBUG,"c_cc[%u]= %02X", i, t->oldOpt.c_cc[i]);
}
syslog(LOG_DEBUG, "current termios settings");
syslog(LOG_DEBUG,"c_iflag= %u", t->curOpt.c_iflag);
syslog(LOG_DEBUG,"c_oflag= %u", t->curOpt.c_oflag);
syslog(LOG_DEBUG,"c_lflag= %u", t->curOpt.c_lflag);
for(unsigned int i=0; i<NCCS; i++)
{
syslog(LOG_DEBUG,"c_cc[%u]= %02X", i, t->curOpt.c_cc[i]);
}
syslog(LOG_DEBUG, "<= serialOptions");
}
eStatus findFrame(edf_teleinfo_t *t)
{
syslog(LOG_DEBUG, "=> findFrame");
eStatus status = failed;
char c, ch[1];
int count = read(t->fd, ch, 1);
if (0 > count)
{
syslog(LOG_ERR, "Error while reading EDF teleinfo: %s",
strerror(errno));
syslog(LOG_DEBUG, "<= findFrame");
return status;
}
do {
if (0x04 == (c = ch[0]))
{
syslog(LOG_ERR, "Line interrup occured");
return status;
}
count = read(t->fd, ch, 1);
if (0 > count)
{
syslog(LOG_ERR, "Error while reading EDF teleinfo: %s",
strerror(errno));
syslog(LOG_DEBUG, "<= findFrame");
return status;
}
#ifdef DEBUG
printf("findFrame: reading char: [0x%x]\n", (unsigned char)ch[0]);
#endif
}
while(!(ch[0] == 0x02 && c == 0x03));
status = success;
syslog(LOG_DEBUG, "<= findFrame");
return status;
}
eStatus readFrame(edf_teleinfo_t *t, char *frameBuf, int size, int *count)
{
syslog(LOG_DEBUG, "=> readFrame");
eStatus status = failed;
char *p = frameBuf;
*count = 0;
char ch[1];
int res = read(t->fd, ch, 1);
do {
if (0 > res)
{
syslog(LOG_ERR, "Error while reading EDF teleinfo: %s",
strerror(errno));
syslog(LOG_DEBUG, "<= readFrame");
return status;
}
else {
if (0x04 == ch[0])
{
syslog(LOG_ERR, "Line interrup occured");
return status;
}
*count += res;
if (*count < size)
{
memcpy((void *)p, ch, 1);
p+= res;
}
else {
syslog(LOG_ERR, "buffer overflow while reading frame content");
return status;
}
}
res = read(t->fd, ch, 1);
} while(ch[0] != 0x03);
res = read(t->fd, ch, 1);
if (0 > res)
{
syslog(LOG_ERR, "Error while reading EDF teleinfo: %s",
strerror(errno));
syslog(LOG_DEBUG, "<= readFrame");
return status;
}
if (0x04 == ch[0])
{
syslog(LOG_ERR, "Line interrup occured");
return status;
}
if (ch[0] != 0x02)
{
syslog(LOG_ERR, "invalid char [0x%x]", (unsigned char)ch[0]);
return status;
}
status = success;
syslog(LOG_DEBUG, "<= readFrame");
return status;
}
/*!
* read the EDF teleinformation sent over the serial line
*/
item_t *createIds(char *frameBuf, int size, int *count)
{
syslog(LOG_DEBUG, "=> createIds");
item_t *ids;
int len = 0;
char *t = frameBuf;
*count = 0;
#ifdef DEBUG
printf("createIds: reading buffer content\n");
for(int i= 0; i<size; i++)
{
printf("createIds: char[%i]= %#x\n", i, *(frameBuf+i));
}
#endif
for (int i=0; i<size; i++, t++)
{
if (0x0a == *t)
{
++len;
}
}
if (NULL == (ids = (item_t *)malloc(sizeof(item_t)*len)))
{
syslog(LOG_ERR, "cannot allocate [%i] items in memory", len);
}
else {
char *r;
item_t *p = ids;
t= frameBuf;
for (int i=0; i<size; i++, t++)
{
if (0x0a == *t)
{
r= t;
}
else if (0x0d == *t)
{
char *s= ++r;
unsigned char cs = (unsigned char)*r;
while (0x20 != *s)
{
++s;
cs += (unsigned char)*s;
}
cs += (unsigned char)*s;
if (NULL == (p->id = (char *)malloc(sizeof(char)*(s-r))))
{
#ifdef ENV_64BIT
syslog(LOG_ERR, "cannot allocate [%ld] items in memory", (s-r));
#else
syslog(LOG_ERR, "cannot allocate [%d] items in memory", (s-r));
#endif
}
else {
p->cs = cs;
memcpy((void *)p->id, r, s-r);
*(p->id+(s-r))= '\0';
#ifdef DEBUG
printf("createIds: id[%i]= [%s], cs= [%#x]\n", *count, p->id, p->cs);
#endif
++*count;
++p;
}
}
}
}
*count = len == *count ? *count : -1;
syslog(LOG_DEBUG, "<= createIds");
return ids;
}
eStatus addValues(char *frameBuf, int size, item_t *ids, int count)
{
syslog(LOG_DEBUG, "=> addValues(buf[%i], count= %i)", size, count);
eStatus status = success;
char *r = NULL;
char *s = NULL;
char *t = frameBuf;
int len = 0;
for (int i=0; i<size; i++, t++)
{
if (0x0a == *t)
{
r= s= NULL;
}
else if (0x20 == *t)
{
if (NULL == r)
{
r = t;
}
else {
s = t;
}
}
else if (0x0d == *t) {
unsigned char cs = (unsigned char)*(++r);
char *p = r;
do {
++p;
cs += (unsigned char)*p;
} while (p<s);
*s++= '\0';
if (success != (status = checksumCmp(ids->cs+cs, (unsigned char)*s)))
{
break;
}
setValue(r, ids);
#ifdef DEBUG
if (item_t::ALPHA == ids->type)
{
printf("addValues: alpha id[%i]= [%s], cs= [%#x], value= [%s]\n",
len, ids->id, ids->cs, *ids->values.sVal);
}
else if (item_t::NUM == ids->type) {
printf("addValues: num id[%i]= [%s], cs= [%#x], value= [%llu]\n",
len, ids->id, ids->cs, *ids->values.nVal);
}
#endif
if (item_t::UNKNOWN == ids->type) {
syslog(LOG_ERR, "unknown value type : id[%i]= [%s]", len, ids->id);
}
++ids;
++len;
}
}
status = status == success ? count == len ? success : failed : status;
syslog(LOG_DEBUG, "<= addValues(%i)", len);
return status;
}
FILE *createCsvFile(item_t *ids, int count)
{
struct stat sb;
item_t *p= ids;
if (-1 == stat(CSV_FILE_PATH, &sb))
{
if (NULL == (gp_csv = fopen(CSV_FILE_PATH, "a")))
{
syslog(LOG_ERR, "cannot open [%s]", CSV_FILE_PATH);
}
else {
fprintf(gp_csv, "##;##\r\ntimestamp;date time");
for (int i= 0; i<count; i++, p++)
{
fprintf(gp_csv, ";%s", p->id);
}
fprintf(gp_csv, "\r\n");
}
}
else {
if (NULL == (gp_csv = fopen(CSV_FILE_PATH, "a")))
{
syslog(LOG_ERR, "cannot open [%s]", CSV_FILE_PATH);
}
}
return gp_csv;
}
void appendCsvFile(FILE *csv, dateTime_t *dt, item_t *ids, int count)
{
item_t *p= ids;
fprintf(csv, "%s; %s %s", dt->ts, dt->d, dt->h);
for (int i= 0; i<count; i++, p++)
{
if (item_t::ALPHA == p->type)
{
fprintf(csv, ";%s", *p->values.sVal);
}
else if (item_t::NUM == p->type) {
fprintf(csv, ";%llu", *p->values.nVal);
}
}
fprintf(csv, "\r\n");
}
item_t *findId(const char *s, item_t *ids, int count)
{
item_t *p = NULL;
for (int i= 0; i<count; i++, ids++)
{
if (0 == strcmp(s, ids->id))
{
p = ids;
break;
}
}
return p;
}
eStatus appendMySql(dateTime_t *dt, item_t *ids, int count)
{
char query[255], data[512];
char *p = data;
const char **s = MYSQL_FIELDS;
MYSQL mysql;
item_t *it;
if(!mysql_init(&mysql))
{
syslog(LOG_ERR, "Erreur: Initialisation MySQL impossible !") ;
return failed;
}
if(!mysql_real_connect(&mysql, MYSQL_HOST, MYSQL_LOGIN, MYSQL_PWD, MYSQL_DB, 0, NULL, 0))
{
syslog(LOG_ERR, "Erreur connection %d: %s \n", mysql_errno(&mysql), mysql_error(&mysql));
return failed;
}
p = (char *)memset(data, '\0', sizeof(data));
strcpy(p, "'");
strcat(p, (const char *)dt->d);
strcat(p, " ");
strcat(p, (const char *)dt->h);
strcat(p, "','");
if (NULL != (it= findId(*s, ids, count)))
{
if (item_t::ALPHA == it->type)
{
// bmdOnline work around
if (0 == strcmp("OPTARIF", it->id))
{
strcat(p, "BBR");
}
else {
strcat(p, (const char *)*it->values.sVal);
}
}
else if (item_t::NUM == it->type) {
sprintf(p+strlen(p), "%llu",*it->values.nVal);
}
strcat(p, "'");
}
else{
strcat(p, " '");
}
++p; ++s;
while (NULL != *s)
{
if (NULL != (it= findId(*s, ids, count)))
{
strcat(p, ",'");
if (item_t::ALPHA == it->type)
{
// bmdOnline work around
if (0 == strcmp("OPTARIF", it->id))
{
strcat(p, "BBR");
}
else {
strcat(p, (const char *)*it->values.sVal);
}
}
else if (item_t::NUM == it->type) {
sprintf(p+strlen(p), "%llu",*it->values.nVal);
}
strcat(p, "'");
}
else{
strcat(p, ",NULL");
}
++p; ++s;
}
sprintf(query, "INSERT INTO %s VALUES (%s)", MYSQL_TABLE, data);
if(mysql_query(&mysql, query))
{
syslog(LOG_ERR, "Erreur INSERT %d: \%s \n", mysql_errno(&mysql), mysql_error(&mysql));
mysql_close(&mysql);
return failed ;
}
#ifdef DEBUG
else printf("MySql request ok\n");
#endif
mysql_close(&mysql);
return success;
}
int main()
{
openlog("edf_tli", LOG_PID, LOG_USER);
syslog(LOG_DEBUG, "=> main");
syslog(LOG_INFO, "Version %s", VERSION);
signal(SIGINT, INThandler);
char buf[BUFFER_SIZE];
int count, len;
#ifdef DEBUG
item_t *p;
#endif
dateTime_t dt;
execStatus_t execStat;
openSerial(&g_tli, SERIAL_DEVICE);
if (opened != g_tli.status)
{
syslog(LOG_ERR, "fails to open serial port [%s]", SERIAL_DEVICE);
goto END;
}
if (success != findFrame(&g_tli))
{
syslog(LOG_ERR, "No frame found");
goto END;
}
if (success != readFrame(&g_tli, buf, BUFFER_SIZE, &len))
{
syslog(LOG_ERR, "Cannot read buffer frame content");
goto END;
}
syslog(LOG_DEBUG, "[%i] char read", len);
gp_ids = createIds(buf, len, &count);
if (0 >= count)
{
syslog(LOG_ERR, "No item found");
goto END;
}
if (NULL == (gp_csv = createCsvFile(gp_ids, count)))
{
syslog(LOG_ERR, "cannot create cvs file");
goto END;
}
while (0 == 0) {
if (0 == execStat.idx%0x400)
{
printf("------------ LOOP : %i ------------------\n", execStat.idx);
}
if (success != readFrame(&g_tli, buf, BUFFER_SIZE, &len))
{
syslog(LOG_ERR, "Cannot read buffer frame content");
goto END;
}
syslog(LOG_DEBUG, "[%i] char read", len);
if (success != (execStat.status = addValues(buf, len, gp_ids, count)))
{
if (csFailed == execStat.status)
{
if (0 == execStat.idx)
{
++execStat.errorCount;
}
else if (execStat.idxError == execStat.idx-1)
{
++execStat.idxError;
if (++execStat.errorCount > MAX_RETRY)
{
printf("[%i] successive checksum arrors\n", MAX_RETRY);
syslog(LOG_ERR, "[%i] successive checksum arrors", MAX_RETRY);
goto END;
}
}
else {
execStat.errorCount = 0;
}
}
else{
printf("cannot read values\n");
syslog(LOG_ERR, "cannot read values");
goto END;
}
}
if (success == execStat.status)
{
#ifdef DEBUG
p= gp_ids;
for (int i= 0; i<count; i++)
{
if (item_t::ALPHA == p->type)
{
printf("main :alpha id[%i, %s]= %s\n",
i, p->id, *p->values.sVal);
}
else if (item_t::NUM == p->type) {
printf("main :num id[%i, %s]= %llu\n",
i, p->id, *p->values.nVal);
}
else {
printf("main :unknown value type id[%i]= %s\n", i, p->id);
}
++p;
}
#endif
// Archive freq: one time series per min
// if (0 == execStat.idx%0x01E)
// {
getDateTime(&dt);
// appendCsvFile(gp_csv, &dt, gp_ids, count);
appendMySql(&dt, gp_ids, count);
// }
}
execStat.idx = ++execStat.idx < UINT32_MAX ? execStat.idx : 0;
}
END:
INThandler(0);
}
Paramétres du code source
- SERIAL_DEVICE="/dev/ttyUSB0": spécifie le port série qui reçoit les trames de téléinformation.
- CSV_FILE_PATH="/home/pi/teleinfo/log/edf_tli.csv": définit l'emplacement d'un fichier pour sauvegarder les données de téléinformation dans le format CSV (Comma Separated Value).
- MYSQL_HOST="192.168.1.xxx": adresse de la machine qui héberhe le serveur MySQL.
- MYSQL_DB="teleinfo": nom de la base contenant les données MySQL de téléinformation.
- MYSQL_TABLE="xxx": nom de la table mySQL contenant les données de téléinformation
- const char * MYSQL_LOGIN="yyy": identifiant pour accéder à la base de données MySQL.
- const char * MYSQL_PWD = "zzz": mot de passe permattant l'accès à la base de données MySQL.
- const char *MYSQL_FIELDS[] ={"ADCO","OPTARIF","ISOUSC","BASE","HCHC","HCHP","EJPHN","EJPHPM", "BBRHCJB","BBRHPJB","BBRHCJW","BBRHPJW","BBRHCJR","BBRHPJR", "PEJP","PTEC","DEMAIN","IINST","ADPS","IMAX", "IINST1","IINST2","IINST3","IMAX1","IMAX2","IMAX3", "PMAX","PAPP","HHPHC","MODETAT","PPOT", NULL}: difinition de tous les champs qui seront recherchés dans les trames de téléinformation.
Procèdure de compilation
Ne pas oublier d'inclure les dépendances à la librairie cliente MySQL comme décrit dans le contenu du fichier Makefilr ci dessous.$ cat Makefile
CXXFLAGS = -g -Wall ${INCLUDES}
OBJS = main.o
SRC = main.cpp
PROG = teleInfo
INCLUDES = -I /usr/local/include
LIBS = -L/usr/lib/mysql -lmysqlclient
all: $(PROG)
${PROG}: $(OBJS)
${OBJS}:; ${CXX} $(INCLUDES) -c ${SRC}
${CXX} -o ${PROG} ${OBJS} ${LIBS}
clean:; $(RM) -f $(PROG) core *.o
Aucun commentaire:
Enregistrer un commentaire