lớp I2CTarget -- thiết bị đích I2C¶

Thiết bị đích I2C là thiết bị kết nối với bus I2C và được điều khiển bởi bộ điều khiển I2C. Thiết bị đích I2C có thể có nhiều dạng. Lớp machine.I2CTarget triển khai một thiết bị đích I2C có thể được cấu hình như thiết bị bộ nhớ/thanh ghi, hoặc như thiết bị I2C tùy ý bằng cách sử dụng các hàm gọi lại (nếu được cổng hỗ trợ).

Khả dụng trên OpenMV Cam M4 / M7 / H7 / H7 Plus / Pure Thermal / RT1062 / AE3.

Ví dụ sử dụng cho trường hợp thiết bị bộ nhớ:

from machine import I2CTarget

# Create the backing memory for the I2C target.
mem = bytearray(8)

# Create an I2C target.  Depending on the port, extra parameters
# may be required to select the peripheral and/or pins to use.
i2c = I2CTarget(addr=67, mem=mem)

# At this point an I2C controller can read and write `mem`.
...

# Deinitialise the I2C target.
i2c.deinit()

Lưu ý rằng một số cổng yêu cầu id, và có thể cả các chân scl và sda, được truyền vào hàm khởi tạo I2CTarget, để chọn phiên bản I2C phần cứng và các chân mà nó kết nối.

Khi được cấu hình như thiết bị bộ nhớ, cũng có thể đăng ký để nhận các sự kiện. Ví dụ để được thông báo khi bộ nhớ được đọc/ghi:

from machine import I2CTarget

# Define an IRQ handler, for I2C events.
def irq_handler(i2c_target):
    flags = i2c_target.irq().flags()
    if flags & I2CTarget.IRQ_END_READ:
        print("controller read target at addr", i2c_target.memaddr)
    if flags & I2CTarget.IRQ_END_WRITE:
        print("controller wrote target at addr", i2c_target.memaddr)

# Create the I2C target and register to receive default events.
mem = bytearray(8)
i2c = I2CTarget(addr=67, mem=mem)
i2c.irq(irq_handler)

Các thiết bị I2C phức tạp hơn có thể được triển khai bằng cách sử dụng toàn bộ tập hợp sự kiện. Ví dụ, để xem các sự kiện thô khi chúng được kích hoạt:

from machine import I2CTarget

# Define an IRQ handler that prints the event id and responds to reads/writes.
def irq_handler(i2c_target, buf=bytearray(1)):
    flags = i2c_target.irq().flags()
    print(flags)
    if flags & I2CTarget.IRQ_READ_REQ:
        i2c_target.write(buf)
    if flags & I2CTarget.IRQ_WRITE_REQ:
        i2c_target.readinto(buf)

# Create the I2C target and register to receive all events.
i2c = I2CTarget(addr=67)
all_triggers = (
    I2CTarget.IRQ_ADDR_MATCH_READ
    | I2CTarget.IRQ_ADDR_MATCH_WRITE
    | I2CTarget.IRQ_READ_REQ
    | I2CTarget.IRQ_WRITE_REQ
    | I2CTarget.IRQ_END_READ
    | I2CTarget.IRQ_END_WRITE
)
i2c.irq(irq_handler, trigger=all_triggers, hard=True)

Các hàm khởi tạo¶

class machine.I2CTarget(id: int, addr: int, *, addrsize: int = 7, mem: bytearray | None = None, mem_addrsize: int = 8, scl: Pin | None = None, sda: Pin | None = None)¶

Xây dựng và trả về một đối tượng I2CTarget mới sử dụng các tham số sau:

id xác định một ngoại vi I2C cụ thể. Các giá trị cho phép phụ thuộc vào cổng/bo mạch cụ thể. Một số cổng có giá trị mặc định trong trường hợp đó tham số này có thể bỏ qua.

addr là địa chỉ I2C của thiết bị đích.

addrsize là số bit trong địa chỉ thiết bị đích I2C. Các giá trị hợp lệ là 7 và 10.

mem là một đối tượng có giao thức bộ đệm có thể ghi. Nếu không được chỉ định thì sẽ không có bộ nhớ lưu trữ và dữ liệu phải được đọc/ghi bằng các phương thức I2CTarget.readinto() và I2CTarget.write().

mem_addrsize là số bit trong địa chỉ bộ nhớ. Các giá trị hợp lệ là 0, 8, 16, 24 và 32.

scl là đối tượng chân (pin) chỉ định chân sử dụng cho SCL.

sda là đối tượng chân (pin) chỉ định chân sử dụng cho SDA.

Lưu ý rằng một số cổng/bo mạch sẽ có giá trị mặc định của scl và sda có thể thay đổi trong hàm khởi tạo này. Các cổng/bo mạch khác sẽ có giá trị cố định của scl và sda không thể thay đổi.

Các phương thức chung¶

deinit() → None¶: Hủy khởi tạo thiết bị đích I2C. Sau khi phương thức này được gọi, phần cứng sẽ không còn đáp ứng các yêu cầu trên bus I2C nữa và không thể gọi bất kỳ phương thức nào khác.

readinto(buf: bytearray) → int¶: Đọc vào bộ đệm đã cho bất kỳ byte nào đang chờ được ghi bởi bộ điều khiển I2C. Trả về số byte đã đọc.

write(buf: bytes) → int¶: Ghi ra các byte từ bộ đệm đã cho, để truyền đến bộ điều khiển I2C sau khi nó gửi yêu cầu đọc. Trả về số byte đã ghi. Hầu hết các cổng chỉ chấp nhận một byte mỗi lần cho phương thức này.

irq(handler: Callable[[I2CTarget], None] | None = None, trigger: int = IRQ_END_READ | IRQ_END_WRITE, hard: bool = False) → None¶

Cài đặt handler IRQ được gọi khi một trong các sự kiện được chọn bởi trigger kích hoạt. trigger là mặt nạ bit của các hằng số IRQ_* được OR với nhau; mặc định kích hoạt khi kết thúc mỗi lần đọc hoặc ghi phía bộ điều khiển.

hard=True đăng ký trình xử lý ngắt cứng (không cấp phát heap trong hàm gọi lại). Mặc định là hàm gọi lại được lên lịch. Truyền handler=None để vô hiệu hóa ngắt.

Ghi chú

IRQ_ADDR_MATCH_READ, IRQ_ADDR_MATCH_WRITE, IRQ_READ_REQ và IRQ_WRITE_REQ phải được xử lý bởi hàm gọi lại IRQ cứng (hard=True) vì các sự kiện phải được xác nhận đồng bộ với phần cứng. IRQ_END_READ và IRQ_END_WRITE có thể được xử lý bởi hàm gọi lại mềm hoặc cứng; tất cả các sự kiện chia sẻ một trình xử lý duy nhất, vì vậy nếu bất kỳ sự kiện nào cần hàm gọi lại cứng thì tất cả đều phải vậy.

Khi bộ đệm bộ nhớ được cung cấp cho hàm khởi tạo, trình điều khiển sẽ loại trừ IRQ_END_WRITE cho giao dịch chỉ ghi địa chỉ bộ nhớ. Điều này giữ cho các sự kiện kết thúc giao dịch có ý nghĩa ngay cả khi bộ lên lịch soft-IRQ trì hoãn hàm gọi lại.

memaddr¶: Giá trị nguyên của địa chỉ bộ nhớ gần nhất được chọn bởi bộ điều khiển I2C (chỉ hợp lệ nếu mem được chỉ định trong hàm khởi tạo).

Các hằng số¶

Mỗi hằng số IRQ_* là một bit cờ. OR chúng lại để tạo mặt nạ trigger cho irq(). Bên trong trình xử lý, tập hợp các sự kiện đã kích hoạt có thể được khôi phục qua self.irq().flags() AND với từng hằng số.

IRQ_ADDR_MATCH_READ: int¶: Kích hoạt khi bộ điều khiển địa chỉ thiết bị đích này cho giao dịch đọc (byte địa chỉ đã được nhận với bit đọc/ghi được đặt thành 1). Chỉ dành cho IRQ cứng.

IRQ_ADDR_MATCH_WRITE: int¶: Kích hoạt khi bộ điều khiển địa chỉ thiết bị đích này cho giao dịch ghi (byte địa chỉ đã được nhận với bit đọc/ghi được đặt thành 0). Chỉ dành cho IRQ cứng.

IRQ_READ_REQ: int¶: Kích hoạt khi bộ điều khiển đang yêu cầu một byte từ thiết bị đích. Trình xử lý phải gọi write() để cung cấp byte trước khi chu kỳ xung nhịp của bộ điều khiển hoàn thành. Chỉ dành cho IRQ cứng.

IRQ_WRITE_REQ: int¶: Kích hoạt khi bộ điều khiển đã truyền một byte vào thiết bị đích. Trình xử lý phải gọi readinto() để lấy byte trước khi bộ điều khiển gửi byte tiếp theo. Chỉ dành cho IRQ cứng.

IRQ_END_READ: int¶: Kích hoạt khi bộ điều khiển đã hoàn thành giao dịch đọc (nhận STOP / lặp lại START). Có thể được xử lý bởi hàm gọi lại IRQ cứng hoặc mềm.

IRQ_END_WRITE: int¶: Kích hoạt khi bộ điều khiển đã hoàn thành giao dịch ghi (nhận STOP / lặp lại START). Có thể được xử lý bởi hàm gọi lại IRQ cứng hoặc mềm. Bị loại trừ cho giao dịch ghi địa chỉ bộ nhớ khi bộ đệm mem được cung cấp cho hàm khởi tạo.