class DHT(object):
def __init__(self,
pin: Pin,
state_machine_id: int = 0,
min_interval: int = 2000):
"""
Create a DHT object to get communication and get data from DHT sensor.
:param pin: Pin connected to DHT's data pin
:param state_machine_id: State Machine ID, default value 1
:param min_interval: Minimum interval between communication with DHT, default value 2000 (for DHT22)
:type pin: machine.Pin
:type state_machine_id: int
:type min_interval: int
"""
self._pin = pin
self._last_pull_time = None
self._temperature = None
self._humidity = None
self._min_interval = min_interval
# 1 cycle should be 10 us, 1s = 1,000,000us so freq should be 100,000
self._sm = StateMachine(state_machine_id,
dht_get_data,
freq=100000,
set_base=pin)
self._sm.irq(handle_dht_irq)
self._sm.active(1)
def _get_data_from_sensor(self, force: bool = False):
if force or self._last_pull_time is None or \
fabs(ticks_diff(ticks_ms(), self._last_pull_time)) > self._min_interval:
global _irq_count, temp_data
_irq_count = 0
for i in range(5):
temp_data[i] = 0
# start state machine
self._sm.put(0)
# Wait for state machine work
utime.sleep_ms(20)
if _irq_count != 5:
print(
"Didn't receive enough data. Received {} byte(s).".format(
len(temp_data)))
return
# data validation, 1st byte + 2nd byte + 3rd byte + 4th byte == 5th byte (last 8 bits)
check_sum = (temp_data[0] + temp_data[1] + temp_data[2] +
temp_data[3]) & EIGHT_1_BIT_MASK
if check_sum != temp_data[4]:
print('Data validation error.')
return
# temperature data is last 15 bits, first bit if 1, is negative. data is 10x of actual value
raw_temperature = (
(temp_data[2] & SEVEN_1_BIT_MASK) << 8) + temp_data[3]
self._temperature = raw_temperature / 10
if temp_data[2] >> 7 == 1:
self._temperature *= -1
raw_humidity = (temp_data[0] << 8) + temp_data[1]
# humidity data is 10x of actual value
self._humidity = raw_humidity / 10
self._last_pull_time = ticks_ms()
def get_temperature(self, force: bool = False) -> float:
"""
Get temperature from DHT
:param force: Force communicate with DHT sensor
:type force: bool
:return: Last measured temperature
:rtype: float
"""
self._get_data_from_sensor(force)
return self._temperature
def get_humidity(self, force: bool = False) -> float:
"""
Get humidity from DHT
:param force: Force communicate with DHT sensor
:type force: bool
:return: Last measured humidity
:rtype: float
"""
self._get_data_from_sensor(force)
return self._humidity
def get_temperature_and_humidity(self,
force: bool = False) -> (float, float):
"""
Get temperature and humidity from DHT
:param force: Force communicate with DHT sensor
:type force: bool
:return: Last measured temperature and humidity
:rtype: (float, float)
"""
self._get_data_from_sensor(force)
return self._temperature, self._humidity
data = [(1, 2, 4, 8), (2, 4, 8, 1), (4, 8, 1, 2), (8, 1, 2, 4)]
steps = 0
def turn(sm):
global steps
global data
idx = steps % 4
a = data[idx][0] | (data[idx][1] << 4) | (data[idx][2] << 8) | (
data[idx][3] << 12)
a = a << 16 | a
#print("{0:b}".format(a))
sleep(1)
sm.put(500)
sm.put(a)
steps += 500
sm.irq(turn)
sm.active(1)
turn(sm)
sleep(50)
print("done")
sm.active(0)
sm.exec("set(pins,0)")
# Function for core1 to execute to write to the given UART.
def core1_task(uart, text):
uart.write(text)
# Set up the hard UART we're going to use to print characters.
uart = UART(1, UART_BAUD, tx=HARD_UART_TX_PIN)
for pio_prog in ("uart_rx_mini", "uart_rx"):
# Set up the state machine we're going to use to receive the characters.
sm = StateMachine(
0,
globals()[pio_prog],
freq=8 * UART_BAUD,
in_base=PIO_RX_PIN, # For WAIT, IN
jmp_pin=PIO_RX_PIN, # For JMP
)
sm.irq(handler)
sm.active(1)
# Tell core 1 to print some text to UART 1
text = "Hello, world from PIO, using {}!".format(pio_prog)
_thread.start_new_thread(core1_task, (uart, text))
# Echo characters received from PIO to the console.
for i in range(len(text)):
print(chr(sm.get() >> 24), end="")
print()
