Pico W RFID music player with a WS2812 strip

# RFID music player: a card carries a tune as note letters (C D E F G A B),
# stored with lesson 6.5's program. Lay it on the reader: each note plays
# on the buzzer (GP15) and the strip (GP0) flashes a color for it.
from machine import Pin, PWM, SPI
from mfrc522 import MFRC522
import neopixel
import random
import time

NOTES = {"C": 262, "D": 294, "E": 330, "F": 349, "G": 392, "A": 440, "B": 494}
spi = SPI(0, baudrate=1000000, sck=Pin(18), mosi=Pin(19), miso=Pin(16))
reader = MFRC522(spi, Pin(17), Pin(9))
strip = neopixel.NeoPixel(Pin(0), 8)
buzzer = PWM(Pin(15))
buzzer.duty_u16(0)

def play(tune):
    for letter in tune:
        hz = NOTES.get(letter.upper())
        if not hz:
            continue
        color = (random.randint(0, 64), random.randint(0, 64), random.randint(0, 64))
        strip.fill(color)
        strip.write()
        buzzer.freq(hz)
        buzzer.duty_u16(30000)
        print("note", letter, hz)
        time.sleep_ms(250)
        buzzer.duty_u16(0)
        time.sleep_ms(50)
    strip.fill((0, 0, 0))
    strip.write()

print("Lay a card with a tune on it")
while True:
    uid = reader.uid()
    if uid:
        data = reader.read(8, uid)
        reader.done()
        tune = data.rstrip(b"\x00").decode() if data else ""
        print("tune:", tune or "(nothing stored)")
        play(tune or "CDEC")
        while reader.uid():
            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