Buffer Protocol Required

[OPSLeoGong]

Hi, I was just trying to communicate with some 3rd party sensors and i was doing byte conversion and tried to put that in an async def. However, it keeps saying this:

Traceback (most recent call last):
  File "WRO_NO_CAM.py", line 170, in <module>
  File "WRO_NO_CAM.py", line 107, in drive_forward
  File "WRO_NO_CAM.py", line 112, in cam_read
TypeError: object with buffer protocol required

And here is the main code:

from pybricks.hubs import PrimeHub
from pybricks.iodevices import UARTDevice
from pybricks.parameters import Port, Direction, Stop, Axis
from pybricks.tools import wait, multitask, run_task
from pybricks.pupdevices import Motor
from pybricks.robotics import DriveBase

hub = PrimeHub(top_side=Axis.Z, front_side=Axis.Y)

lm = Motor(Port.A, Direction.COUNTERCLOCKWISE)
rm = Motor(Port.E, Direction.CLOCKWISE)
kicker = Motor(Port.C, reset_angle=False)
catcher = Motor(Port.F, reset_angle=False)
drivebase = DriveBase(lm, rm, 62.4, 140)
drivebase.use_gyro(True)
hub.imu.reset_heading(0)
catcher.run_target(20000, 90, Stop.HOLD)
kicker.run_target(2000000, 19, Stop.HOLD)
cam = UARTDevice(Port.D)
cam.set_baudrate(115200)
best_x = 0
best_y = 0
action_id = 0
COLOR_ORANGE = 0
COLOR_PURPLE = 1
MAX_BALLS = 10
OFF_SCREEN = 300
ox1 = oy1 = ox2 = oy2 = ox3 = oy3 = ox4 = oy4 = ox5 = oy5 = ox6 = oy6 = ox7 = oy7 = ox8 = oy8 = OFF_SCREEN
orange_count = 0
px1 = py1 = px2 = py2 = px3 = py3 = px4 = py4 = px5 = py5 = px6 = py6 = px7 = py7 = px8 = py8 = OFF_SCREEN
purple_count = 0
buf = bytearray()
def u16(b0, b1): return b0 | (b1 << 8)

def purge(n):
    global buf
    if n >= len(buf):
        buf = bytearray()
    else:
        new_buf = bytearray()
        new_buf.extend(buf[n:])
        buf = new_buf

def checksum(start, length):
    total = 0
    end = start + length
    for i in range(start, min(end, len(buf))):
        total = (total + buf[i]) & 0xFF
    return total

def parse_one():
    global best_x, best_y
    global buf, orange_count, purple_count
    global ox1, oy1, ox2, oy2, ox3, oy3, ox4, oy4, ox5, oy5, ox6, oy6, ox7, oy7, ox8, oy8
    global px1, py1, px2, py2, px3, py3, px4, py4, px5, py5, px6, py6, px7, py7, px8, py8
    if len(buf) < 6:
        return False
    if buf[0] != 0xAA or buf[1] != 0x55:
        purge(1)
        return False
    n = buf[2]
    color_id = buf[3]
    if n == 0 or n > MAX_BALLS or color_id not in (COLOR_ORANGE, COLOR_PURPLE):
        purge(2)
        return False
    need = 6 + 4 * n
    if len(buf) < need:
        return False
    if checksum(2, 3 + 4 * n) != buf[need - 1]:
        purge(1)
        return False
    blobs = []
    p = 5
    for _ in range(n):
        x = u16(buf[p], buf[p + 1]); p += 2
        y = u16(buf[p], buf[p + 1]); p += 2
        blobs.append((x, y))
    purge(need)
    if color_id == COLOR_ORANGE:
        ox1 = oy1 = ox2 = oy2 = ox3 = oy3 = ox4 = oy4 = ox5 = oy5 = ox6 = oy6 = ox7 = oy7 = ox8 = oy8 = OFF_SCREEN
        orange_count = len(blobs)
        if orange_count >= 1:  ox1, oy1 = blobs[0]
        if orange_count >= 2:  ox2, oy2 = blobs[1]
        if orange_count >= 3:  ox3, oy3 = blobs[2]
        if orange_count >= 4:  ox4, oy4 = blobs[3]
        if orange_count >= 5:  ox5, oy5 = blobs[4]
        if orange_count >= 6:  ox6, oy6 = blobs[5]
        if orange_count >= 7:  ox7, oy7 = blobs[6]
        if orange_count >= 8:  ox8, oy8 = blobs[7]
        if orange_count == 0:
            print("ORANGE: none")
    else: 
        px1 = py1 = px2 = py2 = px3 = py3 = px4 = py4 = px5 = py5 = px6 = py6 = px7 = py7 = px8 = py8 = OFF_SCREEN
        purple_count = len(blobs)

        if purple_count >= 1:  px1, py1 = blobs[0]
        if purple_count >= 2:  px2, py2 = blobs[1]
        if purple_count >= 3:  px3, py3 = blobs[2]
        if purple_count >= 4:  px4, py4 = blobs[3]
        if purple_count >= 5:  px5, py5 = blobs[4]
        if purple_count >= 6:  px6, py6 = blobs[5]
        if purple_count >= 7:  px7, py7 = blobs[6]
        if purple_count >= 8:  px8, py8 = blobs[7]
    return True
async def drive_forward():

    await multitask(rm.run_until_stalled(3000, then=Stop.COAST, duty_limit=50), lm.run_until_stalled(3000, then=Stop.COAST, duty_limit=50), cam_read())
def cam_read():
    while True:
        data = cam.read()
        if data:
            buf.extend(data)
            while parse_one():
                pass
        print(best_x, best_y)
def turn_right2(target_angle, turn_speed, slow_point):
    hub.imu.reset_heading(0)

    while abs(hub.imu.heading()) < abs(target_angle):
        yaw = abs(hub.imu.heading())
        remaining = target_angle - abs(hub.imu.heading())

        if yaw > abs(target_angle * slow_point):
            rm.run(-(remaining + 100))
        else:
            rm.run(-turn_speed)
    rm.hold()
    wait(300)
def turn_right(target_angle, turn_speed, slow_point):
    hub.imu.reset_heading(0)

    while abs(hub.imu.heading()) < abs(target_angle):
        yaw = abs(hub.imu.heading())
        remaining = target_angle - abs(hub.imu.heading())

        if yaw > abs(target_angle * slow_point):
            lm.run(remaining + 100)
        else:
            lm.run(turn_speed)

    lm.hold()
    wait(300)


def forward_purple():
    run_task(drive_forward())
while True:
    catcher.run_target(2000, 90, then=Stop.HOLD, wait=False)
    drivebase.settings(1000)
    drivebase.straight(980)
    catcher.run_target(200, -20, Stop.HOLD, wait=False)
    drivebase.settings(900)
    drivebase.straight(180, then=Stop.COAST, wait=False)
    wait(100)
    catcher.run_target(-90000, -20, then=Stop.HOLD, wait=True)
    drivebase.straight(-100)
    print("GRABBED!")
    drivebase.turn(28, then=Stop.BRAKE)
    catcher.run_target(2000, 90, then=Stop.HOLD, wait=False)
    wait(310)
    kicker.dc(-1000000)
    wait(1000)
    kicker.run_target(20000, 19, then=Stop.HOLD, wait=False)
    drivebase.stop()
    drivebase.straight(80)
    drivebase.use_gyro(True)
    drivebase.turn(42, then=Stop.BRAKE)
    drivebase.use_gyro(False)
    drivebase.straight(130)
    run_task(drive_forward())
    catcher.run_target(-90000, -20, then=Stop.HOLD)
    turn_right2(59, 400, 0.9)
    catcher.run_target(90000, 90, then=Stop.HOLD)
    drivebase.settings(1000)
    drivebase.straight(970)
    run_task(drive_forward())
    catcher.run_target(-90000, -20, then=Stop.HOLD)
    turn_right2(53, 400, 0.9)
    catcher.run_target(90000, 90, then=Stop.HOLD)
    run_task(drive_forward())
    catcher.run_target(-90000, -20, then=Stop.HOLD)
    turn_right2(53, 400, 0.9)
    catcher.run_target(90000, 90, then=Stop.HOLD)
    drivebase.straight(970)
    drivebase.settings(900)
    wait(100)
    catcher.run_target(-90000, -20, then=Stop.HOLD, wait=True)
    drivebase.straight(-100)
    print("GRABBED!")
    drivebase.use_gyro(True)
    drivebase.turn(28, then=Stop.BRAKE)
    drivebase.use_gyro(False)
    catcher.run_target(2000, 90, then=Stop.HOLD, wait=False)
    wait(330)
    kicker.dc(-1000000)
    wait(1000)
    kicker.run_target(20000, 19, then=Stop.HOLD, wait=False)
    drivebase.stop()
    drivebase.straight(140)
    turn_right2(53, 400, 0.9)
    catcher.run_target(90000, 90, then=Stop.HOLD)
    run_task(drive_forward())
    catcher.run_target(-90000, -20, then=Stop.HOLD)
    turn_right2(53, 400, 0.9)
    catcher.run_target(90000, 90, then=Stop.HOLD)
    drivebase.settings(1000)
    drivebase.straight(970)
    run_task(drive_forward())
    catcher.run_target(-90000, -20, then=Stop.HOLD)
    turn_right2(53, 400, 0.9)
    catcher.run_target(90000, 90, then=Stop.HOLD)
    run_task(drive_forward())
    catcher.run_target(-90000, -20, then=Stop.HOLD)
    drivebase.straight(-15)
    turn_right2(84, 400, 0.9)
    turn_right(4, 200, 0.7)

Please can someone help I dont know how to fix this

[BertLindeman]

Hello,

No UARTDevice in my inventory, so just trying to help.

The definition of buf is OK.

buf = bytearray()

So the problem in:

def cam_read():
    while True:
        data = cam.read()
        if data:
            buf.extend(data)
            while parse_one():
                pass
        print(best_x, best_y)

maybe in the type of the data field.
This depends on what kind of data is returned by cam.read()
To know the type of data, you could print the type and the value of data.

As a quick fix you could try:

buf.extend(bytes(data))

But always first print type(data) before processing it (in this debug phase).

Bert

[OPSLeoGong]

Traceback (most recent call last):
File "WROGITHUB.py", line 169, in
File "WROGITHUB.py", line 107, in drive_forward
File "WROGITHUB.py", line 112, in cam_read
TypeError: can't convert NoneType to int

[dlech]

No UARTDevice in my inventory, so just trying to help.

You can probably use a LEGO UART sensor with 2400 baud rate to at least read some bytes.

[BertLindeman]

No data was received.

Ah, did you place the print type(data) BEFORE the if data ?

I was to strict in my statement.
Only print the type(data) if there is data.