def _res(self, addr):
ow = OneWire(Pin(self.pin))
ow.reset()
ow.select_rom(addr)
ow.writebyte(0x4E)
if self.res == 12:
ow.writebyte(0x7F)
ow.writebyte(0x7F)
ow.writebyte(0x7F)
print("12 bit mode")
if self.res == 11:
ow.writebyte(0x5F)
ow.writebyte(0x5F)
ow.writebyte(0x5F)
print("11 bit mode")
if self.res == 10:
ow.writebyte(0x3F)
ow.writebyte(0x3F)
ow.writebyte(0x3F)
print("10 bit mode")
if self.res == 9:
ow.writebyte(0x1F)
ow.writebyte(0x1F)
ow.writebyte(0x1F)
print("9 bit mode")
ow.reset()
class TemperatureSensor:
class _Const:
CONVERT = const(0x44)
RD_SCRATCH = const(0xbe)
def __init__(self, pin):
self._onewire = OneWire(pin)
self._buffer = bytearray(9)
self._rom = [rom for rom in self._onewire.scan() if rom[0] in (0x10, 0x22, 0x28)][0]
self._convert_temp()
def _convert_temp(self):
self._onewire.reset(True)
self._onewire.writebyte(self._onewire.SKIP_ROM)
self._onewire.writebyte(self._Const.CONVERT)
def _read_scratch(self):
self._onewire.reset(True)
self._onewire.select_rom(self._rom)
self._onewire.writebyte(TemperatureSensor._Const.RD_SCRATCH)
self._onewire.readinto(self._buffer)
if self._onewire.crc8(self._buffer):
raise Exception('Temperature sensor::CRC error')
return self._buffer
def read(self):
buffer = self._read_scratch()
if self._rom[0] == 0x10:
if self._buffer[1]:
t = self._buffer[0] >> 1 | 0x80
t = -((~t + 1) & 0xff)
else:
t = self._buffer[0] >> 1
return t - 0.25 + (self._buffer[7] - self._buffer[6]) / self._buffer[7]
else:
t = self._buffer[1] << 8 | self._buffer[0]
if t & 0x8000:
t = -((t ^ 0xffff) + 1)
return t / 16
def _request(self, addr):
_res(self, addr)
ow = OneWire(Pin(self.pin))
ow.reset()
ow.select_rom(addr)
ow.writebyte(0x44) # command to take reading
if self.res == 12: # the resolution determines the amount of time needed
time.sleep_ms(1000)
if self.res == 11:
time.sleep_ms(400)
if self.res == 10:
time.sleep_ms(200)
if self.res == 9:
time.sleep_ms(100)
ow.reset() # reset required for data
ow.select_rom(addr)
ow.writebyte(0xBE) # command to send temperature data
# all nine bytes must be read
LSB = ow.readbyte() # least significant byte
MSB = ow.readbyte() # most significant byte
ow.readbyte()
ow.readbyte()
ow.readbyte() # this is the configuration byte for resolution
ow.readbyte()
ow.readbyte()
ow.readbyte()
ow.readbyte()
ow.reset() # reset at end of data transmission
# convert response to binary, format the binary string, and perform math
d_LSB = float(0)
d_MSB = float(0)
count = 0
b = bin(LSB)
b2 = bin(MSB)
b3 = ""
l = 10 - len(b2)
for i in range(l):
if len(b2) < 10:
b3 += "0"
b2 = b3 + b2
b4 = ""
l = 10 - len(b)
for i in range(l):
if len(b) < 10:
b4 += "0"
b5 = b4 + b
for i in b5:
if count == 2:
if i == '1':
d_LSB += 2**3
if count == 3:
if i == '1':
d_LSB += 2**2
if count == 4:
if i == '1':
d_LSB += 2**1
if count == 5:
if i == '1':
d_LSB += 2**0
if count == 6:
if i == '1':
d_LSB += 2**-1
if count == 7:
if i == '1':
d_LSB += 2**-2
if count == 8:
if i == '1':
d_LSB += 2**-3
if count == 9:
if i == '1':
d_LSB += 2**-4
count += 1
count = 0
sign = 1
for i in b2:
if count == 6:
if i == '1':
sign = -1
if count == 7:
if i == '1':
d_MSB += 2**6
if count == 8:
if i == '1':
d_MSB += 2**5
if count == 9:
if i == '1':
d_MSB += 2**4
count += 1
temp = (d_LSB + d_MSB) * sign
if self.unit == 'c' or self.unit == 'C':
print("TEMP is: " + str(temp) + " degrees C")
if self.unit == 'f' or self.unit == 'F':
temp = (temp * 9 / 5) + 32
print("TEMP F is: " + str(temp))
return temp
class DS18X20(object):
def __init__(self, pin):
self.ow = OneWire(pin)
# Scan the 1-wire devices, but only keep those which have the
# correct # first byte in their rom for a DS18x20 device.
self.roms = [rom for rom in self.ow.scan() if rom[0] == 0x10 or rom[0] == 0x28]
def _select_rom(self, rom):
if rom:
self.ow.select_rom(rom)
else:
self.ow.skip_rom()
def read_temp(self, rom=None):
"""
Read and return the temperature of one DS18x20 device.
Pass the 8-byte bytes object with the ROM of the specific device you want to read.
If only one DS18x20 device is attached to the bus you may omit the rom parameter.
"""
ow = self.ow
ow.reset()
self._select_rom(rom)
ow.write_byte(0x44) # Convert Temp
while True:
if ow.read_bit():
break
ow.reset()
self._select_rom(rom)
ow.write_byte(0xbe) # Read scratch
data = ow.read_bytes(9)
return self.convert_temp(rom[0], data)
def read_temps(self):
"""
Read and return the temperatures of all attached DS18x20 devices.
"""
temps = []
for rom in self.roms:
temps.append(self.read_temp(rom))
return temps
def convert_temp(self, rom0, data):
"""
Convert the raw temperature data into degrees celsius and return as a float.
"""
temp_lsb = data[0]
temp_msb = data[1]
if rom0 == 0x10:
if temp_msb != 0:
# convert negative number
temp_read = temp_lsb >> 1 | 0x80 # truncate bit 0 by shifting, fill high bit with 1.
temp_read = -((~temp_read + 1) & 0xff) # now convert from two's complement
else:
temp_read = temp_lsb >> 1 # truncate bit 0 by shifting
count_remain = data[6]
count_per_c = data[7]
temp = temp_read - 0.25 + (count_per_c - count_remain) / count_per_c
return temp
elif rom0 == 0x28:
return (temp_msb << 8 | temp_lsb) / 16
else:
assert False
