def __init__(self):
p_pwr1.value(1)
ow = OneWire(p_DS18B20) # Pin 13 is the data pin for the DS18B20
self.ds = DS18X20(ow) # Initialize a ds18b20 object
self.roms = self.ds.scan(
) # Find all the DS18B20 sensors that are attached (we only have one)
def temp_init(pin=PIN_TEMP):
printHead("temp")
print("dallas temp init >")
from onewire import OneWire
from ds18x20 import DS18X20
dspin = Pin(pin)
# from util.octopus_lib import bytearrayToHexString
try:
ds = DS18X20(OneWire(dspin))
ts = ds.scan()
if len(ts) <= 0:
io_conf['temp'] = False
for t in ts:
print(" --{0}".format(bytearrayToHexString(t)))
except:
io_conf['temp'] = False
print("Err.temp")
print("Found {0} dallas sensors, temp active: {1}".format(
len(ts), io_conf.get('temp')))
if len(ts) > 1:
print(get_temp_n(ds, ts))
else:
print(get_temp(ds, ts))
return ds, ts
def __init__(self, internal_sensor_pin, external_sensor_pin):
self.internal_sensor = DS18X20(OneWire(internal_sensor_pin))
# scan for devices on the bus
self.rom = self.internal_sensor.scan()[0]
self.external_sensor = DHT11(external_sensor_pin)
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 __init__(self):
printflush("Init")
self.unhandled_event = False
printflush('Init LEDs')
self.leds = {
'red': Pin(D2, Pin.OUT, value=False),
'blue': Pin(D3, Pin.OUT, value=False),
'green': Pin(D4, Pin.OUT, value=False)
}
printflush('Init OneWire')
self.ds_pin = Pin(D1)
self.ow_inst = OneWire(self.ds_pin)
self.ds_sensor = DS18X20(self.ow_inst)
self.temp_id = self.ds_sensor.scan()[0]
printflush('Temperature sensor: %s' % self.temp_id)
printflush('set LED red')
self.leds['red'].on()
printflush('Instantiate WLAN')
self.wlan = network.WLAN(network.STA_IF)
printflush('connect_wlan()')
self.connect_wlan()
printflush('turn off red LED')
self.leds['red'].off()
printflush('hexlify mac')
self.mac = hexlify(self.wlan.config('mac')).decode()
printflush('MAC: %s' % self.mac)
self.entity_id = ENTITIES[self.mac]
self.friendly_name = FRIENDLY_NAMES[self.mac]
printflush('Entity ID: %s; Friendly Name: %s' % (
self.entity_id, self.friendly_name
))
self.post_path = '/api/states/' + self.entity_id
printflush('POST path: %s' % self.post_path)
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()
def __init__(self, postfix, pin, **kwargs):
super().__init__(postfix, **kwargs)
self.pin = Pin(pin)
self.onewire = OneWire(self.pin)
self.sensor = DS18X20(self.onewire)
self.roms = self.sensor.scan()
self.initialized = False # Sensor conversion takes 700mS, always lag one iteration behind.
print("Found %d ds18x20 sensor(s)" % len(self.roms))
def __init__(self, pin: int, pause: int = 1, verbose: bool = False):
self._pin = pin
self._temperature_sensor = DS18X20(OneWire(Pin(pin)))
self._temperature_chips = self._temperature_sensor.scan()
self.pause = pause
self.is_verbose = verbose
self.state = dict(temperature=dict())
print("The sensor controller module started")
def __prep_pin(self, pin):
"""Prepare pin for OneWire device
Args:
pin (int): pin with onewire device
"""
self.ds = DS18X20(OneWire(Pin(pin)))
self.dev = self.ds.scan()[0]
def __init__(self, unit='C'):
pin = machine.Pin(18)
o = OneWire(pin)
self.d = DS18X20(o)
self.devicelist = self.d.scan()
self.unit = unit
def setup():
global logger, rtc, sd, iCAM, iACC, CTLR_IPADDRESS, logfile, filename
global wdt, ow, temp, py, sensor
gc.enable()
# HW Setup
wdt = WDT(timeout=wdt_timeout)
sd = SD()
rtc = RTC()
os.mount(sd,'/sd')
# Enable WiFi Antenna
Pin('P12', mode=Pin.OUT)(True)
# TEMPERATURE SENSORS: DS18B20 and SI7006A20
ow = OneWire(Pin('P10'))
temp = DS18X20(ow)
py = Pysense()
sensor = SI7006A20(py)
# SYSTEM VARIABLES
iCAM = pycom.nvs_get('iCAM') # pycom.nvs_set('iCAM',1)
iACC = pycom.nvs_get('iACC') # pycom.nvs_set('iACC',1)
logfile='/sd/log/{}.log'.format(datetime_string(time.time()))
logging.basicConfig(level=logging.DEBUG,filename=logfile)
logger = logging.getLogger(__name__)
# # NETWORK VARIABLES
# pbconf = pybytes.get_config()
# AP = pbconf['wifi']['ssid']
# if AP == 'wings':
# CTLR_IPADDRESS = '192.168.1.51'
# elif AP == 'RUT230_7714':
# CTLR_IPADDRESS = '192.168.1.100'
# # CONNECT TO AP
# wlan = WLAN(mode=WLAN.STA)
# while not wlan.isconnected():
# nets = wlan.scan()
# for net in nets:
# if net.ssid == 'RUT230_7714':
# pybytes.connect_wifi()
#
# wlan.ifconfig(config=('192.168.1.100', '255.255.255.0', '192.168.1.1', '8.8.8.8'))
# wlan.connect('RUT230_7714', auth=(WLAN.WPA2, 'Ei09UrDg'), timeout=5000)
# while not wlan.isconnected():
# machine.idle() # save power while waiting
socket_client.CTLR_IPADDRESS = CTLR_IPADDRESS
# GREETING
logger.info('--------------------')
logger.info(' Starting CAM{}-ACC{}'.format(iCAM, iACC))
logger.info('--------------------')
logger.info('AP={}'.format(AP))
gc.collect()
return
def DS18B20_func(sens_name, sig_nbr, pin_str, temp_prior):
#DS18B20 data line connected to pin pin_str
pin = Pin(pin_str)
ow = OneWire(pin)
temp = DS18X20(ow)
pycom.heartbeat(False)
print('\n' + sens_name + ' sensor is initialized to ' + pin_str)
# Prior needs to be within 5 degrees celsius from actual temp
temperature_prev = temp_prior
while True:
temperature = temp.read_temp_async()
time.sleep(1)
#time.sleep(DELAY)
temp.start_conversion()
time.sleep(1)
# Remove None values and outliers
while temperature is None or abs(temperature -
temperature_prev) > OUTLIER_THRESHOLD:
print(sens_name + ' temperature error: ' + str(temperature))
# In order to remove the None values I need to reinitialize the sensor
# it may be a better solution to this
ow = OneWire(pin)
temp = DS18X20(ow)
temperature = temp.read_temp_async()
time.sleep(1)
temp.start_conversion()
time.sleep(1)
temperature = round(temperature, DECIMALS)
print(sens_name + ' temperature: ' + str(temperature))
# Send to pybytes and blink red
pycom.rgbled(0x330000)
pybytes.send_signal(sig_nbr, temperature)
pycom.rgbled(0x000000)
# Send to ubidots and blink green
pycom.rgbled(0x003300)
ubidots_send.post_var("Pycom", sens_name, temperature)
pycom.rgbled(0x000000)
temperature_prev = temperature
time.sleep(DELAY)
def __init__(self, pin):
"""
Finds addresses of DS18B20 on bus specified by `pin`
:param pin: 1-Wire bus pin
:type pin: int
"""
self.ds = DS18X20(OneWire(Pin(pin)))
self.addrs = self.ds.scan()
if not self.addrs:
raise Exception('no DS18B20 found at bus on pin %d' % pin)
def __init__(self, pin):
"""
Finds address of all DS18B20 on bus specified by `pin`
:param pin: 1-Wire bus pin
:type pin: int
"""
self.ds = ds18x20.DS18X20(OneWire(Pin(pin)))
addr = self.ds.scan()
if not addr:
raise Exception('no DS18B20 found at bus on pin %d' % pin)
def __init__(self, name: str, pin_num: int) -> None:
"""
Digital temp sensor DS18B20 for the tlvlp.iot project
Tested on ESP32 MCUs
:param pin_num: Digital input pin number for reading measurements
"""
self.reference = "ds18b20|" + name
one_wire = OneWire(Pin(pin_num))
self.channel = ds18x20.DS18X20(one_wire)
def __init__(self, ow_pin, fan_pin):
ow = OneWire(ow_pin)
self.ds_sensor = DS18X20(ow)
self.roms = []
fan_pin.value(0)
self.fan_pin = fan_pin
self.fan_value = 'off'
self.acc = 0
self.acc_count = 0
def __init__(self, channel_id, api_key, pin):
self.channel_id = channel_id
self.api_key = api_key
self.ds = DS18X20(OneWire(pin))
self.sensor = first(self.ds.scan())
if self.sensor is None:
raise BrewtrackerError("No temperature sensor available!")
# Last read sensor value in degrees celsius
self.value = 0
def __init__(self, pin=32):
from onewire import OneWire
from ds18x20 import DS18X20
self.pin = pin
self.ts = []
try:
self.ds = DS18X20(OneWire(Pin(self.pin)))
self.ts = self.ds.scan()
except Exception:
print("Found {0} dallas sensors, temp active: {1}".format(len(ts), io_conf.get('temp')))
def __init__(self, pin=12):
self.read_count = 0
self.sensor = 'null'
self.temp = '85.0' # the default error temperature of ds18b20
try:
ow = OneWire(Pin(pin))
self.ds = ds18x20.DS18X20(ow)
self.present = True
except:
self.present = False
self.ds = None
def __init__(self, pin):
self.check_ticks_ms = 0
self.ds = DS18X20(OneWire(Pin(pin)))
self.rom = None
self.buffer = RingBuffer(6)
self.state = DS_IDEL
roms = self.ds.scan()
if roms:
self.rom = roms[0]
UI.LogOut(str(self.rom))
def __init__(self, pin):
if not isinstance(pin, int):
raise TypeError("pin must be integer")
from onewire import OneWire
from ds18x20 import DS18X20
ow = OneWire(machine.Pin(pin))
ow.scan()
ow.reset()
self.ds18b20 = DS18X20(ow)
self.roms = self.ds18b20.scan()
self.temps = [None for rom in self.roms]
def __init__(self, pin):
"""Finds address of single DS18B20 on bus specified by `pin`
Args:
pin: 1-Wire bus pin
"""
self.ds = DS18X20(OneWire(Pin(pin)))
addrs = self.ds.scan()
if not addrs:
raise Exception('no DS18B20 found at bus on pin %d' % pin)
# save what should be the only address found
self.addr = addrs.pop()
def __init__(self, config={}):
self._temp_sens = DS18X20(OneWire(Pin(config.get("pin", 0))))
self._temp_sens_dev = self._temp_sens.scan()[0]
self.last_read = time()
self.state = None
self.old_state = None
self.type = config.get('type', "temp_sensor")
self.topic = config.get('state_topic', None)
self.set_topic = config.get('command_topic', None)
self._temp_sens.convert_temp()
def __init__(self, pin):
"""
Finds address of single DS18B20 on bus specified by `pin`
:param pin: 1-Wire bus pin
:type pin: int
"""
self.ds = DS18X20(OneWire(Pin(pin)))
addrs = self.ds.scan()
if not addrs:
raise Exception('no DS18B20 found at bus on pin %d' % pin)
# save what should be the only address found
self.addr = addrs.pop()
print("found one sensor at address:", self.addr)
def register_sensor(self):
if self.pin > 16 or self.pin < 0:
raise Exception('Invalid GPIO {}'.format(self.pin))
if self.sensor_model == "DHT11":
self.sensor_handle = dht.DHT11(Pin(self.pin))
elif self.sensor_model == "DHT22":
self.sensor_handle = dht.DHT22(Pin(self.pin))
elif self.sensor_model == 'DS18B20':
self.sensor_handle = DS18X20(OneWire(self.pin))
self.sensor_handle.convert_temp()
elif self.sensor_model == 'SWITCH':
self.sensor_handle = Pin(self.pin, Pin.IN, Pin.PULL_UP)
return True
def __init__(self, pin=12):
self.count = 0
self.sensor = 'null'
self.temp = '85.0' # the default error temperature of ds18b20
try:
ow = OneWire(Pin(pin))
self.ds = ds18x20.DS18X20(ow)
self.roms = self.ds.scan() # should we scan again?
self.ds.convert_temp()
time.sleep_ms(750)
self.temp = self.ds.read_temp(self.roms[1])
self.present = True
except:
self.present = False
self.ds = None
def __init__(self, motion_pin, micro_pin, pixel_pin, pixels, temp_pin):
self.motion = 'OFF'
self.motion_timer = Timer(-1)
self.temp_timer = Timer(-2)
self.temperature = None
self.one_wire = DS18X20(OneWire(Pin(temp_pin)))
self.temp_sensor = None # initiated in function temp_sensor
self.micro_sensor = Pin(micro_pin, Pin.IN)
self.micro_sensor.irq(handler=self.micro_high, trigger=Pin.IRQ_RISING)
self.motion_sensor = Pin(motion_pin, Pin.IN)
self.motion_sensor.irq(handler=self.motion_high,
trigger=Pin.IRQ_RISING)
self.pixels = NeoPixel(Pin(pixel_pin), pixels)
self.lastmotion = time()
self.temp_sensor_init()
def daemon():
""" Measure the temperature at fixed intervals """
ds = DS18X20(OneWire(Pin.exp_board.G9))
t = 0.0
while True:
# measure +- every 30 seconds
time.sleep(27)
for i, tx in enumerate([t0, t1]):
time.sleep_ms(750)
ds.start_conversion(ds.roms[i])
time.sleep_ms(750)
t = ds.read_temp_async(ds.roms[i])
with t_lock:
tx.append(t)
if len(tx) > NMEASUREMENTS:
del tx[0]
def __init__(self):
print("Init")
self.unhandled_event = False
print('Init LEDs')
self.leds = {
'red': Pin(D2, Pin.OUT, value=False),
'blue': Pin(D3, Pin.OUT, value=False),
'green': Pin(D4, Pin.OUT, value=False)
}
print('Init OneWire')
self.ds_pin = Pin(D1)
self.ow_inst = OneWire(self.ds_pin)
self.ds_sensor = DS18X20(self.ow_inst)
self.temp_id = self.ds_sensor.scan()[0]
print('Temperature sensor: %s' % self.temp_id)
self.wlan = network.WLAN(network.STA_IF)
self.mac = hexlify(self.wlan.config('mac')).decode()
print('MAC: %s' % self.mac)
def get_data_ds18b20(pin_nr):
ds_pin = machine.Pin(pin_nr)
ds_sensor = DS18X20(OneWire(ds_pin))
roms = ds_sensor.scan()
if not roms:
return None
ds_sensor.convert_temp()
utime.sleep_ms(750) # give enough time to convert the temperature
temperature = None
for rom in roms:
temperature = ds_sensor.read_temp(rom)
return {'temperature': temperature, 'humidity': None}