Pico W MFRC522 reads and writes RFID cards

# Radio frequency identification: an MFRC522 on SPI0 (SCK GP18, MOSI GP19,
# MISO GP16), chip select on GP17 and reset on GP9. Lay a card on the
# reader and its UID and the text in block 8 are printed. Type a line in
# the Serial Monitor first and it is written to the next card instead.
from machine import Pin, SPI
from mfrc522 import MFRC522
import select
import sys
import time

spi = SPI(0, baudrate=1000000, sck=Pin(18), mosi=Pin(19), miso=Pin(16))
reader = MFRC522(spi, Pin(17), Pin(9))
BLOCK = 8
pending = None
typed = ""
poll = select.poll()
poll.register(sys.stdin, select.POLLIN)
print("Lay a card on the reader, or type text to store")

while True:
    while poll.poll(0):
        ch = sys.stdin.read(1)
        if ch in "\r\n":
            if typed:
                pending = typed
                print("Now lay a card on the reader to store:", pending)
            typed = ""
        else:
            typed += ch
    uid = reader.uid()
    if uid:
        name = "-".join("%02X" % b for b in uid)
        if pending is not None:
            ok = reader.write(BLOCK, uid, pending.encode())
            print("card", name, "stored" if ok else "could not be written")
            pending = None
        else:
            data = reader.read(BLOCK, uid)
            text = data.rstrip(b"\x00").decode() if data else "?"
            print("card", name, "says:", text)
        reader.done()
        while reader.uid():            # wait for the card to be taken away
            reader.done()
            time.sleep_ms(100)
    time.sleep_ms(100)

# mfrc522.py: the MFRC522 reader on SPI. Enough to find a MIFARE Classic
# card, read its UID, and read or write a 16-byte block behind the
# factory key, which is what a lesson that stores text on a card needs.
from machine import Pin, SPI
import time

OK, NOTAG, ERR = 0, 1, 2

class MFRC522:
    def __init__(self, spi, cs, rst):
        self.spi = spi
        self.cs = cs
        self.rst = rst
        cs.init(Pin.OUT, value=1)
        rst.init(Pin.OUT, value=0)
        time.sleep_ms(10)
        rst.value(1)
        time.sleep_ms(10)
        self._w(0x01, 0x0F)          # soft reset
        time.sleep_ms(10)
        self._w(0x2A, 0x8D)          # timer: about 25 ms before a card that
        self._w(0x2B, 0x3E)          # does not answer is given up on
        self._w(0x2D, 30)
        self._w(0x2C, 0)
        self._w(0x15, 0x40)          # 100 % ASK
        self._w(0x11, 0x3D)          # CRC preset 0x6363
        self._w(0x14, self._r(0x14) | 0x03)   # antenna on

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

    def _r(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 _card(self, command, send):
        irq_wait = 0x12 if command == 0x0E else 0x30
        self._w(0x02, 0x80 | (0x12 if command == 0x0E else 0x77))
        self._w(0x04, 0x7F)          # clear the interrupt bits
        self._w(0x0A, 0x80)          # flush the FIFO
        self._w(0x01, 0x00)          # idle
        for b in send:
            self._w(0x09, b)
        self._w(0x01, command)
        if command == 0x0C:
            self._w(0x0D, self._r(0x0D) | 0x80)   # start sending
        for _ in range(2000):
            n = self._r(0x04)
            if n & irq_wait or n & 0x01:
                break
        self._w(0x0D, self._r(0x0D) & 0x7F)
        if not (n & irq_wait):
            return NOTAG, [], 0
        if self._r(0x06) & 0x1B:
            return ERR, [], 0
        back, bits = [], 0
        if command == 0x0C:
            count = self._r(0x0A)
            last = self._r(0x0C) & 0x07
            bits = (count - 1) * 8 + last if last else count * 8
            back = [self._r(0x09) for _ in range(count)]
        return OK, back, bits

    def _crc(self, data):
        self._w(0x05, 0x04)
        self._w(0x0A, 0x80)
        for b in data:
            self._w(0x09, b)
        self._w(0x01, 0x03)
        for _ in range(255):
            if self._r(0x05) & 0x04:
                break
        return [self._r(0x22), self._r(0x21)]

    def uid(self):
        """The UID of the card on the reader, selected, or None."""
        self._w(0x0D, 0x07)
        stat, back, bits = self._card(0x0C, [0x26])      # REQA
        if stat != OK or bits != 0x10:
            return None
        self._w(0x0D, 0x00)
        stat, back, _ = self._card(0x0C, [0x93, 0x20])   # anticollision
        if stat != OK or len(back) != 5:
            return None
        frame = [0x93, 0x70] + back
        stat, _, _ = self._card(0x0C, frame + self._crc(frame))   # select
        return back[:4] if stat == OK else None

    def _auth(self, block, uid):
        key = [0xFF] * 6
        stat, _, _ = self._card(0x0E, [0x60, block] + key + uid)
        return stat == OK and self._r(0x08) & 0x08

    def read(self, block, uid):
        if not self._auth(block, uid):
            return None
        frame = [0x30, block]
        stat, back, _ = self._card(0x0C, frame + self._crc(frame))
        return bytes(back[:16]) if stat == OK else None

    def write(self, block, uid, data):
        if not self._auth(block, uid):
            return False
        frame = [0xA0, block]
        stat, back, _ = self._card(0x0C, frame + self._crc(frame))
        if stat != OK:
            return False
        data = list(data[:16]) + [0] * (16 - len(data[:16]))
        stat, back, _ = self._card(0x0C, data + self._crc(data))
        return stat == OK

    def done(self):
        self._w(0x08, self._r(0x08) & 0xF7)   # stop the encryption