micropython开发与实战阅读笔记

对本文的一些说明
本文来源于阅读《MicroPython开发与实战》时所做的笔记，这本书不是很厚，所以内容也不是很全面，但作为一个入门工具书还是够的，再由于本人不是这方面的大佬，也不是这个专业的，所做的笔记也必然不是很全面，这仅是我本人阅读笔记，放出来希望能帮助到一些刚入门的ESP32学者。

本人使用的开发板是合宙esp32c3，书籍使用的是NodeMCU-32S，大部分只是引脚不同和资源个数不同，资源的使用方法是相通的，我对部分代码参数进行调整以适配合宙esp32c3，如果有使用其他型号开发板的学者，也可以很容易复现代码。
书中部分代码我在开发板上无法运行成功，对此类代码已做标注

书籍情况介绍，本书共262页
1~12MPy介绍及Python安装，占比4.6%，累计4.6%
13~125讲解Python语法，占比43.1%，累计47.7%
126~172讲通过MPy使用WIFI,PWM,ADC,定时器，UART，SPI(ADC和SPI仅作必要介绍)，占比17.94%，累计65.65%
后面讲的MQTT连接阿里云，MPy for STM32F4，暂未看到，先不写。

初始环境配置

下载对应的micropython固件
pip install esptool
清空flash: esptool.py --chip esp32c3 --port COM? erase_flash
烧写固件：esptool.py --chip esp32c3 --port COM? --baud 460800 write_flash -z 0x0 esp32c3-xxx.bin
写代码，注意utf-8编码,main.py
cp ./main.py /pyboard/
pip install rshell，安装完成后rshell --buffer-size 512 --editor D:\programfiles\notepad++\notepad++.exe -p COM?
repl并重启开发板，可以看到输出信息
由于每次都要重新输入rshell的一长串命令，十分不便，所以想写成一个bat脚本，但是由于从未接触过bat命令，从网上找了不少，又结合AI，勉强拼凑出一份能用的脚本
conn.bat文件内容，该文件会调用下面的getCOM.bat文件

@echo off  
chcp 65001
call getCOM.bat
setlocal EnableDelayedExpansion  :: 获取用户输入的COM端口号  
set /p "port=请输入COM端口号: "  :: 移除用户输入中可能的前导"COM"字符串  
set "COM_PORT=!port:COM=!"  :: 如果用户没有输入"COM"，则添加前缀  
if not "!COM_PORT:~0,3!"=="COM" set "COM_PORT=COM!COM_PORT!"  :: 调用rshell命令，使用用户输入的COM端口  
rshell --buffer-size 512 --editor "D:\programfiles\notepad++\notepad++.exe" -p !COM_PORT!  goto :EOF

getCOM.bat内容

@echo off
setlocal:: wmic /format:list strips trailing spaces (at least for path win32_pnpentity)
for /f "tokens=1* delims==" %%I in ('wmic path win32_pnpentity get caption /format:list ^| find "COM"') do (call :setCOM "%%~J"
):: display all _COM* variables
set _COM:: end main batch
goto :EOF:setCOM <WMIC_output_line>
:: sets _COM#=line
setlocal
set "str=%~1"
set "num=%str:*(COM=%"
set "num=%num:)=%"
set str=%str:(COM=&rem.%
endlocal & set "_COM%num%=%str%"
goto :EOF

现象截图

如果我有任何错误及改进意见，欢迎指出！

esp32网络基础使用

import networksta_if = network.WLAN(network.STA_IF)    #STA模式
ap_if = network.WLAN(network.AP_IF)     #AP模式

使用以下命令检查接口是否有效

sta_if.active()
ap_if.active()

连接WIFI

#首先激活station接口
sta_if.active(True)
#然后连接到网络
sta_if.connect("WIFI名","WIFI密码")

使用以下命令检查连接是否建立sta_if.isconnected()

查看IPsta_if.ifconfig()

开机自动连接WIFI

下面的函数可以自动运行并连接到WIFI网络，放入boot.py可以自启动

def  do_connect():import networksta_if = network.WLAN(network.STA_IF)if not sta_if.isconnected():print('connecting to network...')sta_if.active(True)sta_if.connect("WIFI名","WIFI密码")while not sta_if.isconnected():passprint('network config:', sta_ifconfig())

获取系统时间

import time
time.localtime()

此方法获取的并不是当前真正的时间，若需获取准确时间，可以用MPY的ntptime时间同步模块，从服务器校准时间

ntptime.settime(timezone = 8,server = 'ntp.ntsc.ac.cn')为默认参数，可以自己修改,目前感觉似乎没有参数

import time
import ntptime
print(f'同步前本地时间{str(time.localtime())}')
ntptime.settime()
print(f'同步后本地时间{str(time.localtime())}')

网上找的

import ntptime
def sync_ntp():ntptime.NTP_DELTA = 3155644800   # 可选 UTC+8偏移时间（秒），不设置就是UTC0ntptime.host = 'ntp1.aliyun.com'  # 可选，ntp服务器，默认是"pool.ntp.org"ntptime.settime()   # 修改设备时间,到这就已经设置好了sync_ntp()

get请求

import urequests
a = urequests.get("http://www.baidu.com")
a.text

socket模块

socket模块的宏

宏	名称	含义
socket.AF_INET	地址簇	TCP/IP-IPV4
socket.AF_INET6	地址簇	TCP/IP-IPV6
socket.SOCK_STREAM	套接字类型	TCP流
socket.SOCK_DGRAM	套接字类型	UDP数据报
socket.SOCK_RAW	套接字类型	原始套接字
socket.SO_REUSEADDR	套接字选项	允许重用地址
socket.IPPROTO_TCP	IP协议号	TCP协议
socket.IPPROTO_UDP	IP协议号	UDP协议
socket.SOL_SOCKET	套接字选项等级	套接字选项

socket模块的API

1.socket.getaddrinfo(host, port)
将主机域名和端口转换为用于创建套接字的5元组序列
(family, type, proto, canonname, sockaddr)

>>> info = socket.getaddrinfo("172.0.0.1",80)
>>> info
[(2, 1, 0, '172.0.0.1', ('172.0.0.1', 80))]

2.socket.socket([af, type, proto])
创建套接字
af:地址，type:类型，proto:协议号
一般不指定proto

>>> s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
>>> print(s)
>>> print(s)
<socket>

3.socket.bind(address)
以列表或元组方式绑定地址和端口号
address:一个包含地址和端口号的元组或列表

addr = ("127.0.0.1", 10000)
s.bind(addr)

4.socket.listen([backlog])
监听套接字，使服务器能够接收连续
backlog:接收套接字的最大个数，有默认值

s.listen(100)

5.socket.accept()
阻塞接收连接请求，只能在绑定地址端口号和监听后调用，返回conn和address
返回值：conn:新的套接字对象，可以用来收发消息
address:连接到服务器的客户端地址

conn, address = s.accept()

6.socket.connect(address)
连接服务器
address:服务器地址和端口号的元组或列表

host = "192.168.3.147"
port = 100
s.connect((host, port))

7.socket.send(bytes)
发送数据，并返回发送的字节数。
bytes:bytes类型数据

s.send("hello, I am TCP Client")

8.socket.recv(bufsize)
接收数据，并返回接收到的数据对象
bufsize: 接收数据的最大字节数

data = conn.recv(1024)

9.socket.close()
关闭套接字

s.close()

利用socket下载网页数据

使用socket定义一个可以下载和打印URL的函数

# 目前似乎无法成功
import socket
def httpGet(url):_,_,host,path = url.split('/', 3)addr = socket.getaddrinfo(host, 80)[0][-1]s = socket.socket()s.connect(addr)s.send(bytes('GET /%s HTTP/1.0\r\nHost: %s\r\n\r\n' % (path, host), 'utf8'))while True:data = s.recv(100)if data:print(str(data, 'utf8'), end='')else:breaks.close()# 函数使用httpGet('http://www.baidu.com/')

利用socket实现ESP32的网络通信

esp32与PC须在同一局域网内

电脑端代码

import socket
import _threaddef tcplink(conn, addr):print('addr:',addr)print('conn',conn)while 1:data = conn.recv(1024)#防止对面断线连接没关掉if not data:breakprint('msg:', str(data,"utf-8"))conn.close()sock_tcp = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock_tcp.bind(('0.0.0.0', 6000))
sock_tcp.listen(100)
print('listening')
while 1:conn, addr = sock_tcp.accept()_thread.start_new_thread(tcplink, (conn, addr))

ESP32端代码

import socket
import _threadsock_tcp = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock_tcp.connect(("电脑IP地址172.26.96.101", 6000))
sock_tcp.sendall(bytes("i am zzp!", "utf-8"))

硬件控制

Pin例程

from machine import Pin
D4 = Pin(12, Pin.OUT)
led.value([x])# 可读可写
led.on()
led.off()

延时

utime模块
utime.sleep(s)
utime.sleep_ms(ms)
utime.sleep_us(us)

import utime
utime.sleep_ms(500) #延时500ms

控制LED闪烁

import utime
from machine import PinD4 = Pin(12, Pin.OUT)
# 循环10次亮灭
for i in range(10):D4.value(1)utime.sleep_ms(500)D4.value(0)utime.sleep_ms(500)

PWM脉宽调制技术-呼吸灯

ESP32的占空比(duty)不是百分比而是一个分辨率，范围0~1023

from machine import Pin, PWM
D4 = Pin(2, Pin.OUT)
# 把Pin对象传入PWM构造器
D4 = PWM(D4) #也可以直接初始化，D4 = PWM(D4, freq=1000, duty=500)

方法

PWM.init(freq, duty)
PWM.freq([freq_val]) 可读可写
PWM.duty([duty_val]) 可读可写
PWM.deinit() 释放PWM对象

PWM控制LED亮度

把下列代码保存为pwm_led.py

from machine import Pin, PWM
class PWM_LED:def __init__(self,pinNum,freq=1000):pin = Pin(pinNum,Pin.OUT)self.pwm = PWM(pin,freq=freq)def change_duty(self,duty):self.pwm.duty(duty)def deinit(self):self.pwm.deinit()

呼吸灯

import machine, utime, math
from pwm_led import *
from machine import Pinpwm_led = PWM_LED(12)
def pulse(switch, period, gears):# 呼吸灯核心代码# 借用sin正弦函数，将PWM范围控制在23~1023# switch开关对象# period呼吸一次的周期，单位ms#gears呼吸过程经历的亮度档位数for i in range(2*gears):switch.change_duty(int(math.sin(i/gears*math.pi)*500)+523)# 延时utime.sleep_ms(int(period/(2*gears)))# 呼吸10次
for i in range(10):pulse(pwm_led, 2000, 100)
# 释放资源
pwm_led.deinit()

ADC例程

构造对象

classmachine.ADC(pin)
创建与设定引脚关联的ADC对象。用户可以读取该引脚上的模拟值
Pin:ADC在专用因脚伤可以用

from machine import ADC, Pin
adc = ADC(Pin(0))

方法

ADC.atten(db)设置ADC衰减量，即设置输入范围，未设置默认为1V

宏定义	衰减量/db	数值	满量程电压
ADC.ATTN_0DB	0	0	1
ADC.ATTN_2_5DB	2.5	1	1.5
ADC.ATTN_6DB	6	2	2
ADC.ATTN_11DB	11	3	3.3

ADC.width(bit)设置分辨率

宏定义	数值	满量程
ADC.WIDTH_9BIT	0	511
ADC.WIDTH_10BIT	1	1023
ADC.WIDTH_11BIT	2	2047
ADC.WIDTH_12BIT	3	4095

ADC.read()读取ADC值并返回读取结果

RTC例程

RTC是独立的时钟，可以跟踪日期和时间

构造对象

classmachine.RTC()创建RTC对象

初始化RTC时间

RTC.init([datetimetuple])
元组(年，月，日，周(0~6)，时，分，秒，毫秒)
rtc.init((2024, 4, 17, 2, 15, 50, 40, 0))

查看RTC时间

RTC.init([datetimetuple])
未给参数则读取时间

缺陷：每过7h45min就会有秒级别的误差，所以建议每隔7小时校准一次时间

Timer例程

构造对象

class machine.Timer(id,...)构造给定id的新计时器对象，id为任意正数

初始化定时器

Timer.init(*, mode=Timer.PERIODIC, period=-1,callback=None)
mode是定时器模式之一
- Timer.ONE_SHOT:计时器运行一次
- Timer.PERIODIC:计时器运行多次

period:定时时间，0~3 435 973 836ms
callback:回调函数
示例代码：tim.init(mode=Timer.ONE_SHOT, period=1000, callback=lambda t:print('haha))

释放定时器资源

Timer.deinit()取消定时器初始化，停止计时器，并禁用计时器外围设备

定时器控制LED闪烁

示例代码

from machine import Timer, Pin
import utime
def toggle_led(led_pin):# LED翻转led_pin.value(not led_pin.value())
def led_blink_timed(timer, led_pin, freq):"""led按照特定的频率闪烁LED闪烁周期 = 1000ms/2状态变换时间间隔(period) = LED闪烁周期/2"""# 计算状态变换时间间隔period = int(1000/freq/2)#初始化定时器# 这里回调是使用了lambda表达式，因为回调函数需要传入led_pintimer.init(period=period, mode=Timer.PERIODIC, callback=lambda t:toggle_led(led_pin))
# 声明D4作为LED引脚
led_pin = Pin(12, Pin.OUT)
timer = Timer(0) # 创建定时器对象,实测1不好使
led_blink_timed(timer, led_pin, freq=20)

串口UART例程

合宙esp32c3
UART0_RX:08 UART0_TX:09
UART1_RX:01 UAER1_TX:00

构造对象

class machine.UART(id, baudrate, bits, parity, rx, tx, stop, timeout)
id:串口编号
bandrate:波特率
bits:数据位，默认8，可选7，9
parity:校验方式，默认None不校验，0偶校验，1奇校验
rx:接收口的GPIO编号
tx:发送口的GPIO编号
stop:停止位，默认1，可选2
timeout:超时时间，0~2 147 483 647

>>> from machine import UART
>>> u = UART(1)
>>> print(u)
UART(1, baudrate=115211, bits=8, parity=None, stop=1, tx=10, rx=9, rts=-1, cts=-1, txbuf=256, rxbuf=256, timeout=0, timeout_char=0)

方法

UART.read([nbytes]):读字符，参数可选，为最多读取字节数，否则尽可能读取多的数据
返回值：包含读入的字节的字节对象，超时返回None
UART.readinto(buf[, nbytes]):将字节读入buf.
返回读取并写入到buf的字节数，超时返回None
UART.readline():读一行，读到换行符结束，超时返回None
UART.write(buf):串口发送数据，返回发送的字节数，超时返回None
UART.any():检查是否有可读的数据，返回可读数据长度

ESP32串口通信——字符串自收发实验

将UART1的TX和RX连接起来，在合宙esp32c3中就是IO00和IO01连接

from machine import UART, Timer
import select, time# 创建一个UART对象，将引脚0和引脚1相连
uart = UART(1, baudrate=9600, tx=01, rx=00)
# 创建一个Timer,使用中断来轮询串口是否有数据可读
timer = Timer(0)
timer.init(period=50,mode=Timer.PERIODIC, callback=lambda t:read_uart(uart))def read_uart(uart):if uart.any():print('received:'+uart.read().decode()+'\n')if __name__ == '__main__':try:for i in range(10):uart.write(input('send:'))time.sleep_ms(50)except:timer.deinit()

SPI例程

构造对象

硬件SPI

HSPI后遭，代码如下

>>> from machine import SPI
>>> hspi = SPI(1)
>>> print(hspi)
SPI(id=1, baudrate=500000, polarity=0, phase=0, bits=8, firstbit=0, sck=6, mosi=7, miso=2)

软件SPI

方法1：类构造

SPI(baudrate, polarity, phase, bits, firstbit, sck, mosi, miso)
baudrate:SCK时钟频率，范围0~0x0FFFFFFF(2 147 483 647)
polarity:极性，分为以下两种情况：
- 0：空闲电平：底
- 1：空闲电平：高
  phase:相位，分为以下两种情况：
- 0:在第一时钟沿采集数据
- 1:在第二时钟沿采集数据
  bits:数据位
  firstbit:从地位向高位发还是从高位往低位发
  sck:时钟引脚
  mosi:主设备出，从设备入引脚
  miso:主设备入，从设备出引脚

from machine import SPI, Pin
spi = SPI(baudrate=115200, polarity=1, phase=0, sck=Pin(17), mosi=Pin(27), miso=Pin(18))

方法2:使用init构造

SPI.init(baudrate, polarity, phase, sck, mosi, miso)
初始化SPI总线

from machine import SPI, Pin
spi = SPI.init(baudrate=115200, polarity=1, phase=0, sck=Pin(17), mosi=Pin(27), miso=Pin(18))

方法

SPI.deinit():关闭SPI总线
SPI.read(nbytes, write=0x00)：读取由nbytes指定的字节数，同时连续写入由write给定的单字节
(Read a number of bytes specified by nbytes while continuously writing the single byte given by write. Returns a bytes object with the data that was read.)
SPI.readinto(buf, write=0x00)：读入由buf指定的缓冲区，同时不断写入由write给定的单字节。返回读取的字节数
SPI.write(buf)：写入buf中的字节，返回写入的字节数
SPI.write_readinto(write_buf, read_buf)
从write_buf中写入字节，同时读入read_buf中。缓冲区可以是相同的，也可以不同，但是两个缓冲区都必须有相同长度，
返回写入的字节数