MicroPython ESP32 & ESP8266 - Cara Menggunakan Sensor BME280 (Tekanan, Suhu, Kelembaban)

Pada artikel ini, Arduino Indonesia akan membahas tentang cara menggunakan modul sensor BME280 dengan ESP32 dan ESP8266 untuk mendapatkan pembacaan tekanan, suhu, dan kelembaban menggunakan firmware MicroPython. Kami akan membuat contoh sederhana untuk mengenalkan sensor tersebut, serta sebuah web server guna menampilkan hasil pembacaan sensor.

Pengenalan Modul Sensor BME280

Modul sensor BME280 membaca tekanan barometrik, suhu, dan kelembaban. Karena tekanan bervariasi dengan ketinggian, sensor ini juga dapat digunakan untuk memperkirakan ketinggian. Terdapat beberapa versi modul sensor ini, tetapi kami menggunakan versi yang ditunjukkan pada gambar di bawah.

Sensor ini berkomunikasi menggunakan protokol I2C, sehingga koneksi kabelnya sangat sederhana. Anda dapat menggunakan pin I2C bawaan ESP32 atau ESP8266 seperti yang ditunjukkan pada tabel berikut:

 

Komponen yang Diperlukan

Untuk proyek ini, Anda perlu menghubungkan modul sensor BME280 ke pin I2C ESP32 atau ESP8266. Berikut daftar komponen yang diperlukan untuk tutorial ini:

- Modul sensor BME280

- ESP32 atau ESP8266

- Breadboard

- Kabel jumper

 

Baca juga: Tutorial MicroPython ESP32 - WiFi Manager (Kompatibel ESP8266)

Diagram Rangkaian – ESP32

Gunakan diagram skematik berikut sebagai panduan jika Anda menggunakan papan ESP32:

Diagram Rangkaian – ESP8266

Gunakan diagram skematik berikut sebagai panduan jika Anda menggunakan papan ESP8266:

Library BME280 untuk MicroPython

Library untuk membaca sensor BME280 tidak termasuk dalam paket standar MicroPython. Oleh karena itu, Anda perlu mengunggah library berikut ke papan ESP32/ESP8266 (simpan dengan nama BME280.py).

 

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)

 

Ikuti langkah-langkah di bawah ini sesuai dengan IDE yang Anda gunakan:

- Mengunggah Library BME280 dengan uPyCraft IDE

- Mengunggah Library BME280 dengan Thonny IDE

Mengunggah Library BME280 dengan uPyCraft IDE

Bagian ini menjelaskan cara mengunggah library menggunakan uPyCraft IDE. Jika Anda menggunakan Thonny IDE, silakan langsung ke bagian berikutnya.

1. Buat file baru dengan menekan tombol New File (1).

2. Salin kode library BME280 ke dalam file tersebut.

3. Setelah menyalin kode, simpan file dengan menekan tombol Save (2).

4. Beri nama file tersebut "BME280.py" lalu tekan OK.

5. Klik tombol Download and Run.

File akan tersimpan dalam folder perangkat dengan nama "BME280.py", seperti yang ditunjukkan pada gambar di bawah.

 

Sekarang, Anda dapat menggunakan fungsi-fungsi dari library ini dalam kode Anda dengan melakukan impor library.

Mengunggah Library BME280 dengan Thonny IDE

Jika Anda menggunakan Thonny IDE, ikuti langkah-langkah berikut:

1. Salin kode library BME280 ke dalam file baru. Kode library dapat ditemukan [di sini (tautan)].

2. Buka menu File > Save as….

3. Pilih "MicroPython device" sebagai lokasi penyimpanan:

4. Beri nama file Anda sebagai BME280.py dan tekan tombol OK:

Selesai. Library telah berhasil diunggah ke papan Anda. Untuk memastikan proses unggah berhasil, buka File > Save as… dan pilih MicroPython device. File Anda akan terdaftar di sana:

Setelah library berhasil diunggah ke papan, Anda dapat menggunakan fungsionalitasnya dalam kode dengan mengimpor library tersebut.

Kode – BME280: Tekanan, Suhu, dan Kelembaban

Setelah mengunggah library ke ESP32 atau ESP8266, salin kode berikut ke dalam file main.py atau boot.py. Kode ini mencetak suhu, kelembaban, dan tekanan ke Shell setiap 5 detik.

 

from machine import Pin, I2C

from time import sleep

import BME280

# ESP32 - Pin assignment

i2c = I2C(scl=Pin(22), sda=Pin(21), freq=10000)

# ESP8266 - Pin assignment

#i2c = I2C(scl=Pin(5), sda=Pin(4), freq=10000)

while True:

  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'

  print('Temperature: ', temp)

  print('Humidity: ', hum)

  print('Pressure: ', pres)

  sleep(5)

 

Penjelasan Kode

Pertama, Anda perlu mengimpor library yang diperlukan, termasuk modul BME280 yang telah diunggah sebelumnya.

 

from machine import Pin, I2C

from time import sleep

import BME280

 

Atur pin I2C. Dalam contoh ini, kami menggunakan pin I2C bawaan. Jika Anda menggunakan ESP32, atur pin sebagai berikut:

 

i2c = I2C(scl=Pin(22), sda=Pin(21), freq=10000)

 

Jika Anda menggunakan ESP8266, berikan komentar pada baris sebelumnya dan hapus komentar pada baris berikut sehingga kode Anda menjadi:

 

i2c = I2C(scl=Pin(5), sda=Pin(4), freq=10000)

 

Di dalam perulangan while, buat objek BME280 bernama bme dengan pin I2C yang telah didefinisikan sebelumnya:

 

bme = BME280.BME280(i2c=i2c)

 

Membaca suhu, kelembaban, dan tekanan sesederhana menggunakan metode temperature, humidity, dan pressure pada objek bme.

 

temp = bme.temperature

hum = bme.humidity

pres = bme.pressure

 

Terakhir, cetak hasil pembacaan di Shell:

 

print('Temperature: ', temp)

print('Humidity: ', hum)

print('Pressure: ', pres)

 

Di akhir, kami tambahkan jeda 5 detik:

 

sleep(5)

 

Demonstrasi

Setelah mengunggah kode ke papan Anda, tekan tombol RST untuk menjalankan kode. Pembacaan sensor BME280 baru akan ditampilkan setiap 5 detik.

Menampilkan Pembacaan BME280 di Web Server

Setelah Anda mengetahui cara membaca tekanan, suhu, dan kelembaban dari sensor BME280, kami akan menampilkan hasil pembacaan tersebut di web server yang dapat diakses dalam jaringan lokal Anda.

Untuk contoh ini, Anda memerlukan tiga file:

1. BME280.py: File yang berisi semua metode untuk menggunakan sensor BME280. Ini adalah file yang telah Anda unggah sebelumnya.

2. boot.py: Dijalankan saat perangkat mulai dan mengatur beberapa konfigurasi seperti kredensial jaringan, impor library, pengaturan pin, dll.

3. main.py: Kode program utama yang menangani web server. Dieksekusi segera setelah boot.py.

Catatan: Praktik yang baik adalah memisahkan kode ke dalam file boot.py dan main.py. Namun, jika Anda lebih suka, Anda dapat menggabungkan semua kode ke dalam file main.py saja.

boot.py

Buat file baru di IDE Anda bernama boot.py dan salin kode berikut.

 

try:

  import usocket as socket

except:

  import socket

  

from time import sleep

from machine import Pin, I2C

import network

import esp

esp.osdebug(None)

import gc

gc.collect()

import BME280

# ESP32 - Pin assignment

i2c = I2C(scl=Pin(22), sda=Pin(21), freq=10000)

# ESP8266 - Pin assignment

#i2c = I2C(scl=Pin(5), sda=Pin(4), freq=10000)

ssid = 'REPLACE_WITH_YOUR_SSID'

password = 'REPLACE_WITH_YOUR_PASSWORD'

station = network.WLAN(network.STA_IF)

station.active(True)

station.connect(ssid, password)

while station.isconnected() == False:

  pass

print('Connection successful')

print(station.ifconfig())

 

File ini mengimpor library yang diperlukan, mendefinisikan pin I2C untuk menghubungkan sensor, dan menyambungkan perangkat ke jaringan Anda.

 

Dalam kode, kami menggunakan pin I2C ESP32:

 

i2c = I2C(scl=Pin(5), sda=Pin(4), freq=10000)

 

Jika Anda menggunakan ESP8266, berikan komentar pada baris sebelumnya dan hapus komentar pada baris berikut:

 

i2c = I2C(scl=Pin(22), sda=Pin(21), freq=10000)

 

Kemudian, masukkan kredensial jaringan Anda ke dalam variabel berikut:

 

ssid = 'REPLACE_WITH_YOUR_SSID'

password = 'REPLACE_WITH_YOUR_PASSWORD'

 

main.py

Di file main.py inilah kita akan membuat web server dan menangani permintaan. Salin kode berikut ke dalam file main.py Anda.

 

def web_page():

  bme = BME280.BME280(i2c=i2c)

  

  html = """<html><head><meta name="viewport" content="width=device-width, initial-scale=1">

  <link rel="icon" href="data:,"><style>body { text-align: center; font-family: "Trebuchet MS", Arial;}

  table { border-collapse: collapse; width:35%; margin-left:auto; margin-right:auto; }

  th { padding: 12px; background-color: #0043af; color: white; }

  tr { border: 1px solid #ddd; padding: 12px; }

  tr:hover { background-color: #bcbcbc; }

  td { border: none; padding: 12px; }

  .sensor { color:white; font-weight: bold; background-color: #bcbcbc; padding: 1px;

  </style></head><body><h1>ESP with BME280</h1>

  <table><tr><th>MEASUREMENT</th><th>VALUE</th></tr>

  <tr><td>Temp. Celsius</td><td><span class="sensor">""" + str(bme.temperature) + """</span></td></tr>

  <tr><td>Temp. Fahrenheit</td><td><span class="sensor">""" + str(round((bme.read_temperature()/100.0) * (9/5) + 32, 2))  + """F</span></td></tr>

  <tr><td>Pressure</td><td><span class="sensor">""" + str(bme.pressure) + """</span></td></tr>

  <tr><td>Humidity</td><td><span class="sensor">""" + str(bme.humidity) + """</span></td></tr></body></html>"""

  return html

s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

s.bind(('', 80))

s.listen(5)

while True:

  try:

    if gc.mem_free() < 102000:

      gc.collect()

    conn, addr = s.accept()

    conn.settimeout(3.0)

    print('Got a connection from %s' % str(addr))

    request = conn.recv(1024)

    conn.settimeout(None)

    request = str(request)

    print('Content = %s' % request)

    response = web_page()

    conn.send('HTTP/1.1 200 OK\n')

    conn.send('Content-Type: text/html\n')

    conn.send('Connection: close\n\n')

    conn.sendall(response)

    conn.close()

  except OSError as e:

    conn.close()

    print('Connection closed')

 

Kode ini membuat server socket yang mengirimkan halaman HTML berisi pembacaan sensor terbaru saat menerima permintaan pada alamat IP ESP32 atau ESP8266.

 

Pada dasarnya, kami memiliki fungsi bernama web_page() yang mengembalikan HTML untuk membangun halaman web dengan pembacaan sensor terbaru. Teks HTML ini membuat tabel untuk menampilkan pembacaan:

 

html = """<html><head><meta name="viewport" content="width=device-width, initial-scale=1">

  <link rel="icon" href="data:,"><style>body { text-align: center; font-family: "Trebuchet MS", Arial;}

  table { border-collapse: collapse; width:35%; margin-left:auto; margin-right:auto; }

  th { padding: 12px; background-color: #0043af; color: white; }

  tr { border: 1px solid #ddd; padding: 12px; }

  tr:hover { background-color: #bcbcbc; }

  td { border: none; padding: 12px; }

  .sensor { color:white; font-weight: bold; background-color: #bcbcbc; padding: 1px;

  </style></head><body><h1>ESP with BME280</h1>

  <table><tr><th>MEASUREMENT</th><th>VALUE</th></tr>

  <tr><td>Temp. Celsius</td><td><span class="sensor">""" + str(bme.temperature) + """</span></td></tr>

  <tr><td>Temp. Fahrenheit</td><td><span class="sensor">""" + str(round((bme.read_temperature()/100.0) * (9/5) + 32, 2)) + """F</span></td></tr>

  <tr><td>Pressure</td><td><span class="sensor">""" + str(bme.pressure) + """</span></td></tr>

  <tr><td>Humidity</td><td><span class="sensor">""" + str(bme.humidity) + """</span></td></tr> 

  </body></html>"""

 

Kemudian, kami membuat server socket yang mengirimkan HTML saat menerima permintaan. Teks HTML tersebut disimpan dalam variabel response:

 

response = web_page()

 

Selanjutnya dikirim ke klien:

 

conn.sendall(response)

 

Demonstrasi Web Server

Unggah semua file sebelumnya ke papan ESP32 atau ESP8266 Anda dengan urutan berikut:

1. BME280.py

2. boot.py

3. main.py

Setelah mengunggah kode, alamat IP ESP32 atau ESP8266 Anda akan ditampilkan di Serial Monitor.

Buka browser web di jaringan lokal Anda dan ketikkan alamat IP ESP (dalam contoh kami, IP-nya adalah http://192.168.1.71). Anda akan melihat halaman dengan pembacaan sensor terbaru seperti yang ditunjukkan pada gambar berikut.

Halaman web pembaruan otomatis

Dengan kode program web server yang disediakan dalam proyek ini, Anda perlu me-refresh halaman web untuk melihat pembacaan terbaru. Jika Anda menambahkan tag <meta> berikut di dalam tag <head></head> HTML, halaman web Anda akan memperbarui diri otomatis setiap 10 detik:

 

<meta http-equiv="refresh" content="10">

 

Baca juga: Input dan Output Digital ESP32/ESP8266 dengan MicroPython

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