连接硬件

1. 将Type-C USB连接未来板后，打开未来板电源开关。

1. 接下来要对未来板编程，所以此处将模式切换成 硬件模式 并选择未来板。

1. 连接串口

:::warning 连不上串口？ 💡 FAQ :::

1. 试着输入一行指令，与未来板交互。不出意外可听到未来板蜂鸣器响起。

buzzer.tone(200, 0.5)

函数API

显示屏

使用screen类调用显示相关功能

• 设置同步刷新

screen.sync = val

• 屏幕填充

screen.fill(color)

• 绘制像素点

screen.pixel(x, y, color=255)

• 绘制线条

screen.line(x1, y1, x2, y2, color=255)
坐标：(x1, y1)和(x2, y2)为顶点绘制线段绘制线条

📋示例程序：亮度曲线

from future import *
import time
Light = [0, 0, 0]
screen.sync = 0
while 1:
    light = sensor.getLight()
    if len(Light) < 160:
        Light.append((125 - int(light/4095*125)))
    else:
        Light.pop(0)
    screen.fill(0)
    i_end = len(Light) - 1
    for i in range(i_end):  # 与 for i in range(i_end) 等效
        screen.pixel(i, Light[i])
        screen.line(i, Light[i], (i+1), Light[(i+1)])
    screen.refresh()
    time.sleep_ms(1)

• 🟥 绘制矩形

screen.rect(x, y, w, h, color=255, fill=0)

• 🔺绘制三角形

screen.triangle(x1, y1, x2, y2, x3, y3, color=255, fill=0)

• 🔴 绘制圆形

screen.circle(cx, cy, r, color=255, fill=0)

• 绘制圆角矩形

screen.roundRect(x,y,r,w,h,color=255,fill=0)

• 🔷 绘制多边形

screen.polygon(x, y, sides=3, r=10, th=3, rot=0, color=255, fill=0)

• 绘制英文字符（字符串）

screen.text(text, x=0, y=0, ext=1, color=255)

• 绘制中文字符（字符串）

screen.textCh(text, x=0, y=0, ext=1, color=255)

• 显示Bmp图片 仅支持24/32位的bmp，尺寸小于等于160x128

screen.loadBmp(path, x=0, y=0)

• 显示PNG图片 尺寸小于等于160x128

screen.loadPng(path, x=0, y=0)

• 显示动态GIF图 尺寸小于等于160x128

screen.loadGif(path, x = 0, y = 0)

📥 测试图片资源pic.zip

# 显示png
from future import *
screen.loadPng('hmP.png')
# 显示gif
from future import *
while 1:
    screen.loadgif('hmG.gif')
# 回调方式显示gif, 可以发现在gif显示过程中你也可以通过按键A播放蜂鸣器
from future import *
def gifCb():
      if sensor.btnValue('a'):
          buzzer.tone(200,-1)
      else:
          buzzer.stop()
      tft.show(fb)
fb.loadgif('boot1.gif',gifCb)

AB按键

• 按键检测

sensor.btnValue(btn)

:::info 可以直接使用sensor.btnValue()则返回一个数组[]，当有按键按下时返回返回对应的键位 :::

"""
REPL
"""
# 没有按下
>>>sensor.btnValue()
>>>[]
# 按住A
>>>sensor.btnValue()
>>>['a']

蜂鸣器

无源蜂鸣器是采用定时器模拟PWM驱动发声

• 使用频率驱动发声 📥频率对应音调表

buzzer.tone(freq, d = 0.5)

• 播放映射好的音调

buzzer.note(note, beats=1)

• 休音一定拍数

buzzer.rest(beats=1)

• 设置Bpm

buzzer.setBpm(bpm=120)

:::warning 设置后，会影响带有beats参数相关的函数 :::

• 播放旋律

buzzer.melody(m)

• 当c4:4在bpm为默认情况下，效果为响1拍（即0.5s）
• 当c4:8在bpm为默认情况下，效果为c4:4时长的2倍
• 改变bpm为60，c4:4的时长变为1s

固件内保留了以下简单音效，使用方式如：buzzer.melody(CORRECT)

CORRECT = "c6:1 f6:2 "
NOTICE = "d5:1 b4:1 "
ERROR = "a3:2 r a3:2 "
DADA = "r4:2 g g g eb:8 r:2 f f f d:8 "
ENTERTAINER = "d4:1 d# e c5:2 e4:1 c5:2 e4:1 c5:3 c:1 d d# e c d e:2 b4:1 d5:2 c:4 "
PRELUDE = "c4:1 e g c5 e g4 c5 e c4 e g c5 e g4 c5 e c4 d g d5 f g4 d5 f c4 d g d5 f g4 d5 f b3 d4 g d5 f g4 d5 f b3 d4 g d5 f g4 d5 f c4 e g c5 e g4 c5 e c4 e g c5 e g4 c5 e "
ODE = "e4 e f g g f e d c c d e e:6 d:2 d:8 e:4 e f g g f e d c c d e d:6 c:2 c:8 "
NYAN = "f#5:2 g# c#:1 d#:2 b4:1 d5:1 c# b4:2 b c#5 d d:1 c# b4:1 c#5:1 d# f# g# d# f# c# d b4 c#5 b4 d#5:2 f# g#:1 d# f# c# d# b4 d5 d# d c# b4 c#5 d:2 b4:1 c#5 d# f# c# d c# b4 c#5:2 b4 c#5 b4 f#:1 g# b:2 f#:1 g# b c#5 d# b4 e5 d# e f# b4:2 b f#:1 g# b f# e5 d# c# b4 f# d# e f# b:2 f#:1 g# b:2 f#:1 g# b b c#5 d# b4 f# g# f# b:2 b:1 a# b f# g# b e5 d# e f# b4:2 c#5 "
RING = "c4:1 d e:2 g d:1 e f:2 a e:1 f g:2 b c5:4 "
FUNK = "c2:2 c d# c:1 f:2 c:1 f:2 f# g c c g c:1 f#:2 c:1 f#:2 f d# "
BLUES = "c2:2 e g a a# a g e c2:2 e g a a# a g e f a c3 d d# d c a2 c2:2 e g a a# a g e g b d3 f f2 a c3 d# c2:2 e g e g f e d "
BIRTHDAY = "c4:3 c:1 d:4 c:4 f e:8 c:3 c:1 d:4 c:4 g f:8 c:3 c:1 c5:4 a4 f e d a#:3 a#:1 a:4 f g f:8 "
WEDDING = "c4:4 f:3 f:1 f:8 c:4 g:3 e:1 f:8 c:4 f:3 a:1 c5:4 a4:3 f:1 f:4 e:3 f:1 g:8 "
FUNERAL = "c3:4 c:3 c:1 c:4 d#:3 d:1 d:3 c:1 c:3 b2:1 c3:4 "
PUNCHLINE = "c4:3 g3:1 f# g g#:3 g r b c4 "
BADDY = "c3:3 r d:2 d# r c r f#:8 "
CHASE = "a4:1 b c5 b4 a:2 r a:1 b c5 b4 a:2 r a:2 e5 d# e f e d# e b4:1 c5 d c b4:2 r b:1 c5 d c b4:2 r b:2 e5 d# e f e d# e "
BA_DING = "b5:1 e6:3 "
WAWA = "e3:3 r:1 d#:3 r:1 d:4 r:1 c#:8 "
JUMP_UP = "c5:1 d e f g "
JUMP_DOWN = "g5:1 f e d c "
POWER_UP = "g4:1 c5 e g:2 e:1 g:3 "
POWER_DOWN = "g5:1 d# c g4:2 b:1 c5:3 "

• 停止播放

buzzer.stop()

亮度检测

• 返回光照强度模拟量

sensor.getLight()

温度检测

• 返回温度值

sensor.getTemp()

:::info 换算华氏度：F = C * 9 / 5 + 32 :::

加速度计

• 三轴加速度

sensor.accX()
sensor.accY()
sensor.accZ()

:::info 通常静置状态下，垂直于某个轴的的数值大约为1g（由于地球重力加速度） :::

• 姿态角—横滚

sensor.roll()

• 姿态角—俯仰

sensor.pitch()

• 姿态检测 :::info 按照未来板屏幕朝向 ::: sensor.gesture(ges)

可以直接使用sensor.gesture(‘face_up’)来检测是否处于当前状态

"""
REPL
"""
# 平方屏幕朝上
>>>sensor.gesture('face_up')
>>>True
# 平方屏幕朝上
>>>sensor.gesture()
>>>'face_up'

• 姿态检测事件

sensor.gesTrig[ges] = fn :::warning 需要注意的是这里参数是使用 [ ]包裹 ::: | 参数 | 含义 | | —- | —- | | ges | ‘shake’ 摇晃、’freefall’ 自由落体、’tilt_up’ 后倾、’tilt_down’ 前倾、’tilt_left’ 左倾、’tilt_right’ 右倾、’face_up’ 朝上、’face_down’ 朝下 | | fn | 自定义需要触发的回调函数 |

当设定的姿态达到时会触发执行自定义的中断函数fn :::warning 自定义函数的定义需要注意：

• 这个函数内容执行应尽量短并且耗时短
• 函数不允许有任何的内存申请，如：a = i+1
• 如需要使用全局变量，除了提前定义一个全局变量外，函数内还需要用global修饰 ::: ```python def fn(): screen.fill(255)

sensor.gesTrig[‘shake’] = fn sensor.startSchedule()

本身板子是黑屏状态下，摇晃一下屏幕变白

<a name="dDxK5"></a>
###   指南针
- 磁场校准
`calibrateCompass()`
| **含义** |
| --- |
| 三维缓慢转动板子，让屏幕中的3种颜色点大致形成3个区域的圆 |
:::warning
至少保证开机使用前要校准1次，可以通过按A键直接完成校准，但建议持续校准直到进度条走完<br />校准时请远离其他磁场，比如电脑机箱，磁铁，手机
:::
- 磁场强度
`sensor.magX()`<br />`sensor.magY()`<br />`sensor.magZ()`<br />`sensor.magStrength()`
| **含义** |
| --- |
| 分别表示x、y、z轴的磁感应强度以及矢量磁感应强度。单位为uT(微特斯拉) |
:::warning
测量范围为±800μT = ±8Gs(高斯)
:::
- 指南针朝向
`sensor.heading()`
| **含义** |
| --- |
| 当前方位，范围在0~360°，0°附近是北。指南针实际是指向地磁南极——地理北极 |
```python
from future import *
import math
calibrateCompass()
screen.sync = 0
ds = ''
while 1:
    d = sensor.heading()
    screen.fill(44)
    if (d<20) | (d>340):
        ds = '北'
    elif (d<70):
        ds = '东北'
    elif (d<110):
        ds = '东'
    elif (d<160):
        ds = '东南'
    elif (d<200):
        ds = '南'
    elif (d<250):
        ds = '西南'
    elif (d<290):
        ds = '西'
    else:
        ds = '西北'
    screen.text(d, 80-len(str(d))*4,113 )
    screen.textCh(ds,80-len(ds)*6,5)
    ax = 30 * math.sin(d / 180.0 * math.pi)
    ay = 30 * math.cos(d / 180.0 * math.pi)
    bx = 8 * math.sin(d / 180.0 * math.pi+ 80)
    by = 8 * math.cos(d / 180.0 * math.pi + 80)
    screen.circle(80,64,40,color=(233,233,99),fill=1)
    screen.circle(80,64,38,color=44,fill=1)
    screen.triangle((ax + 80), (ay + 64), (bx + 80), (by + 64), (-bx + 80), (-by + 64),color=(88,133,243), fill = 1)
    screen.triangle((-ax + 80), (-ay + 64), (bx + 80), (by + 64), (-bx + 80), (-by + 64), fill = 1,color=(243,22,22))
    screen.refresh()

RGB彩灯

• 彩灯类

NeoPixel(pin, num)

np = NeoPixel('P7', 3)  # 初始化灯珠，未来板的3颗RGB挂在P7脚上

• 设置单颗灯

setColor(i, color)

• 设置全部灯

setColorAll(color)

• 刷新显示

update()

from future import *
import time
""" 固件内已经建立的映射，可以直接使用
RED=(255,0,0)
YELLOW=(255,255,0)
PINK=(255,105,180)
WHITE=(255,255,255)
BLACK=(0,0,0)
GREEN=(0,255,0)
BLUE=(0,0,255)
PURPLE=(148,0,211)
CYAN = (0,255,255) 
"""
np = NeoPixel('P7', 3)
color = [RED,GREEN,BLUE]
for i in range(3):
    np.setColorAll(color[i])
    np.update() # 目前需要刷新，可能之后的固件再设置所有灯的时候会优化省略掉这一步
    time.sleep(1)
for i in range(3):
    np.setColor(i,BLACK)
    np.update()
    time.sleep(1)

海龟绘图

turtle. 按下Tab查看所有方法

📋示例程序：简单的绘图

turtle.clear()
turtle.penup()
turtle.setx(80)
turtle.sety(64)
turtle.pendown()
for i in range(5):
    turtle.forward(40)
    turtle.right(144)
# turtle.begin_fill()
turtle.right(120)
for i in range(5):
    turtle.forward(40)
    turtle.right(144)
# turtle.end_fill()

:::warning 硬件性能限制，填充效果将无法达到预期 :::

引脚控制

数字读写引脚类
MeowPin(pin, mode)

p1 = MeowPin('P1', 'IN')  # 实例化IO对象

:::warning

• 引脚的读写方法请对应实例化对象的模式，如’IN’对应getDigital()

• 设置过模拟输入模式的引脚无法在下一次重新上电前被设置为其他模式使用 :::

• 数字读

getDigital()

# P4-亮度传感器 / P5-按键A  /P6-蜂鸣器 / P7-RGB灯  P10-麦克风数据脚 / P11-按键B / P12-传感器输入脚，无上拉
# 数字读=['P0','P1','P2','P3','P8','P9','P12','P13','P14','P15','P16']
p0 = MeowPin('P0','IN')
print(p0.getDigital())

• 数字写

setDigital(val)

# 数字输出=['P0','P1','P2','P6','P7','P8','P10','P13','P3','P9','P14','P15','P16']
p0 = MeowPin('P0','OUT')
while 1:
    p0.setDigital(1)
    time.sleep(1)
    p0.setDigital(0)
    time.sleep(1)

• 模拟读

getAnalog(width=12)

# P4-亮度传感器 / P5-按键A  / P11-按键B
# 两颗按键虽然可以设置为模拟度但不建议
# 模拟读=['P0','P1','P4','P12', 'P3', 'P14', 'P15', 'P16']
p0 = MeowPin('P0','ANALOG')
print(p0.getAnalog())
print(p0.getAnalog(width=10))

• 模拟写（PWM）

setAnalog()

# 模拟输出=['P0','P1','P2','P3','P8','P13','P14','P15','P16']
p0 = MeowPin('P0','PWM')
while 1:
    for i in range(1023): 
        p0.setAnalog(i)
        time.sleep_ms(1)
    for i in range(1023,0,-1): 
        p0.setAnalog(i)
        time.sleep_ms(1)

串口引脚类
UART(id, baudrate, tx, rx)

from machine import UART
uart1 = UART(1, 9600, tx = 33, rx = 32)
# 实例化IO对象，将tx和rx分别设置为33和32，分别对应映射引脚的P1和P0
# 其中tx=33，rx=32可分别写成tx=PINMAP['P1'], Rx=PINMAP['P0']

• 串口发送消息

write(str)

from machine import UART
uart1 = UART(1, 115200, tx = 33, rx = 32)
while 1:
    uart1.write('hello123')    # 发送一行消息
    sleep(1)

• 串口接收消息

readline()
读取单行信息（常用）

read()
一次读出串口内255个字节内的所有消息

from machine import UART
uart1 = UART(1, 115200, tx = 33, rx = 32)
while 1:
    if uart.any():    # 检测串口是否有消息缓存
        mes = uart1.readline()    # 单行读取
        print(mes)

📋示例程序：与microbit进行串口通讯

1. 连接，注意理清rx、tx的对应关系

1. microbit端在makecode写如下程序，实现每隔1s发送一个自增数字到未来板

1. 未来板端程序为接收串口指令，并刷新显示到屏幕上 ```python from future import * from machine import UART

uart1 = UART(1, 115200, tx = 33, rx = 25) screen.sync=0

while 1: if uart1.any(): # 检测串口是否有消息缓存 mes = str(uart1.readline(),’UTF-8’) # 单行读取,如果发送端设备上线较快，接收端在已经接受了多个数据时才开始行读取，会放生堆积现象 screen.fill(1) screen.text(mes) screen.refresh()

<a name="cuDEV"></a>
###   WIFI
- 连接wifi
`wifi.connect(name, pwd)`
| **参数** | **含义** |
| --- | --- |
| name | wifi热点名称，字符串（不要以数字或符号开头） |
| pwd | wifi热点密码 |
- 检测wifi是否连接成功
`wifi.sta.isconnected()`
| **含义** |
| --- |
| 返回布尔值，当wifi连接成功，返回布尔真值 |
📋**示例程序**：连接wifi获取ip<br />未来板连接名称为Kittenbot的wifi，连接成功后，把IP显示在未来板显示屏上，此程序一般用在MQTT、NTP等网络通讯功能前。
```python
from future import *
wifi.connect("Kittenbot", '12345678')
while not wifi.sta.isconnected():
    pass
screen.text(wifi.sta.ifconfig()[0],5,10,1,(0, 119, 255))

• 获取wifi信息

wifi.sta.ifconfig()

• 获取wifi信息的对应项目

wifi.sta.ifconfig()[x]

• 获取MAC地址

  import machine
  import ubinascii
  mac = ubinascii.hexlify(machine.unique_id()).decode().upper()
  print('\n'+mac)

• 断开wifi

wifi.sta.disconnect()

MQTT

• MQTT类

c = mqttsimple.MQTTClient(server,client_id,port=0,user=None,password=None,keepalive=0,
ssl=False,ssl_params={})

• 连接mqtt服务器

c.connect()

• 断开mqtt服务器

c.disconnect()

• 话题消息回调函数

c.set_callback(callback)

def mqttcb(topic, msg):
    print('topic=%s , msg=%s' %(topic, msg))
c.set_callback(mqttcb)

• 订阅话题

c.subscribe(topic, qos=0)

• 发布消息

c.publish(topic, msg)

• 返回值类型的消息读取

c.mqttRead(topic)

📋示例程序1：回调方式使用mqtt发送和接收消息

import mqttsimple
if not(wifi.sta.isconnected()):   # 做一次wifi是否连接的判断，减少重复连接的耗时
    wifi.connect('router', 'password')  # 填写wifi的名称和密码，不支持5G喔。等待一下看屏幕提示是否成功
c = mqttsimple.MQTTClient("iot.kittenbot.cn", 'yourID')
c.connect() 
# 成功连接
# 设置回调函数，当话题有消息更新将自动跳入该函数内执行（比如这个函数执行打印话题和消息）
def sub_cb(topic, msg):
    print((topic, msg))   
c.set_callback(sub_cb)
# 订阅话题/ttt，只有订阅了的话题才能接收到里面的消息
c.subscribe('/ttt')
while 1:
    if sensor.btnValue('a'):
        # 向话题/ttt发送消息hello
        c.publish('/ttt', 'hello')
        sleep(0.2)
    # 执行这条函数当有消息时才会进入sub_cb的回调函数内执行（有缓存机制）
    c.check_msg()
    # 你也可以试试这个方法，是堵塞的效果，将等待有新的话题消息才继续执行
    # c.wait_msg()

📋示例程序2：返回值方式使用mqtt发送和接收消息

import mqttsimple
if not(wifi.sta.isconnected()):   # 做一次wifi是否连接的判断，减少重复连接的耗时
    wifi.connect('router', 'password')  # 填写wifi的名称和密码，不支持5G喔。等待一下看屏幕提示是否成功
c = mqttsimple.MQTTClient("iot.kittenbot.cn", 'yourID', port=1883)
c.connect() 
# 成功连接
# 订阅话题/ttt，只有订阅了的话题才能接收到里面的消息
c.subscribe('/ttt')
t= 0
# 返回值类型的读取消息采用的是取值回收的机制，既当新的消息到来，并通过mqttRead得到后，对该话题直到下一次新消息到来前通过mqttRead出来的数据均为None
while 1:
    if sensor.btnValue('a'):
        t+=1
        c.publish('/ttt','t'+str(t))
        sleep(0.2)
    # 由于机制决定，我们需要将话题存储到变量中使用，当话题消息不为None既有消息，才打印
    mqttT = c.mqttRead('/ttt')
    if mqttT:
        print(mqttT)

📋示例程序3：按键AB向对应话题发送不同消息

from future import *
import mqttsimple
from time import sleep
if not(wifi.sta.isconnected()):   # 做一次wifi是否连接的判断，减少重复连接的耗时
    wifi.connect('router', 'password')  # 填写wifi的名称和密码，不支持5G喔。等待一下看屏幕提示是否成功
mqtt = mqttsimple.MQTTClient("iot.kittenbot.cn", "CCFeatureboard",port=1883)
mqtt.connect()
while True:
    if sensor.btnValue('a'):
        # apple是我的话题，需要修改为你自己申请的！
        mqtt.publish("apple", "hipeilei666")
        buzzer.tone(440,1)
        sleep(1)
    else:
        if sensor.btnValue('b'):
            # apple是我的话题，需要修改为你自己申请的！
            mqtt.publish("apple", "hipeilei123")
            buzzer.tone(880,1)
            sleep(1)

• 喵家提供的mqtt服务器

地址：https://zone.kittenbot.cn/iot/main

1. 在Kzone的IOT页面申请你自己的话题 :::warning 话题名称只能为英文或者数字的字符 :::

2. 查看话题接收结果

NTP

• 同步网络时间

ntptime.settime(zone=8)

:::warning 需要先连接wifi :::

from future import *
from machine import RTC
if not(wifi.sta.isconnected()):   # 做一次wifi是否连接的判断，减少重复连接的耗时
    wifi.connect('Kittenbot', 'kittenbot428')  # 填写wifi的名称和密码，不支持5G喔。等待一下看屏幕提示是否成功
rtc = RTC()
rtc.datetime((2017, 8, 23, 1, 12, 48, 0, 0)) # 设定特定时间
rtc.datetime() # 获取时间
import ntptime
ntptime.settime() # 获取服务器时间到rtc
t = rtc.datetime()    # 获取时间, 格式为(年，月，日，星期，小时，分钟，秒，微妙) 
# REPL显示年月日,星期 
print("\n%d年%d月%d日，星期%d" %(t[0],t[1],t[2],t[3]))

麦克风

使用语音Audio类

import audio
au = audio.Audio()

• 麦克风声音强度

au.loadness()

import time
import audio
au = audio.Audio() 
# 由于I2S端口的初始化不可重复，Audio麦克风目前单次上电只能实例化一次，出现报错现象请重开电源
while 1:
  time.sleep(0.1)
  print(au.loudness())

• 云端语音识别

au.recognize(sec=3,vid=1537)

from future import *
if not(wifi.sta.isconnected()):   # 做一次wifi是否连接的判断，减少重复连接的耗时
    wifi.connect('Kittenbot', 'kittenbot428')  # 填写wifi的名称和密码，不支持5G喔。等待一下看屏幕提示是否成功
au = Audio()
while 1:
    if sensor.btnValue('a'):
        screen.clear()
        result = au.recognize(sec=3, vid=1537) # sec建议在1~3，代表着识别的语音长度，从执行这条语句开始计算
        screen.textCh(result)

识别回来的字符串自动带一个句号

MESH (ESP now)

基于WIFI MESH网络的板对板通讯（精准点对点）

# 1. 启动wifi
import network
w0 = network.WLAN(network.STA_IF)
w0.active(True)
# 2. 分别获取通讯双方的的mac地址
mac = w0.config('mac')
print(mac)
# 记住各自REPL打印的mac地址，如 b'\xc4O3"\xdb\x89'
# 3. 导入espnow
from esp import espnow
e = espnow.ESPNow()
e.init()
# 4. 加入peer节点
# 注意： 这里填写的不是自己的mac地址，而是需要通讯的另一个未来板的mac地址
e.add_peer(b'\x8c\xaa\xb5\xb9\xf8\xf0')
# 5. 目标接收注册接收回调函数
def rxcb(mac, msg):
    print("Recv:", mac, msg)
e.on_recv(rxcb)
# 6. 发送消息
e.send(b'\x8c\xaa\xb5\xb9\xf8\xf0', 'hello world')
# 7. 在接收端可以看到 Recv: b'\xc4O3"\xdb\x89' b'hello world'

radio（2.4g通讯）

基于WIFI MESH网络的板对板广播式通讯（类似microbit的2.4g通讯）

📋示例程序2：回调函数方式运行

from radio import *
def onmsg(msg, mac):
    print('get', msg, 'from', mac)
r = Radio(onmsg)
print('channel', r.channel)
r.channel = 12 # 直接更改wifi频点，频点对不上的收不到
r.send("hello world")

📋示例程序2：返回值方式运行

import time
from radio import *
r = Radio()
print('channel', r.channel)
r.channel = 12 # 直接更改wifi频点，频点对不上的收不到
while True:
    time.sleep(1)
    a = r.read()
    if a:
        print('get', a)

OneNet

中国移动OneNet物联网平台，OneNet物联网平台有点复杂，需要自行研究下使用方法
控制面板地址：https://open.iot.10086.cn/

需要自己进行新建，建立自己独有的设别ID和apikey
新建设备，并把设备ID和APIKey记录下来，接入方式为HTTP

增加数据流模板temp，数据流名称由自己定义，记录下数据流的名称

import onenet
# 只需要 设备ID 和 APIKey 两个参数
onenet = onenet.OneNet(str('581610877'), "6sxkdbL8E=sv4yylQvmvjPc6kRk=")
# 写："数据点","数据"
onenet.write("temp", 123456)
# 读: "数据点"
a = onenet.read("temp")

Robotbit扩展板驱动

使用喵家正版Robotbit扩展板 :::warning 扩展板不支持能量魔块的Armourbit :::

• 初始化扩展板

  import robotbit
  robot = robotbit.RobotBit()
  # 养成好习惯，先实例化再使用

• 电机控制

robot.motor(index,speed)

• 停止所有电机

robot.motorStopAll()

• 180度蓝色小舵机

robot.servo(index, degree)

• 270度Geekservo灰色9g舵机

robot.geekServo9g(index, degree)

• 360度Geekservo灰色2kg舵机

robot.geekServo2kg(index, degree)

• 28byj-48步进电机转动角度（精准相对转动）

robot.stepperDual(degree1,degree2)

• 28byj-48步进电机转动角度（精准相对转动）

robot.stepperDegree(index, degree)