Módulo Leitor RFID RC522 com Raspberry Pi Pico

Neste tutorial, aprenderemos a fazer a interface do Módulo Leitor RFID RC522 com o Raspberry Pi Pico usando o MicroPython. Esses módulos de leitor RFID são muito úteis no mundo acelerado de hoje. Devido à sua natureza rápida, precisa e segura, eles são amplamente utilizados com microcontroladores em vários campos, por exemplo. de supermercados para check-outs rápidos a sistemas de segurança bem conservados para bancos/cadeias/salas de servidores.

O módulo leitor RFID que veremos é conhecido como RC522. Usaremos o Raspberry Pi Pico com ele e mostraremos um projeto MicroPython que usará diferentes cartões RFID para iluminar um LED RGB em três cores diferentes.

Ao final deste tutorial você será capaz de:

• Conheça a introdução sobre o módulo leitor RFID RC522 (recursos e pin out)
• Interface do módulo leitor RC522 com Raspberry Pi Pico juntamente com LED RGB
• Leia a etiqueta RFID
• Controle o LED RGB usando o módulo leitor RFID RC522

Pré-requisitos

Antes de começarmos esta lição, certifique-se de estar familiarizado e ter a versão mais recente do Python3 instalada em seu sistema e configurar o MicroPython em seu Raspberry Pi Pico. Além disso, você deve ter um ambiente de desenvolvimento integrado (IDE) em execução para fazer a programação.

Módulo Leitor RFID RC522

RC522 é um módulo RFID multicomunicação para Arduino e microcontroladores. O RC522 é conhecido como MFRC-522 devido ao seu microcontrolador semicondutor NFX. O módulo permite que os desenvolvedores o conectem com qualquer outro microcontrolador baseado em SPI, I2C e UART. Ele vem com uma etiqueta de cartão RFID e chaveiro com 1 KB de memória.

O módulo RC522 funciona na frequência de 13,56 MHz e pode atuar como leitor e escrever para cartões UID/RFID. Os cartões RFID comunicam-se com o módulo a curta distância com radiofrequência devido à técnica de indução mútua. Na maioria dos produtos comerciais e de segurança, o módulo é eficaz porque os erros e problemas com as etiquetas RFID são detectáveis ​​por ele.

Layout de memória de etiqueta de cartão RFID de 1 KB

O cartão RFID é um dispositivo de armazenamento de memória com 1 KB de memória. Esta memória é dividida em 16 setores (0-15) onde cada setor é dividido em 4 blocos (0,1,2,3). Cada bloco é de 16 bytes cada. Assim 4 blocos x 16 bytes x 16 setores = 1024 bytes que é 1KB

Recursos do Leitor RFID RC522

• RFID RC522 usa indução mútua para ativar os cartões e 13,56MHz para transferência de dados.
• Os Cartões RFID são utilizáveis ​​em ambos os lados do módulo a um máximo de 5 cm.
• Os únicos 3,3 V são necessários para ativar o dispositivo.
• Seu modo de suspensão automática torna o módulo de menor consumo de energia.
• O módulo possui três tipos de comunicação (UART, SPI, I2C). Portanto, é utilizável com quase odos os microcontroladores ou dispositivos do mercado.
• Os cartões e leitor RFID (RC522) podem transferir dados até 10Mb/s.

Aplicações do módulo RFID RC522

• RFID tem a maior parte do uso como um dispositivo de segurança.
• Em algumas empresas, os dispositivos usam com itens de compras.
• Alguns aeroportos também começam a usar RFID para identificar e rastrear malas e outros itens.
• O sistema de atendimento ou estacionamento também usa RFID para manter o sistema seguro.

PinOut

Neste módulo, existem apenas dois tipos de pinos. Então, o primeiro é o poder e o segundo são os pinos de comunicação. Portanto, o dispositivo pode ter seu chip microcontrolador em si mesmo, mas só faz funcionar como um RFID. O microcontrolador integrado não tornará o módulo um dispositivo autônomo.

Todos os pinos do leitor de cartão RFID MFRC/RC522 são:

A tabela abaixo mostra os oito pinos encontrados no módulo RFID RC522. Você também pode ver suas descrições.

Apresentando o LED RGB

O LED RGB é um diodo emissor de luz que emite luzes vermelhas, verdes e azuis. Consiste em três LEDs discretos: vermelho, verde e azul alojados em um único pacote, portanto, combinando essas três cores, podemos criar qualquer cor. Sempre que a tensão for aplicada ao terminal vermelho, uma luz vermelha será emitida e, da mesma forma, quando a tensão for aplicada ao terminal verde e azul, as luzes verde e azul serão emitidas, respectivamente.

O LED RGB tem quatro pinos. Esses pinos são usados ​​para controlar a cor do LED. O pino mais longo é o ânodo ou o cátodo, dependendo do tipo de LED RGB.

Existem dois tipos de diodos emissores de luz RGB disponíveis no mercado.

• Tipo de ânodo comum: No tipo de ânodo comum, o ânodo é comum para todos os três diodos emissores de luz e o ânodo de todos os diodos emissores de luz se conecta com a fonte de alimentação positiva. Outros terminais se conectam com o microcontrolador e ligamos e desligamos esses terminais de acordo com qual LED queremos ligar ou desligar.
• Tipo de cátodo comum: No tipo de cátodo comum, o cátodo de todos os três diodos emissores de luz são comuns e o terminal de cátodo comum é conectado ao terra da fonte de alimentação e o outro terminal de cada LED de energia é conectado ao microcontrolador pic de acordo com o LED que queremos ligar ou desligue.

A imagem do LED RGB do tipo ânodo comum e cátodo comum é mostrada abaixo:

Pinagem

O LED RGB e sua pinagem são mostrados abaixo.

Ponto para Observação:

• Para limitar a corrente que passará pelo LED RGB, precisaremos usar três resistores, um para cada pino de cor. Se não usarmos um resistor ou se usarmos um valor de resistor baixo, o LED será destruído. Precisamos usar um resistor de 220 ohm ou superior. Quanto maior o valor do resistor, menor o brilho do LED.

Módulo LED RGB

O LED RGB também vem em um módulo com os resistores limitadores de corrente já acoplados. Eles também estão disponíveis em dois tipos: o módulo de cátodo comum e o módulo de ânodo comum.

O módulo de LED RGB já vem com os resistores limitadores de corrente para não adicionarmos resistores externos.

Abaixo você pode ver os dois módulos com seus pinos.

Interface do módulo leitor RFID RC522 e LED RGB com Raspberry Pi Pico

Precisaremos dos seguintes componentes para conectar nossa placa Raspberry Pi Pico ao módulo RC522 e ao módulo LED RGB.

• Raspberry Pi Pico
• Módulo leitor RFID RC522
• Módulo LED RGB
• Protoboard
• Fios de conexão

O módulo RC522 possui 8 terminais que iremos conectar com o Raspberry Pi Pico. Como o RC522 requer uma tensão de operação na faixa de 2,5-3,3V, o terminal VCC do módulo RC522 será em comum com o pino de 3,3V da placa. Da mesma forma, todos os dispositivos terão seus fundamentos em comum.

A comunicação SPI ajuda a comunicar com o módulo leitor RFID, que é comum em todos os microcontroladores. Assim, utilizaremos a interface SPI do Raspberry Pi Pico. Vamos primeiro aprender sobre a interface Raspberry Pi Pico SPI.

Pinos SPI Raspberry Pi Pico

Raspberry Pi Pico suporta dois periféricos SPI. Ambos os pinos do módulo SPI são acessíveis através dos pinos GPIO do Raspberry Pi Pico. A tabela a seguir mostra a conexão dos pinos GPIO com ambos os módulos SPI. Cada conexão dos pinos do controlador SPI pode ser configurada através de vários pinos GPIO conforme mostrado na figura. Mas antes de usar o SPI, você deve configurar no software quais pinos do GPIO você deseja usar com um periférico SP específico.

A figura abaixo mostra os pinos SPI do Raspberry Pi Pico.

A figura abaixo mostra os pinos SPI do Raspberry Pi Pico.

Raspberry Pi Pico com Módulo RC522

Raspberry Pi Pico com Módulo LED RGB (Catodo Comum)

Estamos usando o módulo de LED RGB de cátodo comum para este projeto. A tabela abaixo mostra as conexões que estamos usando entre o módulo de LED e o Raspberry Pi Pico.

Os pinos vermelho, verde e azul do módulo LED RGB serão conectados aos pinos GPIO do Raspberry Pi Pico. Usaremos GP13, GP12 e GP11 para conectar com cada pino de cor. Você pode usar qualquer pino GPIO apropriado.

Diagrama esquemático

Siga o diagrama esquemático abaixo e conecte os três dispositivos de acordo.

Todas as conexões entre os dispositivos são as mesmas que as listamos nas tabelas acima.

Instalando a Biblioteca MicroPython MFRC522

Para este projeto, precisaremos da biblioteca MicroPython MRRC522. Copie esta biblioteca e salve-a em seu Raspberry Pi Pico com o respectivo nome de arquivo (mfrc522.py) do link do GitHub.

Abra um novo arquivo no Thonny. Copie a biblioteca fornecida abaixo ou do link fornecido acima. Salve-o no Raspberry Pi Pico com o nome mfrc522.py na pasta lib.

mfrc522.py

from machine import Pin, SPI
from os import uname


class MFRC522:

    DEBUG = False
    OK = 0
    NOTAGERR = 1
    ERR = 2

    REQIDL = 0x26
    REQALL = 0x52
    AUTHENT1A = 0x60
    AUTHENT1B = 0x61
  
    PICC_ANTICOLL1 = 0x93
    PICC_ANTICOLL2 = 0x95
    PICC_ANTICOLL3 = 0x97
  

    def __init__(self, sck, mosi, miso, rst, cs,baudrate=1000000,spi_id=0):

        self.sck = Pin(sck, Pin.OUT)
        self.mosi = Pin(mosi, Pin.OUT)
        self.miso = Pin(miso)
        self.rst = Pin(rst, Pin.OUT)
        self.cs = Pin(cs, Pin.OUT)

        self.rst.value(0)
        self.cs.value(1)
        
        board = uname()[0]

        if board == 'WiPy' or board == 'LoPy' or board == 'FiPy':
            self.spi = SPI(0)
            self.spi.init(SPI.MASTER, baudrate=1000000, pins=(self.sck, self.mosi, self.miso))
        elif (board == 'esp8266') or (board == 'esp32'):
            self.spi = SPI(baudrate=100000, polarity=0, phase=0, sck=self.sck, mosi=self.mosi, miso=self.miso)
            self.spi.init()
        elif board == 'rp2':
            self.spi = SPI(spi_id,baudrate=baudrate,sck=self.sck, mosi= self.mosi, miso= self.miso)
        else:
            raise RuntimeError("Unsupported platform")

        self.rst.value(1)
        self.init()

    def _wreg(self, reg, val):

        self.cs.value(0)
        self.spi.write(b'%c' % int(0xff & ((reg << 1) & 0x7e)))
        self.spi.write(b'%c' % int(0xff & val))
        self.cs.value(1)

    def _rreg(self, reg):

        self.cs.value(0)
        self.spi.write(b'%c' % int(0xff & (((reg << 1) & 0x7e) | 0x80)))
        val = self.spi.read(1)
        self.cs.value(1)

        return val[0]

    def _sflags(self, reg, mask):
        self._wreg(reg, self._rreg(reg) | mask)

    def _cflags(self, reg, mask):
        self._wreg(reg, self._rreg(reg) & (~mask))

    def _tocard(self, cmd, send):

        recv = []
        bits = irq_en = wait_irq = n = 0
        stat = self.ERR

        if cmd == 0x0E:
            irq_en = 0x12
            wait_irq = 0x10
        elif cmd == 0x0C:
            irq_en = 0x77
            wait_irq = 0x30

        self._wreg(0x02, irq_en | 0x80)
        self._cflags(0x04, 0x80)
        self._sflags(0x0A, 0x80)
        self._wreg(0x01, 0x00)

        for c in send:
            self._wreg(0x09, c)
        self._wreg(0x01, cmd)

        if cmd == 0x0C:
            self._sflags(0x0D, 0x80)

        i = 2000
        while True:
            n = self._rreg(0x04)
            i -= 1
            if ~((i != 0) and ~(n & 0x01) and ~(n & wait_irq)):
                break

        self._cflags(0x0D, 0x80)

        if i:
            if (self._rreg(0x06) & 0x1B) == 0x00:
                stat = self.OK

                if n & irq_en & 0x01:
                    stat = self.NOTAGERR
                elif cmd == 0x0C:
                    n = self._rreg(0x0A)
                    lbits = self._rreg(0x0C) & 0x07
                    if lbits != 0:
                        bits = (n - 1) * 8 + lbits
                    else:
                        bits = n * 8

                    if n == 0:
                        n = 1
                    elif n > 16:
                        n = 16

                    for _ in range(n):
                        recv.append(self._rreg(0x09))
            else:
                stat = self.ERR

        return stat, recv, bits

    def _crc(self, data):

        self._cflags(0x05, 0x04)
        self._sflags(0x0A, 0x80)

        for c in data:
            self._wreg(0x09, c)

        self._wreg(0x01, 0x03)

        i = 0xFF
        while True:
            n = self._rreg(0x05)
            i -= 1
            if not ((i != 0) and not (n & 0x04)):
                break

        return [self._rreg(0x22), self._rreg(0x21)]

    def init(self):

        self.reset()
        self._wreg(0x2A, 0x8D)
        self._wreg(0x2B, 0x3E)
        self._wreg(0x2D, 30)
        self._wreg(0x2C, 0)
        self._wreg(0x15, 0x40)
        self._wreg(0x11, 0x3D)
        self.antenna_on()

    def reset(self):
        self._wreg(0x01, 0x0F)

    def antenna_on(self, on=True):

        if on and ~(self._rreg(0x14) & 0x03):
            self._sflags(0x14, 0x03)
        else:
            self._cflags(0x14, 0x03)

    def request(self, mode):

        self._wreg(0x0D, 0x07)
        (stat, recv, bits) = self._tocard(0x0C, [mode])

        if (stat != self.OK) | (bits != 0x10):
            stat = self.ERR

        return stat, bits
  
    def anticoll(self,anticolN):

        ser_chk = 0
        ser = [anticolN, 0x20]

        self._wreg(0x0D, 0x00)
        (stat, recv, bits) = self._tocard(0x0C, ser)

        if stat == self.OK:
            if len(recv) == 5:
                for i in range(4):
                    ser_chk = ser_chk ^ recv[i]
                if ser_chk != recv[4]:
                    stat = self.ERR
            else:
                stat = self.ERR

        return stat, recv

    
    def PcdSelect(self, serNum,anticolN):
        backData = []
        buf = []
        buf.append(anticolN)
        buf.append(0x70)
        #i = 0
        ###xorsum=0;
        for i in serNum:
            buf.append(i)
        #while i<5:
        #    buf.append(serNum[i])
        #    i = i + 1
        pOut = self._crc(buf)
        buf.append(pOut[0])
        buf.append(pOut[1])
        (status, backData, backLen) = self._tocard( 0x0C, buf)
        if (status == self.OK) and (backLen == 0x18):
            return  1
        else:
            return 0
    
    
    def SelectTag(self, uid):
        byte5 = 0
        
        #(status,puid)= self.anticoll(self.PICC_ANTICOLL1)
        #print("uid",uid,"puid",puid)
        for i in uid:
            byte5 = byte5 ^ i
        puid = uid + [byte5]
        
        if self.PcdSelect(puid,self.PICC_ANTICOLL1) == 0:
            return (self.ERR,[])
        return (self.OK , uid)
        
    def tohexstring(self,v):
        s="["
        for i in v:
            if i != v[0]:
                s = s+ ", "
            s=s+ "0x{:02X}".format(i)
        s= s+ "]"
        return s
        
  
            
    
    def SelectTagSN(self):
        valid_uid=[]
        (status,uid)= self.anticoll(self.PICC_ANTICOLL1)
        #print("Select Tag 1:",self.tohexstring(uid))
        if status != self.OK:
            return  (self.ERR,[])
        
        if self.DEBUG:   print("anticol(1) {}".format(uid))
        if self.PcdSelect(uid,self.PICC_ANTICOLL1) == 0:
            return (self.ERR,[])
        if self.DEBUG:   print("pcdSelect(1) {}".format(uid))
        
        #check if first byte is 0x88
        if uid[0] == 0x88 :
            #ok we have another type of card
            valid_uid.extend(uid[1:4])
            (status,uid)=self.anticoll(self.PICC_ANTICOLL2)
            #print("Select Tag 2:",self.tohexstring(uid))
            if status != self.OK:
                return (self.ERR,[])
            if self.DEBUG: print("Anticol(2) {}".format(uid))
            rtn =  self.PcdSelect(uid,self.PICC_ANTICOLL2)
            if self.DEBUG: print("pcdSelect(2) return={} uid={}".format(rtn,uid))
            if rtn == 0:
                return (self.ERR,[])
            if self.DEBUG: print("PcdSelect2() {}".format(uid))
            #now check again if uid[0] is 0x88
            if uid[0] == 0x88 :
                valid_uid.extend(uid[1:4])
                (status , uid) = self.anticoll(self.PICC_ANTICOLL3)
                #print("Select Tag 3:",self.tohexstring(uid))
                if status != self.OK:
                    return (self.ERR,[])
                if self.DEBUG: print("Anticol(3) {}".format(uid))
                if self.MFRC522_PcdSelect(uid,self.PICC_ANTICOLL3) == 0:
                    return (self.ERR,[])
                if self.DEBUG: print("PcdSelect(3) {}".format(uid))
        valid_uid.extend(uid[0:5])
        # if we are here than the uid is ok
        # let's remove the last BYTE whic is the XOR sum
        
        return (self.OK , valid_uid[:len(valid_uid)-1])
        #return (self.OK , valid_uid)
    
    
   
       
    

    def auth(self, mode, addr, sect, ser):
        return self._tocard(0x0E, [mode, addr] + sect + ser[:4])[0]
    
    def authKeys(self,uid,addr,keyA=None, keyB=None):
        status = self.ERR
        if keyA is not None:
            status = self.auth(self.AUTHENT1A, addr, keyA, uid)
        elif keyB is not None:
            status = self.auth(self.AUTHENT1B, addr, keyB, uid)
        return status
       

    def stop_crypto1(self):
        self._cflags(0x08, 0x08)

    def read(self, addr):

        data = [0x30, addr]
        data += self._crc(data)
        (stat, recv, _) = self._tocard(0x0C, data)
        return stat, recv

    def write(self, addr, data):

        buf = [0xA0, addr]
        buf += self._crc(buf)
        (stat, recv, bits) = self._tocard(0x0C, buf)

        if not (stat == self.OK) or not (bits == 4) or not ((recv[0] & 0x0F) == 0x0A):
            stat = self.ERR
        else:
            buf = []
            for i in range(16):
                buf.append(data[i])
            buf += self._crc(buf)
            (stat, recv, bits) = self._tocard(0x0C, buf)
            if not (stat == self.OK) or not (bits == 4) or not ((recv[0] & 0x0F) == 0x0A):
                stat = self.ERR
        return stat


    def writeSectorBlock(self,uid, sector, block, data, keyA=None, keyB = None):
        absoluteBlock =  sector * 4 + (block % 4)
        if absoluteBlock > 63 :
            return self.ERR
        if len(data) != 16:
            return self.ERR
        if self.authKeys(uid,absoluteBlock,keyA,keyB) != self.ERR :
            return self.write(absoluteBlock, data)
        return self.ERR

    def readSectorBlock(self,uid ,sector, block, keyA=None, keyB = None):
        absoluteBlock =  sector * 4 + (block % 4)
        if absoluteBlock > 63 :
            return self.ERR, None
        if self.authKeys(uid,absoluteBlock,keyA,keyB) != self.ERR :
            return self.read(absoluteBlock)
        return self.ERR, None

    def MFRC522_DumpClassic1K(self,uid, Start=0, End=64, keyA=None, keyB=None):
        for absoluteBlock in range(Start,End):
            status = self.authKeys(uid,absoluteBlock,keyA,keyB)
            # Check if authenticated
            print("{:02d} S{:02d} B{:1d}: ".format(absoluteBlock, absoluteBlock//4 , absoluteBlock % 4),end="")
            if status == self.OK:                    
                status, block = self.read(absoluteBlock)
                if status == self.ERR:
                    break
                else:
                    for value in block:
                        print("{:02X} ".format(value),end="")
                    print("  ",end="")
                    for value in block:
                        if (value > 0x20) and (value < 0x7f):
                            print(chr(value),end="")
                        else:
                            print('.',end="")
                    print("")
            else:
                break
        if status == self.ERR:
            print("Authentication error")
            return self.ERR
        return self.OK

Controle de LED RGB RFID RC522

Usaremos o Raspberry Pi Pico com ele e mostraremos um projeto MicroPython que usará diferentes cartões RFID para iluminar um LED RGB em três cores diferentes. Um cartão fará com que o LED acenda na cor verde enquanto outro acenderá na cor azul. Qualquer cartão desconhecido definirá a luz RGB para a cor vermelha. O usuário aproxima o cartão/tags RFID do leitor RFID e a luz RGB é definida para a cor apropriada junto com as mensagens relevantes no Thonny Shell.

Raspberry Pi Pico MicroPython: Lendo etiquetas RFID

Abra seu Thonny IDE e vá em File > New para abrir um novo arquivo. Copie o código a seguir nesse arquivo. Este esboço identificará o ID do cartão/tag RFID. Quando o usuário traz uma etiqueta/cartão RFID próximo ao módulo RC522, ele detecta a etiqueta e lê seu valor.

from mfrc522 import MFRC522
import utime

reader = MFRC522(spi_id=0,sck=2,miso=4,mosi=3,cs=1,rst=0)

print("Bring TAG closer...")
print("")


while True:
    reader.init()
    (stat, tag_type) = reader.request(reader.REQIDL)
    if stat == reader.OK:
        (stat, uid) = reader.SelectTagSN()
        if stat == reader.OK:
            card = int.from_bytes(bytes(uid),"little",False)
            print("CARD ID: "+str(card))
utime.sleep_ms(500)

Como o Código Funciona?

O primeiro passo é incluir todas as bibliotecas necessárias para este projeto. Importaremos o módulo utime para gerar o delay e a classe MFRC522 do módulo mfrc522 para trabalhar com o leitor RC522 para esta tarefa.

from mfrc522 import MFRC522
import utime

Em seguida, definiremos a conexão RFID do RC522 criando um objeto ‘leitor’. Ao usar MFRC522(), especificamos o número do canal SPI como o primeiro parâmetro e os pinos SPI como o restante dos parâmetros.

reader = MFRC522(spi_id=0,sck=2,miso=4,mosi=3,cs=1,rst=0)

A seguinte mensagem impressa no Thonny Shell indica que o usuário deve aproximar seu cartão/tag RFID do módulo RFID.

print("Bring TAG closer...")
print("")

Dentro do loop infinito, primeiro inicializaremos o leitor RFID usando o método init() no objeto leitor. Em seguida, obteremos o status do leitor. Se o status for válido, seguiremos em frente com nosso programa. Criaremos outro objeto ‘cartão’ que conterá o ID do cartão RFID. Obteremos o ID de tag exclusivo associado à tag sempre que ela for detectada. Isso é impresso no console Thonny shell.

while True:
    reader.init()
    (stat, tag_type) = reader.request(reader.REQIDL)
    if stat == reader.OK:
        (stat, uid) = reader.SelectTagSN()
        if stat == reader.OK:
            card = int.from_bytes(bytes(uid),"little",False)
            print("CARD ID: "+str(card))
utime.sleep_ms(500)

Demonstração

Depois de copiar o código a seguir em um novo arquivo, clique no ícone ‘Salvar’ para salvar o código do programa em seu PC.

Depois de salvar o código, pressione o botão Executar para fazer o upload do código para o seu módulo Raspberry Pi Pico. Antes de fazer o upload do código, certifique-se de que a placa correta esteja selecionada.

Agora traga um cartão/tag RFID perto do leitor RC522. Imediatamente o ID do cartão será impresso no terminal shell. Aqui, digitalizamos duas tags diferentes e obtivemos seus IDs.

Usaremos esses dois IDs para acender o LED RGB adequadamente. Se o primeiro ID for digitalizado pelo leitor, o LED RGB será definido para luz verde e se o segundo ID for digitalizado, o LED RGB será definido para luz azul. Para qualquer outra tag RFID que seja digitalizada, o LED RGB será configurado para vermelho.

Raspberry Pi Pico MicroPython: Controle de LED RFID RC522 RGB

Quando o usuário traz uma etiqueta/cartão RFID próximo ao RC522, ele detecta a etiqueta e lê seu valor. Se o valor for o mesmo definido no código para verde, a mensagem ‘PASS: Green Light Activated’ é mostrada no terminal do shell. Se o valor for o mesmo definido no código para azul, a mensagem ‘PASS: Blue Light Activated’ é mostrada no terminal do shell. Caso contrário, ‘CARTÃO DESCONHECIDO! A mensagem Red Light Activated’ é mostrada em vez disso. O LED RGB será definido para as cores verde, azul ou vermelho neste processo. Este processo ocorre sempre que o usuário aproxima uma etiqueta RFID do módulo.

from machine import Pin
from mfrc522 import MFRC522
import utime
       
reader = MFRC522(spi_id=0,sck=2,miso=4,mosi=3,cs=1,rst=0)

red = Pin(13, Pin.OUT)
green = Pin(12, Pin.OUT)
blue = Pin(11, Pin.OUT)

print("Bring RFID TAG Closer...")
print("")


while True:
    reader.init()
    (stat, tag_type) = reader.request(reader.REQIDL)
    if stat == reader.OK:
        (stat, uid) = reader.SelectTagSN()
        if stat == reader.OK:
            card = int.from_bytes(bytes(uid),"little",False)
            
            if card == 612121286:
                print("Card ID: "+ str(card)+" PASS: Green Light Activated")
                red.value(0)
                green.value(1)
                blue.value(0)
                
                
            elif card == 1002696326:
                print("Card ID: "+ str(card)+" PASS: Blue Light Activated")
                red.value(0)
                green.value(0)
                blue.value(1)
                
            else:
                print("Card ID: "+ str(card)+" UNKNOWN CARD! Red Light Activated")
                red.value(1)
                green.value(0)
                blue.value(0)

Como o Código Funciona?

A maior parte do código é semelhante ao acima, onde estamos obtendo as identificações das etiquetas RFID. Depois de obter o ID do cartão, verificaremos se o ID é um dos dois que configuramos para uma passagem verde e azul e, em seguida, configuramos o LED RGB para essa cor específica.

Como estamos usando o módulo RGB de cátodo comum, para definir a cor para verde, teremos que garantir que o GPIO conectado ao pino verde esteja em um estado alto e o restante dos dois esteja em um estado baixo.

red.value(0)
green.value(1)
blue.value(0)

Para definir a cor para azul, teremos que garantir que o GPIO conectado ao pino azul esteja em um estado alto e o restante dos dois esteja em um estado baixo.

red.value(0)
green.value(0)
blue.value(1)

Da mesma forma, para definir a cor para vermelho, teremos que garantir que o GPIO conectado ao pino vermelho esteja em estado alto e o restante dos dois esteja em estado baixo.

red.value(1)
green.value(0)
blue.value(0)

Demonstração

Depois de copiar o código a seguir em um novo arquivo, clique no ícone ‘Salvar’ para salvar o código do programa em seu PC.

Depois de salvar o código, pressione o botão Executar para fazer o upload do código para o seu módulo Raspberry Pi Pico.

Aproxime o cartão/tags RFID do leitor RC522 e imediatamente o LED RGB acenderá em verde, azul ou vermelho.

O terminal Thonny Shell também imprimirá mensagens relevantes à medida que cada tag for digitalizada.