可以收到
1
1
1
1

这是发送端

打印a那是有空格的

不对
enable_lens_corr = False # turn on for straighter lines...

import sensor, image, time, pyb, math
import os, tf
from machine import UART
from pyb import LED
from struct import pack

white=LED(4)
uart = UART(2, 115200)
sensor.reset()
sensor.set_auto_gain(False) # must be turned off for color tracking
sensor.set_auto_whitebal(False) # must be turned off for color tracking
#sensor.set_auto_whitebal(False)
sensor.set_pixformat(sensor.RGB565) # 灰度更快(160x120 max on OpenMV-M7)
sensor.set_framesize(sensor.QVGA)
sensor.skip_frames(time = 2000)
clock = time.clock()
thresholds=(30, 65, -27, 47, -15, 33)
#Large_area=[76,22,210,122]
net_path = "mobilenet_v2-2022-06-29T03-44-15.608Z_in-int8_out-int8_channel_ptq.tflite" # 定义模型的路径
labels = [line.rstrip() for line in open("/sd/labels_animal_fruits_traffic.txt")] # 加载标签
net = tf.load(net_path, load_to_fb=True) # 加载模型

min_degree = 70
max_degree = 110

#点到直线距离公式
def get_point_line_distance(point, p0, p1):
point_x = point[0]
point_y = point[1]
line_s_x, line_s_y=p0
line_e_x, line_e_y=p1
#若直线与y轴平行，则距离为点的x坐标与直线上任意一点的x坐标差值的绝对值
if line_e_x - line_s_x == 0:
return math.fabs(point_x - line_s_x)
#若直线与x轴平行，则距离为点的y坐标与直线上任意一点的y坐标差值的绝对值
if line_e_y - line_s_y == 0:
return math.fabs(point_y - line_s_y)
#斜率
k = (line_e_y - line_s_y) / (line_e_x - line_s_x)
#截距
b = line_s_y - k * line_s_x
#带入公式得到距离dis
dis = math.fabs(k * point_x - point_y + b) / math.pow(k * k + 1, 0.5)
return dis
#两点长度计算
def get_point_point_distance(p0, p1):
line_s_x, line_s_y=p0
line_e_x, line_e_y=p1
line_long = math.sqrt(pow(line_s_x-line_e_x,2)+pow(line_s_y-line_e_y,2))
return line_long

while(True):
clock.tick()
img = sensor.snapshot().lens_corr(1.8)
white.on()
uart_str = uart.read(uart.any()).decode().strip()
print(uart_str)
if(uart_str=='1'):
print("a")
print("...........")

这样我仍然无法打印a

但是我是想认为创建一条直线，比如色块中线之类，画的直线无法使用函数返回他的角度

比如说我识别到了一个矩形，用它四个角的坐标划出一条中线，在返回直线角度，我该用那些函数

# Hello World Example
#
# Welcome to the OpenMV IDE! Click on the green run arrow button below to run the script!

import sensor, image, time, math
from machine import UART

uart = UART(2, baudrate=115200)
sensor.reset()                      # Reset and initialize the sensor.
sensor.set_pixformat(sensor.RGB565) # Set pixel format to RGB565 (or GRAYSCALE)
sensor.set_framesize(sensor.QVGA)   # Set frame size to QVGA (320x240)
sensor.skip_frames(time = 2000)     # Wait for settings take effect.
clock = time.clock()                # Create a clock object to track the FPS.
thresholds = (64, 81)

while(True):
    clock.tick()                    # Update the FPS clock.
    img = sensor.snapshot()         # Take a picture and return the image.
    uart_num = uart.any()      # 获取当前串口数据数量
    if(uart_num):
        uart_str = uart.read(uart_num).decode().strip() # 读取串口数据
        print(uart_str) 
        if(uart_str==3):
           print("lllll")
           for blob in img.find_blobs([thresholds], pixels_threshold=100, area_threshold=100, merge=True):
               # These values depend on the blob not being circular - otherwise they will be shaky.
               if blob.elongation() > 0.5:
                  img.draw_edges(blob.min_corners(), color=0)
                  img.draw_line(blob.major_axis_line(), color=0)
                  img.draw_line(blob.minor_axis_line(), color=0)
                  # These values are stable all the time.
               img.draw_rectangle(blob.rect(), color=127)
               if blob.cy()>110   and blob.cx()<200 and blob.cx()> 160 and blob.cy()<  130:
                  uart.write("t")
                  print("t")
               elif blob.cy()< 110  and blob.cx()> 160 and blob.cx() < 200:
                  uart.write("h")
                  print("q")
               elif blob.cy()> 130 and blob.cx()<200 and blob.cx()> 160:
                  uart.write("q")
                  print("h")
               elif blob.cx()<160:
                  uart.write("y")
                  print("z")
               elif blob.cx() > 200:
                  uart.write("z")
                  print("y")

等于3判定不通过
接受的是
3
3
3
3
3
3
这样的

我选择性的求了x，z的k，当摄像头与tag码平行时误差可以接受，但tag码偏转角度时，测量误差就太大了。想问一下z，x的距离是摄像头到tag码中心的距离吗，当偏转时是要再加入角度进行计算吗？

import sensor, image, time, math

sensor.reset()
sensor.set_pixformat(sensor.RGB565)
sensor.set_framesize(sensor.QQVGA) # 如果分辨率大得多，内存就不够用了……
sensor.skip_frames(time = 2000)
sensor.set_auto_gain(False)  # 必须关闭此功能，以防止图像冲洗…
sensor.set_auto_whitebal(False)  # 必须关闭此功能，以防止图像冲洗…
clock = time.clock()

# 注意！与find_qrcodes不同，find_apriltags方法不需要对镜像进行镜头校正。

#标签系列有什么区别？ 那么，例如，TAG16H5家族实际上是一个4x4的方形标签。
#所以，这意味着可以看到比6x6的TAG36H11标签更长的距离。
#然而，较低的H值（H5对H11），意味着4x4标签的假阳性率远高于6x6标签。
#所以，除非你有理由使用其他标签系列，否则使用默认族TAG36H11。


# AprilTags库输出标签的姿势信息。 这是x / y / z平移和x / y / z旋转。
# x / y / z旋转以弧度表示，可以转换为度数。 至于翻译单位是无量纲的，
# 你必须应用一个转换函数。

# f_x是相机的x焦距。它应该等于以mm为单位的镜头焦距除以x传感器尺寸（以mm为单位）乘以图像中的像素数。
# 以下数值适用于配备2.8毫米镜头的OV7725相机。

# f_y是相机的y焦距。它应该等于以mm为单位的镜头焦距除以y传感器尺寸（以mm为单位）乘以图像中的像素数。
# 以下数值适用于配备2.8毫米镜头的OV7725相机。

# c_x是以像素为单位的图像x中心位置
# c_x是以像素为单位的图像x中心位置

f_x = (2.8 / 3.984) * 160 # find_apriltags 如果没有设置，则默认为这个
f_y = (2.8 / 2.952) * 120 # find_apriltags 如果没有设置，则默认为这个
c_x = 160 * 0.5 # find_apriltags 如果没有设置，则默认为这个 (the image.w * 0.5)
c_y = 120 * 0.5 # find_apriltags 如果没有设置，则默认为这个 (the image.h * 0.5)
k_z=-5.97
k_x=11.159

def degrees(radians):
    return (180 * radians) / math.pi

while(True):
    clock.tick()
    img = sensor.snapshot()
    for tag in img.find_apriltags(families=image.TAG25H9,fx=f_x, fy=f_y, cx=c_x, cy=c_y): # 默认为 TAG36H11
        img.draw_rectangle(tag.rect(), color = (255, 0, 0))
        img.draw_cross(tag.cx(), tag.cy(), color = (0, 255, 0))
        print_args = (tag.x_translation(), tag.y_translation(), tag.z_translation(), \
            degrees(tag.x_rotation()), degrees(tag.y_rotation()), degrees(tag.z_rotation()))
        # 变换单位不详。旋转单位是度数。
        #print("Tx: %f, Ty %f, Tz %f, Rx %f, Ry %f, Rz %f" % print_args)
        print(tag.id(),"x:",k_x*tag.x_translation(),"   z:",k_z*tag.z_translation())
    print(clock.fps())

import sensor, image, time, pyb

sensor.reset()
sensor.set_pixformat(sensor.RGB565) # grayscale is faster
sensor.set_framesize(sensor.QQVGA)
sensor.skip_frames(time = 2000)
clock = time.clock()

while(True):
    clock.tick()
    img = sensor.snapshot().lens_corr(1.8)

    # Circle objects have four values: x, y, r (radius), and magnitude. The
    # magnitude is the strength of the detection of the circle. Higher is
    # better...

    # `threshold` controls how many circles are found. Increase its value
    # to decrease the number of circles detected...

    # `x_margin`, `y_margin`, and `r_margin` control the merging of similar
    # circles in the x, y, and r (radius) directions.

    # r_min, r_max, and r_step control what radiuses of circles are tested.
    # Shrinking the number of tested circle radiuses yields a big performance boost.

    for circles in img.find_circles(threshold = 2000, x_margin = 10, y_margin = 10, r_margin = 10,
            r_min = 2, r_max = 100, r_step = 2):
        img.draw_circle(c.x(), c.y(), c.r(), color = (255, 0, 0))
        c0=circles[0].x()
        print(c0)

最后就会显示AttributeError: 'int' object has no attribute 'x'

像这样