Domoticz

Code: Select all

# based upon: https://github.com/richardkchapman/serproxy/blob/master/serproxy.py
#
# Python version of serproxy for Easywave (RX09) v20180407
#
# Python 3.5.1
# Windows 10, Pi 4.59.  V7+
#
# Accept requests by socket (TCP/IP Raw) and forward to Serial Port
# Return Serial response to socket
#
# Original Author: Richard K Chapman
# Adaptations:     WimR
#
# Date: 2018 01 12 Original version
#       2018 02 28 Added read csv with link: switch id TO domoticz idx
#                  Read serial line and add to log as 'respons'
#       2018 03 16 Added 'C' telegram mapped to 'Stop' (for devices Venitian Blinds EU)
#               19 Added Dict for Commands
#                  Made path to devices.csv relative
#                  Added counter for devices table
#               30 Added different behaviour for Blinds. SwitchType will be checked first
#            04 07 transferred full handling of formatting Easywave Telegram to RX09.py, plugin.py only transfers commands, unit ids and switchtype over socket 
#                    format: Command;Unit Id;SwitchType
#       2024 11 13 Adapted skip usage urllib2 replaced by urllib3
#

from socket import * 
from threading import Thread
from collections import defaultdict
import logging
import serial
import time
import sys
import os
import csv
import json, urllib3
from urllib3.exceptions import HTTPError, MaxRetryError, TimeoutError

ser = None

allClients = []
BUFSIZ = 1024
serialDevice = None

CommandMap = {'A':'On','B':'Off','C':'Stop','D':'Off'}
BasicType = {'On':'A','Off':'B','Stop':'C'}
CommandMapBlind = {'A':'Off','B':'On','C':'Stop','D':'Off'}
BlindType = {'On':'B','Off':'A','Stop':'C'}


def serialReader():
    global ser
    global allClients
    global serialDevice
    global domoticzIP
    global domoticzPort
    global pairingFile
    global allDevices
    global CommandMap
    global CommandMapBlind

    line = []
    oldLine = ''
    oldTime = time.time()
    #allDevices = {}

    http = urllib3.PoolManager()

    while 1:
        try:
            # configure the serial connections (the parameters differs on the device you are connecting to)
            ser = serial.Serial(
            port=serialDevice,
            baudrate=57600,
            parity=serial.PARITY_NONE,
            stopbits=serial.STOPBITS_ONE,
            bytesize=serial.EIGHTBITS
            )

            ser.isOpen()
            logging.info('Serial port opened %s', ser)


            # main listener loop
            while 1:
                out = ser.read(1)
                line.append(out)
                # wait till '\r' as end of line char
                if out == '\r':
                    # handle message received
                    myLine = ''.join(line)
                    logging.info('Serial respons : %s', myLine)
                    # if myLine starts with REC :split line use second part as key in dict and lauch json call
                    if myLine[0:3] == 'REC':
                        EasywaveID = myLine[4:10]
                        logging.info('Check device table for link to idx: %s', EasywaveID)
                        if allDevices[EasywaveID] is None:
                            # transmitter not in devices.csv
                            logging.info('Warning : unknown physical RF transmitter: %s  Please add to device table with corresponding idx', myLine[4:10])
                        else:
                            # switch may be paired to multiple idx's
                            if True:
                                #for idx in allDevices[EasywaveID]:
                                idx = allDevices[EasywaveID][0]
                                oldTime = time.time() -1
                                myTime = time.time()
                                logging.info('Check domiticz device with idx: ' + idx)
                                # Check with Domoticz what kind of switch we are dealing with
                                domoticzUrl = ("http://%s:%s/json.htm?type=devices&rid=%s" % ( domoticzIP, domoticzPort, idx))
                                logging.info('Domiticz url: ' + domoticzUrl)
                                try:
                                    response = http.request('GET', domoticzUrl)
                                    result_data = response.data.decode('utf-8')
                                    result_load = json.loads(result_data)
                                    response_status = result_load["status"]
                                    logging.info('Respons domoticz : %s', response_status)

                                    if result_load["result"][0]["SubType"] != 'Switch':
                                        logging.info("Warning : Key :  %s is linked to idx: %s but its not a Switch "%  (EasywaveID, idx ))
                                    else:
                                        # known physical RF transmitter linked to switch
                                        if result_load["result"][0]["SwitchTypeVal"] == 15:
                                            myCommand = CommandMapBlind.get(myLine[11])
                                        else:
                                            myCommand = CommandMap.get(myLine[11])
                                        if myCommand is None:
                                            logging.info('Warning : unknown Command from physical transmitter: ' + myLine[11])
                                        else:
                                            logging.info('Key : ' + EasywaveID + ' Mapped to : ' +  str(idx) + ' Telegram : ' + myLine[11] + ' mapped to Command : ' + myCommand)
                                            # switches may bounce and emit rapidly 2 to 5 times the same command: debounce by comparing content and time lapse (more than 1 sec apart)
                                            #print('-->'+ oldline + '<-->' +myLine + '<--')
                                            #print('-->'+ str(oldTime) + '<-->' + str(myTime) + '<--')
                                            if myLine <> oldLine or myTime - oldTime > 1: 
                                                # transfer received command to Domoticz
                                                # response = http.request('GET', url)
                                                domoticzUrl = ("http://%s:%s/json.htm?type=command&param=switchlight&idx=%s&switchcmd=%s&level=0" % (domoticzIP, domoticzPort ,idx, myCommand))
                                                logging.info('Domiticz url: ' + domoticzUrl)
                                                try:
                                                    response = http.request('GET', domoticzUrl)
                                                    result_data = response.data.decode('utf-8')
                                                    result_load = json.loads(result_data)
                                                    response_status = result_load["status"]
                                                    logging.info('Respons domoticz : %s', response_status)
                                                except HTTPError as e:
                                                    logging.info('HTTP error occurred:', e)
                                                except MaxRetryError as e:
                                                    logging.info('Max retries exceeded:', e)
                                                except TimeoutError as e:
                                                    logging.info('Request timed out:', e)
                                                # arm debounce mechanism
                                                oldTime = myTime
                                                oldLine = myLine
                                except HTTPError as e:
                                    logging.info('HTTP error occurred:', e)
                                except MaxRetryError as e:
                                    logging.info('Max retries exceeded:', e)
                                except TimeoutError as e:
                                    logging.info('Request timed out:', e)

                    else:
                        # respons is not from a switch telegram captured (OK, ERROR)
                        # write line to all clients
                        for elem in line:
                            for client in allClients:
                                client.send(elem)
                    # Clear line
                    line = []
        except:
            # Wait a while then try again
            logging.debug('Error on serial port')
            if ser is not None:
                ser.close()
            ser = None
            time.sleep(10)

def handler(clientsock,addr):
    global ser
    global allClients
    global BasicType
    global BlindType

    logging.info('Connected from: %s', addr)
    allClients.append(clientsock)
    while 1:
        data = clientsock.recv(BUFSIZ)
        if not data: 
            break 
        if not (ser is None):
            logging.info('Message received: %s ', data)
            logging.info('Message received 3 chars: %s ', data[:3])
            print('Received: ' + data)
            
            # keep version compatible with old plugin versions
            if data[:3] == 'TXP':
                print('Classic: ' + data)
                logging.info('Message received old style: %s ', data)
                ser.write(data)
            else:
                # build Easywave Telegram ( TXP,FF,A\r ) from new plugin format: Command;Unit Id;SwitchType
                # get hex number: str(format( Unit -1 , '02X'))
                # translate command:   BasicType.get(Command)
                # if SwithType == 15 -> BlindType.get(Command)
                print('New: ' + data)
                logging.info('Message received NEW style: %s ', data)
                logging.info('Message new format Switchtype received: %s ', data.split(';')[2])
                logging.info('Message new format SwitchNumber received: %s ', data.split(';')[1])
                logging.info('Message new format SwitchCommand received: %s ', data.split(';')[0])
            
                if data.split(';')[2] == 15:
                    Telegram = 'TXP,' + str(format( data.split(';')[1] -1, '02X')) + ',' +  BlindType.get(data.split(';')[0]) +'\r'
                else:
                    Telegram = 'TXP,' + str(format( data.split(';')[1] -1, '02X')) + ',' +  BasicType.get(data.split(';')[0]) +'\r'
                logging.info('Telegram written: %s ', Telegram)
                ser.write(Telegram)
            
    logging.info('Disconnected from: %s', addr)
    allClients.remove(clientsock)
    clientsock.close()

def mainProgram():
    global serialDevice
    global port
    global domoticzIP
    global domoticzPort
    global pairingFile
    global allDevices
    global PidFile
    global LogFile


    PidFile = '/tmp/serPID.txt'
    if len(sys.argv)>=8 and sys.argv[1] == '-p':
        writePidFile(sys.argv[2])
        PidFile = sys.argv[2]
        del sys.argv[2]
        del sys.argv[1]
    if len(sys.argv) != 7:
        print ('usage: ' + sys.argv[0] + ' device port domoticzIP domoticzPort pairingFile LogFile')
        exit()

    serialDevice=sys.argv[1]
    port=int(sys.argv[2])
    domoticzIP=sys.argv[3]
    domoticzPort=sys.argv[4]
    pairingFile=sys.argv[5]
    LogFile=sys.argv[6]

    print ('\nLogfile: ' + LogFile)
    logging.basicConfig(filename=LogFile, filemode='w', format='%(asctime)s %(levelname)s:%(message)s', level=logging.DEBUG)


    print ('Version Serial Proxy: RX09v20241113')
    print ('Serial Device: ' + sys.argv[1])
    print ('Serial Port: ' + sys.argv[2])
    print ('Domoticz IP: ' + sys.argv[3])
    print ('Domoticz Port: ' + sys.argv[4])
    print ('Pairing File: ' + sys.argv[5])
    print ('Logging File: ' + sys.argv[6])

    logging.info('Version Serial Proxy: RX09v20241116')
    logging.info('Serial Device: ' + sys.argv[1])
    logging.info('Serial Port: ' + sys.argv[2])  
    logging.info('Domoticz IP: ' + sys.argv[3])
    logging.info('Domoticz Port: ' + sys.argv[4])
    logging.info('Pairing File: ' + sys.argv[5])
    logging.info('Logging File: ' + sys.argv[6])

    # check if pairing file exists. Try to create otherwise
    if os.path.exists(pairingFile):
        if not os.path.isfile(pairingFile):
            print ("Pairing File is not a File")
            logging.info("Pairing File is not a File")
            os._exit(0)
    else:
        # create pairingFile
        createPairingFile(pairingFile)

    # load device table from csv file
    allDevices = defaultdict(list)
    logging.info('Device table being loaded in dictionnary.')
    ifile = open(pairingFile, "rU")
    logging.info('Device table being opened.')
    reader = csv.reader(ifile, delimiter=";")
    # built dict of lists
    for row in reader:
        logging.info('Device: ' + row[0] + '    Linked to ' + row[1])
        allDevices[row[0]].append(row[1])
    ifile.close()
    logging.info('Device table being closed.')
    logging.info('Device table loaded in dictionnary. Number of devices loaded: %d ' % (len(allDevices)-1))


    Thread(target=serialReader).start()

    ser = None
    allClients = []

    listenAddr = ('', port)
    try:
        serversock = socket(AF_INET, SOCK_STREAM)
        serversock.bind(listenAddr)
        serversock.listen(2)
        logging.info('waiting for connection')

        while 1:
            clientsock, addr = serversock.accept()
            Thread(target=handler, args=(clientsock, addr)).start()
    except KeyboardInterrupt:
        if not ser is None:
            ser.close()
        os._exit(0)

def writePidFile(pidfile):
    pid = str(os.getpid())
    f = open(pidfile, 'w')
    f.write(pid)
    f.close()

def createPairingFile(pairingFile):
    f = open(pairingFile, 'w')
    f.write("Key;idx")
    f.close()
    print ("Pairing File created:" + pairingFile)
    logging.info("Pairing File created: " + pairingFile)

if __name__=='__main__':
    mainProgram()

Code: Select all

cat /tmp/serLog.txt
2024-11-16 17:12:57,052 INFO:Version Serial Proxy: RX09v20241116
2024-11-16 17:12:57,053 INFO:Serial Device: /dev/ttyUSB0
2024-11-16 17:12:57,053 INFO:Serial Port: 5331
2024-11-16 17:12:57,053 INFO:Domoticz IP: 192.168.1.54
2024-11-16 17:12:57,054 INFO:Domoticz Port: 28080
2024-11-16 17:12:57,054 INFO:Pairing File: /home/pi/project/python_programs/devices.csv
2024-11-16 17:12:57,054 INFO:Logging File: /tmp/serLog.txt
2024-11-16 17:12:57,054 INFO:Device table being loaded in dictionnary.
2024-11-16 17:12:57,055 INFO:Device table being opened.
2024-11-16 17:12:57,055 INFO:Device: Key    Linked to idx
2024-11-16 17:12:57,055 INFO:Device: 2eae2d    Linked to 103
2024-11-16 17:12:57,055 INFO:Device: 201a6c    Linked to 104
2024-11-16 17:12:57,056 INFO:Device: 2eae67    Linked to 107
2024-11-16 17:12:57,056 INFO:Device: 2eae95    Linked to 102
2024-11-16 17:12:57,056 INFO:Device: 2eae9d    Linked to 101
2024-11-16 17:12:57,056 INFO:Device: 2eaea4    Linked to 106
2024-11-16 17:12:57,057 INFO:Device: 167f2a    Linked to 724
2024-11-16 17:12:57,057 INFO:Device: 167f2a    Linked to 725
2024-11-16 17:12:57,057 INFO:Device: 167f2b    Linked to 725
2024-11-16 17:12:57,057 INFO:Device: 167f2c    Linked to 726
2024-11-16 17:12:57,058 INFO:Device: 167f2d    Linked to 727
2024-11-16 17:12:57,058 INFO:Device: 167f2e    Linked to 728
2024-11-16 17:12:57,058 INFO:Device: 167f2f    Linked to 729
2024-11-16 17:12:57,059 INFO:Device: 167f30    Linked to 730
2024-11-16 17:12:57,059 INFO:Device: 167f31    Linked to 731
2024-11-16 17:12:57,059 INFO:Device: 167f32    Linked to 732
2024-11-16 17:12:57,059 INFO:Device: 167f33    Linked to 733
2024-11-16 17:12:57,060 INFO:Device table being closed.
2024-11-16 17:12:57,060 INFO:Device table loaded in dictionnary. Number of devices loaded: 16
2024-11-16 17:12:57,061 INFO:waiting for connection
2024-11-16 17:12:57,065 INFO:Serial port opened Serial<id=0x764c4e10, open=True>(port='/dev/ttyUS                                                     B0', baudrate=57600, bytesize=8, parity='N', stopbits=1, timeout=None, xonxoff=False, rtscts=Fals                                                     e, dsrdtr=False)
2024-11-16 17:14:58,904 INFO:Connected from: ('192.168.1.54', 60013)
2024-11-16 17:14:58,906 INFO:Message received: TXP,05,B

2024-11-16 17:14:58,908 INFO:Message received 3 chars: TXP
2024-11-16 17:14:58,909 INFO:Message received old style: TXP,05,B

2024-11-16 17:14:58,913 INFO:Serial respons : OK
2024-11-16 17:14:59,993 INFO:Disconnected from: ('192.168.1.54', 60013)
2024-11-16 17:15:03,665 INFO:Connected from: ('192.168.1.54', 60014)
2024-11-16 17:15:03,677 INFO:Message received: TXP,05,A

2024-11-16 17:15:03,678 INFO:Message received 3 chars: TXP
2024-11-16 17:15:03,678 INFO:Message received old style: TXP,05,A

2024-11-16 17:15:03,684 INFO:Serial respons : OK
2024-11-16 17:15:04,694 INFO:Disconnected from: ('192.168.1.54', 60014)
2024-11-16 17:15:11,772 INFO:Serial respons : REC,167f33,A
2024-11-16 17:15:11,773 INFO:Check device table for link to idx: 167f33
2024-11-16 17:15:11,774 INFO:Check domiticz device with idx: 733
2024-11-16 17:15:11,774 INFO:Domiticz url: http://192.168.1.54:28080/json.htm?type=devices&rid=73                                                     3
2024-11-16 17:15:11,776 DEBUG:Starting new HTTP connection (1): 192.168.1.54
2024-11-16 17:15:11,792 DEBUG:http://192.168.1.54:28080 "GET /json.htm?type=devices&rid=733 HTTP/                                                     1.1" 200 1610
2024-11-16 17:15:11,796 INFO:Respons domoticz : OK
2024-11-16 17:15:11,799 INFO:Key : 167f33 Mapped to : 733 Telegram : A mapped to Command : On
2024-11-16 17:15:11,799 INFO:Domiticz url: http://192.168.1.54:28080/json.htm?type=command&param=                                                     switchlight&idx=733&switchcmd=On&level=0
2024-11-16 17:15:11,801 DEBUG:Resetting dropped connection: 192.168.1.54
2024-11-16 17:15:11,859 DEBUG:http://192.168.1.54:28080 "GET /json.htm?type=command&param=switchl                                                     ight&idx=733&switchcmd=On&level=0 HTTP/1.1" 200 47
2024-11-16 17:15:11,862 INFO:Respons domoticz : OK
2024-11-16 17:15:11,864 INFO:Serial respons : REC,167f33,A
2024-11-16 17:15:11,864 INFO:Check device table for link to idx: 167f33
2024-11-16 17:15:11,865 INFO:Check domiticz device with idx: 733
2024-11-16 17:15:11,865 INFO:Domiticz url: http://192.168.1.54:28080/json.htm?type=devices&rid=73                                                     3
2024-11-16 17:15:11,867 DEBUG:Resetting dropped connection: 192.168.1.54
2024-11-16 17:15:11,878 DEBUG:http://192.168.1.54:28080 "GET /json.htm?type=devices&rid=733 HTTP/                                                     1.1" 200 1608
2024-11-16 17:15:11,882 INFO:Respons domoticz : OK
2024-11-16 17:15:11,882 INFO:Key : 167f33 Mapped to : 733 Telegram : A mapped to Command : On
2024-11-16 17:15:11,883 INFO:Domiticz url: http://192.168.1.54:28080/json.htm?type=command&param=                                                     switchlight&idx=733&switchcmd=On&level=0
2024-11-16 17:15:11,884 DEBUG:Resetting dropped connection: 192.168.1.54
2024-11-16 17:15:11,910 DEBUG:http://192.168.1.54:28080 "GET /json.htm?type=command&param=switchl                                                     ight&idx=733&switchcmd=On&level=0 HTTP/1.1" 200 47
2024-11-16 17:15:11,913 INFO:Respons domoticz : OK