Pada artikel ini, Arduino Indonesia akan membahas tentang cara membuat perekam data (data logger) yang mengirimkan pembacaan suhu, kelembaban, dan tekanan setiap 10 menit ke spreadsheet Google Sheets menggunakan ESP8266 12-E. Di antara pembacaan sensor, ESP berada dalam mode deep sleep dan hanya mengonsumsi 7 µA. Papan ESP diprogram dengan MicroPython, dan kami menggunakan layanan IFTTT Webhooks untuk mengintegrasikan proyek dengan Google Sheets.
Proyek ini juga kompatibel dengan ESP32. Anda hanya perlu melakukan beberapa modifikasi pada kode (kami akan menunjukkan apa yang perlu dilakukan).
Sepanjang proyek ini, Anda akan mempelajari konsep-konsep berikut:
- Membaca suhu, kelembaban, dan tekanan dengan BME280 dan ESP8266/ESP32 menggunakan MicroPython;
- Melakukan permintaan HTTP POST dalam MicroPython untuk mengirim data sensor ke layanan pihak ketiga;
- Menggunakan layanan IFTTT Webhooks untuk menyimpan data sensor di spreadsheet Google Sheets;
- Menempatkan ESP8266/ESP32 ke dalam mode deep sleep dan membangunkannya dengan timer;
- Pelajari lebih lanjut tentang deep sleep di MicroPython:
- ESP8266 Deep Sleep dan Sumber Wake Up
- ESP32 Deep Sleep dan Sumber Wake Up
Membuat Akun IFTTT Anda
Dalam proyek ini, kami akan memublikasikan data sensor ke spreadsheet Google Sheets. Untuk melakukannya, kami akan menggunakan layanan IFTTT Webhooks. Jadi, Anda perlu membuat akun gratis di IFTTT.
Kunjungi situs resmi ifttt.com, masukkan email Anda, dan lengkapi pendaftaran akun untuk memulai.
Membuat Applet
Selanjutnya, Anda perlu membuat Applet baru. Ikuti langkah-langkah berikut:
1) Buka menu "My Applets" dan buat Applet baru dengan mengklik tombol "New Applet".
2) Klik kata "this" yang berwarna biru – seperti yang ditandai pada gambar di bawah.
3) Cari layanan "Webhooks" dan pilih ikon Webhooks.
4) Pilih pemicu (trigger) "Receive a web request".
5) Berikan nama untuk event tersebut. Dalam kasus ini, kami akan menggunakan "bme_280_readings" dan kami menyarankan untuk menggunakan nama event yang sama persis seperti yang ditunjukkan pada gambar di bawah. Setelah itu, klik tombol "Create trigger".
6) Klik kata "that" untuk melanjutkan.
7) Cari layanan "Google Sheets", dan pilih ikon Google Sheets.
8) Jika Anda belum terhubung dengan layanan Google Sheets, klik tombol "Connect".
9) Pilih aksi (action) "Add a row to spreadsheet".
10) Kemudian, lengkapi kolom aksi. Berikan nama untuk spreadsheet, dan biarkan kolom lainnya sebagai default. Terakhir, klik tombol "Create action".
11) Applet Anda akan dibuat setelah Anda menekan tombol "Finish".
Menguji Applet Anda
Sebelum melanjutkan proyek, sangat penting untuk menguji Applet Anda terlebih dahulu. Ikuti langkah-langkah berikut:
1) Buka halaman layanan Webhooks, dan klik tombol "Documentation".
2) Halaman seperti pada gambar berikut akan muncul. Halaman ini menunjukkan kunci API unik Anda. Jangan bagikan kunci API ini kepada siapa pun.
Isi bagian "To trigger an Event" seperti yang ditunjukkan di bawah – ditandai dengan persegi panjang merah. Kemudian, klik tombol "Test it".
Catatan: Simpan kunci API IFTTT Anda karena akan dibutuhkan nanti dalam proyek ini.
3) Event seharusnya berhasil dipicu, dan Anda akan mendapatkan pesan hijau yang mengatakan "Event has been triggered".
4) Buka Google Drive Anda. Layanan IFTTT seharusnya telah membuat folder bernama "IFTTT" dengan folder "MakerWebhooks/bme_280" di dalamnya. Di dalam folder ini, Anda akan menemukan spreadsheet Bme_280_readings.
5) Buka spreadsheet tersebut. Anda akan melihat nilai-nilai yang Anda isi sebelumnya untuk menguji Applet.
Lanjutkan membaca tutorial ini untuk melihat cara mengintegrasikan layanan IFTTT Google Sheets dengan ESP8266 atau ESP32 Anda.
Komponen yang Diperlukan
Berikut adalah daftar komponen untuk merangkai sirkuit proyek ini:
- ESP8266 12-E
- Adaptor ESP8266 12-E
- FTDI programmer
- [Alternatif] Papan ESP32
- Modul sensor BME280
- [Opsional] Rangkaian regulator tegangan untuk baterai LiPo dan Li-ion
- Kabel jumper
- Breadboard
Untuk proyek ini, kami akan menggunakan ESP8266 12-E karena konsumsi dayanya lebih rendah dalam mode deep sleep (tidak memiliki programmer bawaan). Anda juga dapat menggunakan ESP8266 NodeMCU Kit atau papan pengembangan ESP32.
Baca juga: Panduan Lengkap MicroPython ESP32 & ESP8266 - LED RGB Addressable WS2812B (NeoPixel)
Mengunggah Kode ke Chip ESP8266 12-E
Mengunggah kode ke ESP-12E memerlukan pembentukan komunikasi serial antara ESP8266 Anda dan FTDI Programmer, seperti yang ditunjukkan pada diagram skematik di bawah.
Hubungkan pin sebagai berikut:
- RX – TX
- TX – RX
- VCC – VCC
- VCC – EN
- GND – GND
- GND – GPIO15
- GND – GPIO0
Menginstal Library BME280
Library untuk membaca sensor BME280 tidak termasuk dalam firmware standar MicroPython. Jadi, Anda perlu mengunggah library ke papan ESP8266/ESP32.
Di uPyCraft IDE, buat file baru dengan menekan tombol New File (1). Salin kode library BME280 ke dalamnya. Kode library BME280 dapat ditemukan di tautan berikut:
from machine import I2C
import time
# BME280 default address.
BME280_I2CADDR = 0x76
# Operating Modes
BME280_OSAMPLE_1 = 1
BME280_OSAMPLE_2 = 2
BME280_OSAMPLE_4 = 3
BME280_OSAMPLE_8 = 4
BME280_OSAMPLE_16 = 5
# BME280 Registers
BME280_REGISTER_DIG_T1 = 0x88 # Trimming parameter registers
BME280_REGISTER_DIG_T2 = 0x8A
BME280_REGISTER_DIG_T3 = 0x8C
BME280_REGISTER_DIG_P1 = 0x8E
BME280_REGISTER_DIG_P2 = 0x90
BME280_REGISTER_DIG_P3 = 0x92
BME280_REGISTER_DIG_P4 = 0x94
BME280_REGISTER_DIG_P5 = 0x96
BME280_REGISTER_DIG_P6 = 0x98
BME280_REGISTER_DIG_P7 = 0x9A
BME280_REGISTER_DIG_P8 = 0x9C
BME280_REGISTER_DIG_P9 = 0x9E
BME280_REGISTER_DIG_H1 = 0xA1
BME280_REGISTER_DIG_H2 = 0xE1
BME280_REGISTER_DIG_H3 = 0xE3
BME280_REGISTER_DIG_H4 = 0xE4
BME280_REGISTER_DIG_H5 = 0xE5
BME280_REGISTER_DIG_H6 = 0xE6
BME280_REGISTER_DIG_H7 = 0xE7
BME280_REGISTER_CHIPID = 0xD0
BME280_REGISTER_VERSION = 0xD1
BME280_REGISTER_SOFTRESET = 0xE0
BME280_REGISTER_CONTROL_HUM = 0xF2
BME280_REGISTER_CONTROL = 0xF4
BME280_REGISTER_CONFIG = 0xF5
BME280_REGISTER_PRESSURE_DATA = 0xF7
BME280_REGISTER_TEMP_DATA = 0xFA
BME280_REGISTER_HUMIDITY_DATA = 0xFD
class Device:
"""Class for communicating with an I2C device.
Allows reading and writing 8-bit, 16-bit, and byte array values to
registers on the device."""
def __init__(self, address, i2c):
"""Create an instance of the I2C device at the specified address using
the specified I2C interface object."""
self._address = address
self._i2c = i2c
def writeRaw8(self, value):
"""Write an 8-bit value on the bus (without register)."""
value = value & 0xFF
self._i2c.writeto(self._address, value)
def write8(self, register, value):
"""Write an 8-bit value to the specified register."""
b=bytearray(1)
b[0]=value & 0xFF
self._i2c.writeto_mem(self._address, register, b)
def write16(self, register, value):
"""Write a 16-bit value to the specified register."""
value = value & 0xFFFF
b=bytearray(2)
b[0]= value & 0xFF
b[1]= (value>>8) & 0xFF
self.i2c.writeto_mem(self._address, register, value)
def readRaw8(self):
"""Read an 8-bit value on the bus (without register)."""
return int.from_bytes(self._i2c.readfrom(self._address, 1),'little') & 0xFF
def readU8(self, register):
"""Read an unsigned byte from the specified register."""
return int.from_bytes(
self._i2c.readfrom_mem(self._address, register, 1),'little') & 0xFF
def readS8(self, register):
"""Read a signed byte from the specified register."""
result = self.readU8(register)
if result > 127:
result -= 256
return result
def readU16(self, register, little_endian=True):
"""Read an unsigned 16-bit value from the specified register, with the
specified endianness (default little endian, or least significant byte
first)."""
result = int.from_bytes(
self._i2c.readfrom_mem(self._address, register, 2),'little') & 0xFFFF
if not little_endian:
result = ((result << 8) & 0xFF00) + (result >> 8)
return result
def readS16(self, register, little_endian=True):
"""Read a signed 16-bit value from the specified register, with the
specified endianness (default little endian, or least significant byte
first)."""
result = self.readU16(register, little_endian)
if result > 32767:
result -= 65536
return result
def readU16LE(self, register):
"""Read an unsigned 16-bit value from the specified register, in little
endian byte order."""
return self.readU16(register, little_endian=True)
def readU16BE(self, register):
"""Read an unsigned 16-bit value from the specified register, in big
endian byte order."""
return self.readU16(register, little_endian=False)
def readS16LE(self, register):
"""Read a signed 16-bit value from the specified register, in little
endian byte order."""
return self.readS16(register, little_endian=True)
def readS16BE(self, register):
"""Read a signed 16-bit value from the specified register, in big
endian byte order."""
return self.readS16(register, little_endian=False)
class BME280:
def __init__(self, mode=BME280_OSAMPLE_1, address=BME280_I2CADDR, i2c=None,
**kwargs):
# Check that mode is valid.
if mode not in [BME280_OSAMPLE_1, BME280_OSAMPLE_2, BME280_OSAMPLE_4,
BME280_OSAMPLE_8, BME280_OSAMPLE_16]:
raise ValueError(
'Unexpected mode value {0}. Set mode to one of '
'BME280_ULTRALOWPOWER, BME280_STANDARD, BME280_HIGHRES, or '
'BME280_ULTRAHIGHRES'.format(mode))
self._mode = mode
# Create I2C device.
if i2c is None:
raise ValueError('An I2C object is required.')
self._device = Device(address, i2c)
# Load calibration values.
self._load_calibration()
self._device.write8(BME280_REGISTER_CONTROL, 0x3F)
self.t_fine = 0
def _load_calibration(self):
self.dig_T1 = self._device.readU16LE(BME280_REGISTER_DIG_T1)
self.dig_T2 = self._device.readS16LE(BME280_REGISTER_DIG_T2)
self.dig_T3 = self._device.readS16LE(BME280_REGISTER_DIG_T3)
self.dig_P1 = self._device.readU16LE(BME280_REGISTER_DIG_P1)
self.dig_P2 = self._device.readS16LE(BME280_REGISTER_DIG_P2)
self.dig_P3 = self._device.readS16LE(BME280_REGISTER_DIG_P3)
self.dig_P4 = self._device.readS16LE(BME280_REGISTER_DIG_P4)
self.dig_P5 = self._device.readS16LE(BME280_REGISTER_DIG_P5)
self.dig_P6 = self._device.readS16LE(BME280_REGISTER_DIG_P6)
self.dig_P7 = self._device.readS16LE(BME280_REGISTER_DIG_P7)
self.dig_P8 = self._device.readS16LE(BME280_REGISTER_DIG_P8)
self.dig_P9 = self._device.readS16LE(BME280_REGISTER_DIG_P9)
self.dig_H1 = self._device.readU8(BME280_REGISTER_DIG_H1)
self.dig_H2 = self._device.readS16LE(BME280_REGISTER_DIG_H2)
self.dig_H3 = self._device.readU8(BME280_REGISTER_DIG_H3)
self.dig_H6 = self._device.readS8(BME280_REGISTER_DIG_H7)
h4 = self._device.readS8(BME280_REGISTER_DIG_H4)
h4 = (h4 << 24) >> 20
self.dig_H4 = h4 | (self._device.readU8(BME280_REGISTER_DIG_H5) & 0x0F)
h5 = self._device.readS8(BME280_REGISTER_DIG_H6)
h5 = (h5 << 24) >> 20
self.dig_H5 = h5 | (
self._device.readU8(BME280_REGISTER_DIG_H5) >> 4 & 0x0F)
def read_raw_temp(self):
"""Reads the raw (uncompensated) temperature from the sensor."""
meas = self._mode
self._device.write8(BME280_REGISTER_CONTROL_HUM, meas)
meas = self._mode << 5 | self._mode << 2 | 1
self._device.write8(BME280_REGISTER_CONTROL, meas)
sleep_time = 1250 + 2300 * (1 << self._mode)
sleep_time = sleep_time + 2300 * (1 << self._mode) + 575
sleep_time = sleep_time + 2300 * (1 << self._mode) + 575
time.sleep_us(sleep_time) # Wait the required time
msb = self._device.readU8(BME280_REGISTER_TEMP_DATA)
lsb = self._device.readU8(BME280_REGISTER_TEMP_DATA + 1)
xlsb = self._device.readU8(BME280_REGISTER_TEMP_DATA + 2)
raw = ((msb << 16) | (lsb << 8) | xlsb) >> 4
return raw
def read_raw_pressure(self):
"""Reads the raw (uncompensated) pressure level from the sensor."""
"""Assumes that the temperature has already been read """
"""i.e. that enough delay has been provided"""
msb = self._device.readU8(BME280_REGISTER_PRESSURE_DATA)
lsb = self._device.readU8(BME280_REGISTER_PRESSURE_DATA + 1)
xlsb = self._device.readU8(BME280_REGISTER_PRESSURE_DATA + 2)
raw = ((msb << 16) | (lsb << 8) | xlsb) >> 4
return raw
def read_raw_humidity(self):
"""Assumes that the temperature has already been read """
"""i.e. that enough delay has been provided"""
msb = self._device.readU8(BME280_REGISTER_HUMIDITY_DATA)
lsb = self._device.readU8(BME280_REGISTER_HUMIDITY_DATA + 1)
raw = (msb << 8) | lsb
return raw
def read_temperature(self):
"""Get the compensated temperature in 0.01 of a degree celsius."""
adc = self.read_raw_temp()
var1 = ((adc >> 3) - (self.dig_T1 << 1)) * (self.dig_T2 >> 11)
var2 = ((
(((adc >> 4) - self.dig_T1) * ((adc >> 4) - self.dig_T1)) >> 12) *
self.dig_T3) >> 14
self.t_fine = var1 + var2
return (self.t_fine * 5 + 128) >> 8
def read_pressure(self):
"""Gets the compensated pressure in Pascals."""
adc = self.read_raw_pressure()
var1 = self.t_fine - 128000
var2 = var1 * var1 * self.dig_P6
var2 = var2 + ((var1 * self.dig_P5) << 17)
var2 = var2 + (self.dig_P4 << 35)
var1 = (((var1 * var1 * self.dig_P3) >> 8) +
((var1 * self.dig_P2) >> 12))
var1 = (((1 << 47) + var1) * self.dig_P1) >> 33
if var1 == 0:
return 0
p = 1048576 - adc
p = (((p << 31) - var2) * 3125) // var1
var1 = (self.dig_P9 * (p >> 13) * (p >> 13)) >> 25
var2 = (self.dig_P8 * p) >> 19
return ((p + var1 + var2) >> 8) + (self.dig_P7 << 4)
def read_humidity(self):
adc = self.read_raw_humidity()
# print 'Raw humidity = {0:d}'.format (adc)
h = self.t_fine - 76800
h = (((((adc << 14) - (self.dig_H4 << 20) - (self.dig_H5 * h)) +
16384) >> 15) * (((((((h * self.dig_H6) >> 10) * (((h *
self.dig_H3) >> 11) + 32768)) >> 10) + 2097152) *
self.dig_H2 + 8192) >> 14))
h = h - (((((h >> 15) * (h >> 15)) >> 7) * self.dig_H1) >> 4)
h = 0 if h < 0 else h
h = 419430400 if h > 419430400 else h
return h >> 12
@property
def temperature(self):
"Return the temperature in degrees."
t = self.read_temperature()
ti = t // 100
td = t - ti * 100
return "{}.{:02d}C".format(ti, td)
@property
def pressure(self):
"Return the temperature in hPa."
p = self.read_pressure() // 256
pi = p // 100
pd = p - pi * 100
return "{}.{:02d}hPa".format(pi, pd)
@property
def humidity(self):
"Return the humidity in percent."
h = self.read_humidity()
hi = h // 1024
hd = h * 100 // 1024 - hi * 100
return "{}.{:02d}%".format(hi, hd)
Simpan file dengan menekan tombol Save (2).
Beri nama file baru tersebut "BME280.py" lalu tekan OK.
Klik tombol Download and Run.
Catatan: Jika Anda mengalami kesulitan mengunggah skrip baru ke papan ESP, Anda mungkin perlu memasang ulang firmware MicroPython: Memasang Firmware MicroPython ke ESP. Saat ESP dalam mode deep sleep, Anda tidak dapat mengunggah skrip baru. Pastikan Anda me-reset papan, lalu segera tekan tombol Stop di uPyCraft IDE untuk menangkapnya dalam keadaan bangun, sehingga Anda dapat mengakses skrip yang tersimpan dan mengunggah yang baru.
File akan tersimpan di folder perangkat dengan nama "BME280.py", seperti yang ditunjukkan pada gambar di bawah.
Sekarang, Anda dapat menggunakan fungsionalitas library dalam kode dengan mengimpor library tersebut.
Kode Program
Setelah mengunggah file BME280.py ke ESP8266 atau ESP32 Anda, salin kode berikut ke file boot.py. File boot.py dijalankan sekali saat boot (setiap kali ESP8266/ESP32 bangun).
import machine
from machine import Pin, I2C
import BME280
import network
import urequests
from time import sleep
import esp
esp.osdebug(None)
import gc
gc.collect()
ssid = 'REPLACE_WITH_YOUR_SSID'
password = 'REPLACE_WITH_YOUR_PASSWORD'
api_key = 'REPLACE_WITH_YOUR_IFTTT_API_KEY'
ms_sleep_time = 600000
station = network.WLAN(network.STA_IF)
station.active(True)
station.connect(ssid, password)
while station.isconnected() == False:
pass
print('Connection successful')
print(station.ifconfig())
def deep_sleep(msecs) :
# configure RTC.ALARM0 to be able to wake the device
rtc = machine.RTC()
rtc.irq(trigger=rtc.ALARM0, wake=machine.DEEPSLEEP)
# set RTC.ALARM0 to fire after X milliseconds (waking the device)
rtc.alarm(rtc.ALARM0, msecs)
# put the device to sleep
machine.deepsleep()
# ESP8266 - Pin assignement
i2c = I2C(scl=Pin(5),sda=Pin(4), freq=10000)
# ESP32 - Pin assignement
#i2c = I2C(scl=Pin(22),sda=Pin(21), freq=10000)
try:
bme = BME280.BME280(i2c=i2c)
temp = bme.temperature
hum = bme.humidity
pres = bme.pressure
# uncomment for temperature in Fahrenheit
#temp = (bme.read_temperature()/100) * (9/5) + 32
#temp = str(round(temp, 2)) + 'F'
sensor_readings = {'value1':temp[:-1], 'value2':hum[:-1], 'value3':pres[:-3]}
print(sensor_readings)
request_headers = {'Content-Type': 'application/json'}
request = urequests.post(
'http://maker.ifttt.com/trigger/bme280/with/key/' + api_key,
json=sensor_readings,
headers=request_headers)
print(request.text)
request.close()
except OSError as e:
print('Failed to read/publish sensor readings.')
sleep(10)
#ESP8266
deep_sleep(ms_sleep_time)
#ESP32
#machine.deepsleep(ms_sleep_time)
Sebelum mengunggah kode ke papan Anda, Anda perlu memasukkan kredensial jaringan dan kunci API IFTTT unik Anda. Lanjutkan membaca untuk melihat caranya.
Penjelasan Kode
Mengimpor Library
Anda memulai dengan mengimpor modul yang diperlukan. Untuk berinteraksi dengan GPIO dan membaca data dari sensor melalui komunikasi I2C, Anda perlu mengimpor kelas Pin dan I2C dari modul machine. Anda juga mengimpor modul machine lengkap untuk dapat menggunakan fungsi terkait deep sleep.
import machine
from machine import Pin, I2C
Anda perlu mengimpor library BME280 yang sebelumnya telah diunggah ke papan.
import BME280
Untuk terhubung ke jaringan, Anda perlu mengimpor modul network.
import network
Anda memerlukan library urequests. Library ini memungkinkan Anda membuat permintaan HTTP. Dalam contoh ini, kami akan membuat permintaan ke layanan IFTTT untuk memublikasikan data sensor ke spreadsheet Google Sheets.
import urequests
Terakhir, impor fungsi sleep dari modul time untuk dapat menambahkan jeda dalam kode.
from time import sleep
Mengatur Kredensial Jaringan Anda
Anda perlu menambahkan SSI dan kata sandi pada variabel berikut:
ssid = 'REPLACE_WITH_YOUR_SSID'
password = 'REPLACE_WITH_YOUR_PASSWORD'
Memasukkan Kunci API IFTTT Anda
Masukkan kunci API unik Anda dari layanan Webhooks IFTTT pada baris berikut:
api_key = 'REPLACE_WITH_YOUR_WEBHOOKS_IFTTT_API_KEY'
Mengatur Waktu Tidur
Dalam contoh ini, kami mengatur waktu tidur menjadi 10 menit (600.000 milidetik). Artinya, setiap 10 menit ESP akan bangun, mengambil pembacaan, dan memublikasikannya ke spreadsheet Google Sheets Anda. Waktu tidur diatur dalam variabel ms_sleep_time dalam satuan milidetik:
ms_sleep_time = 600000
Peringatan: Jika Anda mengatur periode yang sangat singkat, Anda mungkin melebihi batas permintaan yang diterapkan oleh layanan IFTTT.
Menghubungkan ke Jaringan
Baris-baris berikut menghubungkan ESP8266/ESP32 ke router Anda dan mencetak alamat IP ESP:
station = network.WLAN(network.STA_IF)
station.active(True)
station.connect(ssid, password)
while station.isconnected() == False:
pass
print('Connection successful')
print(station.ifconfig())
Fungsi Deep Sleep (ESP8266)
Kemudian, buat fungsi bernama deep_sleep() yang menerima argumen jumlah milidetik yang kita inginkan agar ESP8266 berada dalam mode deep sleep.
def deep_sleep(msecs) :
# configure RTC.ALARM0 to be able to wake the device
rtc = machine.RTC()
rtc.irq(trigger=rtc.ALARM0, wake=machine.DEEPSLEEP)
# set RTC.ALARM0 to fire after X milliseconds (waking the device)
rtc.alarm(rtc.ALARM0, msecs)
# put the device to sleep
machine.deepsleep()
Catatan: Jika Anda menggunakan ESP32, Anda tidak perlu membuat/menggunakan fungsi ini.
Membaca Suhu, Kelembaban, dan Tekanan
Selanjutnya, buat instance I2C bernama i2c. Anda memerlukannya untuk membuat koneksi I2C dengan sensor BME280. Berikan sebagai argumen pin SCL dan SDA, serta frekuensi. Jangan khawatir tentang frekuensi, nilai 10000 Hz bekerja dengan baik untuk sensor ini.
Pin I2C default ESP8266 adalah GPIO 5 (SCL) dan GPIO 4 (SDA).
i2c = I2C(scl=Pin(5),sda=Pin(4), freq=10000)
Pin I2C default ESP32 adalah GPIO 22 (SCL) dan GPIO 21 (SDA). Beri komentar pada baris sebelumnya dan hapus komentar pada baris berikut jika Anda menggunakan papan ESP32.
#i2c = I2C(scl=Pin(22),sda=Pin(21), freq=10000)
Kemudian, gunakan pernyataan try-except. Di dalam blok try, kami membaca data dari sensor dan membuat permintaan HTTP POST ke layanan IFTTT.
Suhu disimpan dalam variabel temp, kelembaban dalam variabel hum, dan tekanan dalam variabel pres.
try:
bme = BME280.BME280(i2c=i2c)
temp = bme.temperature
hum = bme.humidity
pres = bme.pressure
Hapus komentar pada baris berikut jika Anda ingin mendapatkan suhu dalam derajat Fahrenheit.
# uncomment for temperature in Fahrenheit
#temp = (bme.read_temperature()/100) * (9/5) + 32
#temp = str(round(temp, 2)) + 'F'
Kemudian, simpan pembacaan sensor dalam format JSON pada variabel `sensor_readings`. Ini diperlukan untuk membuat permintaan HTTP POST ke IFTTT.
sensor_readings = {'value1':temp[:-1], 'value2':hum[:-1], 'value3':pres[:-3]}
Library BME280 mengembalikan pembacaan dengan satuan (°C untuk suhu, % untuk kelembaban, dan hPa untuk tekanan). Agar lebih mudah dianalisis nanti, kami menghapus satuan dengan menambahkan `[:-1] untuk menghapus karakter terakhir dari string. Untuk tekanan, [:-3] menghapus tiga karakter terakhir (hPa).
Permintaan HTTP POST
Format umum permintaan HTTP POST dalam MicroPython menggunakan library `urequests` adalah sebagai berikut:
request= requests.post(<your_url>, json=<json_data>, headers=<headers>)
Parameter pertama adalah URL tempat Anda akan membuat permintaan. Seperti yang telah kita lihat di Applet IFTTT, kita perlu menggunakan URL berikut (di mana api_key akan diganti dengan kunci API Anda sendiri):
http://maker.ifttt.com/trigger/bme_280_readings/with/key/your_api_key
Parameter json harus berisi data dalam format JSON. Dalam kasus kami, itu adalah variabel sensor_readings:
json=sensor_readings
Parameter headers berisi informasi tentang permintaan. Untuk permintaan kami, headers-nya harus sebagai berikut:
request_headers = {'Content-Type': 'application/json'}
Terakhir, kami membuat permintaan menggunakan metode post() dengan informasi yang telah kami definisikan sebelumnya:
request = urequests.post(
'http://maker.ifttt.com/trigger/bme_280_readings/with/key/' + api_key,
json=sensor_readings,
headers=request_headers)
Terakhir, cetak permintaan dan tutup koneksi:
print(request.text)
request.close()
Jika membaca data dari sensor atau memublikasikan data sensor gagal, blok except akan dijalankan dan kami mencetak pesan 'Failed to read/publish sensor readings.'.
except OSError as e:
print('Failed to read/publish sensor readings.')
Pernyataan except dalam MicroPython mencegah papan Anda crash jika terjadi error.
Masuk ke Mode Tidur
Setelah membuat permintaan HTTP POST, kami menempatkan ESP8266/ESP32 ke dalam mode deep sleep. Gunakan baris berikut jika Anda menggunakan ESP8266:
deep_sleep(sleep_time_ms)
Beri komentar pada baris sebelumnya dan hapus komentar pada baris berikut jika Anda menggunakan ESP32:
#machine.deepsleep(ms_sleep_time)
Untuk menggunakan deep sleep pada ESP32 dengan timer wake up, kita hanya perlu menggunakan metode deepsleep() dan memberikan waktu tidur dalam milidetik sebagai argumen.
Merangkai Sirkuit
Sensor BME280 yang kami gunakan berkomunikasi melalui protokol I2C.
Ikuti salah satu skema berikut tergantung pada papan yang Anda gunakan.
ESP8266 12-E
Penting: Anda sebaiknya hanya menghubungkan GPIO1 ke pin RST setelah mengunggah kode. Koneksi ini diperlukan agar ESP8266 dapat membangkitkan dirinya sendiri.
Catatan: Jika Anda menggunakan ESP8266 12-E, kami merekomendasikan penggunaan adaptor untuk memudahkan pemasangan di breadboard. Alternatifnya, Anda dapat membuat PCB sendiri seperti yang kami lakukan. Kami menggunakan teknik etching.
ESP8266 NodeMCU Kit
Jika Anda menggunakan kit ESP8266 NodeMCU, Anda juga perlu menghubungkan pin RST ke GPIO 16 (D0) setelah mengunggah kode.
ESP32
Jika Anda menggunakan ESP32, Anda hanya perlu merangkai sirkuit seperti yang ditunjukkan pada diagram skematik:
Demonstrasi
Setelah mengunggah file yang diperlukan ke papan Anda dengan urutan berikut:
1. BME280.py
2. boot.py
ESP8266/ESP32 akan mulai memublikasikan data sensor ke spreadsheet Google Sheets.
Konsumsi Daya
Ketika ESP8266 12-E dalam mode deep sleep, konsumsinya sekitar 7 µA hingga 8 µA.
Saat ESP8266 bangun dan terhubung ke Wi-Fi, konsumsi arus dapat meningkat hingga 80 mA.
Jika Anda menggunakan papan pengembangan ESP, Anda akan mendapatkan konsumsi arus yang lebih tinggi dalam mode deep sleep.
Memberi Daya ESP8266/ESP32 dengan Baterai
Jika Anda membangun proyek ini dengan chip ESP8266 12-E, daya yang digunakan selama deep sleep sangat rendah (sekitar 7 µA). Anda dapat menyalakannya menggunakan baterai dan baterai akan bertahan selama beberapa bulan (atau bahkan bertahun-tahun tergantung kapasitasnya).
Kami berencana membuat Bagian 2 dari proyek ini dengan menggunakan rangkaian bertenaga baterai. Sementara itu, Anda dapat membaca tutorial ini untuk memberi daya ESP menggunakan baterai LiPo dan Li-ion.
Baca juga: Panduan Lengkap MicroPython ESP32 & ESP8266 - Interrupt GPIO
Dalam praktik, hasil dan kendala yang ditemui bisa berbeda tergantung perangkat, konfigurasi, versi library, dan sistem yang digunakan.
- Diskusi umum dan tanya jawab praktik: https://t.me/edukasielektronika
- Kendala spesifik dan kasus tertentu: http://bit.ly/Chatarduino
0 on: "Panduan Lengkap MicroPython ESP8266 - Stasiun Cuaca Hemat Daya Menggunakan BME280"