【得捷电子Follow me第1期】PicoW蓝牙点灯和配网

HonestQiao

【得捷电子Follow me第1期】PicoW蓝牙点灯和配网 [复制链接]

 

一、前言

2023年6月14日，树莓派官方官宣，PicoW蓝牙功能，正式开启，买到手的PicoW支持蓝牙但不能使用的历史终于翻页。

MicroPython率先提供了对PicoW蓝牙功能的支持，通过 MicroPython for Pico W ，下载 Nightly builds 固件，烧录或者更新到PicoW即可享用蓝牙功能。

 

二、功能

下面，分享一个参考相关资料实现的通过手机控制板载LED以及配网的程序。

通过该程序，可以在手机上，使用工具通过蓝牙发送信息控制PicoW开发板，实现LED的亮灭，以及WiFi网络的配置和连接。

 

三、代码

具体代码如下：

库文件1：ble_advertising.py

# Helpers for generating BLE advertising payloads.

from micropython import const
import struct
import bluetooth

# Advertising payloads are repeated packets of the following form:
#   1 byte data length (N + 1)
#   1 byte type (see constants below)
#   N bytes type-specific data

_ADV_TYPE_FLAGS = const(0x01)
_ADV_TYPE_NAME = const(0x09)
_ADV_TYPE_UUID16_COMPLETE = const(0x3)
_ADV_TYPE_UUID32_COMPLETE = const(0x5)
_ADV_TYPE_UUID128_COMPLETE = const(0x7)
_ADV_TYPE_UUID16_MORE = const(0x2)
_ADV_TYPE_UUID32_MORE = const(0x4)
_ADV_TYPE_UUID128_MORE = const(0x6)
_ADV_TYPE_APPEARANCE = const(0x19)


# Generate a payload to be passed to gap_advertise(adv_data=...).
def advertising_payload(limited_disc=False, br_edr=False, name=None, services=None, appearance=0):
    payload = bytearray()

    def _append(adv_type, value):
        nonlocal payload
        payload += struct.pack("BB", len(value) + 1, adv_type) + value

    _append(
        _ADV_TYPE_FLAGS,
        struct.pack("B", (0x01 if limited_disc else 0x02) + (0x18 if br_edr else 0x04)),
    )

    if name:
        _append(_ADV_TYPE_NAME, name)

    if services:
        for uuid in services:
            b = bytes(uuid)
            if len(b) == 2:
                _append(_ADV_TYPE_UUID16_COMPLETE, b)
            elif len(b) == 4:
                _append(_ADV_TYPE_UUID32_COMPLETE, b)
            elif len(b) == 16:
                _append(_ADV_TYPE_UUID128_COMPLETE, b)

    # See org.bluetooth.characteristic.gap.appearance.xml
    if appearance:
        _append(_ADV_TYPE_APPEARANCE, struct.pack("<h", appearance))

    return payload


def decode_field(payload, adv_type):
    i = 0
    result = []
    while i + 1 < len(payload):
        if payload[i + 1] == adv_type:
            result.append(payload[i + 2 : i + payload[i] + 1])
        i += 1 + payload[i]
    return result


def decode_name(payload):
    n = decode_field(payload, _ADV_TYPE_NAME)
    return str(n[0], "utf-8") if n else ""


def decode_services(payload):
    services = []
    for u in decode_field(payload, _ADV_TYPE_UUID16_COMPLETE):
        services.append(bluetooth.UUID(struct.unpack("<h", u)[0]))
    for u in decode_field(payload, _ADV_TYPE_UUID32_COMPLETE):
        services.append(bluetooth.UUID(struct.unpack("<d", u)[0]))
    for u in decode_field(payload, _ADV_TYPE_UUID128_COMPLETE):
        services.append(bluetooth.UUID(u))
    return services


def demo():
    payload = advertising_payload(
        name="micropython",
        services=[bluetooth.UUID(0x181A), bluetooth.UUID("6E400001-B5A3-F393-E0A9-E50E24DCCA9E")],
    )
    print(payload)
    print(decode_name(payload))
    print(decode_services(payload))


if __name__ == "__main__":
    demo()

 

库文件2：ble_simple_peripheral.py

# This example demonstrates a UART periperhal.

import bluetooth
import random
import struct
import time
from ble_advertising import advertising_payload

from micropython import const

_IRQ_CENTRAL_CONNECT = const(1)
_IRQ_CENTRAL_DISCONNECT = const(2)
_IRQ_GATTS_WRITE = const(3)

_FLAG_READ = const(0x0002)
_FLAG_WRITE_NO_RESPONSE = const(0x0004)
_FLAG_WRITE = const(0x0008)
_FLAG_NOTIFY = const(0x0010)

_UART_UUID = bluetooth.UUID("6E400001-B5A3-F393-E0A9-E50E24DCCA9E")
_UART_TX = (
    bluetooth.UUID("6E400003-B5A3-F393-E0A9-E50E24DCCA9E"),
    _FLAG_READ | _FLAG_NOTIFY,
)
_UART_RX = (
    bluetooth.UUID("6E400002-B5A3-F393-E0A9-E50E24DCCA9E"),
    _FLAG_WRITE | _FLAG_WRITE_NO_RESPONSE,
)
_UART_SERVICE = (
    _UART_UUID,
    (_UART_TX, _UART_RX),
)


class BLESimplePeripheral:
    def __init__(self, ble, name="mpy-uart"):
        self._ble = ble
        self._ble.active(True)
        self._ble.irq(self._irq)
        ((self._handle_tx, self._handle_rx),) = self._ble.gatts_register_services((_UART_SERVICE,))
        self._connections = set()
        self._write_callback = None
        self._payload = advertising_payload(name=name, services=[_UART_UUID])
        self._advertise()

    def _irq(self, event, data):
        # Track connections so we can send notifications.
        if event == _IRQ_CENTRAL_CONNECT:
            conn_handle, _, _ = data
            print("New connection", conn_handle)
            self._connections.add(conn_handle)
        elif event == _IRQ_CENTRAL_DISCONNECT:
            conn_handle, _, _ = data
            print("Disconnected", conn_handle)
            self._connections.remove(conn_handle)
            # Start advertising again to allow a new connection.
            self._advertise()
        elif event == _IRQ_GATTS_WRITE:
            conn_handle, value_handle = data
            value = self._ble.gatts_read(value_handle)
            if value_handle == self._handle_rx and self._write_callback:
                self._write_callback(value)

    def send(self, data):
        for conn_handle in self._connections:
            self._ble.gatts_notify(conn_handle, self._handle_tx, data)

    def is_connected(self):
        return len(self._connections) > 0

    def _advertise(self, interval_us=500000):
        print("Starting advertising")
        self._ble.gap_advertise(interval_us, adv_data=self._payload)

    def on_write(self, callback):
        self._write_callback = callback


def demo():
    ble = bluetooth.BLE()
    p = BLESimplePeripheral(ble)

    def on_rx(v):
        print("RX", v)

    p.on_write(on_rx)

    i = 0
    while True:
        if p.is_connected():
            # Short burst of queued notifications.
            for _ in range(3):
                data = str(i) + "_"
                print("TX", data)
                p.send(data)
                i += 1
        time.sleep_ms(100)


if __name__ == "__main__":
    demo()

 

主程序 main.py：

from machine import Pin 
import bluetooth
from ble_simple_peripheral import BLESimplePeripheral
import network
import time

# 创建BLE对象
ble = bluetooth.BLE()

# 使用BLE对象创建BLESimplePeripheral实例
ble_name = 'pico-ble'
sp = BLESimplePeripheral(ble, name=ble_name)
print('BLE name is %s' % ble_name)

# 初始化LED
led = Pin("LED", Pin.OUT)
led.value(False)
led_state = 0

# WiFi信息
wifi_ssid = ""
wifi_pass = ""

# 联网
def do_connect(ssid, password):
    sta_if = network.WLAN(network.STA_IF)
    if sta_if.isconnected():
        print("STA mode reconnect")
        sta_if.disconnect()
        sta_if.active(False)
        time.sleep(1)
    else:
        print("STA mode connect")

    sta_if.active(True)
    print("STA: ssid=%s password=%s" % (ssid, ("*" * len(wifi_pass))))
    sta_if.connect(ssid, password)
    count=0
    while count<30:
        if sta_if.isconnected():
            break
        count=count+1
        print("count=%d" % count)
        time.sleep(1)
    print("STA info:", sta_if.ifconfig())

# 蓝牙接收信息回调
def on_rx(data):
    global led_state,sp,wifi_ssid,wifi_pass

    print("Data received: ", data)  # d打印接收到的信息
    str_data = data.decode('utf8').rstrip()
    if str_data == 'toggle':  # 收到toggle切换LED状态
        sp.send("[Pico-W@BLE] LED toggle\n")
        led.value(not led_state)
        led_state = 1 - led_state
    elif str_data == 'on':  # 收到on开灯
        sp.send("[Pico-W@BLE] LED on\n")
        led.value(True)
        led_state = 1
    elif str_data == 'off':  # 收到off关灯
        sp.send("[Pico-W@BLE] LED off\n")
        led.value(False)
        led_state = 0
    elif str_data.startswith('ssid:'):  # 收到"ssid:"开头设置ssid信息
        wifi_ssid = str_data.split(':')[1]
        sp.send("[Pico-W@BLE] Got ssid: %s\n" % wifi_ssid)
    elif str_data.startswith('pass:'):  # 收到"pass:"开头设置password信息
        wifi_pass = str_data.split(':')[1]
        sp.send("[Pico-W@BLE] Got pass: %s\n" % ("*" * len(wifi_pass)))
    elif str_data == 'connect':  # 收到connect开始联网
        if len(wifi_ssid) and len(wifi_pass):
            sp.send("[Pico-W@BLE] Connectting...\n")
            do_connect(wifi_ssid, wifi_pass)
            sta_if = network.WLAN(network.STA_IF)
            if sta_if.isconnected(): # 连接成功
                sp.send("[Pico-W@BLE] Connect ok\n")
                sp.send("[Pico-W@BLE] IP Addr: %s\n" % sta_if.ifconfig()[0])
                led.value(True)  # Toggle the LED state (on/off)
                led_state = 1  # Update the LED state
            else: # 连接失败
                sp.send("[Pico-W@BLE] Connect fail\n")
        else:
            sp.send("[Pico-W@BLE] Please config ssid and pass first\n")

while True:
    if sp.is_connected():  # 检查蓝牙是否连接
        sp.on_write(on_rx)  # 收到数据时回调

 

上述主程序的逻辑较为清晰：

1. 启动蓝牙，等待连接
2. 手机端连接后，等待数据
3. 收到数据后，检查数据：
   • toggle：切换LED状态
   • on：开灯
   • off：关灯
   • ssid: ：ssid:开头表示设置wifi的ssid
   • pass: ：pass:开头表示设置wifi的password
   • connect：联网

四、效果

在PicoW上，上传2个库文件，然后运行上述主程序后，将输出提示信息，等待手机蓝牙连接：

 

在安卓手机上，安装 Serial Bluetooth Terminal - Google Play 上的应用 ：

 

安装完成后，打开应用，从左上角的菜单栏，进入 Devices - Bluetooth LE，点击SCAN，将会搜索到：pico-ble，点击连接，然后依次长按M1、M2...M6，设置对应的发送信息：

   

具体设置：

• M1：开灯，Value：on
• M2：关灯，Value：off
• M3：切换，Value：toggle
• M4：设置SSID，Value：ssid:你的无线名称
• M5：设置密码，Value：pass:你的无线密码
• M6：联网，Value：connect

 

设置完成后，在依次点击 开灯、关灯、切换、设置SSID、设置密码、联网，将会通过蓝牙发送信息，并收到PicoW通过蓝牙返回的信息：

 

PicoW也会输出信息：

 

配网成功后，板载LED将会点亮。

 

就这样，通过蓝牙，就能快速的进行通讯，实现控制功能和配网了，赶紧试试吧！

 

nmg

才知道以前的蓝牙是不能用的啊，是因为没提供驱动吗？

ly87802541

这绝对是喜大普奔的好消息，利好mpy哈哈