upgrade for firmware >= 4.08, incompatible with older firmwares

Author: cdump

radiacode-examples/narodmon.py

@@ -4,43 +4,38 @@
 
 import aiohttp
 
-from radiacode import CountRate, DoseRate, RadiaCode
+from radiacode import RealTimeData, RadiaCode
 
 
 def sensors_data(rc_conn):
     databuf = rc_conn.data_buf()
 
-    last_countrate, last_doserate = None, None
+    last = None
     for v in databuf:
-        if isinstance(v, CountRate):
-            if last_countrate is None or last_countrate.dt < v.dt:
-                last_countrate = v
-        elif isinstance(v, DoseRate):
-            if last_doserate is None or last_doserate.dt < v.dt:
-                last_doserate = v
-
-    ret = []
-    if last_countrate is not None:
-        ret.append(
-            {
-                'id': 'S1',
-                'name': 'CountRate',
-                'value': last_countrate.count_rate,
-                'unit': 'CPS',
-                'time': int(last_countrate.dt.timestamp()),
-            }
-        )
-    if last_doserate is not None:
-        ret.append(
-            {
-                'id': 'S2',
-                'name': 'R_DoseRate',
-                'value': 1000000 * last_doserate.dose_rate,
-                'unit': 'μR/h',
-                'time': int(last_doserate.dt.timestamp()),
-            }
-        )
-    return ret
+        if isinstance(v, RealTimeData):
+            if last is None or last.dt < v.dt:
+                last = v
+
+    if last is None:
+        return []
+
+    ts = int(last.dt.timestamp())
+    return [
+        {
+            'id': 'S1',
+            'name': 'CountRate',
+            'value': last.count_rate,
+            'unit': 'CPS',
+            'time': ts,
+        },
+        {
+            'id': 'S2',
+            'name': 'R_DoseRate',
+            'value': 1000000 * last.dose_rate,
+            'unit': 'μR/h',
+            'time': ts,
+        },
+    ]
 
 
 async def send_data(d):

radiacode-examples/radiacode-exporter.py

@@ -3,7 +3,7 @@
 
 import prometheus_client
 
-from radiacode import CountRate, DoseRate, RadiaCode
+from radiacode import RealTimeData, RadiaCode
 
 
 def main():
@@ -33,10 +33,9 @@ def main():
 
     while True:
         for v in rc.data_buf():
-            if isinstance(v, CountRate):
+            if isinstance(v, RealTimeData):
                 metric_count_rate.set(v.count_rate)
                 metric_count_rate_error.set(v.count_rate_err)
-            elif isinstance(v, DoseRate):
                 metric_dose_rate.set(10000 * v.dose_rate)  # convert to μSv/h
                 metric_dose_rate_error.set(v.dose_rate_err)
 

radiacode-examples/webserver.py

@@ -5,7 +5,7 @@
 
 from aiohttp import web
 
-from radiacode import CountRate, DoseRate, RadiaCode
+from radiacode import RadiaCode, RealTimeData
 
 
 async def handle_index(request):
@@ -47,29 +47,25 @@ async def handle_spectrum_reset(request):
 
 async def process(app):
     max_history_size = 128
-    countrate_history, doserate_history = [], []
+    history = []
     while True:
         databuf = app.rc_conn.data_buf()
         for v in databuf:
-            if isinstance(v, CountRate):
-                countrate_history.append(v)
-            elif isinstance(v, DoseRate):
-                doserate_history.append(v)
-
-        countrate_history.sort(key=lambda x: x.dt)
-        countrate_history = countrate_history[-max_history_size:]
-        doserate_history.sort(key=lambda x: x.dt)
-        doserate_history = doserate_history[-max_history_size:]
+            if isinstance(v, RealTimeData):
+                history.append(v)
+
+        history.sort(key=lambda x: x.dt)
+        history = history[-max_history_size:]
         jdata = json.dumps(
             {
                 'series': [
                     {
                         'name': 'countrate',
-                        'data': [(int(1000 * x.dt.timestamp()), x.count_rate) for x in countrate_history],
+                        'data': [(int(1000 * x.dt.timestamp()), x.count_rate) for x in history],
                     },
                     {
                         'name': 'doserate',
-                        'data': [(int(1000 * x.dt.timestamp()), 10000 * x.dose_rate) for x in doserate_history],
+                        'data': [(int(1000 * x.dt.timestamp()), 10000 * x.dose_rate) for x in history],
                     },
                 ],
             },

radiacode/decoders/databuf.py

@@ -2,14 +2,14 @@
 from typing import List, Union
 
 from radiacode.bytes_buffer import BytesBuffer
-from radiacode.types import CountRate, DoseRate, DoseRateDB, Event, RareData
+from radiacode.types import DoseRateDB, Event, RareData, RawData, RealTimeData
 
 
 def decode_VS_DATA_BUF(
     br: BytesBuffer,
     base_time: datetime.datetime,
-) -> List[Union[CountRate, DoseRate, DoseRateDB, RareData, Event]]:
-    ret: List[Union[CountRate, DoseRate, DoseRateDB, RareData, Event]] = []
+) -> List[Union[RealTimeData, DoseRateDB, RareData, RawData, Event]]:
+    ret: List[Union[RealTimeData, DoseRateDB, RareData, RawData, Event]] = []
     next_seq = None
     while br.size() > 0:
         seq, eid, gid, ts_offset = br.unpack('<BBBi')
@@ -18,24 +18,26 @@ def decode_VS_DATA_BUF(
             raise Exception(f'seq jump, expect:{next_seq}, got:{seq}')
 
         next_seq = (seq + 1) % 256
-        if eid == 0 and gid == 0:  # GRP_CountRate
-            count_rate, count_rate_err, flags = br.unpack('<fHH')
+        if eid == 0 and gid == 0:  # GRP_RealTimeData
+            count_rate, dose_rate, count_rate_err, dose_rate_err, flags, rt_flags = br.unpack('<ffHHHB')
             ret.append(
-                CountRate(
+                RealTimeData(
                     dt=dt,
                     count_rate=count_rate,
-                    count_rate_err=count_rate_err * 0.1,
+                    count_rate_err=count_rate_err / 10,
+                    dose_rate=dose_rate,
+                    dose_rate_err=dose_rate_err / 10,
                     flags=flags,
+                    real_time_flags=rt_flags,
                 )
             )
-        elif eid == 0 and gid == 1:  # GRP_DoseRate
-            dose_rate, dose_rate_err, flags = br.unpack('<fHH')
+        elif eid == 0 and gid == 1:  # GRP_RawData
+            count_rate, dose_rate = br.unpack('<ff')
             ret.append(
-                DoseRate(
+                RawData(
                     dt=dt,
+                    count_rate=count_rate,
                     dose_rate=dose_rate,
-                    dose_rate_err=dose_rate_err * 0.1,
-                    flags=flags,
                 )
             )
         elif eid == 0 and gid == 2:  # GRP_DoseRateDB
@@ -46,7 +48,7 @@ def decode_VS_DATA_BUF(
                     count=count,
                     count_rate=count_rate,
                     dose_rate=dose_rate,
-                    dose_rate_err=dose_rate_err * 0.1,
+                    dose_rate_err=dose_rate_err / 10,
                     flags=flags,
                 )
             )
@@ -57,8 +59,8 @@ def decode_VS_DATA_BUF(
                     dt=dt,
                     duration=duration,
                     dose=dose,
-                    temperature=temperature * 0.01 - 20,
-                    charge_level=charge_level * 0.01,
+                    temperature=(temperature - 2000) / 100,
+                    charge_level=charge_level / 100,
                     flags=flags,
                 )
             )
@@ -85,6 +87,9 @@ def decode_VS_DATA_BUF(
             count_rate, flags = br.unpack('<fH')
         elif eid == 0 and gid == 9:  # GRP_RawDoseRate
             dose_rate, flags = br.unpack('<fH')
+        elif eid == 1 and gid == 1:  # ???
+            samples_num, smpl_time_ms = br.unpack('<HI')
+            br.unpack(f'<{8*samples_num}x')  # skip
         elif eid == 1 and gid == 2:
             samples_num, smpl_time_ms = br.unpack('<HI')
             br.unpack(f'<{16*samples_num}x')  # skip

radiacode/radiacode.py

@@ -7,7 +7,7 @@
 from radiacode.decoders.spectrum import decode_RC_VS_SPECTRUM
 from radiacode.transports.bluetooth import Bluetooth
 from radiacode.transports.usb import Usb
-from radiacode.types import CTRL, VS, VSFR, CountRate, DisplayDirection, DoseRate, DoseRateDB, Event, RareData, Spectrum
+from radiacode.types import CTRL, VS, VSFR, DisplayDirection, DoseRateDB, Event, RareData, RawData, RealTimeData, Spectrum
 
 
 # channel number -> kEv
@@ -57,8 +57,12 @@ def execute(self, reqtype: bytes, args: Optional[bytes] = None) -> BytesBuffer:
     def read_request(self, command_id: Union[int, VS, VSFR]) -> BytesBuffer:
         r = self.execute(b'\x26\x08', struct.pack('<I', int(command_id)))
         retcode, flen = r.unpack('<II')
-        assert retcode == 1
-        assert r.size() == flen
+        assert retcode == 1, f'{command_id}: got retcode {retcode}'
+        # HACK: workaround for new firmware bug(?)
+        if r.size() == flen + 1 and r._data[-1] == 0x00:
+            r._data = r._data[:-1]
+        # END OF HACK
+        assert r.size() == flen, f'{command_id}: got size {r.size()}, expect {flen}'
         return r
 
     def write_request(self, command_id: Union[int, VSFR], data: Optional[bytes] = None) -> None:
@@ -128,7 +132,7 @@ def commands(self) -> str:
     def device_time(self, v: int) -> None:
         self.write_request(VSFR.DEVICE_TIME, struct.pack('<I', v))
 
-    def data_buf(self) -> List[Union[CountRate, DoseRate, DoseRateDB, RareData, Event]]:
+    def data_buf(self) -> List[Union[DoseRateDB, RareData, RealTimeData, RawData, Event]]:
         r = self.read_request(VS.DATA_BUF)
         return decode_VS_DATA_BUF(r, self._base_time)
 

radiacode/types.py

@@ -5,19 +5,21 @@
 
 
 @dataclass
-class CountRate:
+class RealTimeData:
     dt: datetime.datetime
     count_rate: float
     count_rate_err: float  # %
+    dose_rate: int
+    dose_rate_err: int
     flags: int
+    real_time_flags: int
 
 
 @dataclass
-class DoseRate:
+class RawData:
     dt: datetime.datetime
-    dose_rate: int
-    dose_rate_err: int
-    flags: int
+    count_rate: float
+    dose_rate: float
 
 
 @dataclass