usbtemp-python3/usbtemp.py at master · usbtemp/usbtemp-python3 · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
import struct
import time

import serial


class ThermometerException(Exception):
    pass


class Thermometer:
    """
    USB Thermometer Middleware
    """
    def __init__(self, port, timeout = 1):
        self.port = port
        self.timeout = timeout
        self.uart = None

    def Open(self):
        if not self.uart or not self.uart.isOpen():
            self.uart = serial.Serial(self.port, timeout = self.timeout)

    def Close(self):
        if self.uart and self.uart.isOpen():
            self.uart.close()
            self.uart = None

    def Rom(self):
        self._owReset()
        self._owWrite(0x33)
        data = self._readBytes(8)
        if self._crc8(data[0:7]) != data[7]:
            raise ThermometerException('CRC error')
        return data.hex()

    def Temperature(self):
        self._owReset()
        self._owWrite(0xcc)
        self._owWrite(0x44)
        time.sleep(1)
        self._owReset()
        self._owWrite(0xcc)
        self._owWrite(0xbe)
        scratchpad = self._readBytes(9)
        if self._crc8(scratchpad[0:8]) != scratchpad[8]:
            raise ThermometerException('CRC error')
        temp = struct.unpack('<h', scratchpad[0:2])[0]
        return float(temp) / 16.0

    def _clear(self):
        self.uart.reset_input_buffer()
        self.uart.reset_output_buffer()

    def _owReset(self):
        if not self.uart or not self.uart.isOpen():
            raise ThermometerException('Device is not connected')
        self._clear()
        self.uart.baudrate = 9600
        self.uart.write(b'\xf0')
        r = self.uart.read(1)
        self.uart.baudrate = 115200
        if len(r) != 1:
            raise ThermometerException('Read/Write error')
        d = r[0]
        if d == 0xf0:
            raise ThermometerException('No device present')
        if d == 0x00:
            raise ThermometerException('Short circuit')
        if 0x10 <= d <= 0xe0:
            return
        raise ThermometerException('Presence error: 0x%02x' % d)

    def _owWriteByte(self, byte):
        if not self.uart or not self.uart.isOpen():
            raise Exception('Device is not connected')
        w = []
        for _ in range(8):
            w.append(0xff if byte & 0x01 else 0x00)
            byte >>= 1
        self._clear()
        self.uart.write(bytes(w))
        r = self.uart.read(8)
        if len(r) != 8:
            raise ThermometerException('Write error')
        value = 0
        for b in iter(r):
            value >>= 1
            if b == 0xff:
                value |= 0x80
        return value

    def _owWrite(self, byte):
        b = self._owWriteByte(byte)
        if b != byte:
            raise ThermometerException('Invalid response')

    def _owRead(self):
        return self._owWriteByte(0xff)

    def _readBytes(self, n):
        return bytes([self._owRead() for i in range(n)])

    def _crc8(self, data):
        crc = 0
        for byte in iter(data):
            for _ in range(8):
                mix = (crc ^ byte) & 0x01
                crc >>= 1
                if mix:
                    crc ^= 0x8c
                byte >>= 1
        return crc

if __name__ == '__main__':
    thermometer = Thermometer('/dev/ttyUSB0')
    try:
        thermometer.Open()
        print("Device ROM is %s" % thermometer.Rom())
        print("Temperature is %0.2f °C" % thermometer.Temperature())
    except Exception as e:
        print(e)
    finally:
        thermometer.Close()