ICode9

精准搜索请尝试: 精确搜索
首页 > 其他分享> 文章详细

maixpy 常用API整理

2022-07-30 09:32:45  阅读:155  来源: 互联网

标签:返回 常用 API math Output GPIO Serial Data maixpy


2.openmvAPI整理

2.1 cmath - 复数的数学函数

  • cos

cmath.cos(z)

返回z的余弦。

  • exp

cmath.exp(z)

返回z的指数。

  • log

cmath.log(z)

返回z的自然对数。分支切割沿负实轴。

  • log10

cmath.log10(z)

返回z的以10为底的对数。分支切割沿负实轴。

  • phase

cmath.phase(z)

返回数字“z”的相位,范围(-pi,+ pi)。

  • polar

cmath.polar(z)

作为元组返回z的极性形式。

  • rect

cmath.rect(r, phi)

返回模数r和相位phi的复数。

  • sin

cmath.sin(z)

返回z的正弦值。

  • sqrt

cmath.sqrt(z)

返回z的平方根。

  • 常数

cmake.e -->自然对数

cmath.pi -->圆周长与直径的比值

2.2 gc - 内存回收

  • gc.enable()

启用自动垃圾回收。

  • gc.disable()

禁用自动垃圾回收。仍然可以分配堆内存,仍然可以使用 gc.collect() 手动启动垃圾收集。

  • gc.collect()

运行垃圾回收。

  • gc.mem_alloc()

返回分配的堆 RAM 的字节数。

  • gc.mem_free()

返回可用堆RAM的字节数,如果堆剩余数量未知,则返回-1。

  • gc.threshold([amount])

设置或查询其他GC分配阈值。通常,仅当不能满足新分配时,即在内存不足(OOM)条件下才触发集合。如果调用此函数,除了OOM之外,每次分配了大量字节后都会触发一个集合(总共,因为上一次分配了这么多的字节)。 amount通常被指定为小于完整堆大小,意图在堆耗尽之前触发集合,并希望早期集合可以防止过多的内存碎片。这是一种启发式度量,其效果因应用程序而异,以及量参数的最佳值。

不带参数调用函数将返回阈值的当前值。值-1表示禁用的分配阈值。

2.3 math - 数学函数

  • math.acos(x)

返回x的反余弦值。

  • math.acosh(x)

返回x的反双曲余弦值。

  • math.asin(x)

返回x的反正弦。

  • math.asinh(x)

返回x的反双曲正弦值。

  • math.atan(x)

返回x的反正切。

  • math.atan2(y, x)

返回y /x的反正切的主值。

  • math.atanh(x)

返回x的反双曲正切。

  • math.ceil(x)

返回一个整数,“x”向正无穷大四舍五入。

  • math.copysign(x, y)

y的符号返回x

  • math.cos(x)

返回x的余弦。

  • math.cosh(x)

返回x的双曲余弦值

  • math.degrees(x)

返回弧度x转换为度数。

  • math.erf(x)

返回x的错误函数。

  • math.erfc(x)

返回x的互补误差函数。

  • math.exp(X)

返回x的指数。

  • math.expm1(x)

返回exp(x) - 1

  • math.fabs(x)

返回x的绝对值。

  • math.floor(x)

返回一个整数,“x”向负无穷大舍入。

  • math.fmod(x, y)

返回x /y的余数。

  • math.frexp(x)

将浮点数分解为尾数和指数。返回的值是元组(m,e),使得x == m * 2 ** e完全正确。如果x == 0则函数返回(0.0,0),否则关系0.5 <= abs(m)<1成立。

  • math.gamma(x)

返回x的伽玛函数。

  • math.isfinite(x)

如果x是有限的,则返回True。

  • math.isinf(X)

如果x是无限的,则返回True。

  • math.isnan(x)

如果x不是数字,则返回True

  • math.ldexp(x, exp)

返回x *(2 ** exp)

  • math.lgamma(x)

返回x的伽玛函数的自然对数。

  • math.log(x)

返回x的自然对数。

  • math.log10(x)

返回x的以10为底的对数。

  • math.log2(x)

返回x的base-2对数。

  • math.modf(x)

返回两个浮点数的元组,是“x”的分数和整数部分。两个返回值都与x具有相同的符号。

  • math.pow(x, y)

x返回到y的幂。

  • math.radians(x)

返回度数x转换为弧度。

  • math.sin(x)

返回x的正弦值。

  • math.sinh(x)

返回x的双曲正弦值。

  • math.sqrt(x)

返回x的平方根。

  • math.tan(x)

返回x的正切值。

  • math.tanh(x)

返回x的双曲正切。

  • math.trunc(x)

返回一个整数,“x”向0舍入。

  • 常数

math.e -->自然对数

math.pi -->圆周长与直径的比值

2.4 sys - 系统特定功能

一 . 功能函数

  • sys.exit(retval=0)

使用给定的退出代码终止当前程序。 根据此,此函数引发“SystemExit”异常。 如果给出了一个参数,它的值作为SystemExit的参数给出。

  • sys.print_exception(exc, file=sys.stdout)

使用回溯到类文件对象文件(或默认情况下为sys.stdout)打印异常。

更多接口点我查看

2.5 ubinascii - 二进制/ASCII转换

  • ubinascii.hexlify(data[, sep])

将二进制数据转换为十六进制表示。返回字节字符串。

  • ubinascii.unhexlify(data)

将十六进制数据转换为二进制表示。返回字节字符串。 (即hexlify的倒数)

  • ubinascii.a2b_base64(data)

解码base64编码的数据,忽略输入中的无效字符。符合 RFC 2045 s.6.8. 返回一个bytes对象。

  • ubinascii.b2a_base64(data)

以base64格式编码二进制数据,如 RFC 3548所述。返回编码数据,后跟换行符,作为bytes对象。

2.6 ucollections - 集合和容器类型

  • ucollections.deque(iterable, maxlen[, flags])

  • 介绍

Deques(双端队列)是一个类似列表的容器,支持O(1)追加并从双端队列的任一侧弹出。使用以下参数创建新的deques:

  • iterable必须是空元组,并且新的deque被创建为空。
  • 必须指定maxlen,并且双端队列将限制为此最大长度。一旦双端队列已满,添加的任何新项目将丢弃对方的项目。
  • 添加项目时,可选标志可以为1以检查溢出。
  • 方法
  • deque.append(x)

x添加到双端队列的右侧。如果启用了溢出检查并且没有剩余空间,则引发 IndexError。

  • deque.popleft()

从双端队列的左侧移除并返回一个项目。如果没有项目,则引发 IndexError。(右端同理)

  • ucollections.namedtuple(name, fields)

  • 介绍

这是工厂函数,用于创建具有特定名称和字段集的新的namedtuple类型。 namedtuple是元组的子类,它不仅可以通过数字索引访问其字段,还可以使用符号字段名称访问属性访问语法。 Fields是指定字段名称的字符串序列。为了与CPython兼容,它也可以是一个以空格分隔的字段命名的字符串(但效率较低)。

  • 示例
from ucollections import namedtuple

MyTuple = namedtuple("MyTuple", ("id", "name"))
t1 = MyTuple(1, "foo")
t2 = MyTuple(2, "bar")
print(t1.name)
assert t2.name == t2[1]
  • ucollections.OrderedDict(...)

  • 介绍

dict类型子类,它记住并保留添加的键的顺序。当迭代命令dict时,按照添加的顺序返回键/项:

from ucollections import OrderedDict

# To make benefit of ordered keys, OrderedDict should be initialized
# from sequence of (key, value) pairs.
d = OrderedDict([("z", 1), ("a", 2)])
# More items can be added as usual
d["w"] = 5
d["b"] = 3
for k, v in d.items():
 print(k, v)

"""
Output:
z 1
a 2
w 5
b 3
"""

2.7 uctypes – 以结构化方式访问二进制数据

2.8 uerrno — 系统错误代码

2.9 uhashlib –哈希算法

  • 介绍

该模块实现二进制数据哈希算法。可用算法的确切清单取决于电路板。在可以实现的算法中:

SHA256-SHA2系列的最新现代哈希算法。它适用于密码安全的目的。除非它具有特定的代码大小限制,否则建议将其包含在MicroPython内核中,并建议任何开发板都提供此功能。

在 K210 中有硬件加速,不是软件计算

a = bytes([0]*65)
b = hashlib.sha256(a)
c = b.digest()
print(c)
  • 类 uhashlib.sha256([data])

创建一个SHA256哈希对象,并有选择地向其中馈送数据。

方法

  • hash.update(data)

将更多的二进制数据输入哈希。

  • hash.digest()

返回通过哈希传递的所有数据的哈希,作为字节对象。调用此方法后,无法再将更多数据馈入哈希。

注意: 在micropython中, 使用此函数会完成最后的计算, 不是单纯的将结果显示出来, 所以只能调用一次, 如果你要多次使用这个值, 请保存到变量.

c = b.digest()
print(c)

多次调用会发现返回值不相同

c = b.digest()
d = b.digest()
print(c == d) # False
  • hash.hexdigest()

未实现此方法。使用 ubinascii.hexlify(hash.digest()) 可获得类似的效果。

2.10 uheapq – 堆队列算法

  • heappush

uheapq.heappush(heap, item)

将元素放入堆。

  • heappop

uheapq.heappop(heap)

弹出堆中的第一个元素,然后将其返回。 如果heap为空,则引发IndexError

  • heapify

uheapq.heapify(x)

将列表x转换为堆。 这是一个 in-place(划分交换排序)操作。

2.11 ujson – JSON encoding and decoding

  • dump

ujson.dump(obj, stream)

obj 序列化化为 JSON 字符串,将其写入给定的流。

  • dumps

ujson.dumps(obj)

返回表示为 JSON 字符串的 obj

  • load

ujson.load(stream)

解析给定的流,将其解释为 JSON 字符串并将数据反序列化为 Python 对象。返回结果对象。

解析继续,直到遇到文件结尾。如果未正确形成流中的数据,则会引发 ValueError。

  • loads

ujson.loads(str)

解析JSON str并返回一个对象。如果字符串格式出错,则引发ValueError。

2.12 uos – 基本的“操作系统”服务

常用函数

  • uos.uname()

返回一个元组(可能是一个命名了的元组),其中包含有关底层机器和/或其操作系统的信息。元组按以下顺序有五个字段,每个字段都是一个字符串:

  • sysname - 底层系统的名称
  • nodename - 节点名(/板子名称)(可以与sysname相同)
  • release - 底层系统的版本
  • version - MicroPython版本和构建日期
  • machine - 底层硬件的标识符(例如,板,CPU)
  • uos.urandom(n)

返回一个包含n个随机字节的字节对象。只要有可能,它就由硬件随机数生成器生成。

  • uos.chdir(path)

更改当前目录。

  • uos.getcwd()

获取当前目录。

  • uos.ilistdir([dir])

此函数返回一个迭代器,然后生成与列出的目录中的条目对应的元组。如果不传参数,它列出了当前目录,否则它列出了dir给出的目录。

元组具有形式(名称,类型,inode [,大小]):

  • name: 是一个字符串(如果dir是一个字节对象,则为字节),并且是条目的名称;
  • type: 是一个整数,指定条目的类型,目录为 0x4000,常规文件为 0x8000;
  • inode: 是对应于文件inode的整数,对于没有这种概念的文件系统可以是0。
  • 某些平台可能会返回包含条目大小的4元组。对于文件条目,size是表示文件大小的整数,如果未知则为-1。目前条目的含义目前尚未定义。
  • uos.listdir([dir])

如果没有参数,请列出当前目录。否则列出给定目录。

  • uos.mkdir(path)

创建一个新目录。

  • uos.remove(path)

删除文件。

  • uos.rmdir(path)

删除目录。

  • uos.rename(old_path,new_path)

重命名文件。

  • uos.stat(path)

获取文件或目录的状态。

更多API点我查看

2.13 ure – 简单的正则表达式

  • 支持的运算符

  • . : 匹配任何字符。
  • [...] : 匹配字符集。 支持单个字符和范围,包括否定集(例如[^ a-c])。
  • ^ : 匹配字符串的开头。
  • $ : 匹配字符串的结尾。
  • ? : 匹配零个或前一个子模式之一。
  • * : 匹配前一个子模式的零个或多个。
  • + : 匹配前一个子模式中的一个或多个。
  • ?? : 非贪婪版的,匹配零或一,偏好为零。
  • *? : *的非贪婪版本,匹配零或更多,优先选择最短匹配。
  • +? : 非贪婪的“+”版本,匹配一个或多个,优先匹配最短。
  • | : 匹配此运算符的左侧或右侧子模式。
  • (...) : 分组。 每个组都在捕获(它捕获的子字符串可以使用`match.group()方法访问)。
  • \d : 匹配数字。 相当于[0-9]
  • \D : 匹配非数字。 相当于[^ 0-9]
  • \s :匹配空白。相当于。[ \t-\r]
  • \S : 匹配非空白。相当于。[^ \t-\r]
  • \w : 匹配“单词字符”(仅限ASCII)。 相当于 [A-Za-z0-9_].
  • \W : 匹配非“单词字符”(仅限ASCII)。 相当于 [^A-Za-z0-9_].
  • \ : 转义字符。 除了上面列出的那些之外,反斜杠后面的任何其他字符都是字面意思。 例如,\*等同于文字*(不被视为*运算符)。 请注意,\r\n,等不是专门处理的,并且相当于文字字母rn等。因此,不建议使用原始Python字符串(r“”)用于正则表达式。 例如,r“\r \n”用作正则表达式时相当于“rn”。 要匹配CR后跟LF的字符,请使用"\r\n"
  • 不支持的运算符

  • 重复计算 ({m,n})
  • 命名组 ((?P<name>...))
  • 非捕获组 ((?:...))
  • 更高级的断言 (\b, \B)
  • \r\n这样的特殊字符转义 - 使用Python自己的转义
  • 其它

例子

import ure

# As ure doesn't support escapes itself, use of r"" strings is not
# recommended.
regex = ure.compile("[\r\n]")

regex.split("line1\rline2\nline3\r\n")

# Result:
# ['line1', 'line2', 'line3', '', '']

方法

  • ure.compile(regex_str[, flags])

编译正则表达式, 返回regex 对象。

  • ure.match(regex_str, string)

编译regex_str并匹配字符串。 匹配始终从字符串中的起始位置开始。

  • ure.search(regex_str, string)

编译regex_str并在字符串中搜索它。 与match不同,这将搜索字符串以匹配正则表达式的第一个位置(如果正则表达式被锚定,它仍然可以是0)。

  • ure.sub(regex_str, replace, string, count=0, flags=0)

编译regex_str并在字符串中搜索它,用replace替换所有匹配项,并返回新字符串。

replace可以是字符串或函数。 如果它是一个字符串,那么\<number>\g<number>形式的转义序列可用于扩展到相应的组(或不匹配组的空字符串)。 如果replace是一个函数,那么它必须采用一个参数(匹配)并且应该返回一个替换字符串。

如果指定了count并且非零,那么在进行许多替换之后,替换将停止。 flags参数被忽略。

注意:此函数的可用性取决于MicroPython port

Regex 对象

编译了的正则表达式。 使用ure.compile()创建此类的实例。

  • regex.match(string) regex.search(string) regex.sub(replace, string, count=0, flags=0)

类似于模块级函数match()search()sub()。 如果将相同的正则表达式应用于多个字符串,则使用方法会更高效。

  • regex.split(string, max_split=-1)

使用正则表达式拆分字符串。 如果给出 max_split,则指定要执行的最大拆分数。 返回字符串列表(如果指定了,则最多可以有 max_split + 1 个元素)。

Match 对象

匹配match()search()方法返回的对象,并传递给sub()中的替换函数。

  • match.group(index)

返回匹配(子)字符串。 整个匹配的索引为0,每个捕获组的索引为1和更高。 仅支持数字组。

  • match.groups()

返回包含匹配组的所有子串的元组。

注意:此方法的可用性取决于MicroPython 移植实现

  • match.start([index]) match.end([index])

返回匹配的子字符串组的开头或结尾的原始字符串中的索引。 index默认为整个组,否则将选择一个组。

注意:这些方法的可用性取决于MicroPython 移植实现

  • match.span([index])

返回2元组(match.start(index),match.end(index))

注意:此方法的可用性取决于MicroPython 移植 是否实现。

2.14 usocket – 套接字模块

2.15 ustruct – 打包和解包原始数据类型

支持的大小/字节顺序前缀: @, <, >, !.

支持的格式代码: b, B, h, H, i, I, l, L, q, Q, s, P, f, d (后者2取决于浮点支持)。

  • calcsize

ustruct.calcsize(fmt)

返回存储给定fmt所需的字节数。

  • pack

ustruct.pack(fmt, v1, v2, ...)

根据格式字符串fmt打包值v1v2...。返回值是编码值的字节对象。

  • pack_into

ustruct.pack_into(fmt, buffer, offset, v1, v2, ...)

根据格式字符串fmt将值v1v2...打包到从offset开始的缓冲区中。从缓冲区的末尾开始计数可能是负数。

  • unpack

ustruct.unpack(fmt, data)

根据格式字符串fmtdata解包。返回值是解压缩值的元组。

  • unpack_from

ustruct.unpack_from(fmt, data, offset=0)

根据格式字符串fmtoffset 开始从data解包。 offset可能是负数,从缓冲区的末尾开始计数。返回值是解压缩值的元组。

2.16 utime – 时间相关的功能

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

时间纪元: Unix移植版本使用标准为1970-01-01 00:00:00 UTC的POSIX系统时代。但是,嵌入式移植版本使用的是2000-01-01 00:00:00 UTC的纪元。

维护实际日历日期/时间: 这需要实时时钟(RTC)。在具有底层OS(包括一些RTOS)的系统上,RTC可能是隐含的。设置和维护实际日历时间是OS / RTOS的责任,并且在MicroPython之外完成,它只使用OS API来查询日期/时间。在裸机移植上,系统时间依赖于machine.RTC()对象。可以使用machine.RTC()。datetime(tuple)函数设置当前日历时间,并通过以下方式维护:

  • 通过备用电池(可能是特定电路板的附加可选组件)。
  • 使用联网时间协议(需要由移植/用户设置)。
  • 每次上电时由用户手动设置(许多电路板在硬复位时保持RTC时间,但有些可能需要在这种情况下再次设置)。
    如果未使用系统/ MicroPython RTC维护实际日历时间,则低于此要求参考当前绝对时间的函数可能与预期不符。

utime函数

  • utime.localtime([secs])

将自纪元(见上文)以秒为单位的时间转换为8元组,其中包含:(年,月,日,小时,分钟,秒,工作日,晚期)如果未提供秒数或无,则为当前时间来自RTC使用。

  • 年份包括世纪(例如2014年)。
  • 月是1-12
  • mday是1-31
  • 小时是0-23
  • 分钟是0-59
  • 秒是0-59
    周一至周日的工作日为0-6
  • yearday是1-366
  • utime.mktime()

这是本地时间的反函数。它的参数是一个完整的8元组,表示按当地时间表示的时间。它返回一个整数,它是自2000年1月1日以来的秒数。

  • utime.sleep(seconds)

睡眠给定的秒数。有些电路板可能会接受秒作为浮点数来休眠几秒钟。请注意,其他板可能不接受浮点参数,因为与它们的兼容性使用 sleep_ms()sleep_us() 函数。

  • utime.sleep_ms(ms)

给定毫秒数的延迟应为正或0。

  • utime.sleep_us(us)

给定微秒数的延迟应为正或0。

  • utime.ticks_ms()

返回一个带有任意参考点的递增毫秒计数器,它在某个值之后回绕。

环绕值未明确公开,但我们将其称为TICKS_MAX以简化讨论。值的周期为TICKS_PERIOD = TICKS_MAX + 1. TICKS_PERIOD保证为2的幂,但在不同硬件的移植之间可能不同。相同的句点值用于所有ticks_ms()ticks_us()ticks_cpu()函数(为简单起见)。因此,这些函数将返回范围[0 .. TICKS_MAX]中的值,包括总TICKS_PERIOD值。请注意,仅使用非负值。在大多数情况下,您应该将这些函数返回的值视为不透明。可用的唯一操作是ticks_diff()ticks_add()函数,如下所述。

注意:直接对这些值执行标准数学运算(+, - )或关系运算符(<,<=,>,> =)将导致无效结果。执行数学运算然后将其结果作为参数传递给ticks_diff()或ticks_add()也将导致后者函数的无效结果。

  • utime.ticks_us()

就像上面的ticks_ms()一样,但是在几微秒内。

  • utime.ticks_cpu()

类似于ticks_ms()ticks_us(),但系统中的分辨率最高。这通常是CPU时钟,这就是函数以这种方式命名的原因。但它不必是CPU时钟,而是可以使用系统中可用的一些其他定时源(例如,高分辨率定时器)。在utime模块级别没有指定此函数的确切时间单位(分辨率),但特定硬件的文档可能提供更具体的信息。此功能用于非常精细的基准测试或非常紧凑的实时循环。避免在便携式代码中使用它。

clock 对象

time.clock() 返回

  • clock.tick()

记录开始时间(ms), 与clock.fps()搭配使用可以计算fps

返回值 ---> None

  • clock.fps()

根据上一个调用clock.tick()到现在的时间计算出帧率(fps

import sensor
import time
clock = time.clock()
sensor.reset()
sensor.set_pixformat(sensor.RGB565)
sensor.set_framesize(sensor.QVGA)
while True:
    clock.tick()
    sensor.snapshot()
    print("fps = ",clock.fps())
  • clock.reset()

重置所有标记

  • clock.avg()

根据上一个调用clock.tick()到现在的时间计算出每帧消耗的时间

更多API点我查看

2.17 uzlib — zlib 解压缩

该模块允许解压使用 DEFLATE 算法压缩的二进制数据(通常用于zlib库和gzip存档器)。

压缩尚未实现。

  • decompress

解压

uzlib.decompress(data, wbits=0, bufsize=0)

参数

  • wbits: 压缩期间使用的 DEFLATE 字典窗口大小(8-15,字典大小是该值的2的幂)。 另外,如果值为正,则假定数据为 zlib 流(使用 zlib 头)。 否则,如果它是负数,则假定它是原始 DEFLATE 流。
  • bufsize: 参数用于与CPython兼容, 可忽略。

返回值

  • 将解压缩的数据作为bytes类型返回。
  • DecompIO

创建一个流包装器,允许对另一个流中的压缩数据进行透明解压缩。 这允许处理具有大于可用堆大小的数据的压缩流。 除了decompress()中描述的值之外,wbits可以取值 24..31(16+8..15),这意味着输入流具有gzip头。

class uzlib.DecompIO(stream, wbits=0)

2.18 machine

  • machine.unique_id()

返回32 字节的唯一ID

  • machine.reset()

重启

2.18.1 machine.I2C

I2C 总线协议,简单地使用两条线(SCL,SDA)可以控制多个从机(主机模式)。

  • 支持主机模式和从机模式
  • 7 位/10 位寻址模式
  • 标准模式 <=100Kb/s
  • 快速模式 <=400Kb/s
  • 超快速模式 <=1000Kb/s
  • 高速模式 3.4Mb/s

2.18.2 machine.PWM

PWM: 脉宽调制模块, 硬件支持的PWM, 可以指定任意引脚(0到47引脚)

每个 PWM 依赖于一个定时器, 即当定时器与 PWM 功能绑定后, 不能作为普通定时器使用了。 因为有 3 个定时器, 每个定时器有 4 个通道, 即最大可以同时产生 12 路 PWM 波形

2.18.3 machine.SPI

SPI(Serial Peripheral Interface) 是一个同步串行协议,由主机和从机组成。

标准4线模式由 SCK(SCLK), CS(片选), MOSI, MISO 4条线连接主从机

在 K210 上, SPI 有一下特征:

  • 共有 4 个 SPI 设备, 其中 SPI0 、SPI1、 SPI3 只能工作在主机模式下, SPI2 只能工作在从机模式时下, 在 MaixPy 上, SPI3 已经用来连接了 SPI Flash 作为保留硬件资源。
  • 支持 1/2/4/8 线全双工模式, 在 MaixPy 中, 目前只支持标准(摩托罗拉)4线全双工模式(即 SCK, MOSI, MISO, CS 四个引脚)
  • 最高传输速率 45M:1/2主频,约 200Mbps
  • 支持 DMA
  • 4个可配置任意引脚的硬件片选

2.18.4 machine.Timer

硬件定时器,可以用来定时触发任务或者处理任务,设定时间到了后可以触发中断(调用回调函数),精度比软件定时器高。
需要注意的是,定时器在不同的硬件中可能会有不同的表现。MicroPython 的 Timer 类定义了在给定时间段内(或在一段延迟后执行一次回调)执行回调的基本操作,并允许特定的硬件上定义更多的非标准行为(因此不能移植到其他板)。

共有 3 个定时器, 每个定时器有 4 个通道可以使用

构造函数

tim = machine.Timer(id, channel, mode=Timer.MODE_ONE_SHOT, period=1000, unit=Timer.UNIT_MS, callback=None, arg=None, start=True, priority=1, div=0)

通过指定的参数新建一个 Timer 对象

  • 参数
  • id: Timer ID, [0~2] (Timer.TIMER0~TIMER2)
  • channel: Timer 通道, [Timer.CHANNEL0~Timer.CHANNEL3]
  • mode: Timer 模式, MODE_ONE_SHOT 或者 MODE_PERIODIC 或者 MODE_PWM
  • period: Timer 周期, 在启动定时器后 period 时间, 回调函数将会被调用,(0,~)
  • unit: 设置周期的单位,默认位毫秒(ms),Timer.UNIT_S 或者 Timer.UNIT_MS 或者 Timer.UNIT_US 或者Timer.UNIT_NS
  • callback: 定时器回调函数, 定义了两个参数, 一个是定时器对象Timer, 第二个是在定义对象是希望传的参数arg,更多请看arg参数解释

注意:回调函数是在中断中调用的,所以在回调函数中请不要占用太长时间以及做动态分配开关中断等动作

  • arg: 希望传给回调函数的参数,作为回调函数的第二个参数
  • start: 是否在对象构建成功后立即开始定时器, True:立即开始, False:不立即开启,需要调用start()函数来启动定时器
  • priority: 硬件定时器中断优先级, 与特定的CPU相关, 在K210中,取值范围是[1,7], 值越小优先级越高
  • div: 硬件定时器分频器,取值范围[0,255], 默认为0, clk_timer(定时器时钟频率) = clk_pll0(锁相环0频率)/2^(div+1)

clk_timer*period(unit:s) 应该 < 2^32 并且 >=1

方法

  • init

类似构造函数

tim.init(id, channel, mode=Timer.MODE_ONE_SHOT, period=1000, unit=Timer.UNIT_MS, callback=None, arg=None, start=True, priority=1, div=0)
  • 参数

类似构造函数

  • 返回值

  • callback_arg

获取设置的传给回调函数的参数,只能是 Timer 对象调用, 类 Timer 不能调用。

  • callback

获取或者设置回调函数

tim.callback(callback)
  • 参数

callback: 设置的回调函数,可选参数, 如果不传参数,则只返回先有的回调函数

  • 返回值

当前的回调函数

  • 例子
def on_timer(timer):
    print("time up:",timer)
    print("param:",timer.callback_arg())

tim.callback(on_timer)
print(on_timer, tim.callback())
  • period

获取或者设置定时周期

tim.period(period)
  • 参数

period: 可选参数,配置周期, 如果不传参数, 则只返回当前周期值

  • 返回值

当前周期值

  • 例子
tim.period(2000)
print( tim.period() )
  • start

启动定时器

tim.start()
  • 参数

  • 返回值

  • 例子
tim.start()
  • stop

停止定时器

tim.stop()
  • 参数

  • 返回值

  • restart

重新开启定时器

tim.restart()
  • 参数

  • 返回值

  • deinit/____del

注销定时器,并且注销硬件的占用,关闭硬件的时钟

tim.deinit()
# del tim
  • 参数

  • 返回值

常量

  • TIMER0: Timer0 id
  • TIMER1: Timer1 id
  • TIMER2: Timer2 id
  • CHANNEL0: Timer 通道 0
  • CHANNEL1: Timer 通道 1
  • CHANNEL2: Timer 通道 2
  • CHANNEL3: Timer 通道 3
  • MODE_ONE_SHOT: Timer 只运行一次(回调一次)
  • MODE_PERIODIC: Timer 始终运行(连续回调)
  • MODE_PWM: 定时器不用来回调函数,用以产生PWM
  • UNIT_S: 单位秒 (s)
  • UNIT_MS: 单位毫秒 (ms)
  • UNIT_US: 单位微秒 (us)
  • UNIT_NS: 单位纳秒 (ns)

例程

  • 例程 1

定时3秒后打印信息

from machine import Timer

def on_timer(timer):
    print("time up:",timer)
    print("param:",timer.callback_arg())

tim = Timer(Timer.TIMER0, Timer.CHANNEL0, mode=Timer.MODE_ONE_SHOT, period=3000, callback=on_timer, arg=on_timer)
print("period:",tim.period())
  • 例程 2

每隔 1 秒打印消息, 停止 5 秒后再重启, 5 秒后关闭并注销定时器

import time
from machine import Timer

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

2.18.5 machine.UART

2.18.6 network

2.18.7 machine.WDT

MaixPy 的 WDT 看门狗模块,用于在应用程序崩溃且最终进入不可恢复状态时重启系统。一旦开始,当硬件运行期间没有定期进行喂狗(feed)就会在超时后自动复位。

构造函数

from machine import WDT
wdt0 = WDT(id=1, timeout=4000, callback=on_wdt, context={})

通过指定的参数新建一个 WDT 对象

  • 参数
  • id: 这个看门狗对象必须初始化时必须指定 ID (0 ~ 2) 用于区分使用的看门狗。
  • timeout: 看门狗超时时间,单位为毫秒(ms)。
  • callback: (可选)可以在超时后执行的回调函数。
  • context: (可选)为回调函数传递的参数。

方法

  • feed

“喂养”看门狗,以防止其重置系统。该应用应将该调用用于合适位置,并确保只在验证一切正常运行后才“喂养”看门狗。

wdt0.feed()
  • 参数

  • 返回值

  • stop

停止当前看门狗对象

wdt0.stop()
  • 参数

  • 返回值

例程

  • 例程 1 (基础使用)

喂一次狗后便不再喂狗使得系统复位

import time
from machine import WDT

# '''
# test default wdt
wdt0 = WDT(id=0, timeout=3000)
print('into', wdt0)
time.sleep(2)
print(time.ticks_ms())
# 1.test wdt feed
wdt0.feed()
time.sleep(2)
print(time.ticks_ms())
# 2.test wdt stop
# wdt0.stop()
  • 例程 2 (进阶使用)

在回调函数中喂狗,系统正常运行

import time
from machine import WDT
def on_wdt(self):
    print(self.context(), self)
    self.feed()
    ## release WDT
    #self.stop()

# test callback wdt
wdt1 = WDT(id=1, timeout=4000, callback=on_wdt, context={})
print('into', wdt1)
time.sleep(2)
print(time.ticks_ms())
# 1.test wdt feed
wdt1.feed()
time.sleep(2)
print(time.ticks_ms())
# 2.test wdt stop
# wdt1.stop()
# print('stop', wdt1)
# 3.wait wdt work
while True:
    print('idle', time.ticks_ms())
    time.sleep(1)

2.19 Maix

2.19.1 FPIOA (现场可编程 IO 阵列, Field Programmable Input and Output Array)

K210 支持每个外设随意映射到任意引脚, 使用 FPIOA 功能来实现。

注意:

以下 GPIOHS 默认已经被使用, 程序中如非必要尽量不要使用:

GPIOHS 功能 描述
GPIOHS5 LCD_DC LCD 读写信号引脚
GPIOHS4 LCD_RST LCD 复位芯片脚
GPIOHS29 SD_CS SD 卡 SPI 片选
GPIOHS28 MIC_LED_CLK SK9822_DAT
GPIOHS27 MIC_LED_DATA SK9822_CLK

方法

  • help(func)

显示外设及其简要描述

  • 参数
  • func: 外设名(功能/编号),可以不传参, 则以表格的形式显示所有外设名即简要描述,这个表格也可以在本页的末尾找到(附录:外设表);

    如果传参,则传一个整型值, 找到该编号对应的外设后会打印外设名和描述,

    比如 FPIOA.JTAG_TCLK 或者 fm.fpioa.JTAG_TCLKfm在本页后面介绍) 或者 0
  • 例程
from Maix import FPIOA

fpioa = FPIOA()
fpioa.help()
fpioa.help(0)
fpioa.help(fpioa.JTAG_TCLK)
fm.fpioa.help()
fm.fpioa.help(fm.fpioa.JTAG_TCLK)
  • 返回

外设名及其简要描述

  • set_function(pin, func)

设置引脚对应的外设功能, 即引脚映射

  • 参数
  • pin: 引脚编号,取值 [0, 47], 具体的引脚连接请看电路图, 也可以使用 board_info. 然后按 TAB 按键补全来获得板子的常用引脚,比如 board_info.LED_G
  • func: 外设功能,传一个整型值,可以通过 fm.fpioa.help()或者查本页末尾的 附录: 外设表 表得到.
  • 例程

需要将连接 绿色 LED 的引脚映射到 高速 GPIO0

fpioa = FPIOA()
fpioa.set_function(board_info.LED_G, fm.fpioa.GPIOHS0)
  • get_Pin_num(func)

获取外设映射到哪个引脚上了

  • 参数
  • func: 外设功能,传一个整型值,可以通过 fm.fpioa.help()或者查本页末尾的 附录: 外设表 表得到
  • 例程
fpioa = FPIOA()
fpioa.set_function(board_info.LED_G, fm.fpioa.GPIOHS0)
pin = fpioa.get_Pin_num(fm.fpioa.GPIOHS0)
if pin == board_info.LED_G:
    print("set function ok")

外设表

外设功能(func) 简要描述
JTAG_TCLK JTAG Test Clock
JTAG_TDI JTAG Test Data In
JTAG_TMS JTAG Test Mode Select
JTAG_TDO JTAG Test Data Out
SPI0_D0 SPI0 Data 0
SPI0_D1 SPI0 Data 1
SPI0_D2 SPI0 Data 2
SPI0_D3 SPI0 Data 3
SPI0_D4 SPI0 Data 4
SPI0_D5 SPI0 Data 5
SPI0_D6 SPI0 Data 6
SPI0_D7 SPI0 Data 7
SPI0_SS0 SPI0 Chip Select 0
SPI0_SS1 SPI0 Chip Select 1
SPI0_SS2 SPI0 Chip Select 2
SPI0_SS3 SPI0 Chip Select 3
SPI0_ARB SPI0 Arbitration
SPI0_SCLK SPI0 Serial Clock
UARTHS_RX UART High speed Receiver
UARTHS_TX UART High speed Transmitter
RESV6 Reserved function
RESV7 Reserved function
CLK_SPI1 Clock SPI1
CLK_I2C1 Clock I2C1
GPIOHS0 GPIO High speed 0
GPIOHS1 GPIO High speed 1
GPIOHS2 GPIO High speed 2
GPIOHS3 GPIO High speed 3
GPIOHS4 GPIO High speed 4
GPIOHS5 GPIO High speed 5
GPIOHS6 GPIO High speed 6
GPIOHS7 GPIO High speed 7
GPIOHS8 GPIO High speed 8
GPIOHS9 GPIO High speed 9
GPIOHS10 GPIO High speed 10
GPIOHS11 GPIO High speed 11
GPIOHS12 GPIO High speed 12
GPIOHS13 GPIO High speed 13
GPIOHS14 GPIO High speed 14
GPIOHS15 GPIO High speed 15
GPIOHS16 GPIO High speed 16
GPIOHS17 GPIO High speed 17
GPIOHS18 GPIO High speed 18
GPIOHS19 GPIO High speed 19
GPIOHS20 GPIO High speed 20
GPIOHS21 GPIO High speed 21
GPIOHS22 GPIO High speed 22
GPIOHS23 GPIO High speed 23
GPIOHS24 GPIO High speed 24
GPIOHS25 GPIO High speed 25
GPIOHS26 GPIO High speed 26
GPIOHS27 GPIO High speed 27
GPIOHS28 GPIO High speed 28
GPIOHS29 GPIO High speed 29
GPIOHS30 GPIO High speed 30
GPIOHS31 GPIO High speed 31
GPIO0 GPIO pin 0
GPIO1 GPIO pin 1
GPIO2 GPIO pin 2
GPIO3 GPIO pin 3
GPIO4 GPIO pin 4
GPIO5 GPIO pin 5
GPIO6 GPIO pin 6
GPIO7 GPIO pin 7
UART1_RX UART1 Receiver
UART1_TX UART1 Transmitter
UART2_RX UART2 Receiver
UART2_TX UART2 Transmitter
UART3_RX UART3 Receiver
UART3_TX UART3 Transmitter
SPI1_D0 SPI1 Data 0
SPI1_D1 SPI1 Data 1
SPI1_D2 SPI1 Data 2
SPI1_D3 SPI1 Data 3
SPI1_D4 SPI1 Data 4
SPI1_D5 SPI1 Data 5
SPI1_D6 SPI1 Data 6
SPI1_D7 SPI1 Data 7
SPI1_SS0 SPI1 Chip Select 0
SPI1_SS1 SPI1 Chip Select 1
SPI1_SS2 SPI1 Chip Select 2
SPI1_SS3 SPI1 Chip Select 3
SPI1_ARB SPI1 Arbitration
SPI1_SCLK SPI1 Serial Clock
SPI_SLAVE_D0 SPI Slave Data 0
SPI_SLAVE_SS SPI Slave Select
SPI_SLAVE_SCLK SPI Slave Serial Clock
I2S0_MCLK I2S0 Master Clock
I2S0_SCLK I2S0 Serial Clock(BCLK)
I2S0_WS I2S0 Word Select(LRCLK)
I2S0_IN_D0 I2S0 Serial Data Input 0
I2S0_IN_D1 I2S0 Serial Data Input 1
I2S0_IN_D2 I2S0 Serial Data Input 2
I2S0_IN_D3 I2S0 Serial Data Input 3
I2S0_OUT_D0 I2S0 Serial Data Output 0
I2S0_OUT_D1 I2S0 Serial Data Output 1
I2S0_OUT_D2 I2S0 Serial Data Output 2
I2S0_OUT_D3 I2S0 Serial Data Output 3
I2S1_MCLK I2S1 Master Clock
I2S1_SCLK I2S1 Serial Clock(BCLK)
I2S1_WS I2S1 Word Select(LRCLK)
I2S1_IN_D0 I2S1 Serial Data Input 0
I2S1_IN_D1 I2S1 Serial Data Input 1
I2S1_IN_D2 I2S1 Serial Data Input 2
I2S1_IN_D3 I2S1 Serial Data Input 3
I2S1_OUT_D0 I2S1 Serial Data Output 0
I2S1_OUT_D1 I2S1 Serial Data Output 1
I2S1_OUT_D2 I2S1 Serial Data Output 2
I2S1_OUT_D3 I2S1 Serial Data Output 3
I2S2_MCLK I2S2 Master Clock
I2S2_SCLK I2S2 Serial Clock(BCLK)
I2S2_WS I2S2 Word Select(LRCLK)
I2S2_IN_D0 I2S2 Serial Data Input 0
I2S2_IN_D1 I2S2 Serial Data Input 1
I2S2_IN_D2 I2S2 Serial Data Input 2
I2S2_IN_D3 I2S2 Serial Data Input 3
I2S2_OUT_D0 I2S2 Serial Data Output 0
I2S2_OUT_D1 I2S2 Serial Data Output 1
I2S2_OUT_D2 I2S2 Serial Data Output 2
I2S2_OUT_D3 I2S2 Serial Data Output 3
RESV0 Reserved function
RESV1 Reserved function
RESV2 Reserved function
RESV3 Reserved function
RESV4 Reserved function
RESV5 Reserved function
I2C0_SCLK I2C0 Serial Clock
I2C0_SDA I2C0 Serial Data
I2C1_SCLK I2C1 Serial Clock
I2C1_SDA I2C1 Serial Data
I2C2_SCLK I2C2 Serial Clock
I2C2_SDA I2C2 Serial Data
CMOS_XCLK DVP System Clock
CMOS_RST DVP System Reset
CMOS_PWDN DVP Power Down Mode
CMOS_VSYNC DVP Vertical Sync
CMOS_HREF DVP Horizontal Reference output
CMOS_PCLK Pixel Clock
CMOS_D0 Data Bit 0
CMOS_D1 Data Bit 1
CMOS_D2 Data Bit 2
CMOS_D3 Data Bit 3
CMOS_D4 Data Bit 4
CMOS_D5 Data Bit 5
CMOS_D6 Data Bit 6
CMOS_D7 Data Bit 7
SCCB_SCLK SCCB Serial Clock
SCCB_SDA SCCB Serial Data
UART1_CTS UART1 Clear To Send
UART1_DSR UART1 Data Set Ready
UART1_DCD UART1 Data Carrier Detect
UART1_RI UART1 Ring Indicator
UART1_SIR_IN UART1 Serial Infrared Input
UART1_DTR UART1 Data Terminal Ready
UART1_RTS UART1 Request To Send
UART1_OUT2 UART1 User-designated Output 2
UART1_OUT1 UART1 User-designated Output 1
UART1_SIR_OUT UART1 Serial Infrared Output
UART1_BAUD UART1 Transmit Clock Output
UART1_RE UART1 Receiver Output Enable
UART1_DE UART1 Driver Output Enable
UART1_RS485_EN UART1 RS485 Enable
UART2_CTS UART2 Clear To Send
UART2_DSR UART2 Data Set Ready
UART2_DCD UART2 Data Carrier Detect
UART2_RI UART2 Ring Indicator
UART2_SIR_IN UART2 Serial Infrared Input
UART2_DTR UART2 Data Terminal Ready
UART2_RTS UART2 Request To Send
UART2_OUT2 UART2 User-designated Output 2
UART2_OUT1 UART2 User-designated Output 1
UART2_SIR_OUT UART2 Serial Infrared Output
UART2_BAUD UART2 Transmit Clock Output
UART2_RE UART2 Receiver Output Enable
UART2_DE UART2 Driver Output Enable
UART2_RS485_EN UART2 RS485 Enable
UART3_CTS UART3 Clear To Send
UART3_DSR UART3 Data Set Ready
UART3_DCD UART3 Data Carrier Detect
UART3_RI UART3 Ring Indicator
UART3_SIR_IN UART3 Serial Infrared Input
UART3_DTR UART3 Data Terminal Ready
UART3_RTS UART3 Request To Send
UART3_OUT2 UART3 User-designated Output 2
UART3_OUT1 UART3 User-designated Output 1
UART3_SIR_OUT UART3 Serial Infrared Output
UART3_BAUD UART3 Transmit Clock Output
UART3_RE UART3 Receiver Output Enable
UART3_DE UART3 Driver Output Enable
UART3_RS485_EN UART3 RS485 Enable
TIMER0_TOGGLE1 TIMER0 Toggle Output 1
TIMER0_TOGGLE2 TIMER0 Toggle Output 2
TIMER0_TOGGLE3 TIMER0 Toggle Output 3
TIMER0_TOGGLE4 TIMER0 Toggle Output 4
TIMER1_TOGGLE1 TIMER1 Toggle Output 1
TIMER1_TOGGLE2 TIMER1 Toggle Output 2
TIMER1_TOGGLE3 TIMER1 Toggle Output 3
TIMER1_TOGGLE4 TIMER1 Toggle Output 4
TIMER2_TOGGLE1 TIMER2 Toggle Output 1
TIMER2_TOGGLE2 TIMER2 Toggle Output 2
TIMER2_TOGGLE3 TIMER2 Toggle Output 3
TIMER2_TOGGLE4 TIMER2 Toggle Output 4
CLK_SPI2 Clock SPI2
CLK_I2C2 Clock I2C2

2.19.2 GPIO

General Purpose Input Output (通用输入/输出)简称为 GPIO,或总线扩展器。

K210上有高速 GPIO(GPIOHS) 和通用 GPIO
在 K210 上, GPIO 有一下特征:

  • 高速 GPIO:

    高速 GPIO 为 GPIOHS,共 32 个。具有如下特点:

    • 可配置输入输出信号
    • 每个 IO 具有独立中断源
    • 中断支持边沿触发和电平触发
    • 每个 IO 可以分配到 FPIOA 上 48 个管脚之一
    • 可配置上下拉,或者高阻
  • 通用 GPIO:

    通用 GPIO 共 8 个,具有如下特点:

    • 8 个 IO 使用一个中断源
    • 可配置输入输出信号
    • 可配置触发 IO 总中断,边沿触发和电平触发
    • 每个 IO 可以分配到 FPIOA 上 48 个管脚之一

注意:

GPIOHS 默认已经被使用, 程序中如非必要尽量不要使用:

GPIOHS 功能
GPIOHS31 LCD_DC
GPIOHS30 LCD_RST
GPIOHS29 SD_CS
GPIOHS28 MIC_LED_CLK
GPIOHS27 MIC_LED_DATA

构造函数

class GPIO(ID, MODE, PULL, VALUE)

通过指定的参数新建一个 SPI 对象

  • 参数
  • ID: 使用的 GPIO 引脚(一定要使用 GPIO 里带的常量来指定)

  • MODE: GPIO模式

    • GPIO.IN就是输入模式

    • GPIO.OUT就是输出模式

  • PULL: GPIO上下拉模式

    • GPIO.PULL_UP 上拉

    • GPIO.PULL_DOWN 下拉

    • GPIO.PULL_NONE 即不上拉也不下拉

方法

  • value

修改/读取 GPIO 引脚状态

GPIO.value([value])
  • 参数

[value]: 可选参数,如果此参数不为空,则返回当前 GPIO 引脚状态

  • 返回值

如果 [value] 参数不为空,则返回当前 GPIO 引脚状态

  • irq

配置一个中断处理程序,当 pin 的触发源处于活动状态时调用它。如果管脚模式为 pin.in,则触发源是管脚上的外部值。

GPIO.irq(CALLBACK_FUNC,TRIGGER_CONDITION,GPIO.WAKEUP_NOT_SUPPORT,PRORITY)
  • 参数
  • CALLBACK_FUNC:中断回调函数,当中断触发的时候被调用,一个入口函数 pin_num

    • PIN_NUM 返回的是触发中断的 GPIO 引脚号(只有GPIOHS支持中断,所以这里的引脚号也是GPIOHS的引脚号)

  • TRIGGER_CONDITION:GPIO 引脚的中断触发模式

    • GPIO.IRQ_RISING 上升沿触发

    • GPIO.IRQ_FALLING 下降沿触发

    • GPIO.IRQ_BOTH 上升沿和下降沿都触发

  • 返回值

  • disirq

关闭中断

GPIO.disirq()
  • 参数

  • 返回值

  • mode

设置 GPIO 输入输出模式

GPIO.mode(MODE)
  • 参数
  • MODE

    GPIO.IN 输入模式

    GPIO.PULL_UP 上拉输入模式

    GPIO.PULL_DOWN 下拉输入模式

    GPIO.OUT 输出模式

  • 返回值

常量

  • GPIO0: GPIO0
  • GPIO1: GPIO1
  • GPIO2: GPIO2
  • GPIO3: GPIO3
  • GPIO4: GPIO4
  • GPIO5: GPIO5
  • GPIO6: GPIO6
  • GPIO7: GPIO7
  • GPIOHS0: GPIOHS0
  • GPIOHS1: GPIOHS1
  • GPIOHS2: GPIOHS2
  • GPIOHS3: GPIOHS3
  • GPIOHS4: GPIOHS4
  • GPIOHS5: GPIOHS5
  • GPIOHS6: GPIOHS6
  • GPIOHS7: GPIOHS7
  • GPIOHS8: GPIOHS8
  • GPIOHS9: GPIOHS9
  • GPIOHS10: GPIOHS10
  • GPIOHS11: GPIOHS11
  • GPIOHS12: GPIOHS12
  • GPIOHS13: GPIOHS13
  • GPIOHS14: GPIOHS14
  • GPIOHS15: GPIOHS15
  • GPIOHS16: GPIOHS16
  • GPIOHS17: GPIOHS17
  • GPIOHS18: GPIOHS18
  • GPIOHS19: GPIOHS19
  • GPIOHS20: GPIOHS20
  • GPIOHS21: GPIOHS21
  • GPIOHS22: GPIOHS22
  • GPIOHS23: GPIOHS23
  • GPIOHS24: GPIOHS24
  • GPIOHS25: GPIOHS25
  • GPIOHS26: GPIOHS26
  • GPIOHS27: GPIOHS27
  • GPIOHS28: GPIOHS28
  • GPIOHS29: GPIOHS29
  • GPIOHS30: GPIOHS30
  • GPIOHS31: GPIOHS31
  • GPIO.IN: 输入模式
  • GPIO.OUT: 输出模式
  • GPIO.PULL_UP: 上拉
  • GPIO.PULL_DOWN: 下拉
  • GPIO.PULL_NONE: 即不上拉也不下拉
  • GPIO.IRQ_RISING: 上升沿触发
  • GPIO.IRQ_FALLING:下降沿触发
  • GPIO.IRQ_BOTH: 上升沿和下降沿都触发

例程

  • DEMO1: 点亮 LED

board_info 与板卡相关,不同板卡配置不同,使用前需要手动配置

import utime
from Maix import GPIO
from board import board_info
from fpioa_manager import fm

fm.register(board_info.LED_R,fm.fpioa.GPIO0)
led_r=GPIO(GPIO.GPIO0,GPIO.OUT)
utime.sleep_ms(500)
led_r.value()
fm.unregister(board_info.LED_R)
  • DEMO2: 按键按下点亮 LED

board_info 与板卡相关,不同板卡配置不同,使用前需要手动配置

import utime
from Maix import GPIO
from board import board_info
from fpioa_manager import fm

fm.register(board_info.LED_R,fm.fpioa.GPIO0)
led_b = GPIO(GPIO.GPIO0,GPIO.OUT)
led_b.value(1)

fm.register(board_info.BOOT_KEY, fm.fpioa.GPIOHS1)
key = GPIO(GPIO.GPIOHS1, GPIO.IN)

utime.sleep_ms(100)
while True:
    if key.value() == 0: # 等待按键按下
        led_b.value(0)
        utime.sleep_ms(1000)
        break
    utime.sleep_ms(10)


led_b.value(1)

fm.unregister(board_info.LED_R)
fm.unregister(board_info.BOOT_KEY)
  • DEMO3: 在 3 秒内等待按键触发中断

0board_info 与板卡相关,不同板卡配置不同,使用前需要手动配置

import utime
from Maix import GPIO
from board import board_info
from fpioa_manager import fm

def test_irq(pin_num):
    print("key", pin_num, "\n")

fm.register(board_info.BOOT_KEY, fm.fpioa.GPIOHS0)
key = GPIO(GPIO.GPIOHS0, GPIO.IN, GPIO.PULL_NONE)

utime.sleep_ms(100)
key.irq(test_irq, GPIO.IRQ_BOTH, GPIO.WAKEUP_NOT_SUPPORT,7)
utime.sleep_ms(3000) # 在 3 秒内等待触发

key.disirq() # 禁用中断
fm.unregister(board_info.BOOT_KEY)

2.19.3 KPU

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

  • KPU 具备以下几个特点:
    • 支持主流训练框架按照特定限制规则训练出来的定点化模型
    • 对网络层数无直接限制,支持每层卷积神经网络参数单独配置,包括输入输出通道数目、输入输 出行宽列高
    • 支持两种卷积内核 1x1 和 3x3
    • 支持任意形式的激活函数
    • 实时工作时最大支持神经网络参数大小为 5.5MiB 到 5.9MiB
    • 非实时工作时最大支持网络参数大小为(Flash 容量-软件体积)

模块方法

  • load

从flash或者文件系统中加载模型

KPU.load(offset, file_path)
  • 参数

offsetfile_path 参数只能二选一,不需要关键词,直接传参即可

  • offset: 模型在 flash 中的偏移大小,如 0xd00000 表示模型烧录在13M起始的地方, 0x300000表示在 Flash 3M的地方
  • file_path: 模型在文件系统中为文件名, 如 “/sd/xxx.kmodel”
  • 返回值

如果正确加载,会返回返回值, 否则会抛出错误, 请看抛出的错误提示, 另外错误代码参考这里

如果发现错误代码是小于 2000 的值, 则是固件版本太低,需要更新固件版本

  • kpu_net: kpu 网络对象
  • load_flash

与 load 方法作用相同

kpu.load_flash(model_addr, is_dual_buf, batch_size, spi_speed)
  • 参数
  • model_addr:Flash addr 经过预处理的模型烧录到 flash 中的偏移地址。注意,这里需要预处理模型文件说明
  • is_dual_buf0,单一缓冲区加载,使用较少的 RAM 和较慢的速度动态加载该模型文件; 1,开启双缓冲加载,需要更大的 RAM, 运行速度相对较快。
  • batch_size:将 is_dual_buf 设置为 1 时,需要设置 load batch_size,建议值为 0x4000~0x10000,可以测试出模型的最佳值。如果 is_dual_buf 为 0 则设置为 0
  • spi_speed:使用 SPI flash 加载模型文件时,我们会暂时将 flash 设置为高速模式,并设置所需的 spi 时钟频率。该值应 <= 80000000(实际频率,设值可能不等于实际频率。)
  • 返回值

kpu_net: kpu 网络对象

  • init_yolo2

yolo2网络模型传入初始化参数, 只有使用yolo2时使用

KPU.init_yolo2(kpu_net, threshold, nms_value, anchor_num, anchor)
  • 例程
import KPU as kpu
task = kpu.load(0x300000)
anchor = (1.889, 2.5245, 2.9465, 3.94056, 3.99987, 5.3658, 5.155437, 6.92275, 6.718375, 9.01025)
kpu.init_yolo2(task, 0.5, 0.3, 5, anchor)
  • 参数
  • kpu_net: kpu 网络对象, 即加载的模型对象, KPU.load()的返回值
  • threshold: 概率阈值, 只有是这个物体的概率大于这个值才会输出结果, 取值范围:[0, 1]
  • nms_value: box_iou 门限, 为了防止同一个物体被框出多个框,当在同一个物体上框出了两个框,这两个框的交叉区域占两个框总占用面积的比例 如果小于这个值时, 就取其中概率最大的一个框
  • anchor_num: anchor 的锚点数, 这里固定为 len(anchors)//2
  • anchor: 锚点参数与模型参数一致,同一个模型这个参数是固定的,和模型绑定的(训练模型时即确定了), 不能改成其它值。
  • 返回值

successbool类型, 是否成功

  • deinit

释放模型占用的内存, 立即释放, 但是变量还在,可以使用del kpu_net_object 的方式删除,
另外也可以直接只使用del kpu_net_object来标记对象已被删除,下一次GC进行内存回收或者手动调用gc.collect()时,会自动释放内存

KPU.deinit(kpu_net)
  • 例程
import KPU as kpu
import gc
task = kpu.load(0x300000)
kpu.deinit(task)
del task
gc.collect()

"""
import KPU as kpu
import gc
task = kpu.load(0x300000)
del task
gc.collect()
"""
  • 参数

successbool 类型, 是否成功

  • run_yolo2

  • 例程(节选代码)

import KPU as kpu
import image
task = kpu.load(offset or file_path)
anchor = (1.889, 2.5245, 2.9465, 3.94056, 3.99987, 5.3658, 5.155437, 6.92275, 6.718375, 9.01025)
kpu.init_yolo2(task, 0.5, 0.3, 5, anchor)
img = image.Image()
kpu.run_yolo2(task, img)
  • 参数
  • kpu_net: kpu_load 返回的 kpu_net 对象
  • image_t:从 sensor 采集到的图像
  • 返回
  • list: kpu_yolo2_find 的列表

更多API点我查看

2.19.4 FFT

2.19.5 I2S

2.19.6 Maix.freq

2.19.7 Maix.utils

2.20 helper

image-20220730091942897

2.21 media

image-20220730092032479

2.22 extend

image-20220730092441652

标签:返回,常用,API,math,Output,GPIO,Serial,Data,maixpy
来源: https://www.cnblogs.com/hnu-hua/p/16534338.html

本站声明: 1. iCode9 技术分享网(下文简称本站)提供的所有内容,仅供技术学习、探讨和分享;
2. 关于本站的所有留言、评论、转载及引用,纯属内容发起人的个人观点,与本站观点和立场无关;
3. 关于本站的所有言论和文字,纯属内容发起人的个人观点,与本站观点和立场无关;
4. 本站文章均是网友提供,不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属;如您发现该文章侵犯了您的权益,可联系我们第一时间进行删除;
5. 本站为非盈利性的个人网站,所有内容不会用来进行牟利,也不会利用任何形式的广告来间接获益,纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。

专注分享技术,共同学习,共同进步。侵权联系[81616952@qq.com]

Copyright (C)ICode9.com, All Rights Reserved.

ICode9版权所有