查看: 6007|回复: 3

MaixPy的功能详细到不能再详细的新手介绍

MaixPy的功能

前言

现在我们就要谈一下MaixPy的功能了，如同所有语言一般，MaixPy也是有自己的语法的，那就是Micropython的库,通信的库,MaixPy开发板特有的库等，其中会有许多常用的函数，我们需要了解他们在需要的时候可以及时找到，灵活应用，这个不需要全部记住，不过在几个常用的板块，如FPIOA（可编程引脚）KPU（神经元网络加速），我们还是要好好理解一下的。

本文中例程还未实践完毕。

接下来，我来把MaixPy的功能简介一下，其所含函数会以链接形式编写，希望对大家有帮助。顺便说一下，英语好在这部分真的很占优势，我这种渣渣，学完了也认识了几个单词，快上车吧。

标准库

cmath

复数的数学函数，提供了一些处理复数的基本数学函数。

控制垃圾收集器,此函数是MicroPython扩展。要求用“malloc”或“new”分配内存，使用用户内存管理自动化，任务是跟踪所有对象被引用到的地方。

math

提供了一些处理浮点数的基本数学函数。

系统特定功能。

ubinascii

以ASCII格式（两个方向）实现二进制数据与其各种编码之间的转换。

ucollections

集合和容器类型，用高级集合和容器类型以保存/累积各种对象。

uctypes

以结构化方式访问二进制数据，允许访问机器的任意内存地址（包括I / O和控制寄存器），要小心，可能会导致崩溃，数据丢失，甚至硬件故障。

定义结构布局

结构布局由“描述符”定义，一个Python字典，它将字段名称编码为键，以及将它们作为关联值访问它们所需的其他属性。uctypes需要明确规定每个字段的偏移量，从结构开始以字节为单位给出偏移量。不同字段类型的编码和偏移量不同。

结构描述符和实例化结构对象

可以使用uctypes.struct（）构造函数在给定的内存地址实例化特定的结构实例。

uerrno

系统错误代码，所有错误代码均以 “E” 开头。

uheapq

堆队列算法，也称为优先队列算法，堆队列只是一个以某种方式存储其元素的列表。

ujson

允许在 Python 对象和 JSON 数据格式之间进行转换。

基本的“操作系统”服务,包含用于文件系统访问和挂载，终端重定向和复制以及uname和urandom等函数。

12.ure

简单的正则表达式,又称规则表达式。通常被用来检索、替换那些符合某个模式(规则)的文本。

usocket

套接字模块,提供对BSD套接字接口的访问。

套接字（socket）是一个抽象层，应用程序可以通过它发送或接收数据，可对其进行像对文件一样的打开、读写和关闭等操作。套接字允许应用程序将I/O插入到网络中，并与网络中的其他应用程序进行通信。网络套接字是IP地址与端口的组合。

例程1：下载图片并显示


# Untitled - By: 86177 - 周一 2月 3 2020

import sensor, image, time#导入工具包

sensor.reset()#初始化单目摄像头

sensor.set_pixformat(sensor.RGB565)#设置摄像头输出格式 RGB565

sensor.set_framesize(sensor.QVGA)#设置帧大小 QVGA

sensor.skip_frames(time = 2000)#跳过指定帧数或者跳过指定时间内的图像

clock = time.clock()#程序运行的实际时间

while(True):

    clock.tick()

    img = sensor.snapshot()#控制摄像头捕捉图像

    print(clock.fps())

import socket

import network

import gc

import os

import lcd, image

#引脚映射，将WIFI_RX设置为UART2_TX的发送引脚，WIFI_TX设置为UART2_RX接收引脚

fm.register(board_info.WIFI_RX,fm.fpioa.UART2_TX)

fm.register(board_info.WIFI_TX,fm.fpioa.UART2_RX)

#通过指定参数新建一个UART对象

#UART号，UART波特率，UART数据宽度，奇偶校验位默认none，停止位默认1，串口接收超时时间，串口接收缓冲

uart = machine.UART(machine.UART.UART2,115200,timeout=1000, read_buf_len=4096)

nic=network.ESP8285(uart)#ESP8266WiFi信号放大器

nic.connect("Sipeed_2.4G","------")#连接到地址处的远程套接字

sock = socket.socket()#连接到一个可操作地址

#gataddrinfo解析文字地址和数字地址

addr = socket.getaddrinfo("dl.sipeed.com", 80)[0][-1]

sock.connect(addr)#然后再使用数字地址

#将数据发送到套接字

sock.send('''GET /MAIX/MaixPy/assets/Alice.bmp HTTP/1.1

Host: dl.sipeed.com

cache-control: no-cache

''')

img = b""

sock.settimeout(5)#阻止套接字操作设置超时，超出 OSError

while True:

    data = sock.recv(4096)#从套接字接收数据

    if len(data) == 0:#个数为零

        break

    print("rcv:", len(data))

    img = img + data

print(len(img))

img = img[img.find(b"\r\n\r\n")+4:]#回车换行，图片的值赋予

print(len(img))

print("save to /sd/Alice.bmp")

f = open("/sd/Alice.bmp","wb")

f.write(img)

f.close()

print("save ok")

print("display")

img = image.Image("/sd/Alice.bmp")#图像对象

lcd.init()#初始化 LCD 屏幕显示

lcd.display(img)#在液晶屏上显示一张 image

例程2：发送图片


# Untitled - By: 86177 - 周一 2月 3 2020

import sensor, image, time

sensor.reset()#初始化单目摄像头

sensor.set_pixformat(sensor.RGB565)#设置摄像头输出格式

sensor.set_framesize(sensor.QVGA)#设置帧大小

sensor.skip_frames(time = 2000)#跳过指定帧数

clock = time.clock()#程序运行时间

while(True):

    clock.tick()

#控制摄像头捕捉图像

    img = sensor.snapshot()

    print(clock.fps())

import os

import socket

import network

import gc

#引脚映射，将WIFI_RX设置为UART2_TX的发送引脚，WIFI_TX设置为UART2_RX接收引脚

fm.register(board_info.WIFI_RX,fm.fpioa.UART2_TX)

fm.register(board_info.WIFI_TX,fm.fpioa.UART2_RX)

#通过指定参数新建一个UART对象

#UART号，UART波特率，UART数据宽度，奇偶校验位默认none，停止位默认1，串口接收超时时间，串口接收缓冲

uart = machine.UART(machine.UART.UART2,115200,timeout=1000, read_buf_len=4096)

#ESP8266WiFi信号放大器

nic=network.ESP8285(uart)

#连接到地址处的远程套接字

nic.connect("Sipeed_2.4G","-------")

addr = ("192.168.0.183", 3456)

#连接到一个可操作地址

sock = socket.socket()

#使用数字地址

sock.connect(addr)

#阻止套接字操作设置超时，超出 OSError

sock.settimeout(5)

f = open("/sd/Alice.bmp","rb")

while True:

#读取大小字节

    img = f.read(2048)

    if not img or (len(img) == 0):

        break

    sock.send(img)

f.close()

#标记套接字已关闭并释放所有资源

sock.close()

ustruct

打包和解包原始数据类型。

utime

提供获取当前时间和日期，测量时间间隔和延迟的功能。

uzlib

允许解压使用 DEFLATE 算法压缩的二进制数据（通常用于zlib库和gzip存档器）。这个类是MicroPython扩展。它包含在临时基础上，可能会在以后的版本中进行大量更改或删除。

machine

主要包含了与硬件相关的各种接口，是通信的库。

总线协议，简单地使用两条线（SCL，SDA）可以控制多个从机（主机模式）。

扫描从机设备例程与输出如图（小白的三个个从机的例程结果都如箭头所指）

MaixPy的功能详细到不能再详细的新手介绍图1

那为什么是有上图这个问题呢，经过查询，个人感觉是没有确认本机的从机设备地址。（注：未实践，需要lic设备）

大家在使用Ginkgo USB-I2C适配器，有个非常重要的信息就是所控制的从机地址必须要知道，否则就无法正确的和I2C从机进行通信，一般来说，在I2C设备的数据手册中都会明确提出这个设备的I2C地址是多少，不过在有的时候，可能手边没有这个设备的地址信息，但是也想和它建立通信，这种情况怎么办呢？

下面我们就可以用我们的适配器并配合我们提供的一个小工具来找到这个设备的地址。

实现的基本原理，我们先假设这个I2C从机设备是7bit模式地址，然后我们以此发送所有地址数据，然后判断从机是否正常应答，如果正常应答了，说明这个地址就是这个I2C从机的地址，否则就不是他的地址。

软件界面如下：

MaixPy的功能详细到不能再详细的新手介绍图2

从软件输出的信息可以看到，当发送0xD0地址的时候，从机正常应答了，而发送其他地址的时候从机都没应答，这就能说明从机设备地址就是0xD0.

例程1：扫描从机设备（例程二和这个例程类似，这里不提了）


# Untitled - By: 86177 - 周一 2月 3 2020

import sensor, image, time

from machine import I2C

#id,通信频率，scl引脚,sda引脚

i2c = I2C(I2C.I2C0, freq=100000, scl=34, sda=33)

#扫描I2C总线上的从机，返回list 对象，包含了所有扫描到的从机地址

devices = i2c.scan()

print(devices)

例程3：从机模式


# Untitled - By: 86177 - 周一 2月 3 2020

import sensor, image, time

sensor.reset()

sensor.set_pixformat(sensor.RGB565)

sensor.set_framesize(sensor.QVGA)

sensor.skip_frames(time = 2000)

clock = time.clock()

while(True):

    clock.tick()

    img = sensor.snapshot()

    print(clock.fps())

from machine import I2C

count = 0

#从机模式的接收回调函数

def on_receive(data):

    print("on_receive:",data)

#从机模式的发送回调函数

def on_transmit():

    count = count+1

print("on_transmit, send:",count)

def on_event(event):

    print("on_event:",event)

i2c = I2C(I2C.I2C0, mode=I2C.MODE_SLAVE, scl=34, sda=33, addr=0x24, addr_size=7, on_receive=on_receive, on_transmit=on_transmit, on_event=on_event)

脉宽调制模块，硬件支持的PWM，可以指定任意引脚（0到47引脚）。

注：未实现，需要示波器。

例程1：呼吸灯


# Untitled - By: 86177 - 周四 2月 6 2020

import sensor, image, time

sensor.reset()

sensor.set_pixformat(sensor.RGB565)

sensor.set_framesize(sensor.QVGA)

sensor.skip_frames(time = 2000)

clock = time.clock()

while(True):

    clock.tick()

    img = sensor.snapshot()

    print(clock.fps())

from machine import Timer,PWM

import time

#Timer ID，通道，模式 硬件定时器    

tim = Timer(Timer.TIMER0, Timer.CHANNEL0, mode=Timer.MODE_PWM)

#定时器对象，波形频率，占空比，输出引脚

ch = PWM(tim, freq=500000, duty=50, pin=board_info.LED_G)

duty=0

dir = True

while True:

    if dir:

        duty += 10

    else:

        duty -= 10

    if duty>100:

        duty = 100

        dir = False

    elif duty<0:

        duty = 0

        dir = True

#暂停0.05秒

    time.sleep(0.05)

    ch.duty(duty)

例程2：


# Untitled - By: 86177 - 周四 2月 6 2020

import sensor, image, time

#初始化单目摄像头

sensor.reset()

#设置摄像头输出格式

sensor.set_pixformat(sensor.RGB565)

#设置帧大小

sensor.set_framesize(sensor.QVGA)

#跳过指定帧数

sensor.skip_frames(time = 2000)

#程序运行时间

clock = time.clock()

while(True):

    clock.tick()

#控制摄像头捕捉图像

img = sensor.snapshot()

print(clock.fps())

import time

import machine

#Timer ID，通道，模式 硬件定时器     

tim = machine.Timer(machine.Timer.TIMER0, machine.Timer.CHANNEL0, mode=machine.Timer.MODE_PWM)

#定时器对象，波形频率，占空比，输出引脚

ch0 = machine.PWM(tim, freq=3000000, duty=20, pin=board_info.LED_G, enable=False)

#使指定的引脚上立即产生波形

ch0.enable()

#暂停三秒

time.sleep(3)

#设置频率

ch0.freq(2000000)

print("freq:",ch0.freq())

#设置占空比

ch0.duty(60)

time.sleep(3)

#使指定的引脚不再出现波形

ch0.disable()

串行外设接口（Serial Peripheral Interface）的缩写，一个同步串行协议，由主机和从机组成。在芯片的管脚上只占用四根线，节约了芯片的管脚，同时为PCB的布局上节省空间，提供方便。

基本读写例程

实现结果如下图（此过程亮两个红灯，一个蓝灯，其中一个红灯闪烁）


# Untitled - By: 86177 - 周一 2月 3 2020

from machine import SPI

#id 0或1,模式MODE_MASTER，波特率（频率），极性，相，数据宽度8，指定输出顺序SPI.MSB，sck时钟引脚，mosi主机输出引脚，cso片选引脚

spi1 = SPI(SPI.SPI1, mode=SPI.MODE_MASTER, baudrate=10000000, polarity=0, phase=0, bits=8, firstbit=SPI.MSB, sck=28, mosi=29, miso=30, cs0=27)

w = b'1234'

#返回一个新字节数组。定义数据及长度

r = bytearray(4)

#发送数据

spi1.write(w)

#定义数据及长度，选择片选引脚SPI.CS0

spi1.write(w, cs=SPI.CS0)

#发送数据并读取数据到变量 ，全双工

#发送的数据及长度，接收数据存放的位置

spi1.write_readinto(w, r)

#读取的长度，全双工时MOSI引脚的值0x00（低电平）

spi1.read(5, write=0x00)

#读取数据并放到指定变量中

spi1.readinto(r, write=0x00)

Timer

硬件定时器，可以用来定时触发任务或者处理任务，设定时间到了后可以触发中断（调用回调函数），精度比软件定时器高。需要注意的是，定时器在不同的硬件中可能会有不同的表现。

那为什么要使用定时器呢？

比如说一个web应用，如果这个应用规模很大，那它的日志数据是不是很多。如果一直存下来服务器的存储量怕是不行吧，需要隔一段时间删除，那么就需要一个线程每隔一段时间去删除日志数据。

例程1：定时三秒打印信息

（注：def定义函数后，下面输出要缩进，相当于c 语言的大括号）

MaixPy的功能详细到不能再详细的新手介绍图3

例程2：每隔 1 秒打印消息，停止 5 秒后再重启， 5 秒后关闭并注销定时器


def on_timer(timer):

        print("time up",timer)

        print("param:",timer.callback_arg())

tim = Timer(Timer.TIMER0, Timer.CHANNEL0, mode=Timer.MODE_PERIODIC, period=1, unit=Timer.UNIT_S, callback=on_timer, arg=on_timer, start=False, priority=1, div=0)

print("period:",tim.period())

#启动定时器

tim.start()

time.sleep(5)

#停止定时器

tim.stop()

time.sleep(5)

#重新开启定时器

tim.restart()

time.sleep(5)

tim.stop()

#删除变量

del tim

UART

主要用于驱动开发板上的异步串口，通用异步收发传输器。

它将要传输的资料在串行通信与并行通信之间加以转换。

作为把并行输入信号转成串行输出信号的芯片，UART通常被集成于其他通讯接口的连结上。

例程1暂时没有杜邦线，还未实践。

例程1

ASCII码

标准ASCII码使用7位二进制数表示大写或小写字母，数字0到9标点符号以及在美式英语中使用的特殊控制字符。

Unicode编码

Unicode只是一个符号集，它规定了符号的二进制代码，却没有规定二进制代码如何存储，是UCS编码方式，即直接存入符号的Unicode二进制代码。

UTF-8编码

UTF-8是互联网上使用最广的一种Unicode的实现方式。UTF-8是一种变长的编码

方式，它使用1-4个字节表示一个符号，根据不同的符号选择不同长度的字节表示。

Unicode与UTF-8的转换方式：

在Windows系统最简单的方式是采用记事本打开文档然后选择编码方式另存为。


from fpioa_manager import fm

from machine import UART

#PIN15设置为UART1发送引脚，PIN17设置为UART1的接收引脚

fm.register(board_info.PIN15,fm.fpioa.UART1_TX)

fm.register(board_info.PIN17,fm.fpioa.UART2_RX)

#PIN9设置为UART2发送引脚，PIN10设置为UART1的接收引脚

fm.register(board_info.PIN9,fm.fpioa.UART2_TX)

fm.register(board_info.PIN10,fm.fpioa.UART2_RX)

#UART号，波特率，数据宽度8，奇偶校验位None，停止位1，串口接收超时时间，串口接收缓存

uart_A = UART(UART.UART1, 115200, 8, None, 1, timeout=1000, read_buf_len=4096)

uart_B = UART(UART.UART2, 115200, 8, None, 1, timeout=1000, read_buf_len=4096)

write_str = 'hello world'

#创建整数列表

for i in range(20):

#使用串口发送数据

    uart_A.write(write_str)

#读取串口缓冲中的数据

    read_data = uart_B.read()

#将utf-8编码的字符转换成成unicode编码字符

    read_str = read_data.decode('utf-8')

    print("string = ",read_str)

    if read_str == write_str:

        print("baudrate:115200 bits:8 parity:None stop:1 ---check Successfully")

#注销UART硬件

uart_A.deinit()

uart_B.deinit()

#删除变量

del uart_A

del uart_B

例程2：AT（attetion)模块串口

例程3：修改 REPL 串口波特率

交互式的REPL，REPL（read-evaluate-print loop）代表读取﹣求值﹣输出循环。


from machine import UART

#获取用于REPL的串口对象

repl = UART.repl_uart()

#初始化uart

#波特率，数据宽度8，奇偶校验位None，停止位1，串口接收缓存

repl.init(1500000, 8, None, 1, read_buf_len=2048)

network

用于初始化各种网卡驱动，网卡具有连接路由，断开路由，查看网卡连接信息，检查是否连接等功能。

使用WiFi请确保已经接上了天线

“配网”指的是，外部向WIFI模组提供SSID和密码，以便WIFI模组可以连接指定的热点或路由器并加入后者所建立的相关WIFI网络。一般可以归为如下：直接配网、智能配网、WPS配网、WEB网页配网。

直接配网（串口AT、SPI API、SDIO API、I2C API….）

通过UART串口、SPI口、SDIO口、I2C等主机接口，按照一定的通信协议，将SSID和密码，直接传递给WIFI模组。WIFI模组在收到SSID和密码后去连接热点或路由器，并将连接的状态结果从主机接口返回。例如，常见的通过UART串口AT指令配网、SPI API函数配网、SDIO API函数配网、I2C API函数配网等等。

GPIO

通用输入/输出 General Purpose Input Output，总线扩展器。

例程1：人脸识别

识别出来我这个大脸还是很欣慰的


import utime

from Maix import GPIO

#LED_R设置为GPIO0发送引脚

fm.register(board_info.LED_R,fm.fpioa.GPIO0)

#ID 使用的引脚，模式 输出

led_r=GPIO(GPIO.GPIO0,GPIO.OUT)

utime.sleep_ms(500)

#读取引脚状态

led_r.value()

fm.unregister(board_info.LED_R,fm.fpioa.GPIO0)

KPU是通用的神经网络处理器，它可以在低功耗的情况下实现卷积神经网络计算，时时获取被检测目标的大小、坐标和种类，对人脸或者物体进行检测和分类。

例程1：人脸识别


# Untitled - By: 86177 - 周四 2月 6 2020

import sensor

import image

import lcd

import KPU as kpu

lcd.init()#初始化

sensor.reset()#初始化单目摄像头

sensor.set_pixformat(sensor.RGB565)#设置摄像头输出格式 RGB565

sensor.set_framesize(sensor.QVGA)#设置帧大小 QVGA

sensor.run(1)#开启芯片捕获对象

#从flash中加载模型，模型在flash中偏移大小

task = kpu.load(0x300000) #使用kfpkg将 kmodel 与 maixpy 固件打包下载到 flash

#为yolo2网络化模型初始化参数

anchor = (1.889, 2.5245, 2.9465, 3.94056, 3.99987, 5.3658, 5.155437, 6.92275, 6.718375, 9.01025)

#网络对象，概率阈值，门限，锚点数，锚点参数与模型参数一致

a = kpu.init_yolo2(task, 0.5, 0.3, 5, anchor)

while(True):

    img = sensor.snapshot()##控制摄像头捕捉图像

#运行yolo2网络

    code = kpu.run_yolo2(task, img)

    if code:

        for i in code:

            print(i)

            a = img.draw_rectangle(i.rect())#画矩形

    a = lcd.display(img)#在液晶屏上显示一张 image

a = kpu.deinit(task)#反初始化

这个第二个例程运行特征图就非常的曲折了，由于工具有限，解决方案也是十分有限。因为这个是特别以前的例程了，在现在的IDE 上不能很好实现，后用到终端Putty实现了一下例程，现在就简介一下历时两天的心酸路。点击这里

FFT快速傅里叶变换模块，对输入数据进行傅里叶变换并返回相应的频率幅值, FFT快速傅里叶运算可以将时域信号转换为频域信号。

例程：采集声音并进行FFT运算，将运算后的数据在屏幕上显示为柱状图

未完全实现，需关闭无线，使用示波器，但是本板子是新版，还是有麦的，可以运行程序。

SPI 串行外设接口


from Maix import GPIO, I2S, FFT

import image, lcd, math

from board import board_info

from fpioa_manager import fm

sample_rate = 38640#采样率

sample_points = 1024#计算点数

fft_points = 512

hist_x_num = 50

lcd.init(freq=15000000)#初始化LCD屏幕显示

fm.register(8,  fm.fpioa.GPIO0, force=True)# close WiFi

wifi_en=GPIO(GPIO.GPIO0,GPIO.OUT)#创建SPI对象

wifi_en.value(0)#读取引脚状态

fm.register(20,fm.fpioa.I2S0_IN_D0, force=True)

fm.register(30,fm.fpioa.I2S0_WS, force=True)    # 19 on Go Board and Bit(new version)

fm.register(32,fm.fpioa.I2S0_SCLK, force=True)  # 18 on Go Board and Bit(new version)

rx = I2S(I2S.DEVICE_0)#UART号

rx.channel_config(rx.CHANNEL_0, rx.RECEIVER, align_mode = I2S.STANDARD_MODE)

rx.set_sample_rate(sample_rate)

img = image.Image()

if hist_x_num > 320:

    hist_x_num = 320

hist_width = int(320 / hist_x_num)#changeable

x_shift = 0

while True:

    audio = rx.record(sample_points)

#傅里叶变换 类型，运算点数

    fft_res = FFT.run(audio.to_bytes(),fft_points)

    fft_amp = FFT.amplitude(fft_res)#幅值

    img = img.clear()#清空

    x_shift = 0

    for i in range(hist_x_num):

        if fft_amp[i] > 240:

            hist_height = 240

        else:

            hist_height = fft_amp[i]

        img = img.draw_rectangle((x_shift,240-hist_height,hist_width,hist_height),[255,255,255],2,True)

        x_shift = x_shift + hist_width

    lcd.display(img)#液晶屏上显示

    fft_amp.clear()

驱动I2S设备,在使用前需要对引脚进行映射管理。

I2S(Inter—IC Sound)总线, 又称集成电路内置音频总线，该总线专门用于音频设备之间的数据传输，广泛应用于各种多媒体系统。将数据和时钟信号分离，避免了因时差诱发的失真。

例程1：


# Untitled - By: 86177 - 周五 2月 7 2020

from Maix import I2S

import time

fm.register(20,fm.fpioa.I2S0_IN_D0)#GO

fm.register(19,fm.fpioa.I2S0_WS)

fm.register(18,fm.fpioa.I2S0_SCLK)

fm.register(34,fm.fpioa.I2S2_OUT_D1)

fm.register(35,fm.fpioa.I2S2_SCLK)

fm.register(33,fm.fpioa.I2S2_WS)

sample_rate = 44*1000

rx = I2S(I2S.DEVICE_0)#新建IS对象 UART号

#配置I2S通道  通道编号，接收模式，通道对齐模式

rx.channel_config(rx.CHANNEL_0, rx.RECEIVER, align_mode = I2S.STANDARD_MODE)

rx.set_sample_rate(sample_rate)#采样率

tx = I2S(I2S.DEVICE_2)

tx.channel_config(tx.CHANNEL_1, tx.TRANSMITTER, align_mode = I2S.RIGHT_JUSTIFYING_MODE)#发送

tx.set_sample_rate(sample_rate)

while True:

    audio = rx.record(256)#sampling points number must be smaller than 256#接收音频数据

    tx.play(audio)#发送音频

audio

抽象的音频对象，该对象可以被当做参数传入也可以直接使用其方法来播放音频。

freq

频率模块，支持程序修改 cpu 中央处理器和 kpu神经网络处理器频率。

fpioa_manager

简称fm，该模块用于注册芯片内部功能和引脚，帮助用户管理内部功能和引脚，如果功能和引脚已经被注册，将无法使用该内部功能和引脚。

board_info

主要用于方便用户使用开发板引脚配置。


from board import board_info

wifi_en_pin = board_info.WIFI_EN

print(wifi_en_pin)#输出为8

board_info.pin_map()#打印所有

board_info.pin_map(8)#只打印8号引脚的信息

机器视觉

屏幕显示驱动

例程1：显示英文（蓝字）


import lcd

#初始化屏幕显示

lcd.init()

lcd.draw_string(100, 100, "hello maixpy", lcd.RED, lcd.BLACK)

例程2：显示图片（无SD卡）


import lcd

import image

#建图片

img = image.Image("/sd/pic.bmp")

lcd.display(img)

sensor

传感器模块，进行摄像头配置及图像抓取等，用于控制开发板摄像头完成摄像任务。

例程1：


import sensor, image, time#导入工具包

sensor.reset()#初始化单目摄像头

sensor.set_pixformat(sensor.RGB565)#设置摄像头输出格式 RGB565

sensor.set_framesize(sensor.QVGA)#设置帧大小 QVGA

sensor.skip_frames(time = 2000)#跳过指定帧数或者跳过指定时间内的图像

clock = time.clock()#程序运行的实际时间

while(True):

    clock.tick()

    img = sensor.snapshot()#控制摄像头捕捉图像

    print(clock.fps())

例程2：


# Untitled - By: 86177 - 周五 2月 7 2020

import sensor

import image

import lcd

import time

lcd.init()

sensor.reset()#初始化单目摄像头

sensor.shutdown(False)#选择sensor并初始化

sensor.set_pixformat(sensor.RGB565)#设置帧格式

sensor.set_framesize(sensor.QVGA)#设置帧大小

sensor.shutdown(True)#选择sensor并初始化

sensor.set_pixformat(sensor.RGB565)

sensor.set_framesize(sensor.QVGA)

sensor.run(1)#开启芯片捕获对象

while True:

    sensor.shutdown(False) #选择sensor

    img=sensor.snapshot()#控制摄像头捕获对象

    lcd.display(img)

    time.sleep_ms(100)

    sensor.shutdown(True) #选择sensor

    img=sensor.snapshot()

    lcd.display(img)

image

ECI：储存了QR码中存储数据字节的编码。

QR码：二维码的一种，快速解码内容，可储存更多资料，不用像条形码一样，扫描时直线对准扫描器。

例程1：找绿色(尝试的魔方呢，还拼了半天）


import sensor,image,lcd,time

lcd.init()

sensor.reset()##初始化单目摄像头

sensor.set_pixformat(sensor.RGB565)#设置帧格式

sensor.set_framesize(sensor.QVGA)#设置帧大小

sensor.run(1)#开启芯片捕获对象

green_threshold   = ((0, 45, 0, 50, 0, 40))#阈值对象

while True:

    img=sensor.snapshot()#控制摄像头捕获对象

    blobs = img.find_blobs([green_threshold])#色块对象

    if blobs:

        for b in blobs:

            tmp=img.draw_rectangle(b[0:4])#绘制矩形

            tmp=img.draw_cross(b[5], b[6])#绘制十字

            c=img.get_pixel(b[5], b[6])#复制图片

    lcd.display(img)#液晶屏上显示

例程2：显示 fps

fps:画面每秒传输帧数，通俗来讲就是指动画或视频的画面数。FPS是测量用于保存、显示动态视频的信息数量。每秒钟帧数越多，所显示的动作就会越流畅。通常，要避免动作不流畅的最低是30。某些计算机视频格式，每秒只能提供15帧。