diff --git a/pyblnet/blnet.py b/pyblnet/blnet.py index 11a23a5..8037f22 100644 --- a/pyblnet/blnet.py +++ b/pyblnet/blnet.py @@ -96,6 +96,11 @@ def fetch(self, node=None): for id, value in direct[domain].items(): if data[domain].get(id) is not None: data[domain][id]["value"] = value + elif not self.blnet_web: + if value is None: + continue + data[domain][id] = {"value": value} + for domain in ["speed", "energy", "power"]: for id, value in direct[domain].items(): if value is None: @@ -162,8 +167,11 @@ def get_value(self, name=None, id=None, type="digital", ret="value", cached=None if cached is None: cached = self.fetch() for key, v in cached[type].items(): - if str(v["name"]) == str(name) or str(v["id"]) == str(id): - val = v[ret] + # values fetched only via blnet_direct have no name + if (name is not None and str(v.get("name")) == str(name)) or ( + id is not None and str(key) == str(id) + ): + val = v.get(ret) dic = v return val, dic, cached diff --git a/pyblnet/blnet_conn.py b/pyblnet/blnet_conn.py index a76e6d7..0037b05 100644 --- a/pyblnet/blnet_conn.py +++ b/pyblnet/blnet_conn.py @@ -9,7 +9,7 @@ @author: Niels """ from builtins import str, int -from socket import socket, getaddrinfo, SOCK_STREAM, IPPROTO_TCP, setdefaulttimeout +from socket import socket, getaddrinfo, SOCK_STREAM, IPPROTO_TCP import struct from time import sleep from datetime import datetime @@ -55,12 +55,12 @@ def __init__(self, address, port: int = 40000, reset: bool = False, timeout: flo self.address = address self.port = port self.reset = reset + # 0 would make the socket non-blocking, treat it like None (no timeout) + self._timeout = timeout or None self._mode = None self._socket = None self._count = None self._check_mode() - if timeout: - setdefaulttimeout(timeout) def get_count(self): """ @@ -90,7 +90,7 @@ def get_count(self): self._fetch_size = 4 + 61 * frame_count elif self._mode == DL_MODE: (_, device, start_address, end_address, checksum) = struct.unpack( - "<5sB3s3sB" + "<5sB3s3sB", data ) self._address_inc = 64 self._can_frames = 1 @@ -98,7 +98,7 @@ def get_count(self): self._fetch_size = 65 elif self._mode == DL2_MODE: (_, device, start_address, end_address, checksum) = struct.unpack( - "<5s2s3s3sB" + "<5s2s3s3sB", data ) self._address_inc = 128 self._can_frames = 1 @@ -167,6 +167,7 @@ def _connect(self): for (family, socktype, proto, _, sockaddr) in available: try: self._socket = socket(family, socktype, proto) + self._socket.settimeout(self._timeout) self._socket.connect(sockaddr) break except: @@ -318,7 +319,7 @@ def get_latest(self, max_retries=MAX_RETRYS): self._connect() self.get_count() frames = {} - info = {"sleep": {}, "got": {}} + info = {"sleep": {}, "got": {}, "timeout": []} # for all frames for frame in range(0, self._can_frames): @@ -342,9 +343,9 @@ def get_latest(self, max_retries=MAX_RETRYS): info["got"][frame] = n frames.update(self._split_latest(data, frame)) break - # TODO this looks suspicious - if n == max_retries - 1: - frames[frame] = "timeout" + else: + # BL-Net did not send data for this frame within max_retries + info["timeout"].append(frame) info["sleep"][frame] = sleeps self._end_read(True) if len(frames) > 0: diff --git a/tests/test_direct.py b/tests/test_direct.py new file mode 100644 index 0000000..fd1e25a --- /dev/null +++ b/tests/test_direct.py @@ -0,0 +1,63 @@ +#!/usr/bin/env python +# -*- coding: utf-8 -*- + +import socket +import threading +import unittest + +from pyblnet import BLNET, BLNETDirect +from tests.test_structure.blnet_direct_mock_server import ( + BLNETDirectServer, + DL_LATEST_RESPONSE, + WAIT_RESPONSE, +) + +ADDRESS = "localhost" + + +class BLNETDirectOnlyTest(unittest.TestCase): + """Test the high level interface with only the direct (DL mode) connection enabled""" + + def setUp(self): + self.server = BLNETDirectServer((ADDRESS, 0)) + threading.Thread(target=self.server.serve_forever, daemon=True).start() + self.port = self.server.server_address[1] + + def tearDown(self): + self.server.shutdown() + self.server.server_close() + + def blnet(self, max_retries=5): + return BLNET( + ADDRESS, + ta_port=self.port, + use_web=False, + use_ta=True, + max_retries=max_retries, + ) + + def test_fetch(self): + data = self.blnet().fetch() + self.assertEqual(data["analog"][6], {"value": 53.9}) + self.assertEqual(data["digital"][1], {"value": 1}) + self.assertEqual(data["speed"][1], {"value": 24}) + self.assertEqual(data["energy"], {1: {"value": 362847.4}}) + + def test_get_value_by_id(self): + value, entry, _ = self.blnet().get_analog_value(id=6) + self.assertEqual(value, 53.9) + self.assertEqual(entry, {"value": 53.9}) + + def test_fetch_succeeds_on_last_retry(self): + self.server.latest_responses = [WAIT_RESPONSE, WAIT_RESPONSE, DL_LATEST_RESPONSE] + data = self.blnet(max_retries=3).fetch() + self.assertEqual(data["analog"][6], {"value": 53.9}) + + def test_timeout_does_not_change_global_socket_timeout(self): + BLNETDirect(ADDRESS, self.port, timeout=7) + self.assertIsNone(socket.getdefaulttimeout()) + + def test_fetch_raises_when_blnet_keeps_waiting(self): + self.server.latest_responses = [WAIT_RESPONSE] + with self.assertRaises(ConnectionError): + self.blnet(max_retries=3).fetch() diff --git a/tests/test_structure/blnet_direct_mock_server.py b/tests/test_structure/blnet_direct_mock_server.py new file mode 100644 index 0000000..fbb96ab --- /dev/null +++ b/tests/test_structure/blnet_direct_mock_server.py @@ -0,0 +1,48 @@ +from socketserver import BaseRequestHandler, ThreadingTCPServer + +# Responses recorded from a real BL-NET with one UVR1611 in DL mode +DL_MODE_RESPONSE = bytes.fromhex("a8") +DL_HEADER_RESPONSE = bytes.fromhex("0fa85e6b1d76809204409204ff") +DL_LATEST_RESPONSE = bytes.fromhex( + "80ff2fff2fff2fff2fff2f1b224d210522e92110216e20322103226f21ff2f003061" + "0218000a1201000000001a216a010b010a3c0001000c04" +) +# Asks the client to wait the given amount of seconds before trying again +WAIT_RESPONSE = bytes.fromhex("ba00ba") + +GET_MODE = 0x81 +GET_HEADER = 0xAA +GET_LATEST = 0xAB +END_READ = 0xAD + + +class BLNETDirectServer(ThreadingTCPServer): + + daemon_threads = True + allow_reuse_address = True + + def __init__(self, server_address): + super().__init__(server_address, BLNETDirectRequestHandler) + # Responses to GET_LATEST, the last one is repeated forever + self.latest_responses = [DL_LATEST_RESPONSE] + + +class BLNETDirectRequestHandler(BaseRequestHandler): + def handle(self): + while True: + command = self.request.recv(1) + if not command: + return + command = command[0] + if command == GET_MODE: + self.request.sendall(DL_MODE_RESPONSE) + elif command == GET_HEADER: + self.request.sendall(DL_HEADER_RESPONSE) + elif command == GET_LATEST: + # frame number + self.request.recv(1) + responses = self.server.latest_responses + response = responses.pop(0) if len(responses) > 1 else responses[0] + self.request.sendall(response) + elif command == END_READ: + self.request.sendall(bytes([END_READ]))