ESP32 MicroPython 개발 참고 문서

 

이 문서는 MicroPython 최신 개발 브랜치의 설명서로, 출시된 버전에서는 사용할 수 없는 기능을 참조할 수 있습니다.

 

특정 릴리스에 대한 문서를 찾고 계시다면, 왼쪽의 드롭다운 메뉴를 사용하여 원하는 버전을 선택하십시오. 

 

 

ESP32에 대한 빠른 참조(공식 문서의 배포는 이곳을 참고하세요)

 

 

Espressif ESP32 개발 보드(이미지 출처: Adafruit).

 

ESP32 기반 보드에 대한 간략한 참고 자료는 다음과 같습니다. 이 보드를 처음 사용하는 경우, 마이크로컨트롤러에 대한 개요를 파악하는 것이 유용할 수 있습니다.

 

• ESP32 포트에 대한 일반 정보
• ESP32를 위한 MicroPython 튜토리얼

 

MicroPython에서 지원하는 ESP32에는 ESP32, ESP32C3, ESP32C6, ESP32S2, ESP32S3 등 여러 종류가 있으며, 이들 간에는 기능상의 약간의 차이가 있습니다.

 

MicroPython 설치

 

튜토리얼의 해당 섹션인 ESP32에서 MicroPython 시작하기를 참조하세요 . 문제 해결 하위 섹션도 포함되어 있습니다.

 

일반 보드 제어

 

MicroPython REPL은 UART0(GPIO1=TX, GPIO3=RX)에 연결되어 있으며, 통신 속도는 115200입니다. 탭 자동 완성 기능은 객체의 메서드를 확인하는 데 유용합니다. 붙여넣기 모드(ctrl-E)는 대량의 Python 코드를 REPL에 붙여넣는 데 유용합니다.

 

* REPL은 "Read-Eval-Print Loop"의 약자로, 프로그래밍 환경에서 사용자가 입력한 코드를 읽고(Read), 평가(Eval)하고, 그 결과를 출력(Print)한 다음, 다시 입력을 기다리는 반복(Loop) 과정을 거치는 대화형 개발 환경을 말합니다. 이 환경을 통해 개발자들은 코드 파일을 따로 만들지 않고도 간단한 코드의 결과를 실시간으로 확인하고 테스트할 수 있습니다.

 

machine 모듈:

 

import machine

machine.freq()          # get the current frequency of the CPU
machine.freq(240000000) # set the CPU frequency to 240 MHz

 

esp 모듈:

 

import esp

esp.osdebug(None)       # turn off vendor O/S debugging messages
esp.osdebug(0)          # redirect vendor O/S debugging messages to UART(0)

# low level methods to interact with flash storage
esp.flash_size()
esp.flash_user_start()
esp.flash_erase(sector_no)
esp.flash_write(byte_offset, buffer)
esp.flash_read(byte_offset, buffer)

 

esp32 모듈:

 

import esp32

esp32.raw_temperature() # read the internal temperature of the MCU, in Fahrenheit
esp32.ULP()             # access to the Ultra-Low-Power Co-processor, not on ESP32C3/C6

 

 

ESP32의 온도 센서는 IC가 동작하는 동안 뜨거워지기 때문에 일반적으로 주변 온도보다 높은 값을 읽습니다. 절전 모드에서 깨어난 직후에 온도 센서 값을 읽으면 이러한 현상을 최소화할 수 있습니다.

 

ESP32C3, ESP32C6, ESP32S2, ESP32S3에도 내부 온도 센서가 있습니다. ESP32와는 약간 다르게 구현되어 있으며, 섭씨 온도를 반환합니다.

 

esp32.mcu_temperature() # read the internal temperature of the MCU, in Celsius

 

 

네트워킹

 

WLAN

 

network 모듈의 network.WLAN 클래스:

 

import network

wlan = network.WLAN()       # create station interface (the default, see below for an access point interface)
wlan.active(True)           # activate the interface
wlan.scan()                 # scan for access points
wlan.isconnected()          # check if the station is connected to an AP
wlan.connect('ssid', 'key') # connect to an AP
wlan.config('mac')          # get the interface's MAC address
wlan.ipconfig('addr4')      # get the interface's IPv4 addresses

ap = network.WLAN(network.WLAN.IF_AP) # create access-point interface
ap.config(ssid='ESP-AP')              # set the SSID of the access point
ap.config(max_clients=10)             # set how many clients can connect to the network
ap.active(True)                       # activate the interface

 

 

로컬 WiFi 네트워크에 연결하는 데 유용한 기능은 다음과 같습니다.

 

def do_connect():
    import machine, network
    wlan = network.WLAN()
    wlan.active(True)
    if not wlan.isconnected():
        print('connecting to network...')
        wlan.connect('ssid', 'key')
        while not wlan.isconnected():
            machine.idle()
    print('network config:', wlan.ipconfig('addr4'))

 

 

네트워크가 구축되면 이 socket모듈을 사용하여 평소처럼 TCP/UDP 소켓을 만들고 사용할 수 있으며, 이 requests모듈을 사용하여 편리한 HTTP 요청을 처리할 수 있습니다.

 

wlan.connect() 호출 후, 인증 실패 또는 AP가 범위 내에 없을 때에도 기본적으로 장치는 영원히 연결을 재시도합니다. wlan.status()는 연결이 성공하거나 인터페이스가 비활성화될 때까지 이 상태에서 network.STAT_CONNECTING을 반환합니다. wlan.config(reconnects=n)을 호출하여 변경할 수 있습니다. 여기서 n은 원하는 재연결 시도 횟수입니다(0은 재시도하지 않음을 의미하며, -1은 무한 재연결을 시도하는 기본 동작으로 복원합니다).

 

LAN

 

내장 MAC(원래 ESP32)

 

원래 ESP32 SoC에는 이더넷 MAC이 내장되어 있습니다. 이 MAC을 사용하려면 외부 이더넷 PHY를 칩의 EMAC 핀에 연결해야 합니다. 대부분의 EMAC 핀 할당은 고정되어 있으며, 자세한 내용은 ESP32 데이터시트를 참조하십시오.

 

PHY가 연결된 경우 network.LAN생성자를 통해 내부 이더넷 MAC을 구성할 수 있습니다.

 

* 'PHY'는 주로 물리 계층(Physical Layer)을 의미하며, 네트워크 인터페이스 컨트롤러에서 물리적 매체(케이블 등)와 통신하기 위한 하드웨어 부분을 지칭합니다. 이는 디지털 시스템과 실제 물리적 신호 사이에서 데이터의 코딩 및 디코딩, 그리고 신호 변환(예: 전기 신호와 디지털 신호의 변환) 역할을 수행합니다. 

 

import network

lan = network.LAN(mdc=PIN_MDC, ...)   # Set the pin and mode configuration
lan.active(True)                      # activate the interface
lan.ipconfig('addr4')                 # get the interface's IPv4 addresses

 

 

생성자에 필요한 키워드 인수:

 

mdc and mdio : machine.PinMDC 및 MDIO 핀을 지정하는 객체(또는 정수).

 

• phy_type : PHY 장치 유형을 선택하세요. 지원되는 장치는 PHY_GENERIC, PHY_LAN8710, PHY_LAN8720, PHY_IP101, , PHY_RTL8201, PHY_DP83848, PHY_KSZ8041입니다 PHY_KSZ8081. 이 값은 모두 network모듈에 정의된 상수입니다.
• phy_addr : PHY 장치의 주소 번호입니다. 0x00부터 0x1f까지의 정수여야 합니다. 일반적인 값은 0과 1입니다.
• 인터페이스를 구성하려면 위의 키워드 인수가 모두 있어야 합니다.

 

선택 키워드 인수:

 

• reset- machine.PinPHY 재설정 핀을 지정하는 객체(또는 정수).
• power- machine.PinPHY 장치의 전원을 전환하는 핀을 지정하는 객체(또는 정수).
• ref_clk- machine.PinEMAC ref_clk신호에 사용되는 핀을 지정하는 객체(또는 정수). 지정하지 않으면 보드 기본값이 사용됩니다(일반적으로 GPIO 0이지만, 특정 보드에 이더넷이 있는 경우 다를 수 있음).
• ref_clk_mode- ESP32의 EMAC ref_clk핀을 입력 또는 출력으로 사용할지 정의합니다. 적절한 값은 machine.Pin.IN과 입니다 machine.Pin.OUT. 지정하지 않으면 보드 기본값이 사용됩니다(일반적으로 입력이지만, 특정 보드에 이더넷이 있는 경우 다를 수 있음).

 

다음은 일부 인기 있는 ESP32 보드의 LAN 인터페이스에 대한 작동 구성입니다.

 

# Olimex ESP32-GATEWAY: power controlled by Pin(5)
# Olimex ESP32 PoE and ESP32-PoE ISO: power controlled by Pin(12)

lan = network.LAN(mdc=machine.Pin(23), mdio=machine.Pin(18), power=machine.Pin(5),
                  phy_type=network.PHY_LAN8720, phy_addr=0,
                  ref_clk=machine.Pin(17), ref_clk_mode=machine.Pin.OUT)

# Wireless-Tag's WT32-ETH01

lan = network.LAN(mdc=machine.Pin(23), mdio=machine.Pin(18),
                  phy_type=network.PHY_LAN8720, phy_addr=1, power=None)

# Wireless-Tag's WT32-ETH01 v1.4

lan = network.LAN(mdc=machine.Pin(23), mdio=machine.Pin(18),
                  phy_type=network.PHY_LAN8720, phy_addr=1,
                  power=machine.Pin(16))

# Espressif ESP32-Ethernet-Kit_A_V1.2

lan = network.LAN(id=0, mdc=Pin(23), mdio=Pin(18), power=Pin(5),
                  phy_type=network.PHY_IP101, phy_addr=1)

 

 

SPI 이더넷 인터페이스

 

모든 ESP32 SoC는 외부 SPI 이더넷 인터페이스 칩을 지원합니다. 이는 이더넷 RMII 인터페이스가 아닌 SPI 버스를 통해 연결되는 이더넷 인터페이스입니다.

 

* RMII는 Reduced Media Independent Interface의 약자로, MII(Media Independent Interface)의 신호선 수를 줄인 이더넷(Ethernet) 물리층 인터페이스입니다. MII의 16개 신호선 대신 100 Mbps 속도를 유지하면서 더 적은 수의 신호선으로 PHY와 MAC(Media Access Control) 간의 데이터 전송을 가능하게 하여 하드웨어 공간을 절약합니다. 

 

Note: 유일한 예외는 ESP32 d2wd변형으로, 코드 크기를 줄이기 위해 이 기능이 비활성화됩니다.

 

SPI 이더넷은 동일한 network.LAN 생성자를 사용하지만, 다른 키워드 인자 집합을 사용합니다:

 

import machine, network

spi = machine.SPI(1, sck=SCK_PIN, mosi=MOSI_PIN, miso=MISO_PIN)
lan = network.LAN(spi=spi, cs=CS_PIN, ...)   # Set the pin and mode configuration
lan.active(True)                             # activate the interface
lan.ipconfig('addr4')                        # get the interface's IPv4 addresses

 

생성자에 필요한 키워드 인수:

 

• spi- 이 연결에 대해 구성된 객체여야 합니다 machine.SPI. SPI 객체에 구성된 클럭 속도는 무시되며, SPI 이더넷 클럭 속도는 컴파일 시점에 설정됩니다.
• cs- machine.Pin인터페이스에 연결된 CS 핀을 지정하는 객체(또는 정수).
• int- machine.Pin인터페이스에 연결된 INT 핀을 지정하는 객체(또는 정수).
• phy_type- SPI 이더넷 인터페이스 유형을 선택하세요. 지원되는 장치는 PHY_KSZ8851SNL, PHY_DM9051, 입니다 PHY_W5500. 이 값들은 모두 모듈에 정의된 상수입니다 network.
• phy_addr- PHY 장치의 주소 번호입니다. 0x00부터 0x1f까지의 정수여야 합니다. 일반적으로 0SPI 이더넷 장치에 사용됩니다.

 

인터페이스를 구성하려면 위의 키워드 인수가 모두 있어야 합니다.

 

생성자에 대한 선택적 키워드 인수:

 

• reset- machine.PinSPI 이더넷 인터페이스 재설정 핀을 지정하는 객체(또는 정수).
• power- machine.PinSPI 이더넷 인터페이스의 전원을 전환하는 핀을 지정하는 객체(또는 정수).

 

다음은 ESP32-S3 개발 보드의 핀에 연결된 WIZNet W5500 칩에 대한 샘플 구성입니다.

 

import machine, network
from machine import Pin, SPI

spi = SPI(1, sck=Pin(12), mosi=Pin(13), miso=Pin(14))
lan = network.LAN(spi=spi, phy_type=network.PHY_W5500, phy_addr=0,
                  cs=Pin(10), int=Pin(11))

 

Note: WIZnet W5500 이더넷은 다른 일부 MicroPython 포트에서도 지원되지만 다른 소프트웨어 인터페이스를 사용합니다 .

 

지연과 타이밍

 

time 모듈 을 사용하세요:

 

import time

time.sleep(1)           # sleep for 1 second
time.sleep_ms(500)      # sleep for 500 milliseconds
time.sleep_us(10)       # sleep for 10 microseconds
start = time.ticks_ms() # get millisecond counter
delta = time.ticks_diff(time.ticks_ms(), start) # compute time difference

 

타이머

 

ESP32 포트에는 ESP32 장치 유형에 따라 1개, 2개 또는 4개의 하드웨어 타이머가 있습니다. ESP32C2에는 타이머 1개, ESP32C4, ESP32C6, ESP32H4에는 타이머 2개, 그리고 그 외의 장치에는 타이머 4개가 있습니다. machine.Timer 클래스를 사용하여 타이머 ID를 0, 0, 1 또는 0부터 3까지(포함)로 지정합니다.

 

from machine import Timer

tim0 = Timer(0)
tim0.init(period=5000, mode=Timer.ONE_SHOT, callback=lambda t:print(0))

tim1 = Timer(1)
tim1.init(period=2000, mode=Timer.PERIODIC, callback=lambda t:print(1))

 

 

주기는 밀리초 단위입니다. UART.IRQ_RXIDLE을 사용하는 경우, IRQ_RXIDLE 메커니즘에 타이머 0이 필요하며, 다른 용도로는 사용할 수 없습니다.

 

타이머 콜백은 이 포트에서 소프트 인터럽트로 예약됩니다. 하드 콜백은 구현되지 않습니다. 지정하면 hard=TrueValueError가 발생합니다.

 

현재 이 포트에서는 가상 타이머가 지원되지 않습니다.

 

핀과 GPIO

 

machine.Pin 클래스를 사용하세요 :

 

from machine import Pin

p0 = Pin(0, Pin.OUT)    # create output pin on GPIO0
p0.on()                 # set pin to "on" (high) level
p0.off()                # set pin to "off" (low) level
p0.value(1)             # set pin to on/high

p2 = Pin(2, Pin.IN)     # create input pin on GPIO2
print(p2.value())       # get value, 0 or 1

p4 = Pin(4, Pin.IN, Pin.PULL_UP) # enable internal pull-up resistor
p5 = Pin(5, Pin.OUT, value=1) # set pin high on creation
p6 = Pin(6, Pin.OUT, drive=Pin.DRIVE_3) # set maximum drive strength

 

 

사용 가능한 핀 범위는 다음과 같습니다(0~19, 21~23, 25~27, 32~39). 이는 ESP32 칩의 실제 GPIO 핀 번호와 일치합니다. 많은 최종 사용자 보드는 자체 임시 핀 번호(예: D0, D1 등)를 사용합니다. 보드 논리 핀과 칩의 물리적 핀 간의 매핑은 보드 설명서를 참조하십시오.

 

Pin() 생성자 또는 Pin.init() 메서드에 drive 키워드 인수를 사용하여 네 가지 드라이브 강도를 지원하며, 각각에 해당하는 안전한 최대 소스/싱크 전류 및 대략적인 내부 드라이버 저항은 다음과 같습니다:

 

• Pin.DRIVE_0: 5mA / 130옴
• Pin.DRIVE_1: 10mA / 60옴
• Pin.DRIVE_2: 20mA / 30옴(구성되지 않은 경우 기본 강도)
• Pin.DRIVE_3: 40mA / 15옴

 

Pin() 및 Pin.init()의 hold= 키워드 인수는 ESP32의 "패드 홀드" 기능을 활성화합니다. True로 설정하면 핀 구성(방향, 풀 저항 및 출력 값)이 유지되며 이후 변경 사항(출력 레벨 변경 포함)은 적용되지 않습니다. hold=False로 설정하면 미적용된 핀 구성 변경 사항이 즉시 적용되고 핀이 해제됩니다. 핀이 이미 홀드 상태일 때 hold=True를 사용하면 구성 변경 사항이 적용된 후 즉시 홀드가 재적용됩니다.

 

참고사항:

 

• 핀 1과 3은 각각 REPL UART TX 및 RX입니다.
• 핀 6, 7, 8, 11, 16 및 17은 내장 플래시를 연결하는 데 사용되며 다른 용도로는 권장되지 않습니다.
• 핀 34-39는 입력 전용이며 내부 풀업 저항이 없습니다.
• 수면 중 핀 동작에 대한 논의는 심층 수면 모드를 참조하세요 .

 

핀을 반전시키는 데 사용할 수 있는 상위 추상화 기계인 machine.Signal이 있습니다. on() 또는 value(1)을 사용하여 액티브 로우 LED를 점등하는 데 유용합니다.

 

UART(직렬 버스)

 

machine.UART를 참조하세요 .

 

from machine import UART

uart1 = UART(1, baudrate=9600, tx=33, rx=32)
uart1.write('hello')  # write 5 bytes
uart1.read(5)         # read up to 5 bytes

 

 

ESP32에는 UART0, UART1, UART2의 세 가지 하드웨어 UART가 있습니다. 각 UART에는 기본 GPIO가 할당되어 있지만, ESP32 모델 및 보드에 따라 이 핀들이 내장 플래시 메모리, 온보드 PSRAM 또는 주변 장치와 충돌할 수 있습니다.

 

GPIO 매트릭스를 사용하는 하드웨어 UART에는 모든 GPIO를 사용할 수 있습니다. 단, 입력 전용 핀인 34~39번은 로 사용할 수 있습니다 rx. 충돌을 방지하려면 구성 시 tx및 rx핀을 제공하기만 하면 됩니다. 아래 나열된 기본 핀은 다음과 같습니다.

 

 

	UART0	UART1	UART2
tx	1	10	17
rx	3	9	16

 

PWM(펄스 폭 변조)

 

PWM은 모든 출력 활성화 핀에서 활성화할 수 있습니다. 기본 주파수는 1Hz에서 40MHz까지 가능하지만, 기본 주파수가 증가 할수록 듀티 분해능이 감소하는 단점이 있습니다 . 자세한 내용은 LED 제어를 참조하십시오.

 

machine.PWM 클래스를 사용하세요 :

 

from machine import Pin, PWM, lightsleep

pwm0 = PWM(Pin(0), freq=5000, duty_u16=32768) # create PWM object from a pin
freq = pwm0.freq()         # get current frequency
pwm0.freq(1000)            # set PWM frequency from 1Hz to 40MHz

duty = pwm0.duty()         # get current duty cycle, range 0-1023 (default 512, 50%)
pwm0.duty(256)             # set duty cycle from 0 to 1023 as a ratio duty/1023, (now 25%)

duty_u16 = pwm0.duty_u16() # get current duty cycle, range 0-65535
pwm0.duty_u16(65536*3//4)  # set duty cycle from 0 to 65535 as a ratio duty_u16/65535, (now 75%)

duty_ns = pwm0.duty_ns()   # get current pulse width in ns
pwm0.duty_ns(250_000)      # set pulse width in nanoseconds from 0 to 1_000_000_000/freq, (now 25%)

pwm0.deinit()              # turn off PWM on the pin

pwm2 = PWM(Pin(2), freq=20000, duty=512)  # create and configure in one go
print(pwm2)                               # view PWM settings
pwm2.deinit()                             # turn off PWM on the pin

pwm0 = PWM(Pin(0), duty_u16=16384)            # The output is at a high level 25% of the time.
pwm2 = PWM(Pin(2), duty_u16=16384, invert=1)  # The output is at a low level 25% of the time.

pwm4 = PWM(Pin(4), lightsleep=True)           # Allow PWM during light sleep mode

lightsleep(10*1000) # pwm0, pwm2 goes off, pwm4 stays on during 10s light sleep
                    # pwm0, pwm2, pwm4 on after 10s light sleep

 

 

ESP 칩에는 다양한 하드웨어 주변 장치가 있습니다.

 

Hardware specification	ESP32	ESP32-S2, ESP32-S3, ESP32-P4	ESP32-C2, ESP32-C3, ESP32-C5, ESP32-C6, ESP32-H2
Number of groups (speed modes)	2	1	1
Number of timers per group	4	4	4
Number of channels per group	8	8	6
Different PWM frequencies = (groups * timers)	8	4	4
Total PWM channels (Pins, duties) = (groups * channels)	16	8	6

 

 

가벼운 절전 모드에서는 ESP32 PWM이 저속 모드에서만 작동할 수 있으므로 타이머 4개와 채널 8개만 사용할 수 있습니다.

 

ESP32에서 사용 가능한 PWM 채널(핀) 수는 최대 16개입니다. 단, 사용 가능한 PWM 주파수는 8개이며, 나머지 8개 채널은 동일한 주파수를 가져야 합니다. 반면, 동일한 주파수에서 16개의 독립적인 PWM 듀티 사이클이 가능합니다.

 

펄스 폭 변조 튜토리얼 에서 더 많은 예를 확인하세요 .

 

DAC(디지털-아날로그 변환)

 

ESP32에서는 DAC 기능이 핀 25, 26에서 사용 가능합니다. ESP32S2에서는 DAC 기능이 핀 17, 18에서 사용 가능합니다.

 

DAC를 사용하세요:

 

from machine import DAC, Pin

dac = DAC(Pin(25))  # create an DAC object acting on a pin
dac.write(128)      # set a raw analog value in the range 0-255, 50% now

 

 

ADC(아날로그-디지털 변환)

 

ESP32에서 ADC 기능은 핀 32-39(ADC 블록 1)와 핀 0, 2, 4, 12-15, 25-27(ADC 블록 2)에서 사용할 수 있습니다.

 

machine.ADC 클래스를 사용하세요 :

 

from machine import ADC

adc = ADC(pin)        # create an ADC object acting on a pin
val = adc.read_u16()  # read a raw analog value in the range 0-65535
val = adc.read_uv()   # read an analog value in microvolts

 

 

ADC 블록 2는 WiFi에서도 사용되므로 WiFi가 활성화되어 있을 때 블록 2 핀에서 아날로그 값을 읽으려고 하면 예외가 발생합니다.

 

내부 ADC 기준 전압은 일반적으로 1.1V이지만 패키지마다 약간 차이가 있습니다. ADC는 기준 전압 근처(특히 높은 감쇠율에서)에서 선형성이 떨어지며, 약 100mV 정도의 최소 측정 전압을 가집니다. 이보다 낮거나 동일한 전압은 0으로 읽힙니다. 전압을 정확하게 읽으려면 read_uv() 메서드를 사용하는 것이 좋습니다(아래 참조).

 

ESP32 관련 ADC 클래스 메서드 참조:

 

class ADC(pin, *, atten)

 

ADC.read_uv ( )​

 

class ADCBlock (id , * , bits)

 

ADCBlock.connect(pin)

 

ADCBlock.connect (channel)

 

ADCBlock. connect (channel, pin)​

 

기존 방법:

 

ADC .read()

 

ADC.atten ( atten )​

 

ADC.width(bits)

 

해상도를 더 낮은 해상도로 전환할 수 있는 유일한 칩은 일반 ESP32입니다. C2와 S3는 12비트에 고정되어 있는 반면, S2는 13비트에 고정되어 있습니다.

 

호환성을 위해 해당 ADC객체는 칩당 지원되는 ADC 해상도와 일치하는 상수도 제공합니다.

 

ESP32:

 

ADC.WIDTH_9BIT= 9

ADC.WIDTH_10BIT= 10

ADC.WIDTH_11BIT= 11

ADC.WIDTH_12BIT= 12

 

ESP32 C3 및 S3:

 

ADC.WIDTH_12BIT= 12

 

ESP32 S2:

 

ADC.WIDTH_13BIT= 13

 

 

ADC.deinit ( )

 

펄스 카운터(핀 펄스/에지 카운팅)

 

ESP32는 하드웨어에 따라 최대 8개의 펄스 카운터 주변장치를 제공하며, 각 주변장치의 ID는 0~7입니다. 이 주변장치들은 모든 입력 핀의 상승 및/또는 하강 에지를 계산하도록 설정할 수 있습니다.

 

esp32.PCNT 클래스를 사용하세요 :

 

from machine import Pin
from esp32 import PCNT

counter = PCNT(0, pin=Pin(2), rising=PCNT.INCREMENT)        # create counter
counter.start()                                             # start counter
count = counter.value()                                     # read count, -32768..32767
counter.value(0)                                            # reset counter
count = counter.value(0)                                    # read and reset

 

PCNT 하드웨어는 단일 장치에서 여러 핀을 모니터링하여 사분면 디코딩이나 업/다운 신호 카운터를 구현하는 것을 지원합니다.

 

일반적인 펄스 계산 응용 프로그램의 더 간단한 추상화를 보려면 machine.Counter 및 machine.Encoder 클래스를 참조하세요 .

 

from machine import Pin, Counter

counter = Counter(0, Pin(2))    # create a counter as above and start it
count = counter.value()         # read the count as an arbitrary precision signed integer

encoder = Encoder(0, Pin(12), Pin(14))    # create an encoder and begin counting
count = encoder.value()                   # read the count as an arbitrary precision signed integer

 

 

이 Counter() 및 Encoder() 객체에 전달되는 id는 반드시 PCNT id여야 합니다.

 

소프트웨어 SPI 버스

 

소프트웨어 SPI(비트뱅잉 사용)는 모든 핀에서 작동하며 machine.SoftSPI 클래스를 통해 액세스합니다.

 

from machine import Pin, SoftSPI

# construct a SoftSPI bus on the given pins
# polarity is the idle state of SCK
# phase=0 means sample on the first edge of SCK, phase=1 means the second
spi = SoftSPI(baudrate=100000, polarity=1, phase=0, sck=Pin(0), mosi=Pin(2), miso=Pin(4))

spi.init(baudrate=200000) # set the baudrate

spi.read(10)            # read 10 bytes on MISO
spi.read(10, 0xff)      # read 10 bytes while outputting 0xff on MOSI

buf = bytearray(50)     # create a buffer
spi.readinto(buf)       # read into the given buffer (reads 50 bytes in this case)
spi.readinto(buf, 0xff) # read into the given buffer and output 0xff on MOSI

spi.write(b'12345')     # write 5 bytes on MOSI

buf = bytearray(4)      # create a buffer
spi.write_readinto(b'1234', buf) # write to MOSI and read from MISO into the buffer
spi.write_readinto(buf, buf) # write buf to MOSI and read MISO back into buf

 

 

경고

 

현재는 소프트웨어 SPI를 초기화할 때 모든sck , mosi및 를 지정 miso 해야 합니다 .

 

하드웨어 SPI 버스

 

더 빠른 전송 속도(최대 80MHz)를 지원하는 두 개의 하드웨어 SPI 채널이 있습니다. 이 채널들은 필요한 방향을 지원하지만 사용하지 않는 모든 IO 핀에 사용할 수 있습니다( 핀 및 GPIO 참조 ). 하지만 기본 핀으로 구성되지 않은 경우, 추가 GPIO 다중화 계층을 거쳐야 하며, 이는 고속에서의 안정성에 영향을 미칠 수 있습니다. 하드웨어 SPI 채널은 아래 나열된 기본 핀 이외의 핀에 사용될 경우 40MHz로 제한됩니다.

 

 

	HSPI (id=1)	VSPI (id=2)
sck	14	18
mosi	13	23
miso	12	19

 

 

하드웨어 SPI는 machine.SPI 클래스를 통해 액세스되며 위의 소프트웨어 SPI와 동일한 메서드를 갖습니다.

 

 

from machine import Pin, SPI

hspi = SPI(1, 10000000)
hspi = SPI(1, 10000000, sck=Pin(14), mosi=Pin(13), miso=Pin(12))
vspi = SPI(2, baudrate=80000000, polarity=0, phase=0, bits=8, firstbit=0, sck=Pin(18), mosi=Pin(23), miso=Pin(19))

 

 

소프트웨어 I2C 버스

 

소프트웨어 I2C(비트뱅잉 사용)는 모든 출력 가능 핀에서 작동하며 machine.SoftI2C 클래스를 통해 액세스합니다.

 

from machine import Pin, SoftI2C

i2c = SoftI2C(scl=Pin(5), sda=Pin(4), freq=100000)

i2c.scan()              # scan for devices

i2c.readfrom(0x3a, 4)   # read 4 bytes from device with address 0x3a
i2c.writeto(0x3a, '12') # write '12' to device with address 0x3a

buf = bytearray(10)     # create a buffer with 10 bytes
i2c.writeto(0x3a, buf)  # write the given buffer to the peripheral

 

 

하드웨어 I2C 버스

 

식별자가 0과 1인 두 개의 하드웨어 I2C 주변 장치가 있습니다. 사용 가능한 모든 출력 가능 핀은 SCL 및 SDA에 사용할 수 있지만 기본값은 아래와 같습니다.

 

 

	I2C(0)	I2C(1)
scl	18	25
sda	19	26

 

 

드라이버는 machine.I2C 클래스를 통해 접근되며 위의 소프트웨어 I2C와 동일한 메서드를 갖습니다.

 

from machine import Pin, I2C

i2c = I2C(0)
i2c = I2C(1, scl=Pin(5), sda=Pin(4), freq=400000)

 

I2S 버스

 

machine.I2S를 참조하세요 .

 

from machine import I2S, Pin

i2s = I2S(0, sck=Pin(13), ws=Pin(14), sd=Pin(34), mode=I2S.TX, bits=16, format=I2S.STEREO, rate=44100, ibuf=40000) # create I2S object
i2s.write(buf)             # write buffer of audio samples to I2S device

i2s = I2S(1, sck=Pin(33), ws=Pin(25), sd=Pin(32), mode=I2S.RX, bits=16, format=I2S.MONO, rate=22050, ibuf=40000) # create I2S object
i2s.readinto(buf)          # fill buffer with audio samples from I2S device

 

 

I2S 클래스는 현재 기술 미리보기로 제공됩니다. 미리보기 기간 동안 사용자 여러분의 피드백을 기다립니다. 피드백을 바탕으로 I2S 클래스 API 및 구현 방식이 변경될 수 있습니다.

 

ESP32에는 id=0 및 id=1인 두 개의 I2S 버스가 있습니다.

 

실시간 시계(RTC)

 

machine.RTC를 참조하세요 .

 

from machine import RTC

rtc = RTC()
rtc.datetime((2017, 8, 23, 0, 1, 12, 48, 0)) # set a specific date and
                                             # time, eg. 2017/8/23 1:12:48
                                             # the day-of-week value is ignored
rtc.datetime() # get date and time

 

 

WDT(워치독 타이머)

 

machine.WDT를 참조하세요 .

 

from machine import WDT

# enable the WDT with a timeout of 5s (1s is the minimum)
wdt = WDT(timeout=5000)
wdt.feed()

 

 

딥슬립 모드

 

다음 코드를 사용하면 절전 모드로 전환하고, 깨우고, 재설정 원인을 확인할 수 있습니다.

 

import machine

# check if the device woke from a deep sleep
if machine.reset_cause() == machine.DEEPSLEEP_RESET:
    print('woke from a deep sleep')

# put the device to sleep for 10 seconds
machine.deepsleep(10000)

 

참고사항:

 

• 인수를 지정하지 않고 deepsleep()을 호출하면 장치가 무기한으로 절전 상태로 전환됩니다
• 소프트웨어 리셋은 리셋 원인을 변경하지 않습니다

 

일부 ESP32 핀(0, 2, 4, 12-15, 25-27, 32-39)은 딥 슬립 모드 동안 RTC에 연결되어 모듈 wake_on_의 기능을 사용하여 장치를 깨우는 데 사용될 수 있습니다 esp32. 출력 가능 RTC 핀(34-39를 제외한 모든 핀)은 딥 슬립 모드 진입 시 풀업 또는 풀다운 저항 설정을 유지합니다.

 

딥 슬립 모드 중에 풀업 저항이 실제로 필요하지 않고 전류 누설을 일으킬 가능성이 있는 경우(예: 풀업 저항이 스위치를 통해 접지에 연결된 경우) 딥 슬립 모드로 들어가기 전에 전력을 절약하기 위해 풀업 저항을 비활성화해야 합니다.

 

from machine import Pin, deepsleep

# configure input RTC pin with pull-up on boot
pin = Pin(2, Pin.IN, Pin.PULL_UP)

# disable pull-up and put the device to sleep for 10 seconds
pin.init(pull=None)
machine.deepsleep(10000)

 

 

출력으로 구성된 RTC 핀은 Pin.init()에 hold=True 인수를 사용하여 패드 홀드가 활성화된 경우 딥 슬립 상태에서도 출력 방향과 레벨을 유지합니다.

 

RTC가 아닌 GPIO 핀은 딥 슬립 모드로 진입하면 기본적으로 연결이 해제됩니다. RTC가 아닌 핀의 설정(출력 레벨 포함)은 해당 핀의 패드 홀드(pad hold)를 활성화하고 딥 슬립 모드 중 GPIO 패드 홀드를 활성화하여 유지할 수 있습니다.

 

from machine import Pin, deepsleep
import esp32

opin = Pin(19, Pin.OUT, value=1, hold=True) # hold output level
ipin = Pin(21, Pin.IN, Pin.PULL_UP, hold=True) # hold pull-up

# enable pad hold in deep-sleep for non-RTC GPIO
esp32.gpio_deep_sleep_hold(True)

# put the device to sleep for 10 seconds
deepsleep(10000)

 

 

패드 홀드를 포함한 핀 구성은 절전 모드에서 깨어날 때에도 유지됩니다. 패드 홀딩에 대한 자세한 내용은 위의 핀 및 GPIO 부분을 참조하세요.

 

SD 카드

 

machine.SDCard를 참조하세요 .

 

import machine, os, vfs

# On original ESP32, slot 2 uses pins sck=18, cs=5, miso=19, mosi=23
sd = machine.SDCard(slot=2)
vfs.mount(sd, '/sd') # mount

os.listdir('/sd')    # list directory contents

vfs.umount('/sd')    # eject

 

 

RMT

 

RMT는 ESP32 전용으로, 12.5ns 분해능의 정확한 디지털 펄스를 생성할 수 있습니다. 자세한 내용은 esp32.RMT를 참조하세요 . 사용법은 다음과 같습니다.

 

import esp32
from machine import Pin

r = esp32.RMT(0, pin=Pin(18), clock_div=8)
r   # RMT(channel=0, pin=18, source_freq=80000000, clock_div=8)
# The channel resolution is 100ns (1/(source_freq/clock_div)).
r.write_pulses((1, 20, 2, 40), 0) # Send 0 for 100ns, 1 for 2000ns, 0 for 200ns, 1 for 4000ns

 

 

ESP32-C2 제품군에는 RMT 주변 장치가 포함되어 있지 않으므로 해당 SoC에서는 이 클래스를 사용할 수 없습니다.

 

OneWire 드라이버

 

OneWire 드라이버는 소프트웨어로 구현되며 모든 핀에서 작동합니다.

 

from machine import Pin
import onewire

ow = onewire.OneWire(Pin(12)) # create a OneWire bus on GPIO12
ow.scan()               # return a list of devices on the bus
ow.reset()              # reset the bus
ow.readbyte()           # read a byte
ow.writebyte(0x12)      # write a byte on the bus
ow.write('123')         # write bytes on the bus
ow.select_rom(b'12345678') # select a specific device by its ROM code

 

 

DS18S20 및 DS18B20 장치용 특정 드라이버가 있습니다.

 

import time, ds18x20
ds = ds18x20.DS18X20(ow)
roms = ds.scan()
ds.convert_temp()
time.sleep_ms(750)
for rom in roms:
    print(ds.read_temp(rom))

 

 

데이터 라인에 4.7kΩ 풀업 저항을 연결하세요. convert_temp()온도를 샘플링할 때마다 이 메서드를 호출해야 합니다.

 

NeoPixel 및 APA106 드라이버

 

네오픽셀 및 APA106 모듈을 사용하십시오:

 

from machine import Pin
from neopixel import NeoPixel

pin = Pin(0, Pin.OUT)   # set GPIO0 to output to drive NeoPixels
np = NeoPixel(pin, 8)   # create NeoPixel driver on GPIO0 for 8 pixels
np[0] = (255, 255, 255) # set the first pixel to white
np.write()              # write data to all pixels
r, g, b = np[0]         # get first pixel colour

 

APA106 드라이버는 NeoPixel을 확장하지만 내부적으로 다른 색상 순서를 사용합니다.

 

from apa106 import APA106
ap = APA106(pin, 8)
r, g, b = ap[0]

 

 

경고

 

기본적으로 NeoPixel은 더 널리 사용되는 800kHz 장치를 제어하도록 구성됩니다. NeoPixel 객체를 생성할 때 timing=0을 전달하면 다른 장치(일반적으로 400kHz)를 제어하기 위해 대체 타이밍을 사용할 수 있습니다.

 

NeoPixel의 저수준 구동을 위해서는 machine.bitstream을 참조하십시오. 이 저수준 드라이버는 기본적으로 RMT 채널을 사용합니다. 이를 구성하려면 RMT.bitstream_channel을 참조하십시오.

 

APA102(DotStar)는 추가 클록 핀이 있어서 다른 드라이버를 사용합니다.

 

정전식 터치

 

ESP32, ESP32-S2 및 ESP32-S3는 기계 모듈의 TouchPad 클래스를 통해 정전식 터치를 지원합니다:

 

from machine import TouchPad, Pin

t = TouchPad(Pin(14))
t.read()              # Returns a smaller number when touched

 

 

TouchPad.read는 핀과 보드의 접지 연결 사이의 정전용량에 비례하는 값을 반환합니다. ESP32에서는 핀(또는 연결된 터치 패드)이 터치될 때 숫자가 작아지며, ESP32-S2 및 ESP32-S3에서는 핀이 터치될 때 숫자가 커집니다.

 

모든 경우에 터치는 반환 값에 상당한 변화를 일으킵니다. 반환 값은 상대적 이며 보드 및 주변 환경에 따라 달라질 수 있으므로 보정(예: 기준선 또는 이동 평균과의 비교)이 필요할 수 있습니다.

 

Chip	Touch-enabled pins
ESP32	0, 2, 4, 12, 13, 14, 15, 27, 32, 33
ESP32-S2	1 to 14 inclusive
ESP32-S3	1 to 14 inclusive

 

 

다른 핀에 할당하려고 하면 ValueError. 이 발생합니다.

 

터치패드를 사용하면 ESP32를 절전 모드에서 깨울 수 있습니다.

 

import machine
from machine import TouchPad, Pin
import esp32

t = TouchPad(Pin(14))
t.config(500)               # configure the threshold at which the pin is considered touched
esp32.wake_on_touch(True)
machine.lightsleep()        # put the MCU to sleep until a touchpad is touched

 

 

터치패드에 대한 자세한 내용은 Espressif Touch Sensor를 참조하세요 .

 

DHT 드라이버

 

DHT 드라이버는 소프트웨어로 구현되며 모든 핀에서 작동합니다.

 

import dht
import machine

d = dht.DHT11(machine.Pin(4))
d.measure()
d.temperature() # eg. 23 (°C)
d.humidity()    # eg. 41 (% RH)

d = dht.DHT22(machine.Pin(4))
d.measure()
d.temperature() # eg. 23.6 (°C)
d.humidity()    # eg. 41.3 (% RH)

 

 

WebREPL(웹 브라우저 대화형 프롬프트)

 

WebREPL(웹 브라우저를 통해 접근 가능한 웹소켓 기반 REPL)은 ESP32 포트에서 사용 가능한 실험적 기능입니다. https://github.com/micropython/webrepl (호스팅 버전은 http://micropython.org/webrepl 에서 이용 가능 )에서 웹 클라이언트를 다운로드하고 다음을 실행하여 설정하세요.

 

import webrepl_setup

 

화면의 지시를 따르세요. 재부팅 후 연결이 가능합니다. 부팅 시 자동 시작을 비활성화한 경우, 다음을 사용하여 구성된 데몬을 필요에 따라 실행할 수 있습니다.

 

import webrepl
webrepl.start()

# or, start with a specific password
webrepl.start(password='mypass')

 

 

WebREPL 데몬은 STA 또는 AP 등 모든 활성 인터페이스를 수신합니다. 이를 통해 라우터(STA 인터페이스)를 통해 ESP32에 연결하거나 액세스 포인트에 직접 연결할 수 있습니다.

 

WebREPL은 터미널/명령 프롬프트 접근 외에도 파일 전송(업로드 및 다운로드) 기능을 제공합니다. 웹 클라이언트에는 해당 기능 버튼이 있으며, webrepl_cli.py위 저장소의 명령줄 클라이언트를 사용할 수도 있습니다.

 

ESP32 보드로 파일을 전송하기 위한 다른 커뮤니티 지원 대안은 MicroPython 포럼을 참조하세요.