samedi 28 novembre 2015

Box et Reverse Proxy

Notions fondamentales

Une box ADSL comprend au minimum deux composants principaux:
  • Un routeur
  • Une passerelle

Routeur

Le routeur sera doté d'une IP publique ou externe de type 93.154.12.218, qui permettra de le contacter depuis Internet. Dans un premier temps, le routeur d'une box ADSL va rejeter tout le trafic entrant depuis Internet. Il ne s'agit pas d'un parefeu mais plus simplement, il ne sait que faire de ce trafic entrant ...
Un routeur à pour fonction principale de router les paquets entre différents réseaux: Réseau privé vs Réseau internet

Passerelle

La passerelle comporte une adresse IP locale de type 192.168.1.1.
Il s'agit d'une notion logique qui constitue un point de sortie lorsque l'adresse d'un hôte de destination est introuvable sur le réseau local.

NAT/PAT

Un équipement connecté au réseau local ou privé sera affecté d'une adresse locale de type 192.168.1.10. Cet équipement peut envoyer des requêtes à destination d'Internet (173.194.67.94) qui seront transmises au routeur. Malheureusement, le routeur ne pourra pas transmettre à son destinataire (173.194.67.94) l'adresse locale de l'expéditeur (192.168.1.10) car celle-ci est inconnue d'Internet. Le routeur va substituer l'adresse locale de l'expéditeur par son adresse IP publique, c'est la Network Address Translation (NAT):
192.168.1.10 => 93.154.12.218.
Pour identifier sans ambiguïté les deux interlocuteurs, il sera nécessaire d'ajouter un port de communication en plus des adresses IP. Le couple adresse IP:Port est appelé socket réseau. En procédant d'une manière analogue aux adresses IP, le routeur va réaliser des translations de ports lors de communication entre différents réseaux: c'est la Port Address translation (PAT).

Hébergement d'applications

Il s'agit d'autoriser l'accès à des applications locales depuis Internet. Dans ce cas, les clients Internet connaissent uniquement l'IP publique du routeur de la Box (soit directement soit par l'intermédiaire d'un nom de domaine).
Pour un serveur Web qui écouterait sur le port 80 d'une machine 192.168.1.10, le routeur doit accepter des requêtes sur son IP publique et sur le port 80. Si ce routeur n'est pas affecté de régles, il va détruire tout le trafic entrant !
Il devient nécessaire de configurer des règles NAT/PAT sur le routeur afin d'autoriser certains trafics entrants depuis Internet. On pourra  par exemple, écrire une consigne pour que le trafic entrant sur le port 80 soit dirigé vers le port 1080 d'une machine locale 192.168.1.10.
  • 93.154.12.218:80 => 192.168.1.10:1080
  • 93.154.12.218:90 => 192.168.1.20:2090
  • ...

Intérêt du Reverse Proxy

Serveur de domaines

Depuis l'apparition des nano-pc, les réseaux domestiques ressemblent de plus en plus à de petits réseaux d'entreprises. On trouve désormais sur de nombreux réseaux domestiques: plusieurs serveurs (nano-pc) hébergeant chacun plusieurs services eux mêmes à l'écoute sur plusieurs ports ...
Il devient très difficile de se souvenir des différentes url et des règles NAT/PAT correspondantes. On peut éviter ces nombreuses règles en redirigeant la totalité du trafic entrant vers un Reverse Proxy qui traduira des requêtes de domaine pour les rediriger vers le service adéquat:
  • http://mondomaine.music.no-ip.biz => 192.168.1.10:1090
  • http://mondomaine.video.no-ip.biz => 192.168.1.11:1091
  • http://mondomaine.camera.no-ip.biz => 192.168.1.12:1092
  • ...

Blocage de ports

De plus, un Reverse Proxy sera très utile pour passer outre certains blocages de ports lors d'une connexion à un réseaux domestique depuis:
  • un réseau d'entreprise (proxy)
  • un réseau mobile
  • un hotspot wifi
  • ...

Connexions SSL

SSL est un protocole utilisé abondamment dans les réseaux domestiques pour sécuriser les accès depuis Internet. En effet, on supposera que personne ne souhaite émettre en clair sur Internet ses informations de connexion pour accéder à des applications Web d'un réseau domestique ...
Un reverse proxy de type NginX peut aussi assurer le rôle d'un front-end HTTPS vers de multiples back-end HTTP. Dans ce cas, le protocole SSL sera entièrement géré par NginX en front-end Internet afin de conserver un simple protocole HTTP pour l'intégralité du réseau domestique local:
[Internet] (web browser) HTTPS [Réseau domestique](front-end Nginx) HTTP (back-end services)

Reverse proxy NginX

Installation et configuration

L'installation du paquet nginx se réalise très simplement depuis un système linux debian:
sudo apt-get install nginx 
 Puis il faut créer ou mettre à jour le fichier de configuration du proxy localisé sous /etc/nginx/nginx.conf:

user www-data;
worker_processes 4;
pid /var/run/nginx.pid;
events {
    worker_connections 768;
}
http {
    # Basic Settings
    sendfile on;
    tcp_nopush on;
    tcp_nodelay on;
    keepalive_timeout 65;
    types_hash_max_size 2048;    include /etc/nginx/mime.types;
    default_type application/octet-stream;
    # Logging Settings
    access_log /var/log/nginx/access.log;
    error_log /var/log/nginx/error.log;
    # Gzip Settings
    gzip on;
    gzip_disable "msie6";
    # Virtual Host Configs
    include /etc/nginx/conf.d/*.conf;
    include /etc/nginx/sites-enabled/*;
}


Maintenant, que le proxy NginX est prêt à fonctionner, il faut définir comment NginX va réagir aux requêtes qu’il recevra. Pour cela, il faut écrire des règles de redirection dans un fichier de configuratio localisé sous le répertoire /etc/nginx/sites-enabled.


Les fichiers de configuration des sites actifs contenus sous le répertoire /etc/nginx/sites-enabled  sont en général des liens symboliques vers le répertoire /etc/nginx/sites-available

pi@rpi-proxy /etc/nginx $ ls -alrht /etc/nginx/sites-enabled/
total 8,0K
drwxr-xr-x 5 root root 4,0K aout   9 21:09 ..
lrwxrwxrwx 1 root root   39 nov.  29 17:21 default -> /etc/nginx/sites-available/domain_no-ip
drwxr-xr-x 2 root root 4,0K nov.  29 17:27
.

NginX prenant en compte les règles dans l’ordre, il faut commencer par lui dire que toutes les requêtes pour un domaine donné arrivant par un port donné doivent être renvoyées vers le serveur web. Dans l'exemple ci-dessous, on demande à NginX d’écouter le port 80 et de rediriger les requêtes pour le domaine tom23.com vers le serveur web situé sur l’ip 192.168.2.56 du réseau domestique local.
server { 
    listen 80; 
    server_name tom23.com; 
    location / { 
        proxy_pass http://192.168.2.56/  
    } 
}

SSL et certificats auto-signé

Il faut d'abord  installer openssl afin de créer les clés SSL et le certificat :

apt-get install openssl
Sous le répertoire /etc/ngnix, il faut genérer une clé RSA en 1024 bits:
openssl genrsa -out ngnix.key 1024
A partir de cette clé, on va pouvoir créer le certificat générique:
openssl req -new -key nginx.key -out nginx.csr
Puis on crée finalement le certificat au format x509:
openssl x509 -req -days 365 -in nginx.csr -signkey nginx.key -out nginx.crt

La configuration du serveur NginX se fait par modification du fichier contenu
dans le répertoire /etc/nginx/sites-enable:
server {
    listen 443;
    server_name localhost;
    root html;
    index index.html index.htm;
    ssl on;
    ssl_certificate nginx.crt;
    ssl_certificate_key nginx.key;
    ssl_session_timeout 5m;
    ssl_protocols SSLv3 TLSv1;
    ssl_ciphers ALL:!ADH:!EXPORT56:RC4+RSA:+HIGH:+MEDIUM:+LOW:+SSLv3:+EXP;
    ssl_prefer_server_ciphers on;
    location / {
        proxy_pass http://tom23:8080;
    }
    location /toto {
        proxy_pass http://tom24:8026/toto;
    }
}
server {
    listen 443;
    server_name toto.no-ip.biz;
    root html;
    index index.html index.htm;
    ssl on;
    ssl_certificate nginx.crt;
    ssl_certificate_key nginx.key;
    ssl_session_timeout 5m;
    ssl_protocols SSLv3 TLSv1;
    ssl_ciphers ALL:!ADH:!EXPORT56:RC4+RSA:+HIGH:+MEDIUM:+LOW:+SSLv3:+EXP;
    ssl_prefer_server_ciphers on;

    location / {
        try_files $uri $uri/ =404;
    }
    location /toto {
        proxy_pass http://
tom24:8026/toto;
    }
}
server {
    listen 443;
    server_name titi.no-ip.biz;
    root html;
    index index.html index.htm;
    ssl on;
    ssl_certificate nginx.crt;
    ssl_certificate_key nginx.key;
    ssl_session_timeout 5m;
    ssl_protocols SSLv3 TLSv1;
    ssl_ciphers ALL:!ADH:!EXPORT56:RC4+RSA:+HIGH:+MEDIUM:+LOW:+SSLv3:+EXP;
    ssl_prefer_server_ciphers on;

    location / {
        proxy_pass http://tom25:8080;
    }
}

Création de domaines No-Ip

Service No-Ip

Les routeurs des box ADSL Orange reposent sur un adressage IP dynamique. Cette caractéristique peut conduire à utiliser des noms de domaines pour atteindre le routeur d'une box depuis Internet.
En effet, il sera difficile de contacter directement un routeur avec une adresse IP susceptible de changer régulièrement...
No-Ip est un service gratuit qui autorise la création de plusieurs noms de domaines. Après la création d'un ou plusieurs noms de domaines, il faudra configurer le routeur de la box ADSL afin qu'il transmette au site No-Ip chaque nouveau changement de son adresse IP externe.
Finalement, il ne sera plus nécessaire de connaitre l'adresse IP externe du routeur, car on pourra saisir son nom de domaine depuis Internet pour accèder à la Box ADSL.

Création d'un compte

Dans un premier temps, il est nécessaire de créer un compte sur le site www.no-ip.com.

Création d'un domaine

La création d'un nom de domaine s'effectue depuis le menu Add a Host de la page principale.
Il suffit de choisir un nom de domaine puis de valider avec l'aide du bouton Add Host

Configuration du routeur ADSL

Finalement, il faudra configurer le routeur ADSL afin qu'il informe automatiquement le service No-Ip lors des changements d’adresse IP externe. Le site No-Ip associera cette nouvelle adresse IP externe au nom de domaine. Cette étape est dépendante de chaque type de routeur ADSL et l’exemple ci-dessous est relatif à une Livebox d'Orange.
Il faut d'abord se connecter sur le serveur Web de configuration de la Livebox (http://192.168.1.1), puis sélectionner l'onglet configuration avancée et le menu DynDNS.

samedi 15 août 2015

Domoticz sur BeagleBone

Introduction


Cet article résume la procèdure de compilation et d'installation de Domoticz sur une carte BeagleBone Black (rev B) configurée avec une distribution Linux Debian 8 (Jessie).

Prérequis


  • Un serveur Linux/Debian
  • Les outils de compilation C++
  • La librairie open-zwave pour utiliser ce protocole
  • Un client Subversion

Client git

Le client git s'installe depuis le repository de paquets Debian avec la commande suivante:
sudo apt-get install git

Outils de compilation C++

Les librairies nécessaires à la compilation s'installent avec les deux commandes suivantes:
sudo apt-get install build-essential -y
sudo apt-get install cmake libboost-dev libboost-thread-dev libboost-system-dev libsqlite3-dev curl libcurl4-openssl-dev libusb-dev zlib1g-dev libssl-dev

Compilation d'openZWave


Installer la dépendance libudev:
sudo apt-get install libudev-dev

Depuis le répertoire racine des compilations qui est par défaut /home/debian:
Récupérer les sources depuis github avec l'aide de la commande suivante:
git clone https://github.com/OpenZWave/open-zwave.git

Lancer la compilation:
/home/debian$ make

La sortie standard de la commande make devrait ressembler aux lignes suivantes (noter la version 1.3.437):
make -C /home/debian/open-zwave/cpp/build/ -
make[1]: Entering directory '/home/debian/open-zwave/cpp/build'
Building OpenZWave Version 1.3-437-g09a092
...
Linking Static Library
Linking Shared Library
make[1]: Leaving directory '/home/debian/open-zwave/cpp/build'
make -C /home/
debian/open-zwave/cpp/examples/MinOZW/ -
make[1]: Entering directory '/home/debian/open-zwave/cpp/examples/MinOZW'
Building Main.o
Linking /home/
debian/open-zwave/.lib/MinOZW
g++ -o /home/
debian/open-zwave/.lib/MinOZW /home/debian/open-zwave/.lib/Main.o /home/debian/open-zwave/libopenzwave.so -pthread
Creating Temporary Shell Launch Script
make[1]: Leaving directory '/home/
debian/open-zwave/cpp/examples/MinOZW'

Création d'un lien vers libOpenZWave


La librairie OpenZwave compilée précedemment correspond à la version 1.3-437. Je recommande la création d'un lien symbolique vers cette librairie depuis le répertoire racine utilisé pour les compilations (/home/debian):

ls -al
drwxr-xr-x 23 debian debiann  4096 Aug 9 15:23 domoticz
drwxr-xr-x 11 debian debian  4096 Aug 9 16:07 open-zwave

mv open-zwave ozw-1.3.434
ln -s ozw-1.3.434 ozw 

ls -al
drwxr-xr-x 23 debiandebian  4096 Aug 9 15:23 domoticz
lrwxrwxrwx 1 debiandebian  11 Aug 9 16:13 ozw -> ozw-1.3.434
drwxr-xr-x 11 debiandebian  4096 Aug 9 16:07 ozw-1.3.434

Compilation de domoticz



Etat des lieux

La commande free -mh affiche la quantité de RAM utilisée:
                              total       used       free     shared    buffers    cached
Mem:                     490M     102M      387M  8,3M       15M        51M
-/+ buffers/cache:  35M       455M
Swap:                     0B         0B            0B

La commande df -h affiche la liste des systémes de fichiers montés ainsi que leurs points de montage et taux d'occupation.
Sys. de fichiers   Taille  Utilisé   Dispo   Utilisé   Monté sur
udev                    10M    0          10M      0% /dev
tmpfs                   99M    4,3M    94M      5% /run
/dev/mmcblk0p1 1,8G    1,1G     573M    66% /
tmpfs                   246M  0          246M    0% /dev/shm
tmpfs                   5,0M   4,0K     5,0M     1% /run/lock
tmpfs                   246M  0          246M     0% /sys/fs/cgroup


Création d'un espace de swap

La commande free montre que ce système ne possède pas d'espace de swap.
L'utilisation de librairies templates comme boost requiert beaucoup de mémoire pendant l'étape de compilation de domoticz, en particulier lors de la fabrication du serveur Web. Afin de garantir le succès de cette étape, je recommande d'ajouter un RAM disk pour permettre au système de swapper s'il ne dispose pas de la quantité de memoire physique nécessaire.

Le file système dispose de 573Mo libre, on peut donc créer un espace de swap temporaire de 256Mo.

La commande suivante permet de créer un fichier d'une capacité de 256Mo pour le futur espace de swap (1024*256 = 262144 blocks).

sudo dd if=/dev/zero of=/swapfile bs=1024 count=262144

262144+0 enregistrements lus
262144+0 enregistrements écrits
268435456 octets (268 MB) copiés, 34,4415 s, 7,8 MB/s


Ensuite, il convient de sécuriser les accès à cet espace mémoire:

sudo chown root:root /swapfile
sudo chmod 0600 /swapfile

Enfin, on définit puis on active cet espace de swap avec l'aide des commandes suivantes:
sudo mkswap /swapfile

Setting up swapspace version 1, size = 262140 KiB
no label, UUID=d1868600-d866-4982-a4f5-e7ee0abd580f


sudo swapon /swapfile
                              total       used       free       shared    buffers     cached
Mem:                     490M     330M      160M    4,3M       7,7M        287M
-/+ buffers/cache:  34M       455M
Swap:                    255M      0B           255M

Compilation

Depuis le répertoire racine des compilations (/home/debian).
Récupérer les sources depuis le repository git hub avec l'aide de la commande suivante:
git clone https://github.com/domoticz/domoticz.git domoticz

Aller dans le réperoire domoticz et modifier le chemin de recherche de la librarie openZWave dans le fichier CMakeLists.txt:

cd domoticz; vi  CMakeLists.txt:

# try to find open-zwave, if found, include supportfind_library(OpenZWave NAMES libopenzwave.a HINTS "../ozw" "../ozw/cpp/build")

Lancer la fabrication du makefile avec la commande suivante:
cmake -DCMAKE_BUILD_TYPE=Release .

La sortie standard de la commande cmake devrait ressembler aux lignes suivantes (noter la révision 2737 ainsi que la détection de libopenzwave):

-- Compiling Revision #2737
-- Boost version: 1.49.0
-- Found the following Boost libraries:
--   thread
--   date_time
--   system
-- Linking against boost static libraries
-- Found ZLIB: /usr/lib/arm-linux-gnueabihf/libz.so (found version "1.2.7")
-- ZLIB libraries found at: /usr/lib/arm-linux-gnueabihf/libz.so
-- ZLIB includes found at: /usr/include
-- Found CURL: /usr/lib/arm-linux-gnueabihf/libcurl.so (found version "7.26.0")
-- Curl libraries found at: /usr/lib/arm-linux-gnueabihf/libcurl.so
-- Curl includes found at: /usr/include
-- Found LIBUSB: /usr/lib/arm-linux-gnueabihf/libusb.so 
-- LIBUSB found at: /usr/lib/arm-linux-gnueabihf/libusb.so
-- Crypto library found at: /usr/lib/arm-linux-gnueabihf/libcrypto.so
-- /home/debian/ozw/libopenzwave.a
 

 Lancer la compilation de domoticz avec l'aide de la commande:
make
... 
Linking C static library liblua.a
[ 19%] Built target lua
Scanning dependencies of target mqtt
[ 19%] Building C object MQTT/CMakeFiles/mqtt.dir/mosquitto.c.o
[ 20%] Building C object MQTT/CMakeFiles/mqtt.dir/logging_mosq.c.o
[ 20%] Building C object MQTT/CMakeFiles/mqtt.dir/memory_mosq.c.o
[ 21%] Building C object MQTT/CMakeFiles/mqtt.dir/messages_mosq.c.o
[ 21%] Building C object MQTT/CMakeFiles/mqtt.dir/net_mosq.c.o
[ 22%] Building C object MQTT/CMakeFiles/mqtt.dir/read_handle.c.o
[ 22%] Building C object MQTT/CMakeFiles/mqtt.dir/read_handle_client.c.o
[ 23%] Building C object MQTT/CMakeFiles/mqtt.dir/read_handle_shared.c.o
[ 24%] Building C object MQTT/CMakeFiles/mqtt.dir/send_client_mosq.c.o
[ 24%] Building C object MQTT/CMakeFiles/mqtt.dir/send_mosq.c.o
[ 25%] Building C object MQTT/CMakeFiles/mqtt.dir/socks_mosq.c.o
[ 25%] Building C object MQTT/CMakeFiles/mqtt.dir/srv_mosq.c.o
[ 26%] Building C object MQTT/CMakeFiles/mqtt.dir/thread_mosq.c.o
[ 26%] Building C object MQTT/CMakeFiles/mqtt.dir/time_mosq.c.o
[ 27%] Building C object MQTT/CMakeFiles/mqtt.dir/tls_mosq.c.o
[ 27%] Building C object MQTT/CMakeFiles/mqtt.dir/util_mosq.c.o
[ 28%] Building C object MQTT/CMakeFiles/mqtt.dir/will_mosq.c.o
Linking C static library libmqtt.a
[ 28%] Built target mqtt
Scanning dependencies of target sqlite
...

Remarque

L'espace de swap est recommandé puisque lors de la phase de compilation du serveur web:
[ 36%] Building CXX object CMakeFiles/domoticz.dir/main/WebServer.cpp.o

Le système réalise quelques opérations de swap (14Mo):
             total         used       free      shared   buffers    cached
Mem:                     490M     456M   33M       280K       636K       
-/+ buffers/cache:  431M     59M
Swap:                     255M     14M     241M

Suppression du swap

La commande suivante desactive l'espace de swap:
sudo swapoff /swapfile

La commande suivante supprime le fichier de swap correspond:
sudo rm /swapfile

Création d'un lien vers domoticz


La version de domoticz compilée précedemment correspond à la révision  2737. Je recommande la création d'un lien symbolique vers cette librairie depuis le répertoire racine utilisé pour les compilations ((/home/debian):

ls -alh
drwxr-xr-x 25 pi   debian   4.0K Aug  9 19:35 domoticz
lrwxrwxrwx  1 debian   debian     11 Aug  9 16:13 ozw -> ozw-1.3.434
drwxr-xr-x 11 debian   debian   4.0K Aug  9 16:07 ozw-1.3.434
mv domoticz domoticz-2737
ln -s domoticz-2737 domoticz

ls -al
lrwxrwxrwx  1 debian   debian       13 Aug  9 19:39 domoticz -> domoticz-2737
drwxr-xr-x 25 debian   debian     4096 Aug  9 19:35 domoticz-2737
lrwxrwxrwx  1 debian   debian       11 Aug  9 16:13 ozw -> ozw-1.3.434
drwxr-xr-x 11 debian   debian     4096 Aug  9 16:07 ozw-1.3.434

Démarrage


Pour démarrer domoticz sous la forme d'un service recopier le script  domoticz.sh sous le répertoire /etc/init.d:
sudo cp domoticz.sh /etc/init.d 
sudo chmod +x /etc/init.d/domoticz.sh 
sudo update-rc.d domoticz.sh defaults 

Editer le script afin de mettre à jour le chemin d'accès au programme domoticz: 
sudo vi /etc/init.d/domoticz.sh 
DAEMON=/home/debian/domoticz/domoticz

Le script permet aussi de changer le port utilisé par l'interface Web:
OPTIONS=-www 8080

domoticz peut maintenant être supervisé avec les commandes suivantes:
sudo service domoticz.sh start
sudo service domoticz.sh stop
sudo service domoticz.sh status

Gestion des services


La commande update-rc.d permet d'ajouter, modifier ou supprimer un service.

Ajout

La commande update-rc.d [-n] domoticz.sh defaults ajoute le service domoticz (l’option -n permet de tester la commande sans la jouer).

Suppression

La commande update-rc.d domoticz.sh remove desactive le service domoticz. Cependant, si on souhaite réactiver le service ultérieurement, on pourra exécuter de nouveau la commande suivante: update-rc.d domoticz.sh defaults.

dimanche 9 août 2015

Domoticz sur Raspbian

Introduction


Cet article résume la procèdure de compilation et d'installation de Domoticz sur une carte Raspberry Pi (1 model B) configurée avec une distribution Linux Debian 7 (Wheezy).

Prérequis


  • Un serveur Linux/Debian
  • Les outils de compilation C++
  • La librairie open-zwave pour utiliser ce protocole
  • Un client git

Client git

Le client git s'installe depuis le repository de paquets Debian avec la commande suivante:
sudo apt-get install git

Outils de compilation C++

Les librairies nécessaires à la compilation s'installent avec les deux commandes suivantes:
sudo apt-get install build-essential -y
sudo apt-get install cmake libboost-dev libboost-thread-dev libboost-system-dev libsqlite3-dev curl libcurl4-openssl-dev libusb-dev zlib1g-dev libssl-dev

Compilation d'openZWave


Installer la dépendance libudev:
sudo apt-get install libudev-dev

Depuis le répertoire racine des compilations qui est par défaut /home/pi:
Récupérer les sources depuis github avec l'aide de la commande suivante:
git clone https://github.com/OpenZWave/open-zwave.git

Lancer la compilation:
cd open-zwave; make

La sortie standard de la commande make devrait ressembler aux lignes suivantes (noter la version 1.3.434):
make -C /home/pi/open-zwave/cpp/build/ -
make[1]: Entering directory '/home/pi/open-zwave/cpp/build'
Building OpenZWave Version 1.3-434-g09a092
...
Linking Static Library
Linking Shared Library
make[1]: Leaving directory '/home/pi/open-zwave/cpp/build'
make -C /home/pi/open-zwave/cpp/examples/MinOZW/ -
make[1]: Entering directory '/home/pi/open-zwave/cpp/examples/MinOZW'
Building Main.o
Linking /home/pi/open-zwave/.lib/MinOZW
g++ -o /home/pi/open-zwave/.lib/MinOZW /home/pi/open-zwave/.lib/Main.o /home/pi/open-zwave/libopenzwave.so -pthread
Creating Temporary Shell Launch Script
make[1]: Leaving directory '/home/pi/open-zwave/cpp/examples/MinOZW'

Création d'un lien vers libOpenZWave


La librairie OpenZwave compilée précedemment correspond à la version 1.3-434. Je recommande la création d'un lien symbolique vers cette librairie depuis le répertoire racine utilisé pour les compilations ((/home/pi):

ls -al
drwxr-xr-x 23 pi pi 4096 Aug 9 15:23 domoticz
drwxr-xr-x 11 pi pi 4096 Aug 9 16:07 open-zwave

mv open-zwave ozw-1.3.434
ln -s ozw-1.3.434 ozw 

ls -al
drwxr-xr-x 23 pi pi 4096 Aug 9 15:23 domoticz
lrwxrwxrwx 1 pi pi 11 Aug 9 16:13 ozw -> ozw-1.3.434
drwxr-xr-x 11 pi pi 4096 Aug 9 16:07 ozw-1.3.434

Compilation de domoticz


Depuis le répertoire racine des compilations (/home/pi).
Récupérer les sources depuis le git hub avec l'aide de la commande suivante:
git clone https://github.com/domoticz/domoticz.git domoticz

Aller dans le réperoire domoticz et modifier le chemin de recherche de la librarie openZWave dans le fichier CMakeLists.txt:

cd domoticz; vi  CMakeLists.txt:

# try to find open-zwave, if found, include supportfind_library(OpenZWave NAMES libopenzwave.a HINTS "../ozw" "../ozw/cpp/build")

Lancer la fabrication du makefile avec la commande suivante:
cmake -DCMAKE_BUILD_TYPE=Release .

La sortie standard de la commande cmake devrait ressembler aux lignes suivantes (noter la révision 2709 ainsi que la détection de libopenzwave):

-- Compiling Revision #2709
-- Boost version: 1.49.0
-- Found the following Boost libraries:
--   thread
--   date_time
--   system
-- Linking against boost static libraries
-- Found ZLIB: /usr/lib/arm-linux-gnueabihf/libz.so (found version "1.2.7")
-- ZLIB libraries found at: /usr/lib/arm-linux-gnueabihf/libz.so
-- ZLIB includes found at: /usr/include
-- Found CURL: /usr/lib/arm-linux-gnueabihf/libcurl.so (found version "7.26.0")
-- Curl libraries found at: /usr/lib/arm-linux-gnueabihf/libcurl.so
-- Curl includes found at: /usr/include
-- Found LIBUSB: /usr/lib/arm-linux-gnueabihf/libusb.so 
-- LIBUSB found at: /usr/lib/arm-linux-gnueabihf/libusb.so
-- Crypto library found at: /usr/lib/arm-linux-gnueabihf/libcrypto.so
-- /home/pi/ozw/libopenzwave.a
 

 Lancer la compilation de domoticz avec l'aide de la commande:
make

Création d'un lien vers domoticz


La version de domoticz compilée précedemment correspond à la révision  2709. Je recommande la création d'un lien symbolique vers cette librairie depuis le répertoire racine utilisé pour les compilations ((/home/pi):

ls -alh
drwxr-xr-x 25 pi   pi   4.0K Aug  9 19:35 domoticz
lrwxrwxrwx  1 pi   pi     11 Aug  9 16:13 ozw -> ozw-1.3.434
drwxr-xr-x 11 pi   pi   4.0K Aug  9 16:07 ozw-1.3.434
mv domoticz domoticz-2709
ln -s domoticz-2709 domoticz

ls -al
lrwxrwxrwx  1 pi   pi       13 Aug  9 19:39 domoticz -> domoticz-2709
drwxr-xr-x 25 pi   pi     4096 Aug  9 19:35 domoticz-2709
lrwxrwxrwx  1 pi   pi       11 Aug  9 16:13 ozw -> ozw-1.3.434
drwxr-xr-x 11 pi   pi     4096 Aug  9 16:07 ozw-1.3.434

Démarrage


Pour démarrer domoticz sous la fomre d'un service recopier le script  domoticz.sh sous le répertoire /etc/init.d:
sudo cp domoticz.sh /etc/init.d 
sudo chmod +x /etc/init.d/domoticz.sh 
sudo update-rc.d domoticz.sh defaults 

Editer le script afin de mettre à jour le chemin d'accès au programme domoticz: 
sudo vi /etc/init.d/domoticz.sh DAEMON=/home/pi/domoticz/domoticz

Le script permet aussi de changer le port utilisé par l'interface Web:
OPTIONS=-www 8080

domoticz peut maintenant être supervisé avec les commandes suivantes:
sudo service domoticz.sh start
sudo service domoticz.sh stop
sudo service domoticz.sh status

Gestion des services


La commande update-rc.d permet d'ajouter, modifier ou supprimer un service.

Ajout

La commande update-rc.d [-n] domoticz.sh defaults ajoute le service domoticz (l’option -n permet de tester la commande sans la jouer).

Suppression

La commande update-rc.d domoticz.sh remove desactive le service domoticz. Cependant, si on souhaite réactiver le service ultérieurement, on pourra exécuter de nouveau la commande suivante: update-rc.d domoticz.sh defaults.



OpenZWave - OZWCP

Introduction


Cet article résume la procèdure de compilation et d'installation d'OpenZWave Control Panel (OZWCP) sur une carte Raspberry Pi (1 model B) configurée avec une distribution Linux Debian 7 (Wheezy).

Prérequis


  • Un serveur Linux/Debian
  • Les outils de compilation C++
  • La librairie open-zwave pour utiliser ce protocole
  • Des client git et subversion

Clients git et subversion

Le client git s'installe depuis le repository de paquets Debian avec la commande suivante:
sudo apt-get install git subversion

Outils de compilation C++

Les librairies nécessaires à la compilation s'installent avec les deux commandes suivantes:
sudo apt-get install build-essential -y

Compilation d'openZWave


Installer la dépendance libudev:
sudo apt-get install libudev-dev

Depuis le répertoire racine des compilations qui est par défaut /home/pi:
Récupérer les sources depuis github avec l'aide de la commande suivante:
git clone https://github.com/OpenZWave/open-zwave.git

Lancer la compilation:
cd open-zwave; make

La sortie standard de la commande make devrait ressembler aux lignes suivantes (noter la version 1.3.434):
make -C /home/pi/open-zwave/cpp/build/ -
make[1]: Entering directory '/home/pi/open-zwave/cpp/build'
Building OpenZWave Version 1.3-434-g09a092
...
Linking Static Library
Linking Shared Library
make[1]: Leaving directory '/home/pi/open-zwave/cpp/build'
make -C /home/pi/open-zwave/cpp/examples/MinOZW/ -
make[1]: Entering directory '/home/pi/open-zwave/cpp/examples/MinOZW'
Building Main.o
Linking /home/pi/open-zwave/.lib/MinOZW
g++ -o /home/pi/open-zwave/.lib/MinOZW /home/pi/open-zwave/.lib/Main.o /home/pi/open-zwave/libopenzwave.so -pthread
Creating Temporary Shell Launch Script
make[1]: Leaving directory '/home/pi/open-zwave/cpp/examples/MinOZW'

Création d'un lien vers libOpenZWave


La librairie OpenZwave compilée précedemment correspond à la version 1.3-434. Je recommande la création d'un lien symbolique vers cette librairie depuis le répertoire racine utilisé pour les compilations ((/home/pi):

ls -al
drwxr-xr-x 23 pi pi 4096 Aug 9 15:23 domoticz
drwxr-xr-x 11 pi pi 4096 Aug 9 16:07 open-zwave

mv open-zwave ozw-1.3.434
ln -s ozw-1.3.434 ozw 

ls -al
drwxr-xr-x 23 pi pi 4096 Aug 9 15:23 domoticz
lrwxrwxrwx 1 pi pi 11 Aug 9 16:13 ozw -> ozw-1.3.434
drwxr-xr-x 11 pi pi 4096 Aug 9 16:07 ozw-1.3.434

Compilation d'OZWCP


Codes sources  Libmicrohttpd

Depuis le répertoire racine des compilations qui est par défaut /home/pi, récupérer les sources du serveur http utilisé par ozwcp avec l'aide de la commande suivante:
wget http://ftpmirror.gnu.org/libmicrohttpd/libmicrohttpd-0.9.42.tar.gz

Compilation de libmicrohttpd

Depuis le répertoire racine des compilations qui est par défaut /home/pi, la compilation de serveur http se réalise avec l'aide des commandes suivantes:
tar -xvzf ./libmicrohttpd-0.9.42.tar.gz
rm libmicrohttpd-0.9.42.tar.gz
cd libmicrohttpd-0.9.42
./configure
make 

Création d'un lien vers libmicrohttpd

La librairie libmcrohttpd  correspond à la version 0.9.42. Je recommande la création d'un lien symbolique vers cette librairie depuis le répertoire racine utilisé pour les compilations ((/home/pi):
ln -s ./libmicrohttpd-0.9.42 libmicrohttpd

drwxr-xr-x 25 pi   pi   4,0K août  18 20:39 domoticz-2709
lrwxrwxrwx  1 pi   pi     22 août  27 09:55 libmicrohttpd -> ./libmicrohttpd-0.9.42
drwxr-xr-x  7 pi   pi   4,0K août  27 09:44 libmicrohttpd-0.9.42
lrwxrwxrwx  1 pi   pi     11 août   9 18:13 ozw -> ozw-1.3.434
drwxr-xr-x 11 pi   pi   4,0K août   9 18:07 ozw-1.3.434

Codes source ozwcp

Depuis le répertoire racine des compilations qui est par défaut /home/pi, récupérer les sources depuis un repository subversion avec l'aide de la commande suivante:
svn checkout http://openzwave-control-panel.googlecode.com/svn/trunk/ ozwcp

Compilation d'OZWCP

La compilation d'OZWCP se réalise sous le répertoire ozwcp et nécessite une modification du fichier Makefile:
#
# Makefile for OpenzWave Control Panel application
# Greg Satz

# GNU make only

.SUFFIXES:      .cpp .o .a .s

CC     := $(CROSS_COMPILE)gcc
CXX    := $(CROSS_COMPILE)g++
LD     := $(CROSS_COMPILE)g++
AR     := $(CROSS_COMPILE)ar rc
RANLIB := $(CROSS_COMPILE)ranlib

DEBUG_CFLAGS    := -Wall -Wno-unknown-pragmas -Wno-inline -Wno-format -g -DDEBUG
RELEASE_CFLAGS  := -Wall -Wno-unknown-pragmas -Wno-format -O3 -DNDEBUG

DEBUG_LDFLAGS   := -g -lrt

# Change for DEBUG or RELEASE
CFLAGS  := -c $(DEBUG_CFLAGS)
LDFLAGS := $(DEBUG_LDFLAGS)

OPENZWAVE := ../ozw
LIBMICROHTTPD := ../libmicrohttpd/src/microhttpd/.libs/libmicrohttpd.a

INCLUDES := -I $(OPENZWAVE)/cpp/src -I $(OPENZWAVE)/cpp/src/command_classes/ \
        -I $(OPENZWAVE)/cpp/src/value_classes/ -I $(OPENZWAVE)/cpp/src/platform/ \
        -I $(OPENZWAVE)/cpp/src/platform/unix -I $(OPENZWAVE)/cpp/tinyxml/ \
        -I ../libmicrohttpd/src/include

# Remove comment below for gnutls support
GNUTLS := -lgnutls -lgcrypt

# for Linux uncomment out next three lines
LIBZWAVE := $(wildcard $(OPENZWAVE)/*.a)
LIBUSB := -ludev
LIBS := $(LIBZWAVE) $(GNUTLS) $(LIBMICROHTTPD) -pthread $(LIBUSB)

Exécution d'OZWCP

Depuis le répaertoire de compilation d'OZWCP (/home/pi/ozwcp), créer un lien symbolique vers le répertoire de configuration d'open zwave: 
 ~/ozwcp $ ln -s ../ozw/config/ ./config

Lancer le serveur Web avec l'aide de la commande suivante, puis se connecter depuis un web browser:
~/ozwcp $ ./ozwcp -p 9090

2015-08-27 10:13:20.399 Always, OpenZwave Version 1.3.434 Starting Up
webserver starting port 9090





TIC - Graphique conso

Visualisation de données TIC


La TéléInformation Client (TIC) est une spécification d'interface mise en place par EDF dans ses compteurs bleus électroniques (CBE). Un article précédent résume comment les données TIC sont sauvegardées dans une base MySQL sur une carte BeagleBone.
Cet article décrit comment visualiser les données TIC d'une base MySQL avec module PHP inclus dans un serveur Apache.

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.

Application PHP/MySQL


 Les sources de l'application PHP/MySQL proviennent du site GitHub BmdOnline. Le modèles de données a subi quelques adaptations pour supporter l'abonnement EDF tempo. Les graphiques qui reposent sur une librairie Javascript (Highcharts) utilisent le code d'origine.

Puissance instantanée

Consommantion actuelle


Données historiques (3D)


samedi 8 août 2015

TIC sur BeagleBone

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)


Les compteurs bleus électroniques sont des objets communicants qui offrent
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 informations de TIC sont transmises cycliquement en série sur la ligne et chaque donnée est précédée d’une étiquette permettant de l’identifier. L’ensemble des informations transmis dépend de la programmation du compteur. Ce point est important pour la réalisation des algorithmes de lecture qui doivent interpréter des trames selon le type d'abonnement. Les groupes d’informations inutiles, compte tenu du mode de fonctionnement programmé, ne sont pas émis.
Les grandeurs fournies par la sortie téléinfo sont classées en deux catégories:
  1. Information sur le client: tarif, puissance souscrite ...
  2. La consommation du client: puissance appelée, Index, Intensité instantanée ...
Les grandeurs sont mises à jour environ chaque seconde, ce qui permet de suivre leur évolution au cours du temps avec une résolution de l'ordre de 1Hz.

Accessoires


  • Carte BeagleBone Black configurée avec une distribution Linux Debian.
  • Démodulateur des trames TIC et circuit FTDI.
Les informations de TIC sont émises cycliquement sous forme de messages composés d’une étiquette d’identification suivie généralement d’une valeur. Le signal est modulé à 50 KHz: la présence de modulation correspondant à un 0 logique, l’absence à un 1 logique. Il est donc nécessaire de démoduler ce signal pour obtenir une suite de caractères ASCII (émise à 1200 bits/s, 7 bits/caractères, parité paire, 1 bit de stop).Chaque information débute par le caractère LF (0A hexa), suivie de l’étiquette et de sa valeur associée, puis se termine par le caractère CR (0D).
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