【得捷Follow me第3期】项目最终汇总贴

SeasonMay · 发表于2023-12-14 17:53

【得捷Follow me第3期】项目最终汇总贴 [复制链接]

<i class="pstatus"> 本帖最后由 SeasonMay 于 2023-12-14 23:41 编辑 </i>

## 演示视频链接
https://training.eeworld.com.cn/video/38615

## 1.固件烧录使用MicroPython系统（必做任务）

熟悉Seeed Studio XIAO ESP32C3开发板基本操作，安装esptool，并给开发板刷写MicroPython系统，完成入门程序的运行
这里采用Thonny环境搭建micropython
下载安装Thonny，我这里是直接下载的最新版本的IDE

链接：https://thonny.org/

进入IDE，用A2C的线连接开发板和电脑，右下角会出现mpy的解释器选项

<ignore_js_op>

<a href="javascript:;" onclick="showWindow(this.id, this.getAttribute('url'), 'get', 0);" id="savephoto_763735" url="home.php?mod=spacecp&ac=album&op=saveforumphoto&aid=763735&handlekey=savephoto_763735">保存到相册</a>

</p>

</div>
<div class="tip_horn"></div>
</div>

</ignore_js_op>

要烧录固件，需要进入烧录模式，我采用的方法为上电前按住boot键（板载丝印B旁边的按钮），然后上电后松开按键，即可进入。

在烧录前，先在官网下载esp32-c3 micropython固件，我这里下载的是最新的1.21.0版本的固件

链接：https://micropython.org/download/ESP32_GENERIC_C3/

点击“三”按钮，点击select local micropython image

<ignore_js_op>

<a href="javascript:;" onclick="showWindow(this.id, this.getAttribute('url'), 'get', 0);" id="savephoto_763736" url="home.php?mod=spacecp&ac=album&op=saveforumphoto&aid=763736&handlekey=savephoto_763736">保存到相册</a>

</p>

</div>
<div class="tip_horn"></div>
</div>

</ignore_js_op>

然后勾选target port和解释器的路径一致，再点击安装即可，等到“Done！”出现，没有报错时，固件烧录即为完成。

<ignore_js_op>

<a href="javascript:;" onclick="showWindow(this.id, this.getAttribute('url'), 'get', 0);" id="savephoto_763737" url="home.php?mod=spacecp&ac=album&op=saveforumphoto&aid=763737&handlekey=savephoto_763737">保存到相册</a>

</p>

</div>
<div class="tip_horn"></div>
</div>

</ignore_js_op>

拔掉数据线，重新连接电脑，不再进入烧录模式。注意右下角解释器选择esp32的而非本机的

跑一个经典例程，至此mpy环境搭建完成

<ignore_js_op>

<a href="javascript:;" onclick="showWindow(this.id, this.getAttribute('url'), 'get', 0);" id="savephoto_763738" url="home.php?mod=spacecp&ac=album&op=saveforumphoto&aid=763738&handlekey=savephoto_763738">保存到相册</a>

</p>

</div>
<div class="tip_horn"></div>
</div>

</ignore_js_op>

## 2.驱动扩展板上的OLED屏幕（必做任务）使用扩展板上的OLED屏幕显示文字和图形

seeed xiao micropython官方文档链接：

https://wiki.seeedstudio.com/XIAO_ESP32C3_MicroPython/

在做显示任务的时候，一开始我按照官方文档打算直接在Thonny里配置并使用SSD1306

<ignore_js_op>

<a href="javascript:;" onclick="showWindow(this.id, this.getAttribute('url'), 'get', 0);" id="savephoto_763739" url="home.php?mod=spacecp&ac=album&op=saveforumphoto&aid=763739&handlekey=savephoto_763739">保存到相册</a>

</p>

</div>
<div class="tip_horn"></div>
</div>

</ignore_js_op>

但是搜索到SSD1306的库后安装时，一直报错如下：

<ignore_js_op>

<a href="javascript:;" onclick="showWindow(this.id, this.getAttribute('url'), 'get', 0);" id="savephoto_763740" url="home.php?mod=spacecp&ac=album&op=saveforumphoto&aid=763740&handlekey=savephoto_763740">保存到相册</a>

</p>

</div>
<div class="tip_horn"></div>
</div>

</ignore_js_op>

尝试了降低Thonny或者MicroPython的版本后，也还是不行，于是我就直接去复制了一份SSD1306的库文件直接放到ESP32的设备上，不过很多方法还是欠缺，因此我加了几个要用到的：

SSD1306.py:

```python
#MicroPython SSD1306 OLED driver, I2C and SPI interfaces created by Adafruit

import time
import framebuf

# register definitions
SET_CONTRAST  = const(0x81)
SET_ENTIRE_ON   = const(0xa4)
SET_NORM_INV  = const(0xa6)
SET_DISP    = const(0xae)
SET_MEM_ADDR  = const(0x20)
SET_COL_ADDR  = const(0x21)
SET_PAGE_ADDR   = const(0x22)
SET_DISP_START_LINE = const(0x40)
SET_SEG_REMAP   = const(0xa0)
SET_MUX_RATIO   = const(0xa8)
SET_COM_OUT_DIR = const(0xc0)
SET_DISP_OFFSET = const(0xd3)
SET_COM_PIN_CFG = const(0xda)
SET_DISP_CLK_DIV  = const(0xd5)
SET_PRECHARGE   = const(0xd9)
SET_VCOM_DESEL  = const(0xdb)
SET_CHARGE_PUMP = const(0x8d)

class SSD1306:
  def __init__(self, width, height, external_vcc):
  self.width = width
  self.height = height
  self.external_vcc = external_vcc
  self.pages = self.height // 8
  # Note the subclass must initialize self.framebuf to a framebuffer.
  # This is necessary because the underlying data buffer is different
  # between I2C and SPI implementations (I2C needs an extra byte).
  self.poweron()
  self.init_display()

def init_display(self):
  for cmd in (
    SET_DISP | 0x00, # off
    # address setting
    SET_MEM_ADDR, 0x00, # horizontal
    # resolution and layout
    SET_DISP_START_LINE | 0x00,
    SET_SEG_REMAP | 0x01, # column addr 127 mapped to SEG0
    SET_MUX_RATIO, self.height - 1,
    SET_COM_OUT_DIR | 0x08, # scan from COM[N] to COM0
    SET_DISP_OFFSET, 0x00,
    SET_COM_PIN_CFG, 0x02 if self.height == 32 else 0x12,
    # timing and driving scheme
    SET_DISP_CLK_DIV, 0x80,
    SET_PRECHARGE, 0x22 if self.external_vcc else 0xf1,
    SET_VCOM_DESEL, 0x30, # 0.83*Vcc
    # display
    SET_CONTRAST, 0xff, # maximum
    SET_ENTIRE_ON, # output follows RAM contents
    SET_NORM_INV, # not inverted
    # charge pump
    SET_CHARGE_PUMP, 0x10 if self.external_vcc else 0x14,
    SET_DISP | 0x01): # on
    self.write_cmd(cmd)
  self.fill(0)
  self.show()

def poweroff(self):
  self.write_cmd(SET_DISP | 0x00)

def contrast(self, contrast):
  self.write_cmd(SET_CONTRAST)
  self.write_cmd(contrast)

def invert(self, invert):
  self.write_cmd(SET_NORM_INV | (invert & 1))

def show(self):
  x0 = 0
  x1 = self.width - 1
  if self.width == 64:
    # displays with width of 64 pixels are shifted by 32
    x0 += 32
    x1 += 32
  self.write_cmd(SET_COL_ADDR)
  self.write_cmd(x0)
  self.write_cmd(x1)
  self.write_cmd(SET_PAGE_ADDR)
  self.write_cmd(0)
  self.write_cmd(self.pages - 1)
  self.write_framebuf()

def fill(self, col):
  self.framebuf.fill(col)

def pixel(self, x, y, col):
  self.framebuf.pixel(x, y, col)

def scroll(self, dx, dy):
  self.framebuf.scroll(dx, dy)

def text(self, string, x, y, col=1):
  self.framebuf.text(string, x, y, col)
  # 下面几个方法自加，非官方提供
  def rect(self,x,y,w,h,c):
  self.framebuf.rect(x, y, w, h, c)
  
  def fill_rect(self,x,y,w,h,c):
  self.framebuf.fill_rect(x, y, w, h, c)
  
  def hline(self,x,y,w,c):
  self.framebuf.hline(x,y,w,c)
  
  def vline(self,x,y,h,c):
  self.framebuf.hline(x,y,h,c)
  
  def line(self,x1,y1,x2,y2,c):
  self.framebuf.line(x1,y1,x2,y2,c)
  
  def circle(self, center_x, center_y, radius, color):
  """Draw a circle at the given midpoint location, radius and color.
  The ```circle```method draws only a 1 pixel outline."""
  x = radius - 1
  y = 0
  d_x = 1
  d_y = 1
  err = d_x - (radius << 1)
  while x >= y:
    self.pixel(center_x + x, center_y + y, color)
    self.pixel(center_x + y, center_y + x, color)
    self.pixel(center_x - y, center_y + x, color)
    self.pixel(center_x - x, center_y + y, color)
    self.pixel(center_x - x, center_y - y, color)
    self.pixel(center_x - y, center_y - x, color)
    self.pixel(center_x + y, center_y - x, color)
    self.pixel(center_x + x, center_y - y, color)
    if err <= 0:
      y += 1
      err += d_y
      d_y += 2
    if err > 0:
      x -= 1
      d_x += 2
      err += d_x - (radius << 1)

class SSD1306_I2C(SSD1306):
  def __init__(self, width, height, i2c, addr=0x3c, external_vcc=False):
  self.i2c = i2c
  self.addr = addr
  self.temp = bytearray(2)
  # Add an extra byte to the data buffer to hold an I2C data/command byte
  # to use hardware-compatible I2C transactions.A memoryview of the
  # buffer is used to mask this byte from the framebuffer operations
  # (without a major memory hit as memoryview doesn't copy to a separate
  # buffer).
  self.buffer = bytearray(((height // 8) * width) + 1)
  self.buffer[0] = 0x40# Set first byte of data buffer to Co=0, D/C=1
  self.framebuf = framebuf.FrameBuffer1(memoryview(self.buffer)[1:], width, height)
  super().__init__(width, height, external_vcc)

def write_cmd(self, cmd):
  self.temp[0] = 0x80 # Co=1, D/C#=0
  self.temp[1] = cmd
  self.i2c.writeto(self.addr, self.temp)

def write_framebuf(self):
  # Blast out the frame buffer using a single I2C transaction to support
  # hardware I2C interfaces.
  self.i2c.writeto(self.addr, self.buffer)

def poweron(self):
  pass

class SSD1306_SPI(SSD1306):
  def __init__(self, width, height, spi, dc, res, cs, external_vcc=False):
  self.rate = 10 * 1024 * 1024
  dc.init(dc.OUT, value=0)
  res.init(res.OUT, value=0)
  cs.init(cs.OUT, value=1)
  self.spi = spi
  self.dc = dc
  self.res = res
  self.cs = cs
  self.buffer = bytearray((height // 8) * width)
  self.framebuf = framebuf.FrameBuffer1(self.buffer, width, height)
  super().__init__(width, height, external_vcc)

def write_cmd(self, cmd):
  self.spi.init(baudrate=self.rate, polarity=0, phase=0)
  self.cs.high()
  self.dc.low()
  self.cs.low()
  self.spi.write(bytearray([cmd]))
  self.cs.high()

def write_framebuf(self):
  self.spi.init(baudrate=self.rate, polarity=0, phase=0)
  self.cs.high()
  self.dc.high()
  self.cs.low()
  self.spi.write(self.buffer)
  self.cs.high()

def poweron(self):
  self.res.high()
  time.sleep_ms(1)
  self.res.low()
  time.sleep_ms(10)
  self.res.high()
```

然后新开一个py文件，测试一下：

```python
import time
from machine import Pin, SoftI2C
import ssd1306
import math

# Pin assignment
i2c = SoftI2C(scl=Pin(7), sda=Pin(6))
oled_width = 128
oled_height = 64
oled = ssd1306.SSD1306_I2C(oled_width, oled_height, i2c)

oled.fill(0)# Clear the screen
oled.text("Hello, ESP32-C3", 10, 15)
oled.text("/////", 30, 40)
oled.text("(`3`)y", 30, 55)
oled.show()# Show the text
```

点击运行，效果如下：

<ignore_js_op>

<a href="javascript:;" onclick="showWindow(this.id, this.getAttribute('url'), 'get', 0);" id="savephoto_763741" url="home.php?mod=spacecp&ac=album&op=saveforumphoto&aid=763741&handlekey=savephoto_763741">保存到相册</a>

</p>

</div>
<div class="tip_horn"></div>
</div>

</ignore_js_op>

显示图形，比如画个简单的小圆圈：

```python
import time
from machine import Pin, SoftI2C
import ssd1306
import math

# Pin assignment
i2c = SoftI2C(scl=Pin(7), sda=Pin(6))# Adjust the Pin numbers based on your connections
oled_width = 128
oled_height = 64
oled = ssd1306.SSD1306_I2C(oled_width, oled_height, i2c)

center_x = oled_width // 2
center_y = oled_height // 2

oled.fill(0)# Clear the screen
oled.circle(center_x,center_y,30,1)
oled.show()# Show the text
```

<ignore_js_op>

<a href="javascript:;" onclick="showWindow(this.id, this.getAttribute('url'), 'get', 0);" id="savephoto_763743" url="home.php?mod=spacecp&ac=album&op=saveforumphoto&aid=763743&handlekey=savephoto_763743">保存到相册</a>

</p>

</div>
<div class="tip_horn"></div>
</div>

</ignore_js_op>

在此基础上，再看看动态显示效果，修改下官方例程：

```python
import time
from machine import Pin, SoftI2C
import ssd1306
import math

# Pin assignment
i2c = SoftI2C(scl=Pin(7), sda=Pin(6))# Adjust the Pin numbers based on your connections
oled_width = 128
oled_height = 64
oled = ssd1306.SSD1306_I2C(oled_width, oled_height, i2c)

center_x = oled_width // 2
center_y = oled_height // 2
square_size = 6# Size of each square
num_squares = 12# Number of squares
angle_increment = 2 * math.pi / num_squares

while True:
  oled.fill(0)# Clear the screen
  oled.circle(center_x+2,center_y+2,20,1)
  for i in range(num_squares):
  angle = i * angle_increment
  x = int(center_x + (center_x - square_size-30) * math.cos(angle))
  y = int(center_y + (center_x - square_size-30) * math.sin(angle))
  
  # Draw all squares
  for j in range(num_squares):
    angle_j = j * angle_increment
    x_j = int(center_x + (center_x - square_size-30) * math.cos(angle_j))
    y_j = int(center_y + (center_x - square_size-30) * math.sin(angle_j))
    
    oled.fill_rect(x_j, y_j, square_size, square_size, 1)# Draw the square
  
  oled.fill_rect(x, y, square_size, square_size, 0)# Erase the current square
  oled.show()
  time.sleep_ms(100)# Pause before next iteration
```
演示效果的小视频可参考过程分享的帖子里

## 3.控制蜂鸣器播放音乐（必做任务）使用Seeed Studio XIAO ESP32C3控制蜂鸣器发出不同频率的声音，并播放一段音乐

查阅扩展板蜂鸣器连接的引脚是5，因此首先配置引脚：

```python
import machine
import time

# Buzzer settings
buzzer_pin = machine.Pin(5, machine.Pin.OUT)
buzzer = machine.PWM(buzzer_pin)
```

然后要让蜂鸣器响起，可通过调节驱动的pwm波的频率和占空比来实现

```python
# 调节频率
buzzer.freq(500)
# 设置占空比——调节音量大小，其中数值设置为0，则会静音
buzzer.duty(50)
```

按照这个规则，类似地，参照乐谱，可以简单播放音乐片段，这里以欢乐颂为例：
![763783](/data/attachment/forum/202312/14/180524m20iiv10v9i01w72.png.thumb.jpg?rand=3424.2227535050574)

```python
import machine
import time

# Buzzer settings
buzzer_pin = machine.Pin(5, machine.Pin.OUT)
buzzer = machine.PWM(buzzer_pin)
buzzer.freq(440)# 设置基础频率，例如 A4

# 定义音符频率
NOTE_G4 = 392
NOTE_A4 = 440
NOTE_B4 = 494
NOTE_C5 = 523
NOTE_D5 = 587
NOTE_E5 = 659
NOTE_F5 = 698
NOTE_G5 = 784

# 欢乐颂的音符和休止符
ode_to_joy_notes = [
  NOTE_E5, NOTE_E5, NOTE_F5, NOTE_G5, NOTE_G5, NOTE_F5, NOTE_E5, NOTE_D5,
  NOTE_C5, NOTE_C5, NOTE_D5, NOTE_E5, NOTE_E5, NOTE_D5, NOTE_D5,
  NOTE_E5, NOTE_E5, NOTE_F5, NOTE_G5, NOTE_G5, NOTE_F5, NOTE_E5, NOTE_D5,
  NOTE_C5, NOTE_C5, NOTE_D5, NOTE_E5, NOTE_D5, NOTE_C5, NOTE_C5,
  0,# 休止符，增加中间停顿
  NOTE_E5, NOTE_E5, NOTE_F5, NOTE_G5, NOTE_G5, NOTE_F5, NOTE_E5, NOTE_D5,
  NOTE_C5, NOTE_C5, NOTE_D5, NOTE_E5, NOTE_D5, NOTE_C5, NOTE_C5
]

# 持续时间（毫秒）
note_duration = 300
long_rest_duration = 500# 较长的休止符持续时间

def play_ode_to_joy():
  for note in ode_to_joy_notes:
  if note != 0:
    buzzer.duty(512)# 设置音量
    buzzer.freq(note)# 设置音符频率
  else:
    buzzer.duty(0)# 关闭声音
    time.sleep_ms(long_rest_duration)# 插入较长的休止符
  time.sleep_ms(note_duration)
  buzzer.duty(0)# 关闭声音

while True:
  # 播放《欢乐颂》
  play_ode_to_joy()
```
演示效果的小视频可参考过程分享的帖子里

## 4.连接WiFi网络（必做任务）将Seeed Studio XIAO ESP32C3连接到WiFi网络，并访问互联网信息

webrepl：[MicroPython-On-ESP8266——自动连接WIFI与开启webrepl_mircopython 自动连接wifi后怎么执行其他代码-CSDN博客](https://blog.csdn.net/fatway/article/details/118736979)

[使用MicroPython开发ESP32（04）：无线网络使用和WebREPL_开发esp32之组建无线ap-CSDN博客](https://blog.csdn.net/Naisu_kun/article/details/104049030)

XIAO开发板板载完整的WiFi子系统：符合IEEE 802.11b/g/n协议，支持Station模式、SoftAP模式、SoftAP+Station模式、混杂模式

在MicroPython中，`network.WLAN` 类提供了对Wi-Fi功能的访问。`network.WLAN(network.STA_IF)` 表示创建一个支持Wi-Fi站点（station）模式的WLAN对象。

在Wi-Fi通信中，有两种常见的模式：

1. **AP模式（Access Point，热点模式）：** 在这种模式下，设备充当Wi-Fi网络的访问点，允许其他设备连接到它并访问其提供的服务。
2. **Station模式：** 在这种模式下，设备通过Wi-Fi连接到现有的Wi-Fi网络，就像智能手机或计算机一样。设备可以获取IP地址，然后使用Wi-Fi访问互联网或局域网。

下面用station模式进行联网并通过OpenWeather获取南京地区的温度信息：

```python
import urequests
import json
import machine
import time
from machine import Pin, SoftI2C
import ssd1306
from time import sleep
import network
import ujson

# 设置I2C总线并初始化OLED
i2c = SoftI2C(scl=Pin(7), sda=Pin(6))
oled_width = 128
oled_height = 64
oled = ssd1306.SSD1306_I2C(oled_width, oled_height, i2c)

oled.text('Connecting', 10, 10)
oled.show()
# 连接到Wi-Fi网络：
station = network.WLAN(network.STA_IF)
station.active(True)

wifi_ssid = "WIFI 名称"
wifi_password = "WIFI 密码"
print("Scanning for WiFi networks, please wait...")

while not station.isconnected():
  print("Connecting...")
  station.connect(wifi_ssid, wifi_password)
  time.sleep(10)

# 连接成功后提示
print("Connected!")
print("My IP Address:", station.ifconfig()[0])
oled.text('IP Address:', 10, 20)
oled.text(f'{station.ifconfig()[0]}', 10, 30)
oled.show()

# OpenWeatherMap API配置
api_key = 'YOUR_API_KEY'
city = 'Nanjing'
country_code = 'CN'
unit = 'metric'# 使用摄氏度

# 构建API请求URL
weather_url = 'http://api.openweathermap.org/data/2.5/weather?q={},{}&units={}&appid={}'.format(city, country_code, unit, api_key)

# 发送HTTP GET请求
response = urequests.get(weather_url)
weather_data = json.loads(response.text)
print(weather_data)

# 解析响应并获取温度
if 'main' in weather_data and 'temp' in weather_data['main']:
  temperature = weather_data['main']['temp']
  print('Current Temperature in Nanjing:', temperature, 'Celsius')
  oled.text(f'NJ: {temperature} C', 10, 40)
  oled.show()
else:
  print('Failed to retrieve temperature data')
```

成功联网显示IP地址（我连的是手机热点）：

<ignore_js_op>

<a href="javascript:;" onclick="showWindow(this.id, this.getAttribute('url'), 'get', 0);" id="savephoto_763747" url="home.php?mod=spacecp&ac=album&op=saveforumphoto&aid=763747&handlekey=savephoto_763747">保存到相册</a>

</p>

</div>
<div class="tip_horn"></div>
</div>

</ignore_js_op>

后续联网成功后会调用api获取天气信息，我这里是获取的南京当前的温度信息

<ignore_js_op>

<a href="javascript:;" onclick="showWindow(this.id, this.getAttribute('url'), 'get', 0);" id="savephoto_763748" url="home.php?mod=spacecp&ac=album&op=saveforumphoto&aid=763748&handlekey=savephoto_763748">保存到相册</a>

</p>

</div>
<div class="tip_horn"></div>
</div>

</ignore_js_op>

## 5.使用外部传感器（必做任务）连接环境光传感器或温湿度传感器，获取传感器的数值，并转换成真实的物理量
这里我用的是温湿度传感器

首先安装个mpy的aht的库

PS：之前任务二直接安装ssd1306不行，后续发现thonny前几天更新了4.1.4版本，把这个包安装的问题修复了下，现在可以直接下载了。

<ignore_js_op>

<a href="javascript:;" onclick="showWindow(this.id, this.getAttribute('url'), 'get', 0);" id="savephoto_763753" url="home.php?mod=spacecp&ac=album&op=saveforumphoto&aid=763753&handlekey=savephoto_763753">保存到相册</a>

</p>

</div>
<div class="tip_horn"></div>
</div>

</ignore_js_op>

接线

<ignore_js_op>

<a href="javascript:;" onclick="showWindow(this.id, this.getAttribute('url'), 'get', 0);" id="savephoto_763754" url="home.php?mod=spacecp&ac=album&op=saveforumphoto&aid=763754&handlekey=savephoto_763754">保存到相册</a>

</p>

</div>
<div class="tip_horn"></div>
</div>

</ignore_js_op>

然后就是调库就完事了

代码：

```python
from ahtx0 import AHT20
import machine
from machine import Pin, SoftI2C
import ssd1306
import time
from time import sleep
import network
import ujson
import urequests
import json

# Oled init
i2c = machine.I2C(0, sda=Pin(6), scl=Pin(7), freq=400000)
oled = ssd1306.SSD1306_I2C(128, 64, i2c)

oled.text("Out Temp", 0, 0)
oled.text("Inside sensor:", 0, 16)
oled.text("Temp:", 0, 32)
oled.text("Humi:", 0, 48)
oled.show()

# aht20
aht = AHT20(i2c)
# 连接网络
station = network.WLAN(network.STA_IF)
station.active(True)

wifi_ssid = "YOUR_SSID"
wifi_password = "YOUR_PASSWORD"
print("Scanning for WiFi networks, please wait...")
# OpenWeatherMap API配置
api_key = 'YOUR_API_KEY'
city = 'Nanjing'
country_code = 'CN'
unit = 'metric'# 使用摄氏度

# 构建API请求URL
weather_url = 'http://api.openweathermap.org/data/2.5/weather?q={},{}&units={}&appid={}'.format(city, country_code, unit, api_key)

# 发送HTTP GET请求
response = urequests.get(weather_url)
weather_data = json.loads(response.text)
print(weather_data)

# 解析响应并获取温度
if 'main' in weather_data and 'temp' in weather_data['main']:
  temperature = weather_data['main']['temp']
  print('Current Temperature in Nanjing:', temperature, 'Celsius')
  oled.text(f'NJ: {temperature}', 65, 0)
  oled.show()
else:
  print('Failed to retrieve temperature data')

while not station.isconnected():
  print("Connecting...")
  station.connect(wifi_ssid, wifi_password)
  time.sleep(10)

# 连接成功后提示
print("Connected!")
print("My IP Address:", station.ifconfig()[0])

def aht20_show(aht):
  temp = aht.temperature
  humi = aht.relative_humidity

# print("\n")
  # print(temp)
  # print("\n")
  # print(humi)

# print("\n");
  # print('{:.2f}'.format(humi))
  oled.fill_rect(50, 32, 40, 30, 0)# 局部清屏
  oled.text('{:.2f}'.format(temp), 50, 32)
  oled.text('{:.2f}'.format(humi), 50, 48)
  oled.show()
  time.sleep(1)

while True:
  aht20_show(aht)
```
第一行的温度显示的是调用WeatherMap API得到的南京市户外的温度结果，下面的温湿度信息则是在室内（怕冷星人开了空调）使用传感器获得的数据

<ignore_js_op>

<a href="javascript:;" onclick="showWindow(this.id, this.getAttribute('url'), 'get', 0);" id="savephoto_763766" url="home.php?mod=spacecp&ac=album&op=saveforumphoto&aid=763766&handlekey=savephoto_763766">保存到相册</a>

</p>

</div>
<div class="tip_horn"></div>
</div>

</ignore_js_op>

## 6.综合实践（选做，非必做）：从以下任务要求中，任选一个完成，也可以根据自己的兴趣爱好和能力特长，自定义难度相仿的任务并完成。
闲着也是闲着，我就把三个任务都试了试
1.**分任务1：寻找WiFi发射源的位置**
实时测量WiFi信号强度，同时移动开发板位置，找到WiFi发射源（例如路由器）的位置。

官方的例程就很有意思，可以显示WIFI信号强度，从而获得大致的位置信息

代码：

```
import network
import time
from time import sleep
import machine
from machine import Pin, SoftI2C
import ssd1306
import math

# ESP32C3 Pin assignment
i2c = SoftI2C(scl=Pin(7), sda=Pin(6))# Adjust the Pin numbers based on your connections
oled_width = 128
oled_height = 64
oled = ssd1306.SSD1306_I2C(oled_width, oled_height, i2c)

# Network settings
wifi_ssid = "Your Own SSID"
wifi_password = "Your Own Password"
machine.freq(160000000)# Set CPU frequency to 160 MHz (ESP8266 specific)
oled.text("Starting up...", 0, 0)
oled.show()

station = network.WLAN(network.STA_IF)
station.active(True)
station.connect(wifi_ssid, wifi_password)
time.sleep(1)

while not station.isconnected():
  time.sleep(1)

oled.fill(0)
oled.text("Connecting to", 0, 0)
oled.text(wifi_ssid, 0, 20)
oled.show()
time.sleep(2)

oled.fill(0)
ip_address = station.ifconfig()[0]# Get the IP address
oled.text("Connected! ", 0, 0)
oled.text("IP Address:", 0, 20)
oled.text(ip_address, 0, 40)
oled.show()
time.sleep(2)

# Buzzer settings
buzzer_pin = machine.Pin(5, machine.Pin.OUT)
buzzer = machine.PWM(buzzer_pin)
buzzer.freq(1047)
buzzer.duty(0)

center_x = oled_width // 2
center_y = oled_height // 2
square_size = 6# Size of each square
num_squares = 12# Number of squares
angle_increment = 2 * math.pi / num_squares

x_pos = [12, 38, 64, 90]
statuses = ["poor", "normal", "good", "excellent"]

def calculate_block_count(rssi):
  # Determine the number of blocks based on RSSI values
  if -80 <= rssi < -60:
  return 1
  elif -60 <= rssi < -40:
  return 2
  elif -40 <= rssi < -20:
  return 3
  elif -20 <= rssi <= 10:
  return 4

def draw_blocks(count):
  for i in range(count):
  y_pos = 50 - calculate_block_height(i)
  oled.fill_rect(x_pos<i>, y_pos, 24, calculate_block_height(i), 1)
  for i in range(count, 4):# Clear unused area
  y_pos = 50 - calculate_block_height(i)
  oled.fill_rect(x_pos<i>, y_pos, 24, calculate_block_height(i), 0)

def calculate_block_height(index):
  return 10 * (index + 1)

loop_count = 0# Initialize loop count

while loop_count < 2:# Execute the loop 24 times
  oled.fill(0)# Clear the screen

for i in range(num_squares):
  angle = i * angle_increment
  x = int(center_x + (center_x - square_size - 30) * math.cos(angle))
  y = int(center_y + (center_x - square_size - 30) * math.sin(angle))

# Draw all squares
  for j in range(num_squares):
    angle_j = j * angle_increment
    x_j = int(center_x + (center_x - square_size - 30) * math.cos(angle_j))
    y_j = int(center_y + (center_x - square_size - 30) * math.sin(angle_j))

oled.fill_rect(x_j, y_j, square_size, square_size, 1)# Draw the square

oled.fill_rect(x, y, square_size, square_size, 0)# Erase the current square
  oled.show()
  time.sleep_ms(100)# Pause before next iteration

loop_count += 1# Increase loop count

oled.fill(0)# Clear the screen after finishing the loops
oled.show()

while True:
  oled.fill(0)
  station = network.WLAN(network.STA_IF)
  time.sleep(0.1)
  rssi = station.status('rssi')
  rssi_duty = 160 + 2 * int(rssi)
  rssi_duty_2 = int(rssi_duty / 2)
  rssi_abs = abs(int(rssi)) / 100

block_count = calculate_block_count(rssi)
  status = statuses[block_count - 1]# Get the status text based on block count

draw_blocks(block_count)

oled.text(status, 11, 56)

oled.text("RSSI:", 0, 0)
  oled.text(str(rssi), 40, 0)
  # Update the display
  oled.show()

buzzer.duty(rssi_duty)
  time.sleep(rssi_abs)
  buzzer.duty(0)
  time.sleep(rssi_abs)
  buzzer.duty(rssi_duty_2)
  time.sleep(rssi_abs)
  buzzer.duty(0)
  time.sleep(rssi_abs)

```

连接的手机热点，凑近：

<ignore_js_op>

<a href="javascript:;" onclick="showWindow(this.id, this.getAttribute('url'), 'get', 0);" id="savephoto_763775" url="home.php?mod=spacecp&ac=album&op=saveforumphoto&aid=763775&handlekey=savephoto_763775">保存到相册</a>

</p>

</div>
<div class="tip_horn"></div>
</div>

</ignore_js_op>

离远：

<ignore_js_op>

<a href="javascript:;" onclick="showWindow(this.id, this.getAttribute('url'), 'get', 0);" id="savephoto_763776" url="home.php?mod=spacecp&ac=album&op=saveforumphoto&aid=763776&handlekey=savephoto_763776">保存到相册</a>

</p>

</div>
<div class="tip_horn"></div>
</div>

</ignore_js_op>

2.**分任务2：温湿度数据记录仪**
定时记录温湿度传感器的值，并展示出来。可记录到开发板内置存储中，也可以通过物联网服务发送数据到云端。

这个也很容易实现，在前面读取温湿度数据的基础上加个文件读写的代码就可以实现

代码：

```
from ahtx0 import AHT20
import machine
from machine import Pin, SoftI2C
import ssd1306
import time
from time import sleep
import network
import ujson
import urequests
import json

# Oled init
i2c = machine.I2C(0, sda=Pin(6), scl=Pin(7), freq=400000)
oled = ssd1306.SSD1306_I2C(128, 64, i2c)

oled.text("Out Temp", 0, 0)
oled.text("Inside sensor:", 0, 16)
oled.text("Temp:", 0, 32)
oled.text("Humi:", 0, 48)
oled.show()

# aht20
aht = AHT20(i2c)
# file
file_store = open('data_wenshi.txt', "w")

def aht20_show(aht):
  temp = aht.temperature
  humi = aht.relative_humidity

oled.fill_rect(50, 32, 40, 30, 0)# 局部清屏
  oled.text('{:.2f}'.format(temp), 50, 32)
  oled.text('{:.2f}'.format(humi), 50, 48)
  oled.show()
  file_store.write("temp:")
  file_store.write('{:.2f}'.format(temp))
  file_store.write("\nhumi:")
  file_store.write('{:.2f}'.format(humi))
  print("data saved!")

time.sleep(1)

aht20_show(aht)
```

数据存储到目录下的data_wenshi.txt里

<ignore_js_op>

<a href="javascript:;" onclick="showWindow(this.id, this.getAttribute('url'), 'get', 0);" id="savephoto_763777" url="home.php?mod=spacecp&ac=album&op=saveforumphoto&aid=763777&handlekey=savephoto_763777">保存到相册</a>

</p>

</div>
<div class="tip_horn"></div>
</div>

</ignore_js_op>

3.**分任务3：开灯提醒器**

监测环境光强度，如果光线太暗，通过屏幕和蜂鸣器提醒用户开灯，达到保护视力的效果。

主要是通过读取光传感器的值，转换为光强，然后设置一个阈值来判定是否需要响蜂鸣器以及显示对应状态

代码：

```
from machine import Pin, SoftI2C, ADC
import ssd1306
import utime
import time
from ahtx0 import AHT20
import machine
import time

# Buzzer settings
buzzer_pin = machine.Pin(5, machine.Pin.OUT)
buzzer = machine.PWM(buzzer_pin)
# 调节频率
buzzer.freq(500)
# 设置占空比——调节音量大小，其中数值设置为0，则会静音
buzzer.duty(50)
time.sleep(0.1)
buzzer.duty(0)
# ssd1306
i2c = SoftI2C(scl=Pin(7), sda=Pin(6))

oled_width = 128
oled_height = 64
oled = ssd1306.SSD1306_I2C(oled_width, oled_height, i2c)

# 清空屏幕，并显示任务要求
oled.fill(0)
oled.text("Light:", 0, 0)
oled.text("TimeDay:", 0, 16)
oled.text("Alert:",0,32)
oled.show()

# 光照部分
adc = ADC(Pin(2))
adc.atten(ADC.ATTN_11DB)
adc.width(ADC.WIDTH_12BIT)# 4095

while True:
  light_adc = adc.read()
  # 计算光强
  light_lux = light_adc * 350 * 1.0 / 4095
  print("Light(lux): "+'{:.2f}'.format(light_lux))

# 清除变化部分的内容
  oled.fill_rect(64, 0, 64, 48, 0)
  oled.text('{:.2f}'.format(light_lux), 64, 0)
  if light_lux > 43.96:
  print('day')
  oled.text("day", 64, 16)
  oled.text("off", 64, 32)

else:
  print('night')
  oled.text("night", 64, 16)
  oled.text("on", 64, 32)
  buzzer.duty(50)
  time.sleep(0.5)
  buzzer.duty(0)
  oled.show()

# 延时1秒
  time.sleep(1)
```

效果：

不遮挡传感器，模拟光源充足，TimeDay判定现在是白天，所以不需要开灯，Alert蜂鸣器不响起：

<ignore_js_op>

<a href="javascript:;" onclick="showWindow(this.id, this.getAttribute('url'), 'get', 0);" id="savephoto_763778" url="home.php?mod=spacecp&ac=album&op=saveforumphoto&aid=763778&handlekey=savephoto_763778">保存到相册</a>

</p>

</div>
<div class="tip_horn"></div>
</div>

</ignore_js_op>

遮挡传感器，模拟暗处需要开灯，TimeDay判定现在是晚上，所以需要开灯，Alert蜂鸣器间隔响起：

<ignore_js_op>

<a href="javascript:;" onclick="showWindow(this.id, this.getAttribute('url'), 'get', 0);" id="savephoto_763779" url="home.php?mod=spacecp&ac=album&op=saveforumphoto&aid=763779&handlekey=savephoto_763779">保存到相册</a>

</p>

</div>
<div class="tip_horn"></div>
</div>

</ignore_js_op>

## 项目源码
https://download.eeworld.com.cn/detail/SeasonMay/630274
## 心得体会
感谢得捷金主的大力支持，也感谢EEWorld社区的付出，在此活动中，我也跟随着社区的各位大佬学习到了许多知识，特别对ESP32、MicroPython以及相关物联网应用领域有了进一步了解，往后我也会继续加油，在有限的时光内学习更多知识，争取做出更多有意思的作品出来。
## 参考过的部分链接，感谢这些作者的付出：

王皓东教学：
https://doc.itprojects.cn/0006.zhishi.esp32/02.doc/index.html#/30.oled
mpy framebuf：http://www.micropython.com.cn/en/latet/library/framebuf.html
香蕉派framebuf - 帧缓冲操作：https://bpisteam.com/WebBit_doc/zh/micropython/library/framebuf.html#%E7%BB%98%E5%88%B6%E5%8E%9F%E5%A7%8B%E5%BD%A2%E7%8A%B6
随机显示：
[ESP32(MicroPython) OLED随机显示_esp32 oled_路易斯720的博客-CSDN博客](https://blog.csdn.net/weixin_74155302/article/details/131015326?ops_request_misc=&request_id=&biz_id=102&utm_term=micropython oled&utm_medium=distribute.pc_search_result.none-task-blog-2~all~sobaiduweb~default-5-131015326.142^v96^control&spm=1018.2226.3001.4187)
mpy ssd1306：
[14. 使用SSD1306 OLED显示屏 —MicroPython中文 1.17 文档](http://micropython.com.cn/en/latet/esp8266/tutorial/ssd1306.html#ssd1306)
显示世界地图map：
https://mpython.readthedocs.io/zh/master/tutorials/basics/oled.html
esp32教学up：
https://space.bilibili.com/11156113
esp32库索引：
https://www.bilibili.com/read/cv10922418/
显示图像，transpic：
https://blog.csdn.net/jd3096/article/details/121319042

## follow me 3活动过程分享贴，有分任务的演示视频：
任务1：https://bbs.eeworld.com.cn/thread-1263193-1-1.html
任务2：https://bbs.eeworld.com.cn/thread-1263261-1-1.html
任务3：https://bbs.eeworld.com.cn/thread-1263426-1-1.html
任务4：https://bbs.eeworld.com.cn/thread-1263468-1-1.html