MicroPython RFID on a Pico: write a card and read it back

# Write to a card and read it back: type up to 16 characters in the Serial
# Monitor, lay a card on the reader, and the text goes into block 8; it is
# then read back to check it.
from machine import Pin, SoftSPI
import time
from mfrc522 import MFRC522, OK

Pin(6, Pin.OUT, value=1)
spi = SoftSPI(baudrate=100000, polarity=0, phase=0, sck=Pin(2), mosi=Pin(3), miso=Pin(4))
reader = MFRC522(spi, cs=5)
KEY = [0xFF] * 6

def card():
    """The UID of a card on the reader, selected, or None."""
    if reader.request() != OK:
        return None
    status, uid = reader.anticoll()
    if status != OK or reader.select(uid) != OK:
        return None
    return uid

while True:
    text = input("Text for block 8: ")[:16]
    print("Lay a card on the reader")
    uid = None
    while uid is None:
        uid = card()
        time.sleep_ms(100)
    if reader.auth(8, KEY, uid) == OK and reader.write_block(8, text.encode()) == OK:
        back = bytes(reader.read_block(8)).rstrip(b"\x00").decode()
        print("wrote", repr(text), "read back", repr(back))
    else:
        print("could not write the card")
    reader.stop_crypto()

# mfrc522.py: an MFRC522 RFID reader on SPI, and MIFARE Classic cards.
# The reader is a set of registers: a byte with the register's address in
# bits 6 to 1 (bit 7 set to read), then the data. Talking to a card is
# filling the reader's FIFO, starting a command and reading the answer back.
from machine import Pin
import time

OK, NOTAG, ERR = 0, 1, 2

class MFRC522:
    def __init__(self, spi, cs):
        self.spi = spi
        self.cs = Pin(cs, Pin.OUT, value=1)
        self.write_reg(0x01, 0x0F)          # soft reset
        time.sleep_ms(50)
        self.write_reg(0x2A, 0x8D)          # timer: give up on a silent card
        self.write_reg(0x2B, 0x3E)
        self.write_reg(0x2D, 30)
        self.write_reg(0x2C, 0)
        self.write_reg(0x15, 0x40)          # 100 % ASK modulation
        self.write_reg(0x11, 0x3D)          # CRC preset 0x6363
        self.set_bits(0x14, 0x03)           # antenna on

    def write_reg(self, reg, value):
        self.cs.value(0)
        self.spi.write(bytes([(reg << 1) & 0x7E, value]))
        self.cs.value(1)

    def read_reg(self, reg):
        self.cs.value(0)
        self.spi.write(bytes([((reg << 1) & 0x7E) | 0x80]))
        value = self.spi.read(1)[0]
        self.cs.value(1)
        return value

    def set_bits(self, reg, mask):
        self.write_reg(reg, self.read_reg(reg) | mask)

    def clear_bits(self, reg, mask):
        self.write_reg(reg, self.read_reg(reg) & ~mask)

    def command(self, cmd, data):
        """Run Transceive (0x0C) or MFAuthent (0x0E) on data; (status, bytes back, bits back)."""
        wait = 0x30 if cmd == 0x0C else 0x10
        self.write_reg(0x04, 0x7F)          # clear every interrupt flag
        self.set_bits(0x0A, 0x80)           # empty the FIFO
        self.write_reg(0x01, 0x00)          # idle
        for b in data:
            self.write_reg(0x09, b)
        self.write_reg(0x01, cmd)
        if cmd == 0x0C:
            self.set_bits(0x0D, 0x80)       # start sending
        for _ in range(2000):
            irq = self.read_reg(0x04)
            if irq & wait or irq & 0x01:
                break
        self.clear_bits(0x0D, 0x80)
        if not irq & wait:
            return NOTAG, [], 0
        if self.read_reg(0x06) & 0x1B:
            return ERR, [], 0
        back = []
        bits = 0
        if cmd == 0x0C:
            n = self.read_reg(0x0A)
            last = self.read_reg(0x0C) & 0x07
            bits = (n - 1) * 8 + last if last else n * 8
            back = [self.read_reg(0x09) for _ in range(n)]
        return OK, back, bits

    def crc(self, data):
        self.clear_bits(0x05, 0x04)
        self.set_bits(0x0A, 0x80)
        for b in data:
            self.write_reg(0x09, b)
        self.write_reg(0x01, 0x03)          # CalcCRC
        for _ in range(255):
            if self.read_reg(0x05) & 0x04:
                break
        return [self.read_reg(0x22), self.read_reg(0x21)]

    def request(self):
        """Wake a card in the field: OK when one answers."""
        self.write_reg(0x0D, 0x07)          # REQA is a 7-bit frame
        status, back, bits = self.command(0x0C, [0x26])
        return OK if status == OK and bits == 0x10 else NOTAG

    def anticoll(self):
        """The card's four UID bytes, checked against their XOR byte."""
        self.write_reg(0x0D, 0x00)
        status, back, _ = self.command(0x0C, [0x93, 0x20])
        if status != OK or len(back) != 5 or back[0] ^ back[1] ^ back[2] ^ back[3] != back[4]:
            return ERR, []
        return OK, back

    def select(self, uid5):
        frame = [0x93, 0x70] + uid5
        status, back, bits = self.command(0x0C, frame + self.crc(frame))
        return OK if status == OK and bits == 0x18 else ERR

    def auth(self, block, key, uid5):
        status, _, _ = self.command(0x0E, [0x60, block] + key + uid5[:4])
        if status != OK or not self.read_reg(0x08) & 0x08:
            return ERR
        return OK

    def stop_crypto(self):
        self.clear_bits(0x08, 0x08)

    def read_block(self, block):
        frame = [0x30, block]
        status, back, _ = self.command(0x0C, frame + self.crc(frame))
        return back[:16] if status == OK and len(back) >= 16 else None

    def write_block(self, block, data):
        frame = [0xA0, block]
        status, back, bits = self.command(0x0C, frame + self.crc(frame))
        if status != OK or bits != 4 or back[0] & 0x0F != 0x0A:
            return ERR
        data = list(data[:16]) + [0] * (16 - len(data))
        status, back, bits = self.command(0x0C, data + self.crc(data))
        if status != OK or bits != 4 or back[0] & 0x0F != 0x0A:
            return ERR
        return OK