def _check_refresh(self, min_refresh_rate):
now = ticks_ms()
if self.last_measure == 0 or now - self.last_measure > min_refresh_rate:
try:
DHT11.measure(self)
except OSError:
raise OSError(
"Please check if sensor is connected to Port {0}".format(
self.port))
self.last_measure = now
def temp_and_hum():
data = DHT11(Pin(16))
data.measure()
temp = str(data.temperature())
hum = str(data.humidity())
print("dht11: %s, %s" % (temp, hum))
return temp, hum
def run():
sleep = utime.sleep
dhtPin = Pin(2, Pin.IN, Pin.PULL_UP)
sensor = DHT11(dhtPin)
measure = sensor.measure
temp = sensor.temperature
hum = sensor.humidity
httpget = urequests.get
wifi = WLAN(STA_IF)
if not wifi.active():
wifi.active(True)
while True:
if not connect(wifi):
return
try:
measure()
t = temp() * 1.8 + 32
h = hum()
print(t, h)
httpget(
THINGSPEAK_REQUEST.format(temperature=t,
humidity=h,
location='livingroom',
api_key=secrets.THINKSPEAK_API_KEY))
except:
print('Failed to read sensor')
sleep(PUBLISH_PERIOD_IN_SEC)
def DHTlog():
#set up a DHT11 sensor on GPIO pin 4
d = DHT11(machine.Pin(4))
d.measure()
temp = float('{:.1f}'.format(d.temperature() * 1.8 + 32))
humid = float('{:.1f}'.format(d.humidity()))
return {'temp': temp, 'humid': humid}
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 dht11_sensor():
d = DHT11(Pin(14))
d.measure() # mesure temp and humidity
temp = d.temperature()
hum = d.humidity()
pins[1] = str(temp) + ' C'
pins[2] = str(hum) + ' %'
def __init_DHT11():
global __DHT_OBJ
if __DHT_OBJ is None:
from dht import DHT11
from machine import Pin
from LogicalPins import get_pin_on_platform_by_key
__DHT_OBJ = DHT11(Pin(get_pin_on_platform_by_key('simple_1')))
return __DHT_OBJ
def __init__(self, pin):
if not isinstance(pin, int):
raise TypeError('pin must be integer')
from dht import DHT11
self.sensor = DHT11(machine.Pin(pin))
time.sleep(1) # some delay to stabilize sensor
self.t = None
self.h = None
def temp_humi_reader():
""" Give the temperature in Celcius and Humidity in % """
temp_humi_sensor = DHT11(Pin(DHT11_PIN))
temp_humi_sensor.measure()
return {
"temp" : temp_humi_sensor.temperature(),
"humi" : temp_humi_sensor.humidity()
}
def __init__(self, id="", unit="dht11", pin=2, freq=5):
self.sensor_id = id
self.info = dict(id=self.sensor_id,
type=unit,
label='Humidity',
uom='%',
freq=freq)
global dht
if (not dht):
dht = DHT11(Pin(pin))
def initDHT(self):
self.dhtSensor = DHT11(self.dhtPin)
self.dhtSensor.measure()
# sample usage
# while not dht.getMeasure():
# sleep(5)
# if dht.getMeasure():
# break
# sleep(1)
def get_data():
"""Return current temp and humidity.
According to some comments online re. the DHT11,
to get accurate measurements we need to read
from the sensor twice, waiting for 1s between
reads, as some of the data is "cached".
"""
d = DHT11(PIN)
d.measure()
sleep(1)
d.measure()
return d.temperature(), d.humidity()
def main():
#h = DHT11(machine.Pin(33)) # J8
h = DHT11(machine.Pin(26)) # J7
ugfx.set_default_font('IBMPlexMono_Bold24')
ugfx.clear()
ugfx.Label(40, 0, 240, 60, text='DHT11/22 Demo')
ugfx.set_default_font('IBMPlexMono_Regular24')
l = ugfx.Label(40, 60, 240, 120, text='')
while True:
h.measure()
h.temperature()
l.text('temperature:{},humidity:{}'.format(h.temperature(),
h.humidity()))
time.sleep(1)
def Grab_DATA_Devices_Send():
from dht import DHT11
from hcsr04 import HCSR04
import MQ2
global Devices_Data, Mqtt_User, MQTT_Client
while True:
sleep(5)
#dht:[pin,[],[]]
for i in Devices["DHT"]:
DHT = DHT11(Pin(i, Pin.IN, Pin.PULL_UP))
DHT.measure()
Devices_Data["DHT"].append([i, DHT.temperature, DHT.humidity])
# for i in Devices["GSense"]:
# GS = MQ2(pinData = i, baseVoltage = 5)
# GS.calibrate()
# Devices_Data["GSense"].append([i,GS.readSmoke(), GS.readLPG(), GS.readMethane(), readHydrogen()])
# #checking smoke (recheck the values online!!!)
# if Devices_Data["GSense"][j][0]>500 or Devices_Data["GSense"][j][1]>500:
# Alarm = True
# Fire_Gas_Alarm()
j = 0
for i in Devices["Ultrason"]:
US = HCSR04(trigger_pin=i[0], echo_pin=i[1])
if US.distance_cm() > 3.0:
#Door id and the second value is bool either open or not
Devices_Data["Ultrason"][j] = [i[0], {"value": True}]
else:
Devices_Data["Ultrason"][j] = [i[0], {"value": False}]
j += 1
try:
MQTT_Client.publish(
bytes(Mqtt_User + "/Values", "UTF-8"),
bytes(
"{'data':" + str(Devices_Data) + ",'clientid':" +
MQTT_ClientID + "}", "UTF-8"))
except OSError as e:
restart_and_reconnect()
def __init__(self, **kwargs):
super().__init__(**kwargs)
self.temperature_id = None
self.humidity_id = None
self.add_id(self.sensor, kwargs.get('_id'))
self._last_measure = None
sensor_value = getattr(HumidityTemperatureSensor, self.pattern)
if sensor_value == 0:
from dht import DHT11
self.sensor = DHT11(Pin(self.pins[0], Pin.PULL_UP))
elif sensor_value == 1:
from dht import DHT22
self.sensor = DHT22(Pin(self.pins[0], Pin.PULL_UP))
else:
raise Exception('sensor not available')
self._last_temperature = None
self._last_humidity = None
def main():
"""Measure and talk to MQTT broker."""
d = DHT11(machine.Pin(0))
SERVER = '192.168.1.8'
CLIENT_ID = ubinascii.hexlify(machine.unique_id())
TOPIC_HUMIDITY = b'kgrund/fukt'
TOPIC_TEMPERATURE = b'kgrund/temp'
c = MQTTClient(CLIENT_ID, SERVER)
c.connect()
print('Connected to {}'.format(SERVER))
while True:
"""Measure and then publish values to the broker every 20 seconds."""
try:
d.measure()
humidity = bytes(str(d.humidity()), 'ascii')
temperature = bytes(str(d.temperature()), 'ascii')
c.publish(TOPIC_HUMIDITY, humidity)
c.publish(TOPIC_TEMPERATURE, temperature)
except Exception:
print('Cant find DHT, will try again')
time.sleep(20)
def main():
try:
while True:
d = DHT11(Pin(DHT_PIN))
d.measure()
temperature = d.temperature()
humidity = d.humidity()
# print(self.payload)
print("Temp: {:.1f} *C \t Humidity: {}%".format(temperature, humidity))
# sensor.Sensor.json()
sensor_data['temperature'] = temperature
sensor_data['humidity'] = humidity
client.publish('sensor', json.dumps(sensor_data))
next_reading = time.time()
next_reading += INTERVAL
sleep_time = next_reading - time.time()
if sleep_time > 0:
time.sleep(sleep_time)
except KeyboardInterrupt:
pass
client.disconnect()
from machine import Pin
import utime
from dht import DHT11, InvalidChecksum
# Wait 1 second to let the sensor power up
utime.sleep(1)
pin = Pin(15, Pin.OUT, Pin.PULL_DOWN)
sensor = DHT11(pin)
while True:
utime.sleep(1)
try:
print("Temperature: {}".format(sensor.temperature))
print("Humidity: {}".format(sensor.humidity))
except InvalidChecksum:
print("Checksum from the sensor was invalid")
from machine import Pin, ADC, deepsleep
from dht import DHT11
import time
print("Seedling Environment Monitor by Aidan Taylor")
print("v1.5 2018. Fab-Cre8\n")
import myNet
# Hardware object setup:
led = Pin(22, Pin.OUT) # on board LED on pin 22
ks = Pin(2, Pin.IN, Pin.PULL_UP) # killswitch pin, tie to gnd to stop loop
# Todo - try different resistor value for LDR, between 47k and 75k, maybe trim?
ldr = ADC(Pin(35))
dhtEn = Pin(0, Pin.OUT) # EXPERIMENTAL power the DHT11 from a GPIO pin
dSens = DHT11(Pin(17))
print("setup complete, starting loop...\n\n\n")
configMode = ks.value()
# note internal LED will stay on when in configMode
while configMode:
configMode = ks.value()
if not myNet.station.isconnected():
myNet.WiFiConnect()
# EXPERIMENTAL activate the DHT11
dhtEn.value(1)
import dht
import urequests
import connectWifi
from machine import Pin
from dht import DHT11
# Connect to WIFI
connectWifi.connect()
url = "YOUR URL"
#Set-up led
led = machine.Pin(5, machine.Pin.OUT)
# Set-up temperature sensor.
d = DHT11(Pin(4))
d.measure()
#Proccess transmission.
while True:
led.on()
temperature = d.temperature()
response = urequests.post(url,
json={
'temperature': temperature,
'location': 'Sensor 2'
})
response.close()
led.off()
time.sleep(30)
import network
from time import sleep
from umqtt.simple import MQTTClient
from machine import Pin
from dht import DHT11
led = Pin(2, Pin.OUT)
sensor = DHT11(Pin(15, Pin.IN, Pin.PULL_UP))
station = network.WLAN(network.STA_IF)
station.active(True)
station.connect("ssid","passwd")
while station.isconnected() == False:
pass
print('Connection successful')
print(station.ifconfig())
#flash once
led.value(1)
sleep(0.1)
led.value(0)
sleep(1)
#SERVER = '192.168.1.61' #MQTT Server address
SERVER = "test.mosquitto.org"
CLIENT_ID = 'ESP32_DHT22_Sensor'
TOPIC = b'temp_humidity'
client = MQTTClient(CLIENT_ID, SERVER)
client.connect()
def dht_value():
dht11 = DHT11(Pin(16))
dht11.measure()
return ('Temperature = ', dht11.temperature(), ' Humidity = ',
dht11.humidity())
from time import sleep
from umqtt.simple import MQTTClient
from machine import Pin
from dht import DHT11
SERVER = '192.168.43.251'
CLIENT_ID = 'ESP32_DHT11_Sensor'
TOPIC = b'temp_humidity'
cleint = MQTTClient(CLIENT_ID, SERVER)
client.connect()
sensor = DHT11(Pin(23))
while True:
try:
sensor.measure()
t = sensor.temperature()
h = sensor.humidity()
if isinstance(t, float) and isinstance(h, float):
msg = (b'{0:3.1f},{1:3.1f}'.format(t, h))
client.publish(TOPIC, msg)
print(msg)
else:
print('Invalid sensor readings.')
except OSError:
print('Failed to read sensor.')
sleep(4)
c.set_callback(sub_cb)
c.connect()
c.subscribe(topic)
#print("Connected to %s, subscribed to %s topic" % (server, topic))
try:
c.wait_msg()
finally:
c.disconnect()
#---End MQTT Sending---
#---DHT22---
from dht import DHT11
ds = DHT11(Pin(16)) #DHT11 connected to GPIO16
def medirTemHum():
try:
ds.measure()
tem = ds.temperature()
hum = ds.humidity()
#ed.value(1)
return (tem, hum)
except Exception as e:
#led.value(0)
return (-1, -1)
#---End DHT22---
)
utime.sleep(3)
def inetConnect():
"""Connect to the internet using the SPI to Eth interface chip, w5500"""
"""sck, mosi, miso are pins (machine.Pin)"""
#Generic Init
print("Initializing...")
rtc = machine.RTC()
#sta_if = network.WLAN(network.STA_IF)
eth_if = inetConnect()
dhtSensor = DHT11(machine.Pin(4)) # D2 pin on NodeMCU board. DHT signal pin
pirSig = machine.Pin(5, machine.Pin.IN) # D1 pin on NodeMCU. PIR signal pin
pirSig.irq(handler=lambda p: pin_interrupt(), trigger=machine.Pin.IRQ_RISING)
#Init SPI
#MISO is GPIO12(D6), MOSI is GPIO13(D7), and SCK is GPIO14(D5)
###hspi = machine.SPI(1, baudrate=40000000, polarity=0, phase=0)
#Carbon Monoxide sensor
#Init ADC
adc = machine.ADC(0)
#Threshold pin
gasD0 = machine.Pin(1)
#MQTT configs
if not DEBUG:
def initDHT(self):
self.dhtSensor = DHT11(self.dhtPin)
self.dhtSensor.measure()
from machine import Pin
from dht import DHT11
import urequests
import time
PHANT_HOST = "192.168.43.217:8080"
PUBLIC_KEY = "4YkYvXgMBPFlE1DZZPKJhdVm9W4"
PRIVATE_KEY = "qOaO3mXpgZUl372VVqpRhxaLmBe"
d = DHT11(Pin(14))
def read_sensor():
d.measure()
return {"temperature": d.temperature(), "humidity": d.humidity()}
def get_query(data):
return "&".join(["%s=%.1f" % (k, v) for k, v in data.items()])
def phant_log(data):
url = "http://%s/input/%s?%s" % (PHANT_HOST, PUBLIC_KEY, get_query(data))
headers = {"Phant-Private-Key": PRIVATE_KEY}
response = urequests.post(url, headers=headers)
print(url, response.status_code, response.reason)
response.close()
def run():
while True:
from time import sleep_ms, ticks_ms
from machine import I2C, Pin
from esp8266_i2c_lcd import I2cLcd
from dht import DHT11
DEFAULT_I2C_ADDR = 0x27
i2c = I2C(scl=Pin(5), sda=Pin(4), freq=400000)
lcd = I2cLcd(i2c, DEFAULT_I2C_ADDR, 2, 16)
dht11 = DHT11(Pin(2))
lcd.clear()
lcd.move_to(0, 0)
lcd.putstr('booting.')
count = 6
while count > 0:
sleep_ms(500)
lcd.putstr('.')
count = count - 1
def dump_dht11():
dht11.measure()
text = "T:%d oC\nH:%d /100 RH" % (dht11.temperature(), dht11.humidity())
lcd.clear()
lcd.move_to(0, 0)
lcd.putstr(text)
while True:
import network
import socket
import sys
from time import sleep
from machine import Pin
from dht import DHT11
print("libray importted")
sensor = DHT11(Pin(21, Pin.IN, Pin.PULL_UP))
print("sensor set")
IP = "192.168.2.115"
PORT = 2431
def do_connect():
sta_if = network.WLAN(network.STA_IF)
if not sta_if.isconnected():
sta_if.active(True)
sta_if.connect('<wifi SSID>>', '<wifi password>')
while not sta_if.isconnected():
pass
do_connect()
client = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
client.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
client.connect((IP, PORT))
client.setblocking(False)
while True:
from machine import Pin, SPI
from dht import DHT11
from ssd1306 import SSD1306_SPI
from time import sleep, sleep_ms
import onewire, ds18x20
import network
import urequests
HTTP_SERVER = "http://136.167.58.213:1880" # The IP address of the raspberry pi
HTTP_NODE = "/sensor"
RATE = 10 # How often do you want the update to be
dat = Pin(2)
d = DHT11(Pin(16))
ds = ds18x20.DS18X20(onewire.OneWire(dat))
roms = ds.scan()
ip = network.WLAN(network.STA_IF).ifconfig()[0]
spi = SPI(1, baudrate=8000000, polarity=0, phase=0)
oled = SSD1306_SPI(128,64, spi, res=Pin(4), dc=Pin(5), cs=Pin(15))
while True:
oled.fill(0)
oled.text(ip, 0, 0)
d.measure()
temp = 1.8*d.temperature()+32
hum = d.humidity()
oled.text("Temp: {} F".format(temp), 0, 20)
oled.text("Hum: {}%".format(hum), 0, 30)
ds.convert_temp()
