Belajar

Simulator MicroPython ESP32: firmware resmi, online

Pemula

Atau lihat semua pelajaran.

  • 526komponen di meja kerja
  • 46board sedang berjalan
  • 1.00xwaktu nyata, di semua board
ESP32 DevKit: MicroPython membuat LED berkediplive0.000 s 0.00x
Klik untuk membukanya di editor
Tekan Jalankan. Firmware MicroPython resmi akan boot, main.py disalin ke board, dan GPIO 2 membuat kedua LED berkedip.

Mokxi menjalankan MicroPython di board ESP32 klasik: DOIT DevKit V1, DevKitC, dan LOLIN32 Lite. Letakkan salah satunya di kanvas, pilih MicroPython (main.py) di panel Firmware-nya, tulis main.py dan tekan Jalankan. Yang berjalan adalah firmware MicroPython v1.29.0 resmi untuk ESP32, file yang sama dengan yang dipublikasikan micropython.org, di model seluruh chip milik Mokxi, di-boot dari mask ROM buatan Espressif sendiri. Tidak ada bagian di halaman ini yang menginterpretasi Python-mu.

Saat kamu menekan Jalankan, komputer di ujung kabel USB simulasi board menyalin file .py kamu ke flash board seperti yang dilakukan Thonny dan mpremote, lalu melakukan soft-reboot. MicroPython mencetak MPY: soft reboot dan menjalankan main.py. Semua yang dikatakan print() muncul di Serial Monitor, dan saat main.py selesai, atau kamu menghentikannya dengan Ctrl-C, REPL menjawab di sana.

Rangkaian di atas adalah yang pertama dari enam starter di bawah: GPIO 2 membuat LED biru milik DevKit sendiri dan LED merah yang disambung ke D2 berkedip, dan Serial Monitor menampilkan on dan off.

Blink dengan machine.Pin

Pin(2, Pin.OUT) adalah GPIO 2, yang pada DevKit V1 tersambung ke LED biru board dan ke pin header D2. LED merah di D2 lewat resistor 220 ohm ke ground, jadi keduanya menyala bersamaan dan padam bersamaan.

main.py: bikin LED berkedip
# MicroPython on an ESP32 DevKit: blink an LED.
# GPIO 2 is the DevKit's own blue LED, and the red LED wired to D2 through
# 220 ohms blinks with it.
from machine import Pin
import time

led = Pin(2, Pin.OUT)

while True:
    led.value(1)
    print("on")
    time.sleep_ms(500)
    led.value(0)
    print("off")
    time.sleep_ms(500)

Tombol dengan Pin.irq()

A button from D15 to ground, with the pin’s own pull-up: the pin reads 1 until the button is pressed, and Pin.IRQ_FALLING calls the handler when it goes to 0. A real button bounces, and so does this one, so the handler only sets a flag. The main loop waits 20 ms for the contacts to settle and counts a press only if the pin is still 0. Pressed three times, it prints presses 1, presses 2 and presses 3, once each, and toggles the board’s LED with each press.

main.py: hitung tekanan dengan interrupt
# MicroPython on an ESP32 DevKit: count button presses with an interrupt.
# The button joins D15 to ground. The pin's own pull-up holds it at 1, so a
# press pulls it to 0 and IRQ_FALLING calls pressed().
from machine import Pin
import time

led = Pin(2, Pin.OUT)                       # the DevKit's blue LED
button = Pin(15, Pin.IN, Pin.PULL_UP)
presses = 0
flag = False

def pressed(pin):
    global flag
    flag = True                             # keep a handler short: set a flag

button.irq(trigger=Pin.IRQ_FALLING, handler=pressed)
print("Press the button")

while True:
    if flag:
        time.sleep_ms(20)                   # let the contacts stop bouncing
        flag = False
        if button.value() == 0:             # still down: a real press
            presses += 1
            led.value(not led.value())
            print("presses", presses)
    time.sleep_ms(5)

Memudarkan LED dengan PWM

PWM(Pin(4), freq=1000) adalah salah satu kanal LEDC ESP32 di D4, dan duty_u16() menerima 0 sampai 65535. Loop menaikkan duty lalu menurunkannya lagi, jadi LED menyala terang dan meredup dalam langkah kecil: ia bernapas, bukan berkedip.

main.py: LED yang bernapas
# MicroPython on an ESP32 DevKit: an LED that breathes.
# The LED on D4 is driven by PWM at 1 kHz; the duty goes up and down
# from 0 to 65535 in steps, so the LED fades in and out.
from machine import Pin, PWM
import time

led = PWM(Pin(4), freq=1000)

while True:
    for duty in range(0, 65536, 2048):
        led.duty_u16(duty)
        time.sleep_ms(20)
    for duty in range(65535, -1, -2048):
        led.duty_u16(duty)
        time.sleep_ms(20)
    print("breath")

DHT22 dengan modul dht

Modul dht bawaan MicroPython membaca DHT22 di D4, bit demi bit lewat pin, seperti di board sungguhan. Dengan komponen diatur ke 23.5 C dan 41% ia mencetak Temperature: 23.5 C Humidity: 41.0 %, dan saat kamu mengubah suhu di komponen, pembacaan berikutnya mengikutinya.

main.py: DHT22
# MicroPython on an ESP32 DevKit: a DHT22 temperature and humidity sensor.
# DATA is on D4; the module has its own pull-up.
from machine import Pin
import dht
import time

sensor = dht.DHT22(Pin(4))
time.sleep(2)                    # the DHT22 needs a moment after power-up

while True:
    try:
        sensor.measure()
        print("Temperature: %.1f C  Humidity: %.1f %%" % (sensor.temperature(), sensor.humidity()))
    except OSError as e:
        print("Could not read the DHT22:", e)
    time.sleep(2)                # a DHT22 gives a new reading every two seconds

OLED SSD1306 di I2C

I2C(0, scl=Pin(22), sda=Pin(21)) adalah blok I2C pertama ESP32 di pin yang dipakai kebanyakan tutorial ESP32. scan() menemukan OLED dan mencetak I2C: ['0x3c']. Tambahkan ssd1306.py dari micropython-lib sebagai tab di samping main.py dan file itu ikut disalin ke board, seperti Thonny akan menyalinnya; program lalu menggambar dua baris teks dan penghitung yang naik sekali per detik.

main.py: teks di OLED SSD1306
# MicroPython on an ESP32 DevKit: an SSD1306 OLED on I2C.
# SCL is on D22 and SDA on D21, the ESP32's usual I2C pins.
# ssd1306.py, micropython-lib's driver, is in its own tab.
from machine import I2C, Pin
import ssd1306
import time

i2c = I2C(0, scl=Pin(22), sda=Pin(21), freq=400000)
print("I2C:", [hex(a) for a in i2c.scan()])   # 0x3c, the OLED

oled = ssd1306.SSD1306_I2C(128, 64, i2c)
count = 0

while True:
    oled.fill(0)
    oled.text("Hello, ESP32!", 0, 0)
    oled.text("MicroPython", 0, 16)
    oled.text("count %d" % count, 0, 40)
    oled.show()
    print("count", count)
    count += 1
    time.sleep(1)

WiFi dan HTTP GET dengan urequests

network.WLAN bergabung ke access point simulasi Mokxi. Nama dan kata sandinya adalah properti WiFi board, yang awalnya Mokxi-Lab dan breadboard. Board mendapat alamatnya lewat DHCP dan mencetak Connected, IP address 192.168.4.2.

urequests.get() lalu mengambil http://weather.mokxi/, salah satu situs rekaan dari jaringan simulasi, dan program mencetak Mokxi: 21.5 C, 48 % humidity. Panel Cloud menampilkan permintaan yang dibuat board. Jaringannya disimulasikan: nama di luar .mokxi tidak ditemukan, dan https:// tidak punya tujuan.

main.py: gabung ke WiFi dan ambil cuaca
# MicroPython on an ESP32 DevKit: join WiFi and fetch the weather.
# The board joins Mokxi's simulated access point; its name and password are
# the board's WiFi properties. On a real board, put in your own network's.
import network
import time
import urequests

SSID = "Mokxi-Lab"
PASSWORD = "breadboard"

wlan = network.WLAN(network.STA_IF)
wlan.active(True)
wlan.connect(SSID, PASSWORD)
print("Connecting to", SSID)
while not wlan.isconnected():
    time.sleep_ms(250)
print("Connected, IP address", wlan.ifconfig()[0])

while True:
    r = urequests.get("http://weather.mokxi/")
    weather = r.json()
    r.close()
    print("%s: %.1f C, %d %% humidity" % (weather["location"], weather["temperatureC"], weather["humidity"]))
    time.sleep(10)

Apa yang berfungsi, dan apa yang tidak

Berfungsi: machine.Pin dengan interrupt, PWM pada LEDC, ADC di delapan channel ADC1 dengan empat atenuasi, I2C dan SoftI2C, SPI dan SoftSPI, UART(1) dan UART(2), neopixel, dht, onewire dan ds18x20, machine.freq() di 80, 160 atau 240 MHz, serta network.WLAN dengan socket dan urequests di jaringan simulasi. Driver seperti ssd1306.py bisa berbicara dengan komponen di kanvas.

Tidak disimulasikan: light dan deep sleep; ADC2; PSRAM; mode slave I2C dan SPI; flow control UART; menerima dengan RMT; watchdog yang me-reset board; dan di jaringan, station kedua di soft AP (HP panel Web bergabung ke WLAN(AP_IF)), ESP-NOW, power save, TLS, dan jaringan apa pun selain jaringan simulasi. Firmwarenya adalah build single-core. Kode di flash berjalan sama cepat dengan kode di RAM, karena timing cache tidak dimodelkan.

Mengimpor dari Wokwi

Proyek Wokwi untuk ESP32 dengan main.py diimpor sebagai proyek MicroPython, dengan boardnya disetel ke MicroPython. Boardnya bergabung ke Wokwi-GUEST tanpa kata sandi, seperti di Wokwi, jadi wlan.connect("Wokwi-GUEST", "") yang biasa langsung berfungsi apa adanya.

Kode yang sama di ESP32 sungguhan

Board MicroPython tidak perlu build. Pasang MicroPython ke ESP32 dengan esptool (esptool.py --chip esp32 erase_flash, lalu esptool.py --chip esp32 write_flash -z 0x1000 ESP32_GENERIC-UNICORE-20260824-v1.29.0.bin, dari micropython.org/download/ESP32_GENERIC), lalu salin main.py ke board dengan Thonny atau mpremote.

Di board sungguhan, ubah SSID dan kata sandi di starter WiFi ke jaringanmu sendiri. Situs .mokxi hanya ada di Mokxi.

Buka rangkaian ini di editor. ESP32 DevKit: MicroPython mengedipkan LED, dirangkai seperti yang berjalan di bagian atas halaman ini. Ubah komponen atau nilainya dan jalankan lagi.

Buka rangkaian ini

Pertanyaan

Apakah ini MicroPython sungguhan?

Ya. Board menjalankan firmware MicroPython v1.29.0 resmi untuk ESP32, build single-core yang diterbitkan micropython.org, di model seluruh chip yang di-boot dari mask ROM Espressif. Tidak ada bagian dari halaman web yang menafsirkan Python-mu.

Board mana yang bisa menjalankan MicroPython?

Board ESP32 klasik: DOIT DevKit V1, DevKitC, dan LOLIN32 Lite, serta Raspberry Pi Pico. Pilih MicroPython (main.py) di panel Firmware board. Sketch Arduino di board yang sama tetap berjalan seperti biasa.

Bagaimana main.py bisa masuk ke board?

Cara yang sama seperti mpremote. Saat Jalankan, komputer simulasi di port USB board masuk ke raw REPL lewat UART0, menulis setiap file .py ke filesystem board, lalu melakukan soft-reboot pada board, yang kemudian menjalankan boot.py dan main.py.

Apakah ini mengunduh sesuatu?

Run pertama untuk proyek MicroPython di ESP32 mengunduh firmware dan ROM chip, 1.4 MB, dan browser menyimpannya untuk setiap Run berikutnya. Sketch Arduino tidak pernah mengunduhnya.

Rakit versi nyatanya

Buka editor, ubah sebuah nilai, dan lihat angkanya ikut berubah. Tidak ada yang perlu dipasang, dan tidak perlu akun.