MicroPython RFID on a Pico: read a card’s UID, RC522

# An RC522 RFID reader on SoftSPI (SCK GP2, MOSI GP3, MISO GP4, CS GP5).
# When a card is laid on it: its UID, then block 8 read with the factory
# key. mfrc522.py, in the next tab, speaks to the reader.
from machine import Pin, SoftSPI
import time
from mfrc522 import MFRC522, OK

Pin(6, Pin.OUT, value=1)                 # RST high: the reader runs
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
print("Lay a card on the reader")

while True:
    if reader.request() == OK:
        status, uid = reader.anticoll()
        if status == OK and reader.select(uid) == OK:
            print("card UID:", " ".join("%02X" % b for b in uid[:4]))
            if reader.auth(8, KEY, uid) == OK:
                print("block 8:", reader.read_block(8))
            reader.stop_crypto()
            time.sleep(1)
    time.sleep_ms(100)

# 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