wip

tic.py

@@ -1,5 +1,4 @@
 import logging
-import time
 
 import tic_device
 import tic_standard
@@ -12,9 +11,8 @@ TIC_ETX     = b'\x03'
 TIC_SGR     = b'\x0a'
 TIC_EGR     = b'\x0d'
 
-TIC_MODE_STD = "standard"
-TIC_MODE_HIS = "historique"
-
+TIC_MODE_STD = 1
+TIC_MODE_HIS = 2
 
 type_str = {
     '61': "Compteur monophasé 60 A généralisation Linky G3 - arrivée puissance haute",
@@ -87,40 +85,48 @@ class Tic:
         self.device_serial = None
         self.mode = None
         self._tic = None
-        self._cb_ads = None
-        self._cb_msg = None
-
-    def set_mode(self, mode):
-        if mode == TIC_MODE_STD:
-            self.mode = TIC_MODE_STD
-            self._tic = tic_standard.TicStandard()
-            self.device.set_baudrate(9600)
-            log.info(f"set_mode: {self._tic.name()}")
-        elif mode == TIC_MODE_HIS:
-            self.mode = TIC_MODE_HIS
-            self._tic = tic_hist.TicHist()
-            self.device.set_baudrate(1200)
-            log.info(f"set_mode: {self._tic.name()}")
-        else:
-            self.mode = None
-            self._tic = None
-            log.info(f"set_mode: unsupported")
 
     def detect_mode(self):
-        for mode in ( TIC_MODE_STD, TIC_MODE_HIS ):
-            self.set_mode(mode)
-            f = self.get_frame()
-            if not f:
-                continue
-            groups = self.split_frame(f)
-            for group in groups:
-                if not self.check_sum(group):
-                    continue
-                self.decode_group(group)
-            if self.ads:
-                log.info(f"detected {self._tic.name()}")
-                return mode
-        log.error("no valid frame detected")
+        if self._detect_mode():
+            return
+        if self.device.is_serial():
+            log.debug("tring speed 1200bps")
+            self.device.set_baudrate(1200)
+            if self._detect_mode():
+                return
+        log.error("no TIC protocol detected")
+        return None
+
+    def _detect_mode(self):
+        ok_mask = 0x00
+        tic_map = { TIC_STX:     0x01,
+                    TIC_ETX:     0x02,
+                    TIC_SGR:     0x04,
+                    TIC_EGR:     0x08,
+                    b'\x09': 0x10 } # TODO
+
+        nb_reset = 0
+        while c := self.device.get_char():
+            ok = tic_map.get(c, 0)
+            if ok_mask or ok == 0x01:
+                ok_mask = ok_mask | ok
+            if ok_mask == 0x1f:
+                log.info(f"Standard mode detected")
+                self.mode = TIC_MODE_STD
+                self._tic = tic_standard.TicStandard()
+                return self.mode
+            if ok_mask == 0x0f:
+                log.info(f"Historiqual mode detected")
+                self.mode = TIC_MODE_HIS
+                self._tic = tic_hist.TicHist()
+                return self.mode
+            if not ok and (c < b' ' or c > b'\x7f'):
+                log.debug(f"bad char: {c}")
+                ok_mask = 0x00
+                nb_reset = nb_reset + 1
+                if nb_reset >= 20:
+                    break
+        log.debug("Timeout/EOF")
         return None
 
     def get_frame(self):
@@ -159,8 +165,7 @@ class Tic:
 
     def decode_group(self, group):
         msg = self._tic.decode_group(group)
-        log.debug(f"msg: {msg}")
-        if msg and msg.get('label') in ( 'ADSC', 'ADCO' ):
+        if msg['label'] == 'ADSC':
             self.parse_ads(msg['value'])
         return msg
 
@@ -179,18 +184,6 @@ class Tic:
             log.info(f"year: {self.device_year}")
             log.info(f"model: {self.device_model}")
             log.info(f"serial number: {self.device_serial}")
-            if self._cb_ads:
-                self._cb_ads(self.ads, self.device_manufacturer, self.device_year, self.device_model, self.device_serial)
-
-    def set_callback_ads(self, function):
-        self._cb_ads = function
-        if self.ads:
-            ads = self.ads
-            self.ads = None
-            self.parse_ads(self.ads)
-
-    def set_callback_msg(self, function):
-        self._cb_msg = function
 
     def run(self):
         while True:
@@ -203,8 +196,4 @@ class Tic:
                     continue
                 msg = self.decode_group(group)
                 log.info(msg)
-                if msg and self._cb_msg:
-                    self._cb_msg(msg)
-            #if not self.device.is_serial():
-            #    time.sleep(1)
 

tic2mqtt

@@ -26,17 +26,12 @@ def main():
 
     logging.basicConfig(level=getattr(logging, args.log.upper()))
 
-    my_tic = tic.Tic(args.input)
-    if args.mode == "auto":
-        my_tic.detect_mode()
-    else:
-        my_tic.set_mode(args.mode)
+    tc = tic.Tic(args.input)
+    tc.detect_mode()
 
     mqtt = tic_mqtt.TicPublisher(args.broker)
-    my_tic.set_callback_ads(mqtt.set_ads)
-    my_tic.set_callback_msg(mqtt.send_msg)
 
-    my_tic.run()
+    tc.run()
 
     if mqtt:
         mqtt.close()

tic_hist.py

@@ -6,40 +6,18 @@ log = logging.getLogger(__name__)
 TIC_SEP_HIS = b'\x20'
 
 msgs = {
-    'ADCO':     { 'len': 12, },
+    'ADCO':     { 'len': 12, 'value': 'adsc' },
     'OPTARIF':  { 'len': 4 },
-    'ISOUSC':   { 'len': 2, 'unit': 'A' },
-    'BASE':     { 'len': 9, 'unit': 'Wh' },
-    'HCHC':     { 'len': 9, 'unit': 'Wh' },
-    'HCHP':     { 'len': 9, 'unit': 'Wh' },
-    'EJPHN':    { 'len': 9, 'unit': 'Wh' },
-    'EJPHPM':   { 'len': 9, 'unit': 'Wh' },
-    'BBRHCJB':  { 'len': 9, 'unit': 'Wh' },
-    'BBRHPJB':  { 'len': 9, 'unit': 'Wh' },
-    'BBRHCJW':  { 'len': 9, 'unit': 'Wh' },
-    'BBRHPJW':  { 'len': 9, 'unit': 'Wh' },
-    'BBRHCJR':  { 'len': 9, 'unit': 'Wh' },
-    'BBRHPJR':  { 'len': 9, 'unit': 'Wh' },
-    'PEJP':     { 'len': 9, 'unit': 'min' },
+    'ISOUSC':   { 'len': 2, 'value': 'num' },
+    'HCHC':     { 'len': 9, 'value': 'num' },
+    'HCHP':     { 'len': 9, 'value': 'num' },
     'PTEC':     { 'len': 4 },
-    'DEMAIN':   { 'len': 9 },
-    'IINST':    { 'len': 3, 'unit': 'A' },
-    'IINST1':   { 'len': 3, 'unit': 'A' },
-    'IINST2':   { 'len': 3, 'unit': 'A' },
-    'IINST3':   { 'len': 3, 'unit': 'A' },
-    'ADPS':     { 'len': 3, 'unit': 'A' },
-    'IMAX':     { 'len': 3, 'unit': 'A' },
-    'IMAX1':    { 'len': 3, 'unit': 'A' },
-    'IMAX2':    { 'len': 3, 'unit': 'A' },
-    'IMAX3':    { 'len': 3, 'unit': 'A' },
-    'PMAX':     { 'len': 5, 'unit': 'W' },
-    'PAPP':     { 'len': 5, 'unit': 'VA' },
+    'IINST':    { 'len': 3, 'value': 'num' },
+    'ADPS':     { 'len': 3, 'value': 'num' },
+    'IMAX':     { 'len': 3, 'value': 'num' },
+    'PAPP':     { 'len': 5, 'value': 'num' },
     'HHPHC':    { 'len': 1 },
-    'MOTDETAT': { 'len': 6 },
-    'PPOT':     { 'len': 2 },
-    'ADIR1':    { 'len': 3, 'unit': 'A' },
-    'ADIR2':    { 'len': 3, 'unit': 'A' },
-    'ADIR3':    { 'len': 3, 'unit': 'A' },
+    'MOTDETAT': { 'len': 6, 'value': 'num' },
 }
 
 class TicHist:
@@ -47,9 +25,6 @@ class TicHist:
         self.sep = TIC_SEP_HIS.decode('ascii')
         pass
 
-    def name(self):
-        return "mode historique"
-
     def check_sum(self, group):
         checksum = group[-1]
         sum = 0
@@ -74,8 +49,8 @@ class TicHist:
         if len(value) != msgs[label]['len']:
             log.warning(f'bad value length: {group}')
             return None
-        unit = msgs[label].get('unit')
-        if unit:
+        value_type = msgs[label].get('value', None)
+        if value_type == 'num':
             try:
                 value = int(value)
             except:
@@ -86,7 +61,5 @@ class TicHist:
 
         msg['label'] = label
         msg['value'] = value
-        if unit:
-            msg['unit'] = unit
         return msg
 

tic_mqtt.py

@@ -1,29 +1,8 @@
 import paho.mqtt.client as mqtt
-import time
-import json
 import logging
 
 log = logging.getLogger(__name__)
 
-state_class_from_unit = {
-    'Wh':   'total_increasing',
-    'VArh': 'power',
-    'A':    'measurement',
-    'V':    'measurement',
-    'kVA':  'measurement',
-    'VA':   'measurement',
-    'W':    'measurement',
-}
-
-device_class_from_unit = {
-    'Wh':   'energy',
-    'VArh': 'power',
-    'A':    'current',
-    'V':    'voltage',
-    'kVA':  'apparent_power',
-    'VA':   'apparent_power',
-    'W':    'power',
-}
 
 class TicPublisher:
     def __init__(self, hostname=None, port=1883):
@@ -32,100 +11,9 @@ class TicPublisher:
             self.client = mqtt.Client()
             self.client.connect(hostname, port)
             #self.client.loop_start()
-        self._ads = None
-        self._manufacturer = None
-        self._year = None
-        self._model = None
-        self._serial = None
-        self._last_ts = {}
-        self._ha_config = {}
 
     def close(self):
         if self.client:
             #self.client.loop_stop()
             self.client = None
 
-    def set_ads(self, ads, manufacturer, year, model, serial):
-        log.debug(f"ads: {ads} manufacturer: {manufacturer} year: {year} model: {model} serial: {serial}")
-        self._ads = ads
-        self._manufacturer = manufacturer
-        self._year = year
-        self._model = model
-        self._serial = serial
-
-    def get_topic(self, label):
-        label = label.replace('+', 'PLUS').replace('-', 'MOINS')
-        topic = f"tic/{self._ads}/{label}"
-        return topic
-
-    def send_ha_config(self, msg, topic):
-        if not self._ads:
-            return
-        label = msg.get('label')
-        unit = msg.get('unit')
-        device_class = device_class_from_unit.get(unit) if unit else None
-        state_class = state_class_from_unit.get(unit) if unit else None
-        unique_id = f"tic_{self._ads}_{label.replace('+','PLUS').replace('-','MOINS')}"
-        node_id = f"tic"
-        object_id = unique_id
-
-        config_topic = f"homeassistant/sensor/{node_id}/{object_id}/config"
-        config = {
-            'unique_id': unique_id,
-            'name': label,
-            'state_topic': topic,
-            'value_template': "{% if 'value' in value_json %}{{ value_json.value }}{% endif %}",
-            'device_class': device_class,
-            'unit_of_measurement': unit,
-            'device': {
-                'identifiers': [ f'tic_{self._ads}' ],
-                'manufacturer': self._manufacturer,
-                'model': self._model,
-                'name': 'Tic Enedis',
-            },
-            'origin': {
-                'name': 'tic2mqtt',
-                'sw_version': "0.1",
-                'support_url': "https://git.grandou.net/gilles/tic2mqtt",
-            }
-        }
-        if unit:
-            config['unit_of_measurement'] = unit
-        if device_class:
-            config['device_class'] = device_class
-        if state_class:
-            config['state_class'] = state_class
-
-        log.debug(f"HA config topic: {config_topic}")
-        log.debug(f"HA config: {config}")
-        result = self.client.publish(config_topic, json.dumps(config), retain=True)
-
-    def send_msg(self, msg):
-        log.debug(f"msg: {msg}")
-        if not self.client:
-            return
-        if not self._ads:
-            return
-        if msg.get('label') is None:
-            return
-        if msg.get('value') is None:
-            return
-        ts = time.time()
-        label = msg.get('label')
-        value = msg.get('value')
-        unit = msg.get('unit')
-        if self._last_ts.get(label):
-            if ts < self._last_ts[label]['ts'] + 60 and value == self._last_ts[label]['value']:
-                log.debug(f"skip msg {label} {value}")
-                return
-        self._last_ts[label] = { 'value': value, 'ts': ts }
-        topic = self.get_topic(label)
-        if not self._ha_config.get('label'):
-            self.send_ha_config(msg, topic)
-        _msg = { 'value': msg['value'] }
-        if msg.get('date'):
-            _msg['date'] = msg['date']
-        log.debug(f"topic: {topic} msg: {_msg}")
-        result = self.client.publish(topic, json.dumps(_msg))
-
-

tic_standard.py

@@ -8,61 +8,61 @@ log = logging.getLogger(__name__)
 TIC_SEP_STD = b'\x09'
 
 msgs = {
-    'ADSC':      { 'len': 12 },
-    'VTIC':      { 'len': 2 },
+    'ADSC':      { 'len': 12, 'value': 'adsc' },
+    'VTIC':      { 'len': 2,  'value': 'num' },
     'DATE':      { 'len': 0   },
     'NGTF':      { 'len': 16  },
     'LTARF':     { 'len': 16  },
-    'EAST':      { 'len': 9,  'unit': 'Wh' },
-    'EASF01':    { 'len': 9,  'unit': 'Wh' },
-    'EASF02':    { 'len': 9,  'unit': 'Wh' },
-    'EASF03':    { 'len': 9,  'unit': 'Wh' },
-    'EASF04':    { 'len': 9,  'unit': 'Wh' },
-    'EASF05':    { 'len': 9,  'unit': 'Wh' },
-    'EASF06':    { 'len': 9,  'unit': 'Wh' },
-    'EASF07':    { 'len': 9,  'unit': 'Wh' },
-    'EASF08':    { 'len': 9,  'unit': 'Wh' },
-    'EASF09':    { 'len': 9,  'unit': 'Wh' },
-    'EASF10':    { 'len': 9,  'unit': 'Wh' },
-    'EASD01':    { 'len': 9,  'unit': 'Wh' },
-    'EASD02':    { 'len': 9,  'unit': 'Wh' },
-    'EASD03':    { 'len': 9,  'unit': 'Wh' },
-    'EASD04':    { 'len': 9,  'unit': 'Wh' },
-    'EAIT':      { 'len': 9,  'unit': 'Wh' },
-    'ERQ1':      { 'len': 9,  'unit': 'VArh' },
-    'ERQ2':      { 'len': 9,  'unit': 'VArh' },
-    'ERQ3':      { 'len': 9,  'unit': 'VArh' },
-    'ERQ4':      { 'len': 9,  'unit': 'VArh' },
-    'IRMS1':     { 'len': 3,  'unit': 'A' },
-    'IRMS2':     { 'len': 3,  'unit': 'A' },
-    'IRMS3':     { 'len': 3,  'unit': 'A' },
-    'URMS1':     { 'len': 3,  'unit': 'V' },
-    'URMS2':     { 'len': 3,  'unit': 'V' },
-    'URMS3':     { 'len': 3,  'unit': 'V' },
-    'PREF':      { 'len': 2,  'unit': 'kVA' },
-    'PCOUP':     { 'len': 2,  'unit': 'kVA' },
-    'SINSTS':    { 'len': 5,  'unit': 'VA' },
-    'SINST1':    { 'len': 5,  'unit': 'VA' },
-    'SINST2':    { 'len': 5,  'unit': 'VA' },
-    'SINST3':    { 'len': 5,  'unit': 'VA' },
-    'SMAXSN':    { 'len': 5,  'unit': 'VA' },
-    'SMAXSN1':   { 'len': 5,  'unit': 'VA' },
-    'SMAXSN2':   { 'len': 5,  'unit': 'VA' },
-    'SMAXSN3':   { 'len': 5,  'unit': 'VA' },
-    'SMAXSN-1':  { 'len': 5,  'unit': 'VA' },
-    'SMAXSN1-1': { 'len': 5,  'unit': 'VA' },
-    'SMAXSN2-1': { 'len': 5,  'unit': 'VA' },
-    'SMAXSN3-1': { 'len': 5,  'unit': 'VA' },
-    'SINSTI':    { 'len': 5,  'unit': 'VA' },
-    'SMAXIN':    { 'len': 5,  'unit': 'VA' },
-    'SMAXIN-1':  { 'len': 5,  'unit': 'VA' },
-    'CCASN':     { 'len': 5,  'unit': 'W' },
-    'CCASN-1':   { 'len': 5,  'unit': 'W' },
-    'CCAIN':     { 'len': 5,  'unit': 'W' },
-    'CCAIN-1':   { 'len': 5,  'unit': 'W' },
-    'UMOY1':     { 'len': 3,  'unit': 'V' },
-    'UMOY2':     { 'len': 3,  'unit': 'V' },
-    'UMOY3':     { 'len': 3,  'unit': 'V' },
+    'EAST':      { 'len': 9,  'value': 'num' },
+    'EASF01':    { 'len': 9,  'value': 'num' },
+    'EASF02':    { 'len': 9,  'value': 'num' },
+    'EASF03':    { 'len': 9,  'value': 'num' },
+    'EASF04':    { 'len': 9,  'value': 'num' },
+    'EASF05':    { 'len': 9,  'value': 'num' },
+    'EASF06':    { 'len': 9,  'value': 'num' },
+    'EASF07':    { 'len': 9,  'value': 'num' },
+    'EASF08':    { 'len': 9,  'value': 'num' },
+    'EASF09':    { 'len': 9,  'value': 'num' },
+    'EASF10':    { 'len': 9,  'value': 'num' },
+    'EASD01':    { 'len': 9,  'value': 'num' },
+    'EASD02':    { 'len': 9,  'value': 'num' },
+    'EASD03':    { 'len': 9,  'value': 'num' },
+    'EASD04':    { 'len': 9,  'value': 'num' },
+    'EAIT':      { 'len': 9,  'value': 'num' },
+    'ERQ1':      { 'len': 9,  'value': 'num' },
+    'ERQ2':      { 'len': 9,  'value': 'num' },
+    'ERQ3':      { 'len': 9,  'value': 'num' },
+    'ERQ4':      { 'len': 9,  'value': 'num' },
+    'IRMS1':     { 'len': 3,  'value': 'num' },
+    'IRMS2':     { 'len': 3,  'value': 'num' },
+    'IRMS3':     { 'len': 3,  'value': 'num' },
+    'URMS1':     { 'len': 3,  'value': 'num' },
+    'URMS2':     { 'len': 3,  'value': 'num' },
+    'URMS3':     { 'len': 3,  'value': 'num' },
+    'PREF':      { 'len': 2,  'value': 'num' },
+    'PCOUP':     { 'len': 2,  'value': 'num' },
+    'SINSTS':    { 'len': 5,  'value': 'num' },
+    'SINST1':    { 'len': 5,  'value': 'num' },
+    'SINST2':    { 'len': 5,  'value': 'num' },
+    'SINST3':    { 'len': 5,  'value': 'num' },
+    'SMAXSN':    { 'len': 5,  'value': 'num' },
+    'SMAXSN1':   { 'len': 5,  'value': 'num' },
+    'SMAXSN2':   { 'len': 5,  'value': 'num' },
+    'SMAXSN3':   { 'len': 5,  'value': 'num' },
+    'SMAXSN-1':  { 'len': 5,  'value': 'num' },
+    'SMAXSN1-1': { 'len': 5,  'value': 'num' },
+    'SMAXSN2-1': { 'len': 5,  'value': 'num' },
+    'SMAXSN3-1': { 'len': 5,  'value': 'num' },
+    'SINSTI':    { 'len': 5,  'value': 'num' },
+    'SMAXIN':    { 'len': 5,  'value': 'num' },
+    'SMAXIN-1':  { 'len': 5,  'value': 'num' },
+    'CCASN':     { 'len': 5,  'value': 'num' },
+    'CCASN-1':   { 'len': 5,  'value': 'num' },
+    'CCAIN':     { 'len': 5,  'value': 'num' },
+    'CCAIN-1':   { 'len': 5,  'value': 'num' },
+    'UMOY1':     { 'len': 3,  'value': 'num' },
+    'UMOY2':     { 'len': 3,  'value': 'num' },
+    'UMOY3':     { 'len': 3,  'value': 'num' },
     'STGE':      { 'len': 8 },
     'DPM1':      { 'len': 2 },
     'FPM1':      { 'len': 2 },
@@ -93,9 +93,6 @@ class TicStandard:
         }
         pass
 
-    def name(self):
-        return "mode standard"
-
     def check_sum(self, group):
         checksum = group[-1]
         sum = 0
@@ -123,9 +120,8 @@ class TicStandard:
         if len(value) != msgs[label]['len']:
             log.warning(f'bad value length: {group}')
             return None
-        unit = msgs[label].get('unit')
         value_type = msgs[label].get('value', None)
-        if unit:
+        if value_type == 'num':
             try:
                 value = int(value)
             except:
@@ -133,16 +129,11 @@ class TicStandard:
                 return None
         else:
             value = re.sub('\s\s+', ' ', value).strip()
-            if not len(value):
-                value = None
 
         msg['label'] = label
-        if value is not None:
-            msg['value'] = value
+        msg['value'] = value
         if date:
             msg['date'] = date
-        if unit:
-            msg['unit'] = unit
         return msg
 
     def parse_date(self, str):