Reading from an RFID Reader (MFRC522)

I was following this tutorial, but it isn’t working since the python modules used only work Raspberry Pi.

I tried modifying the MFRC522 module so that it didn’t depend on RPi.GPIO, but that didn’t seem to work. The program starts up but nothing is ever read.

What other alternatives are there to get this working?

main file:

from module.mfrc522 import SimpleMFRC522

reader = SimpleMFRC522()

id, text =

This is my modified MFRC522

SimpleMFRC522 is kept the same but I just removed the RPi.GPIO import.

Which board are you using? I have one of these kicking around, I can try it on my S905X.

1 Like

It is a Le Potato, S905X.

Ok, I don’t have a lot of experience with SPI, but I’ll give it a try. I’m working a lot of overtime right now, so it might be a bit.

1 Like

Thanks! Take your time.

Instead of the Raspberry Pi SPI instructions, you can enable SPI on Le Potato like this:

Then just run the Python script.


I think something still needs to replace that RPi.GPIO library to handle that one lonely reset pin. I have a rough idea how do do it, just need the time. If I’m not too exhausted after work, I’ll give it a crack tonight. 70 hr. weeks don’t leave a lot of time for tinkering.

Also, I had to download the whole module from github, since RPi.GPIO seems to be used in too. That and I’d like to test it for myself. I’ve only used SPI to connect a microcontroller to an LCD, so I’m in uncharted waters.

1 Like

RPi.GPIO is not a good library. Best to avoid using it in any application. To modify a GPIO, look up the GPIO chip number and line number and use those directly via libgpiod.


Thank you so much for your time! No worries about the speed, take your time.

Still doesn’t seem to work.

You are doing a step incorrectly if that is the case. lgpio tool directly uses libgpiod so it is definitely working.

Just managed to wrap my head around libgpiod. I’ll try to apply what I’ve learned tonight when I get home from work.

1 Like

the only pin being modified directly is the rst, but I will send pictures tomorrow of my setup to ensure everything is right. thanks!

Still getting errors here or there, but works for the most part.

First, enable spi with sudo ldto enable spicc spicc-spidev

I put the following files in the same directory instead of installing as a module. I left most of the original code commented out so you can see what I changed, otherwise just the import statements got shuffled. I hope this is helpful, I definitely learned a lot in the process. Thanks to @librecomputer for all the guidance.

#!/usr/bin/env python
# -*- coding: utf8 -*-
#    Copyright 2014,2018 Mario Gomez <>
#    This file is part of MFRC522-Python
#    MFRC522-Python is a simple Python implementation for
#    the MFRC522 NFC Card Reader for the Raspberry Pi.
#    MFRC522-Python is free software: you can redistribute it and/or modify
#    it under the terms of the GNU Lesser General Public License as published by
#    the Free Software Foundation, either version 3 of the License, or
#    (at your option) any later version.
#    MFRC522-Python is distributed in the hope that it will be useful,
#    but WITHOUT ANY WARRANTY; without even the implied warranty of
#    GNU Lesser General Public License for more details.
#    You should have received a copy of the GNU Lesser General Public License
#    along with MFRC522-Python.  If not, see <>.
# Modified by Angus for use with Libre Computer AML-S905X-CC "le Potato"  
# 1-April-2013

#import RPi.GPIO as GPIO
# Replaced RPi lib with libgpiod
import gpiod
import spidev
import signal
import time
import logging

class MFRC522:
    MAX_LEN = 16

    PCD_IDLE = 0x00
    PCD_AUTHENT = 0x0E
    PCD_RECEIVE = 0x08
    PCD_TRANSMIT = 0x04
    PCD_CALCCRC = 0x03

    PICC_REQIDL = 0x26
    PICC_REQALL = 0x52
    PICC_ANTICOLL = 0x93
    PICC_SElECTTAG = 0x93
    PICC_AUTHENT1A = 0x60
    PICC_AUTHENT1B = 0x61
    PICC_READ = 0x30
    PICC_WRITE = 0xA0
    PICC_HALT = 0x50

    MI_OK = 0
    MI_ERR = 2

    Reserved00 = 0x00
    CommandReg = 0x01
    CommIEnReg = 0x02
    DivlEnReg = 0x03
    CommIrqReg = 0x04
    DivIrqReg = 0x05
    ErrorReg = 0x06
    Status1Reg = 0x07
    Status2Reg = 0x08
    FIFODataReg = 0x09
    FIFOLevelReg = 0x0A
    WaterLevelReg = 0x0B
    ControlReg = 0x0C
    BitFramingReg = 0x0D
    CollReg = 0x0E
    Reserved01 = 0x0F

    Reserved10 = 0x10
    ModeReg = 0x11
    TxModeReg = 0x12
    RxModeReg = 0x13
    TxControlReg = 0x14
    TxAutoReg = 0x15
    TxSelReg = 0x16
    RxSelReg = 0x17
    RxThresholdReg = 0x18
    DemodReg = 0x19
    Reserved11 = 0x1A
    Reserved12 = 0x1B
    MifareReg = 0x1C
    Reserved13 = 0x1D
    Reserved14 = 0x1E
    SerialSpeedReg = 0x1F

    Reserved20 = 0x20
    CRCResultRegM = 0x21
    CRCResultRegL = 0x22
    Reserved21 = 0x23
    ModWidthReg = 0x24
    Reserved22 = 0x25
    RFCfgReg = 0x26
    GsNReg = 0x27
    CWGsPReg = 0x28
    ModGsPReg = 0x29
    TModeReg = 0x2A
    TPrescalerReg = 0x2B
    TReloadRegH = 0x2C
    TReloadRegL = 0x2D
    TCounterValueRegH = 0x2E
    TCounterValueRegL = 0x2F

    Reserved30 = 0x30
    TestSel1Reg = 0x31
    TestSel2Reg = 0x32
    TestPinEnReg = 0x33
    TestPinValueReg = 0x34
    TestBusReg = 0x35
    AutoTestReg = 0x36
    VersionReg = 0x37
    AnalogTestReg = 0x38
    TestDAC1Reg = 0x39
    TestDAC2Reg = 0x3A
    TestADCReg = 0x3B
    Reserved31 = 0x3C
    Reserved32 = 0x3D
    Reserved33 = 0x3E
    Reserved34 = 0x3F

    serNum = []

    def __init__(self, bus=0, device=0, spd=1000000, debugLevel='WARNING'): # removed " pin_mode=10, pin_rst=-1," from args
        self.spi = spidev.SpiDev(), device)
        self.spi.max_speed_hz = spd

        self.logger = logging.getLogger('mfrc522Logger')
        level = logging.getLevelName(debugLevel)

# replaced RPi code with libgpiod, no option for pin 15 anymore
        # gpioMode = GPIO.getmode()
        # if gpioMode is None:
            # GPIO.setmode(pin_mode)
        # else:
            # pin_mode = gpioMode
        # if pin_rst == -1:
            # if pin_mode == 11:
                # pin_rst = 15
            # else:
                # pin_rst = 22
        # GPIO.setup(pin_rst, GPIO.OUT)
        # GPIO.output(pin_rst, 1)

        chip = gpiod.Chip('1') # set the chip number
        lines = chip.get_lines([79]) # setthe line number
        lines.request(consumer='spam', type=gpiod.LINE_REQ_DIR_OUT, default_vals=[1]) # set direction and value

    def MFRC522_Reset(self):
        self.Write_MFRC522(self.CommandReg, self.PCD_RESETPHASE)

    def Write_MFRC522(self, addr, val):
        val = self.spi.xfer2([(addr << 1) & 0x7E, val])

    def Read_MFRC522(self, addr):
        val = self.spi.xfer2([((addr << 1) & 0x7E) | 0x80, 0])
        return val[1]

    def Close_MFRC522(self):

    def SetBitMask(self, reg, mask):
        tmp = self.Read_MFRC522(reg)
        self.Write_MFRC522(reg, tmp | mask)

    def ClearBitMask(self, reg, mask):
        tmp = self.Read_MFRC522(reg)
        self.Write_MFRC522(reg, tmp & (~mask))

    def AntennaOn(self):
        temp = self.Read_MFRC522(self.TxControlReg)
        if (~(temp & 0x03)):
            self.SetBitMask(self.TxControlReg, 0x03)

    def AntennaOff(self):
        self.ClearBitMask(self.TxControlReg, 0x03)

    def MFRC522_ToCard(self, command, sendData):
        backData = []
        backLen = 0
        status = self.MI_ERR
        irqEn = 0x00
        waitIRq = 0x00
        lastBits = None
        n = 0

        if command == self.PCD_AUTHENT:
            irqEn = 0x12
            waitIRq = 0x10
        if command == self.PCD_TRANSCEIVE:
            irqEn = 0x77
            waitIRq = 0x30

        self.Write_MFRC522(self.CommIEnReg, irqEn | 0x80)
        self.ClearBitMask(self.CommIrqReg, 0x80)
        self.SetBitMask(self.FIFOLevelReg, 0x80)

        self.Write_MFRC522(self.CommandReg, self.PCD_IDLE)

        for i in range(len(sendData)):
            self.Write_MFRC522(self.FIFODataReg, sendData[i])

        self.Write_MFRC522(self.CommandReg, command)

        if command == self.PCD_TRANSCEIVE:
            self.SetBitMask(self.BitFramingReg, 0x80)

        i = 2000
        while True:
            n = self.Read_MFRC522(self.CommIrqReg)
            i -= 1
            if ~((i != 0) and ~(n & 0x01) and ~(n & waitIRq)):

        self.ClearBitMask(self.BitFramingReg, 0x80)

        if i != 0:
            if (self.Read_MFRC522(self.ErrorReg) & 0x1B) == 0x00:
                status = self.MI_OK

                if n & irqEn & 0x01:
                    status = self.MI_NOTAGERR

                if command == self.PCD_TRANSCEIVE:
                    n = self.Read_MFRC522(self.FIFOLevelReg)
                    lastBits = self.Read_MFRC522(self.ControlReg) & 0x07
                    if lastBits != 0:
                        backLen = (n - 1) * 8 + lastBits
                        backLen = n * 8

                    if n == 0:
                        n = 1
                    if n > self.MAX_LEN:
                        n = self.MAX_LEN

                    for i in range(n):
                status = self.MI_ERR

        return (status, backData, backLen)

    def MFRC522_Request(self, reqMode):
        status = None
        backBits = None
        TagType = []

        self.Write_MFRC522(self.BitFramingReg, 0x07)

        (status, backData, backBits) = self.MFRC522_ToCard(self.PCD_TRANSCEIVE, TagType)

        if ((status != self.MI_OK) | (backBits != 0x10)):
            status = self.MI_ERR

        return (status, backBits)

    def MFRC522_Anticoll(self):
        backData = []
        serNumCheck = 0

        serNum = []

        self.Write_MFRC522(self.BitFramingReg, 0x00)


        (status, backData, backBits) = self.MFRC522_ToCard(self.PCD_TRANSCEIVE, serNum)

        if (status == self.MI_OK):
            i = 0
            if len(backData) == 5:
                for i in range(4):
                    serNumCheck = serNumCheck ^ backData[i]
                if serNumCheck != backData[4]:
                    status = self.MI_ERR
                status = self.MI_ERR

        return (status, backData)

    def CalulateCRC(self, pIndata):
        self.ClearBitMask(self.DivIrqReg, 0x04)
        self.SetBitMask(self.FIFOLevelReg, 0x80)

        for i in range(len(pIndata)):
            self.Write_MFRC522(self.FIFODataReg, pIndata[i])

        self.Write_MFRC522(self.CommandReg, self.PCD_CALCCRC)
        i = 0xFF
        while True:
            n = self.Read_MFRC522(self.DivIrqReg)
            i -= 1
            if not ((i != 0) and not (n & 0x04)):
        pOutData = []
        return pOutData

    def MFRC522_SelectTag(self, serNum):
        backData = []
        buf = []
        for i in range(5):

        pOut = self.CalulateCRC(buf)
        (status, backData, backLen) = self.MFRC522_ToCard(self.PCD_TRANSCEIVE, buf)

        if (status == self.MI_OK) and (backLen == 0x18):
            self.logger.debug("Size: " + str(backData[0]))
            return backData[0]
            return 0

    def MFRC522_Auth(self, authMode, BlockAddr, Sectorkey, serNum):
        buff = []

        # First byte should be the authMode (A or B)

        # Second byte is the trailerBlock (usually 7)

        # Now we need to append the authKey which usually is 6 bytes of 0xFF
        for i in range(len(Sectorkey)):

        # Next we append the first 4 bytes of the UID
        for i in range(4):

        # Now we start the authentication itself
        (status, backData, backLen) = self.MFRC522_ToCard(self.PCD_AUTHENT, buff)

        # Check if an error occurred
        if not (status == self.MI_OK):
            self.logger.error("AUTH ERROR!!")
        if not (self.Read_MFRC522(self.Status2Reg) & 0x08) != 0:
            self.logger.error("AUTH ERROR(status2reg & 0x08) != 0")

        # Return the status
        return status

    def MFRC522_StopCrypto1(self):
        self.ClearBitMask(self.Status2Reg, 0x08)

    def MFRC522_Read(self, blockAddr):
        recvData = []
        pOut = self.CalulateCRC(recvData)
        (status, backData, backLen) = self.MFRC522_ToCard(self.PCD_TRANSCEIVE, recvData)
        if not (status == self.MI_OK):
            self.logger.error("Error while reading!")

        if len(backData) == 16:
            self.logger.debug("Sector " + str(blockAddr) + " " + str(backData))
            return backData
            return None

    def MFRC522_Write(self, blockAddr, writeData):
        buff = []
        crc = self.CalulateCRC(buff)
        (status, backData, backLen) = self.MFRC522_ToCard(self.PCD_TRANSCEIVE, buff)
        if not (status == self.MI_OK) or not (backLen == 4) or not ((backData[0] & 0x0F) == 0x0A):
            status = self.MI_ERR

        self.logger.debug("%s backdata &0x0F == 0x0A %s" % (backLen, backData[0] & 0x0F))
        if status == self.MI_OK:
            buf = []
            for i in range(16):

            crc = self.CalulateCRC(buf)
            (status, backData, backLen) = self.MFRC522_ToCard(self.PCD_TRANSCEIVE, buf)
            if not (status == self.MI_OK) or not (backLen == 4) or not ((backData[0] & 0x0F) == 0x0A):
                self.logger.error("Error while writing")
            if status == self.MI_OK:
                self.logger.debug("Data written")

    def MFRC522_DumpClassic1K(self, key, uid):
        for i in range(64):
            status = self.MFRC522_Auth(self.PICC_AUTHENT1A, i, key, uid)
            # Check if authenticated
            if status == self.MI_OK:
                self.logger.error("Authentication error")

    def MFRC522_Init(self):

        self.Write_MFRC522(self.TModeReg, 0x8D)
        self.Write_MFRC522(self.TPrescalerReg, 0x3E)
        self.Write_MFRC522(self.TReloadRegL, 30)
        self.Write_MFRC522(self.TReloadRegH, 0)

        self.Write_MFRC522(self.TxAutoReg, 0x40)
        self.Write_MFRC522(self.ModeReg, 0x3D)

# Code by Simon Monk
# Modified by Angus for use with Libre Computer AML-S905X-CC "le Potato"  
# 1-April-2013

from MFRC522 import MFRC522
#import RPi.GPIO as GPIO
# Replaced fruity lib with libgpiod, though it does not seem to be used here.
import gpiod
class SimpleMFRC522:

  READER = None
  KEY = [0xFF,0xFF,0xFF,0xFF,0xFF,0xFF]
  BLOCK_ADDRS = [8, 9, 10]
  def __init__(self):
    self.READER = MFRC522()
  def read(self):
      id, text = self.read_no_block()
      while not id:
          id, text = self.read_no_block()
      return id, text

  def read_id(self):
    id = self.read_id_no_block()
    while not id:
      id = self.read_id_no_block()
    return id

  def read_id_no_block(self):
      (status, TagType) = self.READER.MFRC522_Request(self.READER.PICC_REQIDL)
      if status != self.READER.MI_OK:
          return None
      (status, uid) = self.READER.MFRC522_Anticoll()
      if status != self.READER.MI_OK:
          return None
      return self.uid_to_num(uid)
  def read_no_block(self):
    (status, TagType) = self.READER.MFRC522_Request(self.READER.PICC_REQIDL)
    if status != self.READER.MI_OK:
        return None, None
    (status, uid) = self.READER.MFRC522_Anticoll()
    if status != self.READER.MI_OK:
        return None, None
    id = self.uid_to_num(uid)
    status = self.READER.MFRC522_Auth(self.READER.PICC_AUTHENT1A, 11, self.KEY, uid)
    data = []
    text_read = ''
    if status == self.READER.MI_OK:
        for block_num in self.BLOCK_ADDRS:
            block = self.READER.MFRC522_Read(block_num) 
            if block:
            		data += block
        if data:
             text_read = ''.join(chr(i) for i in data)
    return id, text_read
  def write(self, text):
      id, text_in = self.write_no_block(text)
      while not id:
          id, text_in = self.write_no_block(text)
      return id, text_in

  def write_no_block(self, text):
      (status, TagType) = self.READER.MFRC522_Request(self.READER.PICC_REQIDL)
      if status != self.READER.MI_OK:
          return None, None
      (status, uid) = self.READER.MFRC522_Anticoll()
      if status != self.READER.MI_OK:
          return None, None
      id = self.uid_to_num(uid)
      status = self.READER.MFRC522_Auth(self.READER.PICC_AUTHENT1A, 11, self.KEY, uid)
      if status == self.READER.MI_OK:
          data = bytearray()
          data.extend(bytearray(text.ljust(len(self.BLOCK_ADDRS) * 16).encode('ascii')))
          i = 0
          for block_num in self.BLOCK_ADDRS:
            self.READER.MFRC522_Write(block_num, data[(i*16):(i+1)*16])
            i += 1
      return id, text[0:(len(self.BLOCK_ADDRS) * 16)]
  def uid_to_num(self, uid):
      n = 0
      for i in range(0, 5):
          n = n * 256 + uid[i]
      return n

#!/usr/bin/env python

#import RPi.GPIO as GPIO
from SimpleMFRC522 import SimpleMFRC522

reader = SimpleMFRC522()

        text = input('New data:')
        print("Now place your tag to write")

#!/usr/bin/env python

#import RPi.GPIO as GPIO
from SimpleMFRC522 import SimpleMFRC522

reader = SimpleMFRC522()

        id, text =
        # GPIO.cleanup()

Sample Usage:

angus@aml-s905x-cc:~/Documents/MFRC522-python-master/mfrc522$ python3 
New data:spam
Now place your tag to write
angus@aml-s905x-cc:~/Documents/MFRC522-python-master/mfrc522$ python3 
1 Like

I’ve been trying to set up the card reader with this code for a little bit but I’ve been having some issues for quite some time now. I attempted to use this code, I fixed a couple of capitalization issues and got the code to run but it’s not able to write to a card (Not able to detect when the blank RFID card is nearby). Looking into it I see that the line number is set to 79 (lines=chip.get_lines([79])
According to the setup guide we don’t use that pin? I’ve checked the connections as well and I’m positive I have the wires in the right place. My knowledge of hardware is pretty limited, so I’m assuming my issue is pretty simple. I’ve tried the other GPIO pins that we are connected to, thinking that maybe MISO or MOSI would work, but when I attempt to use their pins (19,21) i get the error that the device or resource is busy.

What pin should data be going in and out through exactly?

Any help would be really appreciated. I’m all open to learn more!

Just learned that GPIO pin# != Line number after looking at ‘lgpio info’ data

I have now tried line 88, 87, 89, 90, and 79, but I’m still not getting anything.

Also just to mention I do 100% the reader works, I tested it on an arduino and it worked flawlessly. Unfortunately for the project I’d like to use it on, the arduino won’t cut it.

If it’s a SPI device, enable the SPI device and SPI userspace overlays and use /dev/spidev to send and receive data. Take the time to learn how to properly uses busses in Linux. Even better if there’s a kernel driver (ask the manufacturer) and just create an overlay for it.

You don’t bit bang GPIOs in software. RPi.GPIO is an unreliable piece of crap that should have never been made.

Would you be able to provide me more detail about what would go into SPI userspace overlays? If you had any good resources to learn more about it I would really appreciate it as well!