【K210】K210学习笔记五——串口通信
- 前言
- K210如何进行串口通信
- K210串口配置
- K210串口发送相关定义
- K210串口接收相关定义
- K210串口发送接收测试
- 完整源码
前言
本人大四学生,电赛生涯已经走到尽头,一路上踩过不少坑,但运气也不错拿了两年省一,思来想去,决定开始写博客,将电赛经验分享一二,能力有限,高手轻喷。
往期的博客讲述了 K210 的感光元件模块 sensor 的配置,机器视觉模块 image 中部分函数的使用(目前是用 find_blobs 函数实现一些寻找不同颜色的目标点,寻找不同颜色的线,后面会更新更多 image 模块中的函数使用方法),按键、LCD、LED的使用,以及定时器的使用。
sensor 的学习笔记传送门
【K210】K210学习笔记一——sensor
image 的学习笔记传送门
【K210】K210学习笔记二——image
按键、LCD、LED的使用 的学习笔记传送门
【K210】K210学习笔记三——按键、LCD、LED的使用
定时器的使用
【K210】K210学习笔记四——定时器的使用
本文着重于 K210 如何进行串口通信,如果 MCU 之间无法通信,就算在 K210 上识别做的再好也没有用。我之前发过一篇K210和STM32通信、K210和OpenMV通信的博客,但我觉得那一份的代码还不够“通用”,因此我今天将串口通信的代码进行重置,希望能让大家觉得比上次那一期更好用,要是想回顾上一期代码,了解串口发送与接收,传送门如下。
串口通信 传送门
【串口通信】K210与STM32串口通信、K210与OpenMV串口通信
K210如何进行串口通信
K210串口配置
串口配置需要导入串口相关模块,以提供硬件支持。UART、fm、GPIO、math这四个是必不可少的。其他模块是往期代码中的,我没有删除(主要是想让这份代码大家拿去就可以使用,不用一篇篇翻我的博客去添加那些模块的配置,按需删除不需要的部分)。
import sensor, time, image
import utime
from fpioa_manager import fm
from Maix import GPIO
import lcd
from machine import Timer, PWM, UART
import math
然后就是对 K210 的串口进行设置,这里我设置了两个串口。K210的串口引脚是可以自行映射的,我用的 K210 是 01Studio 的,这一款 K210 的 P9 和 P6 引脚是相邻的,P7 和 P8 引脚是相邻的,因此我就把 P9 映射为 串口1的RX,P6 映射为 串口1的TX,P7 映射为 串口2的RX,P8 映射为 串口2的TX。波特率是设置为 921600,这个是可以更改的,你要使用 115200也是可以的,只要和其他硬件的串口波特率对的上都可以。至于其他设置,数据位8,校验位0,停止位1,一般都是这样设置,这个不建议更改。
需要注意的是,不建议使用K210引脚号数偏大的引脚,比如26以后的,因为这些引脚似乎在接入SD卡、LCD、麦克风阵列等外设的时候会被占用。
fm.register(9, fm.fpioa.UART1_RX, force = True)
fm.register(6, fm.fpioa.UART1_TX, force = True)
uart1 = UART(UART.UART1, 921600, 8, 0, 1)
fm.register(7, fm.fpioa.UART2_RX, force = True)
fm.register(8, fm.fpioa.UART2_TX, force = True)
uart2 = UART(UART.UART2, 921600, 8, 0, 1)
K210串口发送相关定义
这里我定义了一个类,用来保存串口发送的相关信息,方便传入参数。
串口发送数据的核心思想就是将要发送的数据打包成一个数组,然后将这个数组发送出去。如果不打包,接收端很难将数据正常解析出来,帧头的目的就是方便接收端找到数组的“头”,然后从这个“头”开始,逐个接收数据,有效数据长度位控制的是接收多少个有效数据(就是你要发送的数据),加有效数据长度位是方便后续添加新的需要发送的数据,另外接收端可以灵活接收不同长度的数据,最后接收端对接收数据进行校验,如果校验通过,则保存这些数据,这里用的校验方法是校验和。
帧头我都是用 0xAA,因为 0xAA 转换成8位是 1010 1010 电平是有持续跳变的,可以提高点稳定性。
需要注意的是一次最好不要发送太多的数据,我在接收端代码的定义中是定义有效数据长度不超过40个8位,如果要发送x,y,color,shape,flag,虽然好像这里只有五个数据,但x和y是需要使用两个8位来发送的,因此实际有效数据长度是7个8位。关于为什么要用两个8位来发,原因就是我感光元件设置的图像大小是QVGA,x轴坐标变化范围为0到319,y轴坐标变化范围为0到239,x超过了255因此需要用两个8位来发送,一个8位能保存的数据是从0到255,两个8位是可以保存0到65535的。至于像颜色标志位、形状标志位、目标标志位这些一个8位就足够了,比如用1、2、3分别表示红、绿、蓝,也就是在识别到红色的时候,加一句TSTM32.color = 1,以此类推。当然,这些参数都只是一个名字而已,想来保存什么标志位或者什么数据发送到主控,都可以根据个人需求定义,理解了就不难。
还有一点就是,如果接收端经常出现乱序,不妨可以试一下更改帧头。当然,发送端发送的帧头和接收端识别接收的帧头要一并修改,这一点需要牢记。
class UART_Transmit():
pack_flag = 0
head1 = 0x00
head2 = 0x00
x = 0
y = 0
color = 0
shape = 0
flag = 0
mode = 0
TSTM32 = UART_Transmit()
TSTM32.pack_flag = 1
TSTM32.head1 = 0xAA
TSTM32.head2 = 0xAA
TOpenMV = UART_Transmit()
TOpenMV.pack_flag = 2
TOpenMV.head1 = 0xAA
TOpenMV.head2 = 0xAA
def Pack_Data(TData):
data = UART_Pack_Method(TData)
data_len = len(data)
data[2] = data_len - 4
sum = 0
for i in range(0,data_len-1):
sum = sum + data[i]
data[data_len-1] = sum
return data
与之前不同的是,我将打包函数做成了一个可以带入参数的函数,这样就可以方便实现不同的打包需求,不需要每一次有新的需求的时候,将整段代码复制下来,然后改个名字。 如果你有新的打包需求,就只需要实例化一个新的串口发送类,然后将打包方法设置为3,在这里加个
elif TData.pack_flag == 3:
然后在这个 elif 里面写上你新的打包需求即可。
def UART_Pack_Method(TData):
if TData.pack_flag == 1:
data = bytearray([TData.head1,
TData.head2,
0x00,
TData.mode,
0x00])
elif TData.pack_flag == 2:
data = bytearray([TData.head1,
TData.head2,
0x00,
TData.x>>8,
TData.x,
TData.y>>8,
TData.y,
TData.color,
TData.shape,
TData.flag,
0x00])
return data
K210串口接收相关定义
串口接收数据需要用数组来缓冲,因此还需要定义一个类来缓冲串口数据。与之前不同的是,我新增了一点定义,目的是为了让串口接收的函数可以带入参数,就不用在每次有新的接收方法的时候将整段的代码复制下来改名字了。
class UART_Receive(object):
uart_buf = []
data_len = 0
data_cnt = 0
state = 0
buf_len = 0
head1 = 0x00
head2 = 0x00
lenmax = 0
save_flag = 0
RSTM32 = UART_Receive()
RSTM32.head1 = 0xAA
RSTM32.head2 = 0xAA
RSTM32.lenmax = 40
RSTM32.save_flag = 1
ROpenMV = UART_Receive()
ROpenMV.head1 = 0xAA
ROpenMV.head2 = 0xAA
ROpenMV.lenmax = 40
ROpenMV.save_flag = 2
首先是串口数据的读取,这个被我制成了可以带入参数的读取函数,每次有新的需求也不需要整段复制改名字。
def UART_Read(RData, uart):
RData.buf_len = uart.any()
for i in range(0, RData.buf_len):
Receive_Data(RData, uart.readchar())
串口数据接收函数的执行流程如下。
默认状态为状态0,若传入的数据等于帧头1,则保存该数据,然后进入状态1。
进入状态1后,若传入的数据等于帧头2,则保存该数据,然后进入状态2。
进入状态2后,判断需要接收的有效数据长度是否小于设定的有效数据最大长度,若小于,则保存该数据以及总数据长度,然后进入状态3。
进入状态3后,开始接收有效数据长度个数据,接收完毕会进入状态4。
进入状态4后,保存最后一位校验位,然后将数组以及数据总长传入解析函数进行解析。
解析完会将状态置0,数组清空,准备下一次接收。
这个同样也被我制成了可以带入参数的接收函数,每次有新的需求也不需要整段复制改名字。
def Receive_Data(RData, buf):
if RData.state == 0 and buf == RData.head1:
RData.state = 1
RData.uart_buf.append(buf)
elif RData.state == 1 and buf == RData.head2:
RData.state = 2
RData.uart_buf.append(buf)
elif RData.state == 2 and buf < RData.lenmax:
RData.state = 3
RData.data_len = buf
RData.data_cnt = buf + 4
RData.uart_buf.append(buf)
elif RData.state == 3 and RData.data_len > 0:
RData.data_len = RData.data_len - 1
RData.uart_buf.append(buf)
if RData.data_len == 0:
RData.state = 4
elif RData.state == 4:
RData.uart_buf.append(buf)
RData.state = 0
Parse_Data(RData)
RData.uart_buf = []
else:
RData.state = 0
RData.uart_buf = []
解析函数其实就是判断接收到的数据累加和是否等于接收到的校验位的值,等于则校验成功,保存数据,不等于则退出,不保存数据。与往期不同的是,这个同样也被我制成了可以带入参数的解析函数,每次有新的需求也不需要整段复制改名字。
def Parse_Data(PData):
sum = 0
i = 0
while i < (PData.data_cnt - 1):
sum = sum + PData.uart_buf[i]
i = i + 1
sum = sum % 256
if sum != PData.uart_buf[PData.data_cnt - 1]:
return
UART_Save_Method(PData)
然后说一下数据的保存方法,这里我定义了两种。
假设发送过来的数据包是
AA AA 01 01 56
数组的下标从0开始,AA是帧头,第一个01是有效数据长度位,第二个01是要被保存的模式,56是校验和,因此数组下标范围0到4。
第二个01在数组中的下标是3,因此数组下标3的数据被保存到K210.mode
需要注意的是,如果用一个8位来发送一个数据,那么这个数据只能是0到255之间的值,如果要发送超过255的值,则需要用两个8位来发送。
比如需要发送数据为 257 258 3 4 5 而一个8位只能保存0到255,那么就需要将257分成两个8位发送,第一个8位是高八位,需要乘以256还原,第二个8位是低8位,因此257 = 256 + 1 也就是 01 01,所以258就是 01 02
因此整个数组为
AA AA 07 01 01 01 02 03 04 05 6C
K210.x 所对应的高8位在数组中下标是3,低8位在数组中下标是4,数组下标3的数据是01,下标4的数据是01,则有
K210.x = 1 * 256 + 1 = 257
以此类推
当然,如果你有新的保存需求,只需要加个 elif PData.save_flag == 3:
然后在这个 elif 中写下你新的保存需求即可
需要注意的是,最好加一个数据长度的判断,PData.uart_buf[2] 是有效数据长度位,比如发送过来1个数据,那么下标 3 和 下标 4(此时的下标4是校验位) 是存在的,但如果设置保存方法标志的时候错误设置成了2,则下标5之后的所有值都是不存在的,运行就会出错。
def UART_Save_Method(PData):
if PData.save_flag == 1 and PData.uart_buf[2] > 0:
K210.mode = PData.uart_buf[3]
elif PData.save_flag == 2 and PData.uart_buf[2] > 6:
K210.x = PData.uart_buf[3]*256 + PData.uart_buf[4]
K210.y = PData.uart_buf[5]*256 + PData.uart_buf[6]
K210.color = PData.uart_buf[7]
K210.shape = PData.uart_buf[8]
K210.flag = PData.uart_buf[9]
K210串口发送接收测试
这里就用 K210 进行测试即可,自己发送,自己接收,当然你要是用我之前那篇博客中的测试方法进行测试也是没问题的。后面我回学校了会更新与32通信的测试。
自发自收就很简单了,只需要将 K210 的6脚和9脚,7脚和8脚连到一起就好,用跳线帽将它们短接即可。
然后就是设置一下发送的信息。
TSTM32.mode = 1
TOpenMV.x = 65535
TOpenMV.y = 65536
TOpenMV.color = 255
TOpenMV.shape = 256
TOpenMV.flag = 3
然后上电运行,在串行终端中将接收到的参数打印出来即可。这里可以看出,如果用两个8位来发送数据,最大可以支持到65535,如果超过这个值,就会变成0了,而用一个8位来发送,就只能支持到255。
完整源码
完整源码如下所示,大家可以复制该源码,进行测试,要是遇到什么问题可以问我哦!我们下期再见~!
现在串口完成啦!那么现在开始,K210这一系列可能不会日更,后面我会着手于写K210跑训练模型,以及怎么训练模型的教程,难度比现在来得大,因此更新的速度会放缓。
但我一定会保持质量,做到句句有注释,句句有原因,思路清晰, 喜欢我的教程的,希望能换到你们的一个关注。
import sensor, time, image
import utime
from fpioa_manager import fm
from Maix import GPIO
import lcd
from machine import Timer, PWM, UART
import math
sensor.reset()
sensor.set_pixformat(sensor.RGB565)
sensor.set_framesize(sensor.QVGA)
sensor.set_auto_exposure(0)
sensor.set_auto_gain(0)
sensor.set_auto_whitebal(0)
sensor.set_vflip(1)
sensor.set_hmirror(1)
sensor.skip_frames(time = 2000)
clock = time.clock()
class Point_Input():
point1 = 0
point2 = 0
cross = 0
send = 0
point = Point_Input()
def Point_Control(ckey):
if ckey.control == 1:
ckey.control = 0
if ckey.cs == 0:
point.send = 1
elif ckey.cs == 1:
point.point1 = ckey.cinput
elif ckey.cs == 2:
point.point2 = ckey.cinput
elif ckey.cs == 3:
point.cross = ckey.cinput
if ckey.csflag == 1:
ckey.csflag = 0
ckey.cinput = 0
class Key_Control():
cnt = 0
cs = 0
csmax = 0
csflag = 0
cinput = 0
control = 0
key = Key_Control()
key.csmax = 3
fm.register(16, fm.fpioa.GPIOHS0, force = True)
fm.register(18, fm.fpioa.GPIOHS1, force = True)
fm.register(19, fm.fpioa.GPIOHS2, force = True)
fm.register(20, fm.fpioa.GPIOHS3, force = True)
KEY0 = GPIO(GPIO.GPIOHS0, GPIO.IN, GPIO.PULL_UP)
KEY1 = GPIO(GPIO.GPIOHS1, GPIO.IN, GPIO.PULL_UP)
KEY2 = GPIO(GPIO.GPIOHS2, GPIO.IN, GPIO.PULL_UP)
KEY3 = GPIO(GPIO.GPIOHS3, GPIO.IN, GPIO.PULL_UP)
def Key0_Switch(KEY0):
utime.sleep_ms(10)
if KEY0.value() == 0:
key.csflag = 1
if key.cs < key.csmax:
key.cs = key.cs + 1
else:
key.cs = 0
def Key1_Switch(KEY1):
utime.sleep_ms(10)
if KEY1.value() == 0:
key.cinput = key.cinput + 1
def Key2_Switch(KEY2):
utime.sleep_ms(10)
if KEY2.value() == 0:
key.cinput = key.cinput - 1
def Key3_Switch(KEY3):
utime.sleep_ms(10)
if KEY3.value() == 0:
key.control = 1
KEY0.irq(Key0_Switch, GPIO.IRQ_FALLING)
KEY1.irq(Key1_Switch, GPIO.IRQ_FALLING)
KEY2.irq(Key2_Switch, GPIO.IRQ_FALLING)
KEY3.irq(Key3_Switch, GPIO.IRQ_FALLING)
fm.register(14, fm.fpioa.GPIO2, force = True)
fm.register(13, fm.fpioa.GPIO1, force = True)
fm.register(12, fm.fpioa.GPIO0, force = True)
LED_R = GPIO(GPIO.GPIO2, GPIO.OUT)
LED_G = GPIO(GPIO.GPIO1, GPIO.OUT)
LED_B = GPIO(GPIO.GPIO0, GPIO.OUT)
def LED_Control(led_flag):
if led_flag == 0:
LED_R.value(0)
LED_G.value(0)
LED_B.value(0)
elif led_flag == 1:
LED_R.value(1)
LED_G.value(1)
LED_B.value(1)
elif led_flag == 2:
LED_R.value(0)
LED_G.value(1)
LED_B.value(1)
elif led_flag == 3:
LED_R.value(1)
LED_G.value(0)
LED_B.value(1)
elif led_flag == 4:
LED_R.value(1)
LED_G.value(1)
LED_B.value(0)
else:
LED_R.value(0)
LED_G.value(1)
LED_B.value(0)
class Timer_Property():
cnt = 0
cnt_max = 0
period = 0
freq = 0
timer0 = Timer_Property()
timer0.cnt_max = 9
timer0.period = 100
def Timer0_Back(tim0):
if timer0.cnt < timer0.cnt_max:
timer0.cnt = timer0.cnt + 1
else:
timer0.cnt = 0
tim0 = Timer(Timer.TIMER0,
Timer.CHANNEL0,
mode = Timer.MODE_PERIODIC,
unit = Timer.UNIT_MS,
period = timer0.period,
callback = Timer0_Back)
class Motor_Property():
motor1 = 0
motor2 = 0
motor3 = 0
motor4 = 0
motor1_pin = 0
motor2_pin = 0
motor3_pin = 0
motor4_pin = 0
control_x = 0
control_y = 0
motor = Motor_Property()
motor.motor1 = 50
motor.motor2 = 50
motor.motor1_pin = 14
motor.motor2_pin = 13
timer1 = Timer_Property()
timer1.freq = 1000
tim1_ch0 = Timer(Timer.TIMER1,
Timer.CHANNEL0,
mode = Timer.MODE_PWM)
tim1_ch1 = Timer(Timer.TIMER1,
Timer.CHANNEL1,
mode = Timer.MODE_PWM)
motor1 = PWM(tim1_ch0, freq = timer1.freq, duty = motor.motor1, pin = motor.motor1_pin)
motor2 = PWM(tim1_ch1, freq = timer1.freq, duty = motor.motor2, pin = motor.motor2_pin)
def Motor_Control(motor, x):
val = 0
if x < motor.control_x:
val = (motor.control_x - x) * 0.3125
motor.motor1 = 50 - val
motor.motor2 = 50 + val
elif x > motor.control_x:
val = (x - motor.control_x) * 0.3125
motor.motor1 = 50 + val
motor.motor2 = 50 - val
motor.motor1 = int(motor.motor1)
motor.motor2 = int(motor.motor2)
fm.register(9, fm.fpioa.UART1_RX, force = True)
fm.register(6, fm.fpioa.UART1_TX, force = True)
uart1 = UART(UART.UART1, 115200, 8, 0, 1)
fm.register(7, fm.fpioa.UART2_RX, force = True)
fm.register(8, fm.fpioa.UART2_TX, force = True)
uart2 = UART(UART.UART2, 921600, 8, 0, 1)
class UART_Transmit():
pack_flag = 0
head1 = 0x00
head2 = 0x00
x = 0
y = 0
color = 0
shape = 0
flag = 0
mode = 0
TSTM32 = UART_Transmit()
TSTM32.pack_flag = 1
TSTM32.head1 = 0xAA
TSTM32.head2 = 0xAA
TOpenMV = UART_Transmit()
TOpenMV.pack_flag = 2
TOpenMV.head1 = 0xAA
TOpenMV.head2 = 0xAA
def Pack_Data(TData):
data = UART_Pack_Method(TData)
data_len = len(data)
data[2] = data_len - 4
sum = 0
for i in range(0,data_len-1):
sum = sum + data[i]
data[data_len-1] = sum
return data
class UART_Receive(object):
uart_buf = []
data_len = 0
data_cnt = 0
state = 0
buf_len = 0
head1 = 0x00
head2 = 0x00
lenmax = 0
save_flag = 0
RSTM32 = UART_Receive()
RSTM32.head1 = 0xAA
RSTM32.head2 = 0xAA
RSTM32.lenmax = 40
RSTM32.save_flag = 1
ROpenMV = UART_Receive()
ROpenMV.head1 = 0xAA
ROpenMV.head2 = 0xAA
ROpenMV.lenmax = 40
ROpenMV.save_flag = 2
def UART_Read(RData, uart):
RData.buf_len = uart.any()
for i in range(0, RData.buf_len):
Receive_Data(RData, uart.readchar())
def Receive_Data(RData, buf):
if RData.state == 0 and buf == RData.head1:
RData.state = 1
RData.uart_buf.append(buf)
elif RData.state == 1 and buf == RData.head2:
RData.state = 2
RData.uart_buf.append(buf)
elif RData.state == 2 and buf < RData.lenmax:
RData.state = 3
RData.data_len = buf
RData.data_cnt = buf + 4
RData.uart_buf.append(buf)
elif RData.state == 3 and RData.data_len > 0:
RData.data_len = RData.data_len - 1
RData.uart_buf.append(buf)
if RData.data_len == 0:
RData.state = 4
elif RData.state == 4:
RData.uart_buf.append(buf)
RData.state = 0
Parse_Data(RData)
RData.uart_buf = []
else:
RData.state = 0
RData.uart_buf = []
def Parse_Data(PData):
sum = 0
i = 0
while i < (PData.data_cnt - 1):
sum = sum + PData.uart_buf[i]
i = i + 1
sum = sum % 256
if sum != PData.uart_buf[PData.data_cnt - 1]:
return
UART_Save_Method(PData)
class Color_Property():
cx = 0
cy = 0
flag = 0
color = 0
density = 0
pixels_max = 0
led_flag = 0
color_threshold = (0, 0, 0, 0, 0, 0)
color_roi = (0,0,320,240)
color_x_stride = 1
color_y_stride = 1
color_pixels_threshold = 100
color_area_threshold = 100
color_merge = True
color_margin = 1
black = Color_Property()
black.color_threshold = (0, 50, -10, 10, -10, 10)
black.color_roi = (0,0,320,240)
black.color_x_stride = 1
black.color_y_stride = 1
black.color_pixels_threshold = 100
black.color_area_threshold = 100
black.color_merge = True
black.color_margin = 1
red = Color_Property()
red.color_threshold = (0, 100, 20, 127, -10, 127)
red.color_roi = (0,110,320,20)
red.color_x_stride = 1
red.color_y_stride = 1
red.color_pixels_threshold = 10
red.color_area_threshold = 10
red.color_merge = True
red.color_margin = 1
green = Color_Property()
blue = Color_Property()
def K210_Find_Blobs(color,led_flag):
color.pixels_max = 0
color.flag = 0
color.led_flag = 0
for blobs in img.find_blobs([color.color_threshold],
roi = color.color_roi,
x_stride = color.color_x_stride,
y_stride = color.color_y_stride,
pixels_threshold = color.color_pixels_threshold,
area_threshold = color.color_area_threshold,
merge = color.color_merge,
margin = color.color_margin):
img.draw_rectangle(blobs[0:4])
if color.pixels_max < blobs.pixels():
color.pixels_max = blobs.pixels()
color.cx = blobs.cx()
color.cy = blobs.cy()
color.flag = 1
color.density = blobs.density()
color.led_flag = led_flag
if color.flag == 1:
img.draw_cross(color.cx,color.cy, color=127, size = 15)
img.draw_circle(color.cx,color.cy, 15, color = 127)
class K210_Property(object):
x = 0
y = 0
color = 0
shape = 0
flag = 0
mode = 0
K210 = K210_Property()
LED_Control(1)
TSTM32.mode = 1
TOpenMV.x = 65535
TOpenMV.y = 65536
TOpenMV.color = 255
TOpenMV.shape = 256
TOpenMV.flag = 3
def Print_sensor():
print("Exposure :", sensor.get_exposure_us(), "Gain:", sensor.get_gain_db(), "RGB:", sensor.get_rgb_gain_db())
def Print_K210():
print("Mode:", K210.mode, "x:", K210.x, "y:", K210.y, "color:", K210.color, "shape:", K210.shape, "flag:", K210.flag)
def Print_Blobs_Property(color,name):
print(name,"cx:",color.cx,"cy:",color.cy,"flag:",color.flag,"color:",color.color,"density:",color.density,"led_flag:",color.led_flag)
def Print_All():
print("______________________________________________________________________")
Print_sensor()
Print_Blobs_Property(black,"Black ")
Print_Blobs_Property(red, "Red ")
Print_K210()
lcd.init()
def LCD_Show():
lcd.draw_string(0, 0, "key_cs: "+str(key.cs), lcd.BLUE, lcd.WHITE)
lcd.draw_string(0, 15, "cinput: "+str(key.cinput), lcd.BLUE, lcd.WHITE)
lcd.draw_string(0, 30, "point1: "+str(point.point1), lcd.BLUE, lcd.WHITE)
lcd.draw_string(0, 45, "point2: "+str(point.point2), lcd.BLUE, lcd.WHITE)
lcd.draw_string(0, 60, "cross : "+str(point.cross), lcd.BLUE, lcd.WHITE)
lcd.draw_string(0, 75, "red_cx: "+str(red.cx), lcd.BLUE, lcd.WHITE)
lcd.draw_string(0, 90, "motor1: "+str(motor.motor1), lcd.BLUE, lcd.WHITE)
lcd.draw_string(0, 105,"motor2: "+str(motor.motor2), lcd.BLUE, lcd.WHITE)
lcd.draw_string(0, 120,"FPS : "+str(clock.fps()), lcd.BLUE, lcd.WHITE)
def UART_Pack_Method(TData):
if TData.pack_flag == 1:
data = bytearray([TData.head1,
TData.head2,
0x00,
TData.mode,
0x00])
elif TData.pack_flag == 2:
data = bytearray([TData.head1,
TData.head2,
0x00,
TData.x>>8,
TData.x,
TData.y>>8,
TData.y,
TData.color,
TData.shape,
TData.flag,
0x00])
return data
def UART_Save_Method(PData):
if PData.save_flag == 1 and PData.uart_buf[2] > 0:
K210.mode = PData.uart_buf[3]
elif PData.save_flag == 2 and PData.uart_buf[2] > 6:
K210.x = PData.uart_buf[3]*256 + PData.uart_buf[4]
K210.y = PData.uart_buf[5]*256 + PData.uart_buf[6]
K210.color = PData.uart_buf[7]
K210.shape = PData.uart_buf[8]
K210.flag = PData.uart_buf[9]
while(True):
clock.tick()
if K210.mode == 0x00:
img=sensor.snapshot()
elif K210.mode == 0x01:
img=sensor.snapshot()
K210_Find_Blobs(black,1)
motor.control_x = 160
Motor_Control(motor,black.cx)
motor1.duty(motor.motor1)
motor2.duty(motor.motor2)
elif K210.mode == 0x02:
img=sensor.snapshot()
K210_Find_Blobs(red,2)
motor.control_x = 160
Motor_Control(motor,red.cx)
motor1.duty(motor.motor1)
motor2.duty(motor.motor2)
elif K210.mode == 0x03:
img=sensor.snapshot()
else:
img=sensor.snapshot()
Point_Control(key)
lcd.display(img)
LCD_Show()
UART_Read(RSTM32,uart1)
UART_Read(ROpenMV,uart2)
if timer0.cnt == 0:
Print_All()
uart1.write(Pack_Data(TSTM32))
uart2.write(Pack_Data(TOpenMV))
本文内容由网友自发贡献,版权归原作者所有,本站不承担相应法律责任。如您发现有涉嫌抄袭侵权的内容,请联系:hwhale#tublm.com(使用前将#替换为@)