Code : Tout sélectionner
#!#!/usr/bin/env python
# coding=UTF-8
# Script Cozytouch pour Domoticz
# Auteur : OBone
version=1
import requests,shelve,json,time,unicodedata,os
'''
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Réglages des paramètres
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
'''
domoticz_ip='xxx'
domoticz_port='xxx'
login="xxxx"
password="xxx"
'''
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Fin des réglages des paramètres
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
'''
'''
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Commentaires
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Ce script permet de récupérer les données d'un compte Cozytouch stockées sur le cloud
Etapes du script :
- Au démarrage, on établi la connexion TLS avec le serveur
- On interroge le serveur via une requete GET avec l'identifiant de session (cookie transmis préalablement par le serveur lors de l'identification)
- Si la réponse est OK (200): on lance les interrogations pour rafraichir les devices et on transmet le tout à Domoticz
- Si la réponse est NOK (autre que 200) : on tente une connexion avec une requete POST avec les identifiants,
une fois connecté, on sauvegarde l'identificant de session transmis par le serveur (cookie) pour les futures interrogations.
- Ensuite on scanne les devices contenus dans l'api cozytouch, on ne retient que les devices dont l'url contient un '#1' (device principal)
- Si le device est connu via son nom de classe, on créé un dictionnaire contenant ses données
- On ajoute les dictionnaires à une liste que l'on balaye et compare aux devices de l'api Cozytouch à chaque démarrage
'''
'''
**********************************************************
Variables globlales
**********************************************************
'''
global url_defaut, cookies, url_creation_domoticz
url_defaut='https://ha110-1.overkiz.com/enduser-mobile-web/externalAPI/json/'
url_creation_domoticz='http://'+domoticz_ip+":"+domoticz_port+'/json.htm?type='
'''Dictionnaire devices principaux cozytouch :
permet d'identifier les devices lors de la fonction découverte
AtlanticElectricalHeaterWithAdjustableTemperatureSetpointIOComponent = radiateur,
AtlanticDomesticHotWaterProductionIOComponent = chauffe eau
'''
dict_cozytouch = {}
dict_cozytouch['radiateur']='io:AtlanticElectricalHeaterWithAdjustableTemperatureSetpointIOComponent'
dict_cozytouch['chauffe eau']='io:AtlanticDomesticHotWaterProductionIOComponent'
'''
**********************************************************
Fonctions génériques pour Domoticz
**********************************************************
'''
def write_log(message):
"""Fonction d'ecriture log dans Domoticz
message : string
"""
send=requests.get(url_creation_domoticz+'command¶m=addlogmessage&message='+str(message))
def write_device(valeur, idx):
"""Fonction écriture device domoticz
valeur : données à inscrire, idx : idx domoticz
"""
valeur=str(valeur)
idx=str(idx)
send=requests.get(url_creation_domoticz+'command¶m=udevice&idx='+idx+'&nvalue=0&svalue='+valeur)
def write_device_onoff(etat, idx):
''' Fonction d'écriture device light/switch
'''
etat=str(etat)
idx=str(idx)
send=requests.get(url_creation_domoticz+'command¶m=switchlight&idx='+idx+'&switchcmd='+etat)
def write_device_switch(level, idx):
''' Fonction d'écriture device selector switch
'''
level=str(level)
send=requests.get(url_creation_domoticz+'command¶m=switchlight&idx='+idx+'&switchcmd=Set%20Level&level='+level)
def read_device_data (idx):
''' Fonction de lecture d'un device analogique domoticz
renvoi un flottant
'''
idx=str(idx)
# Lecture de l'état du device
resp=requests.get(url_creation_domoticz+'devices&rid='+idx)
# Réponse HTTP 200 OK
if resp.status_code==200 :
data=json.loads(resp.text)
# Lecture de l'état du device
# Les données sont dans un dictionnaire ( [] ) d'où le [0]
select=float((data[u'result'][0][u'Data']))
return (select)
def read_user_variable (idx):
''' Fonction de lecture d'une variable utilisateur
renvoi la variable lue selon l'idx
'''
idx=str(idx)
# Lecture de l'état du device
resp=requests.get(url_creation_domoticz+'command¶m=getuservariables')
# Réponse HTTP 200 OK
if resp.status_code==200 :
data=json.loads(resp.text)
# Lecture de l'état du device
# Les données sont dans un dictionnaire ( [] ) d'où le [0]
select=(data[u'result'][0][u'Value'])
return select
def create_user_variable (nom_variable, valeur_variable):
''' création d'une variable utilisateur dans domoticz
renvoi l'idx créé
'''
resp=requests.get (url_creation_domoticz+'command¶m=saveuservariable&vname='+nom_variable+'&vtype=2&vvalue='+valeur_variable)
if resp.status_code==200 :
data=json.loads(resp.text)
if data[u'status'] == ('Variable name already exists!') or ('OK'):
resp=requests.get(url_creation_domoticz+'command¶m=getuservariables')
if resp.status_code==200 :
data=json.loads(resp.text)
for a in data[u'result']:
if a[u'Name'] == nom_variable:
idx = a[u'idx']
return idx
def rename_device(idx, nom):
''' renomme un device dans domoticz
'''
nom = str(nom)
# renomme un device domoticz
send=requests.get (url_creation_domoticz+'command¶m=renamedevice&idx='+idx+'&name='+nom)
def ajout_virtual_harware_domoticz ():
''' Fonction de création du virtual hardware (matériel/dummy)
'''
resp=requests.get(url_creation_domoticz+'command¶m=addhardware&htype=15&port=1&name=Cozytouch_V'+str(version)+'&enabled=true')
# Réponse HTTP 200 OK
if resp.status_code==200 :
data=json.loads(resp.text)
# Lecture de l'idx attribué
idx=(data[u'idx'])
else :
idx=0
return idx
def ajout_virtual_device_domoticz (idx,typ,nom,option='none'):
''' Fonction de création de device virtuel
'''
if option == 'none' :
req_option = ''
else :
req_option='&sensoroptions=1;'+str(option)
resp=requests.get(url_creation_domoticz+'createvirtualsensor&idx='+str(idx)+'&sensorname='+str(nom)+'+&sensortype='+str(typ)+req_option)
# Réponse HTTP 200 OK
if resp.status_code==200 :
data=json.loads(resp.text)
# Lecture de l'idx attribué
idx=(data[u'idx'])
print 'Ajout device :'+str(idx)
else :
idx=0
return idx
'''
**********************************************************
Fonctions génériques
**********************************************************
'''
def save (var, var_str):
"""Fonction de sauvegarde
var: valeur à sauvegarder, var_str: nom objet en mémoire
"""
d = shelve.open('cozytouch_save')
if not (var_str) in d :
d[var_str] = 0 # init variable
d[var_str] = var
d.close()
def restore (var_str):
'''Fonction de restauration
var_str: nom objet en mémoire
'''
d = shelve.open('cozytouch_save')
if not (var_str) in d :
value = 0 # init variable
else :
value = d[var_str]
d.close()
return value
def erreur_HTTP (code_erreur, texte_erreur):
''' Evaluation des exceptions HTTP '''
print "Erreur HTTP : "+str(code_erreur)+" "+texte_erreur
def requete_GET_test ():
''' Fonction d'interrogation HTTP GET, la réponse HTTP fournie permet
d'évaluer si l'authentification est toujours valable
'''
headers = {
'cache-control': "no-cache",
'Host' : "ha110-1.overkiz.com",
'Connection':"Keep-Alive",
}
url=url_defaut+'refreshAllStates'
r = requests.get(url,headers=headers,cookies=restore('cookies'))
if r.status_code==200 : # Réponse HTTP 200 : OK
return True
else:
erreur_HTTP(r.status_code,r.reason)
print r.text
return False
'''
**********************************************************
Fonctions Cozytouch
**********************************************************
'''
def authentification (login,password):
""" Fonction d'authentification à l'API Cozytouch, transmets une
requete POST avec le couple login/password et sauvegarde le cookie de session
"""
# Headers HTTP
headers= {
'content-type': "application/x-www-form-urlencoded",
'cache-control': "no-cache"
}
url=url_defaut+'login'
payload = 'userId='+login+'&'+'userPassword='+password
r = requests.post(url, data=payload, headers=headers)
if r.status_code==200 : # Réponse HTTP 200 : OK
print "Authentification OK"
cookies =dict(JSESSIONID=(r.cookies['JSESSIONID'])) # Récupération cookie ID de session
save(cookies,'cookies') #Sauvegarde cookie
return True
else :
erreur_HTTP(r.status_code,r.reason)
return False
def requete_GET (json):
''' Fonction d'interrogation HTTP GET avec l'url par défaut
json: nom de fonction JSON à transmettre au serveur
'''
headers = {
'cache-control': "no-cache",
'Host' : "ha110-1.overkiz.com",
'Connection':"Keep-Alive",
}
url=url_defaut+json
cookies=restore('cookies')
r = requests.get(url,headers=headers,cookies=cookies)
if r.status_code==200 : # Réponse HTTP 200 : OK
data=r.json()
return data
else:
erreur_HTTP(r.status_code,r.reason) # Appel fonction sur erreur HTTP
def requete_POST (url_device,name,parametre):
""" Fonction d'envoi requete POST
name = "setTargetTemperature" pour consigne température radiateur
"""
# Headers HTTP
headers= {
'content-type': "application/json",
'cache-control': "no-cache"
}
url=url_defaut+'../../enduserAPI/exec/apply'
payload ="{\"actions\": [{ \"deviceURL\": \""+str(url_device)+"\" ,\n\"commands\": [{ \"name\": \""+str(name)+"\",\n\"parameters\":["+str(parametre)+"]}]}]}"
cookies=restore('cookies')
r = requests.post(url, data=payload, headers=headers,cookies=cookies)
if r.status_code<>200 : # Réponse HTTP 200 : OK
erreur_HTTP(r.status_code,r.reason)
def test_cozytouch ():
# Test si l'idx matériel Cozytouch n'a pas été créé sinon on créé un virtual hardware
# Cas où le fichier de sauvegarde contenant l'idx du matériel est inexistant:
if os.path.isfile('cozytouch_save')==False:
print "fichier cozytouch_save non trouve : creation du materiel..."
idx = ajout_virtual_harware_domoticz() # création d'un virtual hardware
save(idx,'save_idx') # implique la création du fichier
# Cas où le fichier est existant et virtual hardware de domoticz inexistant/supprimé
else :
save_idx = restore ('save_idx')
print 'fichier cozytouch_save trouve avec idx='+str(save_idx)
# Test si le virtual hardware est toujours dans domoticz
resp=requests.get('http://'+domoticz_ip+':'+domoticz_port+'/json.htm?type=hardware') # renvoi une liste du matériel domoticz
if resp.status_code==200 : #Réponse HTTP OK
data=json.loads(resp.text)
# On boucle sur chaque virtual hardware trouvé :
y=0
reset=False
if 'result' in data:
while True:
try :
(data[u'result'][y])
for a in data[u'result'][y]['idx']:
if a <> save_idx:
print "l'idx "+str(a)+" ne correspond pas"
reset=True
elif a==save_idx and data[u'result'][y][u'Name']=='Cozytouch_V'+str(version):
print "l'idx "+str(a)+" correspond, nom :Cozytouch_V"+str(version)
reset=False
y+=1
except :
break
else:
reset=True
if reset:
# on supprime le fichier de sauvegarde
print "fichier cozytouch_save trouve / suppression du fichier..."
os.remove('cozytouch_save')
# et on passe à la création d'un virtual hardware
idx = ajout_virtual_harware_domoticz()
save(idx,'save_idx') # implique la création du fichier
def decouverte_devices ():
''' Fonction de découverte des devices Cozytouch
Scanne les devices présents dans l'api cozytouch et gère les ajouts à Domoticz
'''
# Renvoi toutes les données du cozytouch
data = requete_GET ('getSetup')
# Initialisation variables
count_radiateur = 0 # compteur d'éléments "radiateurs"
count_chauffe_eau = 0 # compteur d'éléments "chauffe eau"
# Restauration de l'idx matériel
save_idx = restore ('save_idx')
print 'idx sauvegarde : '+str(save_idx)
if save_idx==0:
save_idx = ajout_virtual_harware_domoticz() # création d'un virtual hardware
print 'idx materiel virtuel ajoute : '+str(save_idx)
save(save_idx,'save_idx')
# Restauration de la liste des devices
save_devices = restore ('save_devices')
print 'liste des devices sauvegardes:'
print save_devices
'''
Cas de la liste vide, au premier démarrage du script par ex.
On passe en revue les devices principaux de l'API Cozytouch dont l'url contient un '#1#' et on l'ajoute à une liste
si sa classe est connu dans le dictionnaire Cozytouch
'''
if not save_devices : # si la liste est vide on passe à la création des devices
liste=[] # on crée une liste vide
write_log ('Cozytouch : Recherche des devices connectés ... ')
# Initialisation variables
x = 0
p = 0
# On boucle sur chaque device trouvé :
for a in data['setup']['devices']:
url = a['deviceURL']
name = a['controllableName']
if ('#1') in url : # si c'est un device principal
if name == dict_cozytouch.get('radiateur'): # on vérifie si le nom du device est connu
count_radiateur +=1
liste= ajout_radiateur (save_idx,liste,url,x) # ajout du device à la liste
# maj_device (data,name,p,x)
elif name == dict_cozytouch.get('chauffe eau'): # on vérifie si le nom du device est connu
count_chauffe_eau +=1
liste = ajout_chauffe_eau (save_idx,liste,url,x) # ajout du device à la liste
# maj_device (data,name,p,x)
else :
write_log ('Cozytouch : Device avec classe '+str(name)+' inconnu')
p+=1 # incrément position dans dictionnaire des devices
x+=1 # incrément device dans data json cozytouch
else :
x+=1 # incrément device dans data json cozytouch
continue # on reboucle si le device n'est pas un device principal
# Fin de la boucle :
# Sauvegarde des devices ajoutés
save(liste,'save_devices')
# Log résumé des ajouts :
if count_radiateur >0 :
write_log ('Cozytouch : '+str(count_radiateur) + ' radiateur(s) trouve(s)')
if count_chauffe_eau >0 :
write_log ('Cozytouch : '+str(count_chauffe_eau) + ' chauffe eau trouve(s)')
# Lecture données Gateway Cozytouch (pour info)
select=(data[u'setup'][u'gateways'][0])
write_log ('Cozytouch : Version gateway : '+str(select[u'connectivity'][u'protocolVersion']))
#print "Etat de connexion de la gateway : "+(select[u'connectivity'][u'status'])
#print (select[u'connectivity'][u'alive'])
'''
Cas de liste non vide
On passe en revue les devices principaux de l'API Cozytouch dont l'url contient un '#1#'
si sa classe est connu dans le dictionnaire Cozytouch on met à jour les données
'''
if save_devices <> 0 : # si la liste contient des devices
# Initialisation variables
liste_inconnu = []
x = 0
p = 0
# On boucle sur chaque device trouvé :
for a in data['setup']['devices']:
url = a['deviceURL']
name = a['controllableName']
if ('#1') in url : # si c'est un device principal :
# On boucle sur les éléments du dictionnaire de devices
for element in save_devices :
if element.has_key('url') : # si la clé url est présente dans le dictionnaire
if element.get('url') == url : # si l'url du device est stocké dans le dictionnaire
maj_device (data,name,p,x) # mise à jour du device
p+=1 # incrément position dans le dictionnaire
for inconnu in liste_inconnu :
if inconnu == url :
liste_inconnu.remove(url) # on retire l'url inconnu à la liste
break
else : # sinon on reboucle
liste_inconnu.append(url)
else : # sinon on reboucle
continue
x+=1 # incrément position du device dans les datas json cozytouch
else :
x+=1 # incrément position du device dans les datas json cozytouch
continue # on reboucle si le device n'est pas un device principal
'''
**********************************************************
Fonctions d'ajouts des devices cozytouch dans Domoticz
suivant la classe
**********************************************************
'''
def ajout_radiateur (idx,liste,url,x):
''' Fonction ajout radiateur
'''
# création du nom suivant la position JSON du device dans l'API Cozytouch
nom = 'radiateur_'+str(x)
# création du dictionnaire de définition du device
radiateur = {}
radiateur['url'] = url
radiateur['x']= x
radiateur['nom']= nom
# Switch selecteur :
nom_switch = 'Mode '+nom
radiateur['idx_switch']= ajout_virtual_device_domoticz (idx,1002,nom)
# Personnalisation du switch (Modification du nom des levels et de l'icone)
option = 'TGV2ZWxOYW1lcyUzQU9mZiU3Q0VjbyU3Q0NvbmZvcnQlN0NIb3JzJTIwZ2VsJTNCTGV2ZWxBY3Rpb25zJTNBJTdDJTdDJTdDJTNCU2VsZWN0b3JTdHlsZSUzQTAlM0JMZXZlbE9mZkhpZGRlbiUzQWZhbHNlJTNC'
send=requests.get('http://'+domoticz_ip+":"+domoticz_port+'/json.htm?type=setused&idx='+(radiateur['idx_switch'])+'&name='+nom_switch+
'&description=&strparam1=&strparam2=&protected=false&switchtype=18&customimage=15&used=true&addjvalue=0&addjvalue2=0&options='+option)
# Mesure température :
nom_mesure = 'Mesure '+nom
radiateur['idx_mesure_temp']= ajout_virtual_device_domoticz (idx,80,nom_mesure)
# Consigne température Confort :
nom_cons_conf = 'Consigne confort '+nom
radiateur['idx_cons_temp_confort']= ajout_virtual_device_domoticz (idx,8,nom_cons_conf )
radiateur['cons_temp_confort_domoticz_prec']= 0 # création et initialisation de la mémorisation de consigne précédente
# Consigne température Eco :
nom_cons_eco= 'Abaissement consigne eco '+nom
radiateur['idx_cons_temp_eco']= ajout_virtual_device_domoticz (idx,8,nom_cons_eco)
# Compteur d'énergie :
nom_compteur= 'Compteur '+nom
radiateur['idx_compteur']= ajout_virtual_device_domoticz (idx,113,nom_compteur)
# Log Domoticz :
write_log("Cozytouch : création "+nom+" ,url: "+str(url))
# ajout du dictionnaire dans la liste des device:
liste.append(radiateur)
return liste
def ajout_chauffe_eau (idx,liste,url,x):
''' Fonction ajout chauffe eau
'''
# création du nom suivant la position JSON du device dans l'API Cozytouch
nom = 'chauffe eau_'+str(x)
# création du dictionnaire de définition du device
chauffe_eau= {}
chauffe_eau['url'] = url
chauffe_eau['x']= x
chauffe_eau['nom']= nom
# Switch selecteur auto/manu/manu+eco:
nom_switch = 'Mode '+nom
chauffe_eau['idx_switch_auto_manu']= ajout_virtual_device_domoticz (idx,1002,nom)
# Personnalisation du switch (Modification du nom des levels et de l'icone)
option = 'TGV2ZWxOYW1lcyUzQUF1dG8lN0NNYW51JTdDTWFudStFY28lM0JMZXZlbEFjdGlvbnMlM0ElN0MlN0MlN0MlM0JTZWxlY3RvclN0eWxlJTNBMCUzQkxldmVsT2ZmSGlkZGVuJTNBZmFsc2UlM0I='
send=requests.get('http://'+domoticz_ip+":"+domoticz_port+'/json.htm?type=setused&idx='+(chauffe_eau['idx_switch_auto_manu'])+'&name='+nom_switch+
'&description=&strparam1=&strparam2=&protected=false&switchtype=18&customimage=15&used=true&addjvalue=0&addjvalue2=0&options='+option)
# Switch on/off
nom_switch_on_off = 'Etat '+nom
chauffe_eau['idx_on_off']= ajout_virtual_device_domoticz (idx,6,nom_switch_on_off)
send=requests.get('http://'+domoticz_ip+":"+domoticz_port+'/json.htm?type=setused&idx='+(chauffe_eau['idx_on_off'])+'&name='+nom_switch_on_off+
'&description=&strparam1=&strparam2=&protected=false&switchtype=0&customimage=15&used=true&addjvalue=0&addjvalue2=0&options=')
# Mesure température eau:
nom_mesure = 'Temperature eau '+nom
chauffe_eau['idx_mesure_temp']= ajout_virtual_device_domoticz (idx,80,nom_mesure)
# Compteur d'eau :
nom_compteur= 'Eau restante '+nom
chauffe_eau['idx_conso_eau']= ajout_virtual_device_domoticz(idx,1004,nom_compteur,option='litres')
# Personnalisation du switch (Modification de l'icone)
send=requests.get('http://'+domoticz_ip+":"+domoticz_port+'/json.htm?type=setused&idx='+(chauffe_eau['idx_conso_eau'])+'&name='
+nom_compteur+'&description=&switchtype=2&addjvalue=0&used=true&options=')
# Compteur temps de fonctionnement pompe à chaleur :
nom_compteur_pompe = 'Pompe a chaleur '+nom
chauffe_eau['idx_compteur_pompe']= ajout_virtual_device_domoticz (idx,113,nom_mesure)
# Personnalisation du switch (Modification du nom des levels et de l'icone)
option = 'VmFsdWVRdWFudGl0eSUzQUglM0JWYWx1ZVVuaXRzJTNBSGV1cmVzJTNC'
send=requests.get('http://'+domoticz_ip+":"+domoticz_port+'/json.htm?type=setused&idx='+(chauffe_eau['idx_compteur_pompe'])+'&name='+nom_compteur_pompe+
'&switchtype=3&addjvalue=0&used=true&options='+option)
# Compteur d'énergie :
nom_compteur= 'Energie '+nom
chauffe_eau['idx_compteur']= ajout_virtual_device_domoticz (idx,18,nom_compteur)
# Log Domoticz :
write_log("Cozytouch : création "+nom+" ,url: "+str(url))
# ajout du dictionnaire dans la liste des device:
liste.append(chauffe_eau)
return liste
'''
**********************************************************
Fonction de comparaison de consigne pour maj Domoticz
**********************************************************
'''
def comparaison_consigne (texte,url_device,nom_device, idx_cons_domoticz, cons_device,cde_name):
''' Compare les consignes de domoticz ancienne / actuelle / ainsi que celle du device
pour déterminer qui demande un changement de consigne
envoi le changement de consigne au device ou à Domoticz et inscrit un log
'''
cons_domoticz_prec = restore ('save_consigne_'+str(nom_device)+str(idx_cons_domoticz))
# Calcul de l'écart de consigne
# limitation consigne : la consigne n'accepte que des pas de 0,5°C
# si la partie décimale est égale à 0,5 on accepte, sinon on arrondi
cons_domoticz = read_device_data (idx_cons_domoticz)
e = int(cons_domoticz)
e = cons_domoticz - e
# si la partie décimale est différente de 0,5°C on arrondi
if e <> 0.5:
cons_domoticz = round(cons_domoticz)
# comparaison avec la consigne en cours du radiateur
if cons_device <> cons_domoticz and cons_domoticz <> cons_domoticz_prec and cons_domoticz_prec > 0:
# si un écart est détecté
# et si le changement de consigne vient de domoticz, on envoie le changement au device
# et si la consigne précédente est différente de 0 (cas au démarrage)
requete_POST (url_device,cde_name,cons_domoticz)
write_log('Cozytouch - '+nom_device+' : nouvelle consigne '+str(texte)+' transmise: '+str(cons_domoticz)+'°C')
save (cons_domoticz, ('save_consigne_'+str(nom_device)+str(idx_cons_domoticz)))
elif cons_device <> cons_domoticz and cons_domoticz == cons_domoticz_prec and cons_domoticz_prec > 0:
# sinon, le changement vient du device
# mise à jour de domoticz
write_log('Cozytouch - '+nom_device+' : détection changement consigne ' +str(texte)+' : '+str(cons_device)+'°C')
write_device(cons_device,idx_cons_domoticz)
save (cons_device, ('save_consigne_'+str(nom_device)+str(idx_cons_domoticz)))
else :
# ou simple rafraichissement si aucun changement
# mise à jour de domoticz
write_device(cons_device,idx_cons_domoticz)
save (cons_device, ('save_consigne_'+str(nom_device)+str(idx_cons_domoticz)))
def maj_device (data,name,p,x):
''' Fonction de mise à jour du device dans Domoticz
'''
def value (data,device, item):
value=(data['setup']['devices'][device]['states'][item]['value'])
return value
a = restore ('save_devices')
classe = a[p]
''' Mise à jour : Données radiateur
'''
if name == dict_cozytouch.get('radiateur'):
# Switch selecteur : définition des levels du switch
on_off = value(data,x,4)
mode = value(data,x,3)
if on_off == 'off':
switch = 0
if on_off == 'on' and mode == 'eco':
switch = 10
if on_off == 'on' and mode == 'comfort':
switch = 20
if on_off == 'on' and mode == 'frostprotection':
switch = 30
#comparaison_switch ( value(data,x,4),value(data,x,3)
#(texte,classe.get('url'),classe.get('nom'), idx_cons_domoticz, cons_device,cde_name):
# Mesure température :
write_device ((value(data,(x+1),1)),(classe.get('idx_mesure_temp')))
# Lecture et comparaison de la consigne de température actuelle :
comparaison_consigne ('confort',classe.get('url'),classe.get('nom'),classe.get('idx_cons_temp_confort'),value(data,x,10),("setComfortTemperature"))
# Lecture et comparaison de la consigne de température eco (abaissement en °C de la température de confort):
comparaison_consigne ('eco',classe.get('url'),classe.get('nom'),classe.get('idx_cons_temp_eco'),value(data,x,17),"setSetpointLoweringTemperatureInProgMode")
# Switch selecteur :
# Comparaison avec l'état précédent pour mettre à jour uniquement sur changement (évite de remplir les logs inutilement)
switch_prec = restore ('save_switch_'+str(classe.get('idx_switch')))
if switch_prec <> switch :
write_device_switch(switch, classe.get('idx_switch'))
save (switch, ('save_switch_'+str(classe.get('idx_switch'))))
# Compteur d'énergie:
write_device((value(data,x+4,1)),(classe.get('idx_compteur')))
''' Mise à jour : Données chauffe eau
'''
if name == dict_cozytouch.get('chauffe eau'):
# Switch on/off
a = (value(data,x,7)[u'energyDemandStatus'])
if a == 1 :
a = 'On'
else:
a = 'Off'
# Comparaison avec l'état précédent pour mettre à jour uniquement sur changement (évite de remplir les logs inutilement)
onoff_prec = restore ('save_onoff_'+str(classe.get('idx_on_off')))
if onoff_prec <> a :
write_device_onoff(a,(classe.get('idx_on_off')))
save (a, ('save_onoff_'+str(classe.get('idx_on_off'))))
# Switch selecteur auto/manu/manu+eco : définition des levels du switch
auto_manu = value(data,x,15)
if auto_manu == 'autoMode':
switch = 0
if auto_manu == 'manualEcoInactive':
switch = 10
if auto_manu == 'manualEcoActive':
switch = 20
# Switch selecteur :
# Comparaison avec l'état précédent pour mettre à jour uniquement sur changement (évite de remplir les logs inutilement)
switch_prec = restore ('save_switch_'+str(classe.get('idx_switch_auto_manu')))
if switch_prec <> switch :
write_device_switch(switch, classe.get('idx_switch_auto_manu'))
save (switch, ('save_switch_'+str(classe.get('idx_switch_auto_manu'))))
# Mesure température :
write_device((value(data,x,5)),(classe.get('idx_mesure_temp')))
# Compteur d'eau:
# Mise en forme
a = str(float((value(data,x,10)))/10.)
# Eau restante:
write_device(value(data,x,10),(classe.get('idx_conso_eau')))
# Calcul puissance moyenne :
wh_prec = restore ('wh_prec_'+str(classe.get('idx_compteur')))
wh_actuel = (value(data,x+1,1))
wh_1min = wh_actuel - wh_prec
Pmoy_1min = wh_1min * 60
save (wh_actuel, ('wh_prec_'+str(classe.get('idx_compteur'))))
# Compteur d'énergie:
write_device(str(Pmoy_1min)+';'+str((value(data,x+1,1))),(classe.get('idx_compteur')))
# Compteur temps de fonctionnement pompe à chaleur :
write_device((value(data,x,12)),(classe.get('idx_compteur_pompe')))
'''
**********************************************************
Déroulement du script
**********************************************************
'''
# Test de présence du fichier de sauvegarde cozytouch et du virtual hardware
#test_cozytouch()
# Test d'une requete GET pour évaluer la réponse
if requete_GET ('refreshAllStates'):
print "Requete de test reussie : Interrogation serveur..."
decouverte_devices ()
else:
# Tentative de connexion à l'API Cozytouch
if authentification(login,password):
time.sleep(2)
decouverte_devices ()