【K210】【MaixPy】二、Maix Dock入门之Timer、PWM基础模块，实现一个变色呼吸灯（效果参考罗技G502）

107 阅读 0 评论 71 点赞

我是靠谱客的博主标致金鱼，这篇文章主要介绍【K210】【MaixPy】二、Maix Dock入门之Timer、PWM基础模块，实现一个变色呼吸灯（效果参考罗技G502），现在分享给大家，希望可以做个参考。

文章目录

- 1、Timer模块
- - 1.1、构造函数
  - 1.2、参数
  - 1.3、例程
  - 1.4、附录
- 2、PWM功能设置
- - 2.1、构造函数
  - 2.2、参数
  - 2.3、例程

官方文档点这里

1、Timer模块

K210中包含3个的定时器，每个定时器有4个通道可用。

1.1、构造函数

class 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)

1.2、参数

在这里插入图片描述
mode参数解析:
MODE_ONE_SHOT：一拍模式，即只能单次触发中断
MODE_PERIODIC：周期模式，可以多次触发中断
MODE_PWM：PWM模式
关于callback：
可以将回调函数看成中断服务函数，在此选项中输入中断函数名称，在时间按到达要求之后即可调用该函数。

1.3、例程

例程1：
定时3秒后打印信息

复制代码

1
2
3
4
5
6
7
8
9
10
11
from machine import Timer

def on_timer(timer):#定义中断服务函数
    print("time up:",timer)#打印定时器设置信息
    print("param:",timer.callback_arg())#打印创建对象时输入的arg参数（如果是函数名称则输入函数存放地址）

#于Timer0的0通道设置3s触发的单次中断
tim = Timer(Timer.TIMER0, Timer.CHANNEL0, mode=Timer.MODE_ONE_SHOT, period=3000, callback=on_timer, arg=on_timer)
print("period:",tim.period())#打印周期即时间

串行终端输出信息：

复制代码

1
2
3
4
period: 3000
>>> time up: [MAIXPY]Timer:(802f0660) timer=0, channel=0, mode=0, period=3000ms, priority=1, div=0, callback=802f05e0, arg=802f05e0
param: <function on_timer at 0x802f05e0>

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

复制代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
import time
from machine import Timer

def on_timer(timer):#定义中断服务函数
    print("time up:",timer)#打印定时器设置信息
    print("param:",timer.callback_arg())#打印创建对象时输入的arg参数（如果是函数名称则输入函数存放地址）

#于Timer0的0通道设置1s触发的中断，设置优先级1（小→高），设置定时器不启动，时钟不分频
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)#延时5S
tim.stop()#关闭定时器
time.sleep(5)#延时5S
tim.restart()#再次启动定时器
time.sleep(5)#延时5S
tim.stop()#关闭定时器
del tim#注销定时器、注销硬件占用、关闭硬件时钟

串行终端输出信息：

复制代码

period: 1
time up: [MAIXPY]Timer:(802f02c0) timer=0, channel=0, mode=1, period=1s, priority=1, div=0, callback=802eff60, arg=802eff60
param: <function on_timer at 0x802eff60>
time up: [MAIXPY]Timer:(802f02c0) timer=0, channel=0, mode=1, period=1s, priority=1, div=0, callback=802eff60, arg=802eff60
param: <function on_timer at 0x802eff60>
time up: [MAIXPY]Timer:(802f02c0) timer=0, channel=0, mode=1, period=1s, priority=1, div=0, callback=802eff60, arg=802eff60
param: <function on_timer at 0x802eff60>
time up: [MAIXPY]Timer:(802f02c0) timer=0, channel=0, mode=1, period=1s, priority=1, div=0, callback=802eff60, arg=802eff60
param: <function on_timer at 0x802eff60>
time up: [MAIXPY]Timer:(802f02c0) timer=0, channel=0, mode=1, period=1s, priority=1, div=0, callback=802eff60, arg=802eff60
param: <function on_timer at 0x802eff60>
time up: [MAIXPY]Timer:(802f02c0) timer=0, channel=0, mode=1, period=1s, priority=1, div=0, callback=802eff60, arg=802eff60
param: <function on_timer at 0x802eff60>
time up: [MAIXPY]Timer:(802f02c0) timer=0, channel=0, mode=1, period=1s, priority=1, div=0, callback=802eff60, arg=802eff60
param: <function on_timer at 0x802eff60>
time up: [MAIXPY]Timer:(802f02c0) timer=0, channel=0, mode=1, period=1s, priority=1, div=0, callback=802eff60, arg=802eff60
param: <function on_timer at 0x802eff60>
time up: [MAIXPY]Timer:(802f02c0) timer=0, channel=0, mode=1, period=1s, priority=1, div=0, callback=802eff60, arg=802eff60
param: <function on_timer at 0x802eff60>
time up: [MAIXPY]Timer:(802f02c0) timer=0, channel=0, mode=1, period=1s, priority=1, div=0, callback=802eff60, arg=802eff60
param: <function on_timer at 0x802eff60>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
period: 1
time up: [MAIXPY]Timer:(802f02c0) timer=0, channel=0, mode=1, period=1s, priority=1, div=0, callback=802eff60, arg=802eff60
param: <function on_timer at 0x802eff60>
time up: [MAIXPY]Timer:(802f02c0) timer=0, channel=0, mode=1, period=1s, priority=1, div=0, callback=802eff60, arg=802eff60
param: <function on_timer at 0x802eff60>
time up: [MAIXPY]Timer:(802f02c0) timer=0, channel=0, mode=1, period=1s, priority=1, div=0, callback=802eff60, arg=802eff60
param: <function on_timer at 0x802eff60>
time up: [MAIXPY]Timer:(802f02c0) timer=0, channel=0, mode=1, period=1s, priority=1, div=0, callback=802eff60, arg=802eff60
param: <function on_timer at 0x802eff60>
time up: [MAIXPY]Timer:(802f02c0) timer=0, channel=0, mode=1, period=1s, priority=1, div=0, callback=802eff60, arg=802eff60
param: <function on_timer at 0x802eff60>
time up: [MAIXPY]Timer:(802f02c0) timer=0, channel=0, mode=1, period=1s, priority=1, div=0, callback=802eff60, arg=802eff60
param: <function on_timer at 0x802eff60>
time up: [MAIXPY]Timer:(802f02c0) timer=0, channel=0, mode=1, period=1s, priority=1, div=0, callback=802eff60, arg=802eff60
param: <function on_timer at 0x802eff60>
time up: [MAIXPY]Timer:(802f02c0) timer=0, channel=0, mode=1, period=1s, priority=1, div=0, callback=802eff60, arg=802eff60
param: <function on_timer at 0x802eff60>
time up: [MAIXPY]Timer:(802f02c0) timer=0, channel=0, mode=1, period=1s, priority=1, div=0, callback=802eff60, arg=802eff60
param: <function on_timer at 0x802eff60>
time up: [MAIXPY]Timer:(802f02c0) timer=0, channel=0, mode=1, period=1s, priority=1, div=0, callback=802eff60, arg=802eff60
param: <function on_timer at 0x802eff60>

1.4、附录

常量表：
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)

2、PWM功能设置

Maix Dock开发板上刚好有一个RGB LED可以用来做彩灯以检验PWM的实现。关于点灯方面的教程戳这里。

2.1、构造函数

class machine.PWM(tim, freq, duty, pin, enable=True)

2.2、参数

在这里插入图片描述
！！注意！！：
实测duty参数为低电平占整个周期的百分比。

2.3、例程

例程1：
十种颜色轮流切换。

复制代码

from machine import Timer,PWM
import time
from fpioa_manager import board_info

Tim0 = Timer(Timer.TIMER0, Timer.CHANNEL0, mode=Timer.MODE_PWM)#新建定时器对象于定时器0，0通道
Tim1 = Timer(Timer.TIMER0, Timer.CHANNEL1, mode=Timer.MODE_PWM)
Tim2 = Timer(Timer.TIMER0, Timer.CHANNEL2, mode=Timer.MODE_PWM)

LEDR = PWM(Tim0, freq=500000, duty=0, pin=board_info.LED_R)#新建PWM对象于Tim0定时器对象，频率500000Hz，duty为0，映射到LED_R引脚
LEDG = PWM(Tim1, freq=500000, duty=0, pin=board_info.LED_G)
LEDB = PWM(Tim2, freq=500000, duty=0, pin=board_info.LED_B)

'''
1.R 25 G 202 B 173
2.R 140 G 199 B 181
3.R 160 G 238 B 225
4.R 190 G 231 B 233
5.R 190 G 237 B 199
6.R 214 G 213 B 183
7.R 209 G 186 B 116
8.R 230 G 206 B 172
9.R 236 G 173 B 158
10.R 244 G 96 B 108
'''

ColorIndex = 0  #颜色索引
Duty=0          #待计算的占空比
#RGB数值列表
ValR = [25 , 140, 160, 190, 190, 214, 209, 230, 236, 244]
ValG = [202, 199, 238, 231, 237, 213, 186, 206, 173, 96 ]
ValB = [173, 181, 255, 233, 199, 183, 116, 172, 158, 108]

while True:
    Duty = 100 - ((ValR[ColorIndex] / 255) * 100)#根据RGB数值计算出相应的占空比参数
    LEDR.duty(Duty)
    Duty = 100 - ((ValG[ColorIndex] / 255) * 100)
    LEDG.duty(Duty)
    Duty = 100 - ((ValB[ColorIndex] / 255) * 100)
    LEDB.duty(Duty)
    time.sleep_ms(1500)                         #延时1.5s
    if ColorIndex < len(ValR) - 1:              #使颜色于1~10轮流切换
        ColorIndex += 1
    else:
        ColorIndex = 0

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
from machine import Timer,PWM
import time
from fpioa_manager import board_info

Tim0 = Timer(Timer.TIMER0, Timer.CHANNEL0, mode=Timer.MODE_PWM)#新建定时器对象于定时器0，0通道
Tim1 = Timer(Timer.TIMER0, Timer.CHANNEL1, mode=Timer.MODE_PWM)
Tim2 = Timer(Timer.TIMER0, Timer.CHANNEL2, mode=Timer.MODE_PWM)

LEDR = PWM(Tim0, freq=500000, duty=0, pin=board_info.LED_R)#新建PWM对象于Tim0定时器对象，频率500000Hz，duty为0，映射到LED_R引脚
LEDG = PWM(Tim1, freq=500000, duty=0, pin=board_info.LED_G)
LEDB = PWM(Tim2, freq=500000, duty=0, pin=board_info.LED_B)

'''
1.R 25 G 202 B 173
2.R 140 G 199 B 181
3.R 160 G 238 B 225
4.R 190 G 231 B 233
5.R 190 G 237 B 199
6.R 214 G 213 B 183
7.R 209 G 186 B 116
8.R 230 G 206 B 172
9.R 236 G 173 B 158
10.R 244 G 96 B 108
'''

ColorIndex = 0  #颜色索引
Duty=0          #待计算的占空比
#RGB数值列表
ValR = [25 , 140, 160, 190, 190, 214, 209, 230, 236, 244]
ValG = [202, 199, 238, 231, 237, 213, 186, 206, 173, 96 ]
ValB = [173, 181, 255, 233, 199, 183, 116, 172, 158, 108]

while True:
    Duty = 100 - ((ValR[ColorIndex] / 255) * 100)#根据RGB数值计算出相应的占空比参数
    LEDR.duty(Duty)
    Duty = 100 - ((ValG[ColorIndex] / 255) * 100)
    LEDG.duty(Duty)
    Duty = 100 - ((ValB[ColorIndex] / 255) * 100)
    LEDB.duty(Duty)
    time.sleep_ms(1500)                         #延时1.5s
    if ColorIndex < len(ValR) - 1:              #使颜色于1~10轮流切换
        ColorIndex += 1
    else:
        ColorIndex = 0

对应颜色表：
在这里插入图片描述
例程1++：
相较于例程1使用了渐变切换的效果。

复制代码

from machine import Timer,PWM
import time
from fpioa_manager import board_info

LEDR = PWM(Tim0, freq=500000, duty=100, pin=board_info.LED_R)#新建PWM对象于Tim0定时器对象，频率500000Hz，duty为0，映射到LED_R引脚
LEDG = PWM(Tim1, freq=500000, duty=100, pin=board_info.LED_G)
LEDB = PWM(Tim2, freq=500000, duty=100, pin=board_info.LED_B)

'''
红：255 0   0
橙: 255 125 0
黄：255 255 0
绿：0   255 0
靛: 0   255 255
蓝：0   0   255
紫: 255 0   255
'''

ColorIndex = 1  #颜色索引
Duty = 0        #待计算的占空比
DutyTempR = 0   #占空比临时值R
DutyTempG = 0   #占空比临时值G
DutyTempB = 0   #占空比临时值B
OperateTemp = 0 #计算产生的临时变量，用于使DutyTemp逼近Duty
#RGB数值列表
ValR = [255, 255, 255, 0  , 0  , 0  , 255]
ValG = [0  , 125, 255, 255, 255, 0  , 0  ]
ValB = [0  , 0  , 0  , 0  , 255, 255, 255]
#初始化RGB LED 使显示第一组颜色
Duty = 100 - ((ValR[0] / 255) * 100)#根据RGB数值计算出相应的占空比参数
DutyTempR = Duty
LEDR.duty(Duty)                     #赋值
Duty = 100 - ((ValG[0] / 255) * 100)#根据RGB数值计算出相应的占空比参数
DutyTempG = Duty
LEDG.duty(Duty)                     #赋值
Duty = 100 - ((ValB[0] / 255) * 100)#根据RGB数值计算出相应的占空比参数
DutyTempB = Duty
LEDB.duty(Duty)                     #赋值
time.sleep_ms(2000)                 #延时2s
while True:
    #R
    Duty = 100 - ((ValR[ColorIndex] / 255) * 100)#根据RGB数值计算出相应的占空比参数
    OperateTemp = Duty - DutyTempR              #计算总差值
    OperateTemp /= 10                           #差值分10次补偿给DutyTemp
    while DutyTempR != Duty:
        if OperateTemp > 0 and DutyTempR > Duty:#解决因小数精度问题而无法满足循环解除条件的问题
            break
        if OperateTemp < 0 and DutyTempR < Duty:#解决因小数精度问题而无法满足循环解除条件的问题
            break
        DutyTempR += OperateTemp                 #差值补偿
        if DutyTempR > 100:                     #防溢出操作
            DutyTempR = 100
        elif DutyTempR < 0:
            DutyTempR = 0
        LEDR.duty(DutyTempR)                    #赋值
        time.sleep_ms(100)                      #延时100ms
    LEDR.duty(DutyTempR)                        #最终赋确定值，此时DutyTemp=Duty
    #G
    Duty = 100 - ((ValG[ColorIndex] / 255) * 100)#根据RGB数值计算出相应的占空比参数
    OperateTemp = Duty - DutyTempG              #计算总差值
    OperateTemp /= 10                           #差值分10次补偿给DutyTemp
    while DutyTempG != Duty:
        if OperateTemp > 0 and DutyTempG > Duty:#解决因小数精度问题而无法满足循环解除条件的问题
            break
        if OperateTemp < 0 and DutyTempG < Duty:#解决因小数精度问题而无法满足循环解除条件的问题
            break
        DutyTempG += OperateTemp                #差值补偿
        if DutyTempG > 100:                     #防溢出操作
            DutyTempG = 100
        elif DutyTempG < 0:
            DutyTempG = 0
        LEDG.duty(DutyTempG)                    #赋值
        time.sleep_ms(100)                      #延时100ms
    LEDG.duty(DutyTempG)                        #最终赋确定值，此时DutyTemp=Duty
    #B
    Duty = 100 - ((ValB[ColorIndex] / 255) * 100)#根据RGB数值计算出相应的占空比参数
    OperateTemp = Duty - DutyTempB              #计算总差值
    OperateTemp /= 10                           #差值分10次补偿给DutyTemp
    while DutyTempB != Duty:
        if OperateTemp > 0 and DutyTempB > Duty:#解决因小数精度问题而无法满足循环解除条件的问题
            break
        if OperateTemp < 0 and DutyTempB < Duty:#解决因小数精度问题而无法满足循环解除条件的问题
            break
        DutyTempB += OperateTemp                #差值补偿
        if DutyTempB > 100:                     #防溢出操作
            DutyTempB = 100
        elif DutyTempB < 0:
            DutyTempB = 0
        LEDB.duty(DutyTempB)                    #赋值
        time.sleep_ms(100)                      #延时100ms
    LEDB.duty(DutyTempB)                        #最终赋确定值，此时DutyTemp=Duty
    time.sleep_ms(1500)                         #延时1.5s
    if ColorIndex < len(ValR) - 1:              #使颜色于红~紫轮流切换
        ColorIndex += 1
    else:
        ColorIndex = 0

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
from machine import Timer,PWM
import time
from fpioa_manager import board_info

Tim0 = Timer(Timer.TIMER0, Timer.CHANNEL0, mode=Timer.MODE_PWM)#新建定时器对象于定时器0，0通道
Tim1 = Timer(Timer.TIMER0, Timer.CHANNEL1, mode=Timer.MODE_PWM)
Tim2 = Timer(Timer.TIMER0, Timer.CHANNEL2, mode=Timer.MODE_PWM)

LEDR = PWM(Tim0, freq=500000, duty=100, pin=board_info.LED_R)#新建PWM对象于Tim0定时器对象，频率500000Hz，duty为0，映射到LED_R引脚
LEDG = PWM(Tim1, freq=500000, duty=100, pin=board_info.LED_G)
LEDB = PWM(Tim2, freq=500000, duty=100, pin=board_info.LED_B)

'''
红：255 0   0
橙: 255 125 0
黄：255 255 0
绿：0   255 0
靛: 0   255 255
蓝：0   0   255
紫: 255 0   255
'''

ColorIndex = 1  #颜色索引
Duty = 0        #待计算的占空比
DutyTempR = 0   #占空比临时值R
DutyTempG = 0   #占空比临时值G
DutyTempB = 0   #占空比临时值B
OperateTemp = 0 #计算产生的临时变量，用于使DutyTemp逼近Duty
#RGB数值列表
ValR = [255, 255, 255, 0  , 0  , 0  , 255]
ValG = [0  , 125, 255, 255, 255, 0  , 0  ]
ValB = [0  , 0  , 0  , 0  , 255, 255, 255]
#初始化RGB LED 使显示第一组颜色
Duty = 100 - ((ValR[0] / 255) * 100)#根据RGB数值计算出相应的占空比参数
DutyTempR = Duty
LEDR.duty(Duty)                     #赋值
Duty = 100 - ((ValG[0] / 255) * 100)#根据RGB数值计算出相应的占空比参数
DutyTempG = Duty
LEDG.duty(Duty)                     #赋值
Duty = 100 - ((ValB[0] / 255) * 100)#根据RGB数值计算出相应的占空比参数
DutyTempB = Duty
LEDB.duty(Duty)                     #赋值
time.sleep_ms(2000)                 #延时2s
while True:
    #R
    Duty = 100 - ((ValR[ColorIndex] / 255) * 100)#根据RGB数值计算出相应的占空比参数
    OperateTemp = Duty - DutyTempR              #计算总差值
    OperateTemp /= 10                           #差值分10次补偿给DutyTemp
    while DutyTempR != Duty:
        if OperateTemp > 0 and DutyTempR > Duty:#解决因小数精度问题而无法满足循环解除条件的问题
            break
        if OperateTemp < 0 and DutyTempR < Duty:#解决因小数精度问题而无法满足循环解除条件的问题
            break
        DutyTempR += OperateTemp                 #差值补偿
        if DutyTempR > 100:                     #防溢出操作
            DutyTempR = 100
        elif DutyTempR < 0:
            DutyTempR = 0
        LEDR.duty(DutyTempR)                    #赋值
        time.sleep_ms(100)                      #延时100ms
    LEDR.duty(DutyTempR)                        #最终赋确定值，此时DutyTemp=Duty
    #G
    Duty = 100 - ((ValG[ColorIndex] / 255) * 100)#根据RGB数值计算出相应的占空比参数
    OperateTemp = Duty - DutyTempG              #计算总差值
    OperateTemp /= 10                           #差值分10次补偿给DutyTemp
    while DutyTempG != Duty:
        if OperateTemp > 0 and DutyTempG > Duty:#解决因小数精度问题而无法满足循环解除条件的问题
            break
        if OperateTemp < 0 and DutyTempG < Duty:#解决因小数精度问题而无法满足循环解除条件的问题
            break
        DutyTempG += OperateTemp                #差值补偿
        if DutyTempG > 100:                     #防溢出操作
            DutyTempG = 100
        elif DutyTempG < 0:
            DutyTempG = 0
        LEDG.duty(DutyTempG)                    #赋值
        time.sleep_ms(100)                      #延时100ms
    LEDG.duty(DutyTempG)                        #最终赋确定值，此时DutyTemp=Duty
    #B
    Duty = 100 - ((ValB[ColorIndex] / 255) * 100)#根据RGB数值计算出相应的占空比参数
    OperateTemp = Duty - DutyTempB              #计算总差值
    OperateTemp /= 10                           #差值分10次补偿给DutyTemp
    while DutyTempB != Duty:
        if OperateTemp > 0 and DutyTempB > Duty:#解决因小数精度问题而无法满足循环解除条件的问题
            break
        if OperateTemp < 0 and DutyTempB < Duty:#解决因小数精度问题而无法满足循环解除条件的问题
            break
        DutyTempB += OperateTemp                #差值补偿
        if DutyTempB > 100:                     #防溢出操作
            DutyTempB = 100
        elif DutyTempB < 0:
            DutyTempB = 0
        LEDB.duty(DutyTempB)                    #赋值
        time.sleep_ms(100)                      #延时100ms
    LEDB.duty(DutyTempB)                        #最终赋确定值，此时DutyTemp=Duty
    time.sleep_ms(1500)                         #延时1.5s
    if ColorIndex < len(ValR) - 1:              #使颜色于红~紫轮流切换
        ColorIndex += 1
    else:
        ColorIndex = 0