Uncategorized

pn532 nfc module SPI config test notes

Testing Procedure of PN532 NFC/RFID Module in SPI Mode – tlfong01 2010mar29hkt2112

Reference: SundFounder PN532 NFC Module for Raspberry Pi Tutorial – 2017jun08
http://wiki.sunfounder.cc/index.php?title=PN532_NFC_Module_for_Raspberry_Pi

Section 4 – SPI Communication Instructions for Raspberry Pi

1. libnfc-1.7.1 driver – already installed when testing PN532 module inI2C conf, therefore no need to install again.

2. Must change interface jumper to SPI

3. Must modify /etc/nfc/libnfc.conf as described below.

# For both I2C and SPI config
allow_autoscan = true
allow_intrusive_scan = false
log_level = 1

# For I2C Config
# device.name = “_PN532_I2c”
# device.connstring = “pn532_i2c:/dev/i2c-1”

# For SPI Config
device.name = “_PN532_SPI”
#device.connstring = “pn532_spi:/dev/spidev0.0:500000” # Lower SPI speed if not working
device.connstring = “pn532_spi:/dev/spidev0.0:50000”

3. $ ls /dev/spidev0.* to make sure spi channel is open.

4. use nfc-list and nfc-poll to do testing, as for I2C configuration.

.END

============================================

https://elinux.org/RPi_SPI
https://github.com/mxgxw/MFRC522-python

https://github.com/mxgxw/MFRC522-python/blob/master/Write.py

https://www.raspberrypi.org/forums/viewtopic.php?t=207328#p1282986
How to setup a Raspberry Pi RFID RC522 Chip – Gus, PiUpMyLife 2019nv17
https://pimylifeup.com/raspberry-pi-rfid-rc522/

=============================================================================

pimylifeup/MFRC522-python – GitHub
https://github.com/pimylifeup/MFRC522-python

=============================================================================

README.md

mfrc522

A python library to read/write RFID tags via the budget MFRC522 RFID module.

This code was published in relation to a blog post and you can find out more about how to hook up your MFRC reader to a Raspberry Pi there.

Installation
Until the package is on PyPi, clone this repository and run python setup.py install in the top level directory.

Example Code

The following code will read a tag from the MFRC522

from time import sleep
import sys
from mfrc522 import SimpleMFRC522
reader = SimpleMFRC522()

try:
while True:
print(“Hold a tag near the reader”)
id, text = reader.read()
print(“ID: %s\nText: %s” % (id,text))
sleep(5)
except KeyboardInterrupt:
GPIO.cleanup()
raise

=============================================================================================================

MFRC522-python/mfrc522/SimpleMFRC522.py /

@death-droid death-droid Improve compataibility with Python 3 741e9d9 on Mar 26, 2019
@proffalken@death-droid 90 lines (78 sloc) 2.76 KB

# Code by Simon Monk https://github.com/simonmonk/

from . import MFRC522
import RPi.GPIO as GPIO

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)
self.READER.MFRC522_SelectTag(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)
self.READER.MFRC522_StopCrypto1()
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)
self.READER.MFRC522_SelectTag(uid)
status = self.READER.MFRC522_Auth(self.READER.PICC_AUTHENT1A, 11, self.KEY, uid)
self.READER.MFRC522_Read(11)
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
self.READER.MFRC522_StopCrypto1()
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

==========================================================================================================================

MFRC522-python/mfrc522/MFRC522.py /
@death-droid death-droid Shouldnt rush updates f8cefd6 on Apr 2, 2019
@death-droid@proffalken 425 lines (349 sloc) 12.3 KB

#!/usr/bin/env python
# -*- coding: utf8 -*-
#
# Copyright 2014,2018 Mario Gomez <mario.gomez@teubi.co>
#
# 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
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# 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 <http://www.gnu.org/licenses/&gt;.
#
import RPi.GPIO as GPIO
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_TRANSCEIVE = 0x0C
PCD_RESETPHASE = 0x0F
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_DECREMENT = 0xC0
PICC_INCREMENT = 0xC1
PICC_RESTORE = 0xC2
PICC_TRANSFER = 0xB0
PICC_HALT = 0x50

MI_OK = 0
MI_NOTAGERR = 1
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, pin_mode=10, pin_rst=-1, debugLevel=’WARNING’):
self.spi = spidev.SpiDev()
self.spi.open(bus, device)
self.spi.max_speed_hz = spd

self.logger = logging.getLogger(‘mfrc522Logger’)
self.logger.addHandler(logging.StreamHandler())
level = logging.getLevelName(debugLevel)
self.logger.setLevel(level)

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)
self.MFRC522_Init()

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):
self.spi.close()
GPIO.cleanup()

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)):
break

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
else:
backLen = n * 8

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

for i in range(n):
backData.append(self.Read_MFRC522(self.FIFODataReg))
else:
status = self.MI_ERR

return (status, backData, backLen)

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

self.Write_MFRC522(self.BitFramingReg, 0x07)

TagType.append(reqMode)
(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)

serNum.append(self.PICC_ANTICOLL)
serNum.append(0x20)

(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
else:
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)):
break
pOutData = []
pOutData.append(self.Read_MFRC522(self.CRCResultRegL))
pOutData.append(self.Read_MFRC522(self.CRCResultRegM))
return pOutData

def MFRC522_SelectTag(self, serNum):
backData = []
buf = []
buf.append(self.PICC_SElECTTAG)
buf.append(0x70)

for i in range(5):
buf.append(serNum[i])

pOut = self.CalulateCRC(buf)
buf.append(pOut[0])
buf.append(pOut[1])
(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]
else:
return 0

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

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

# Second byte is the trailerBlock (usually 7)
buff.append(BlockAddr)

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

# Next we append the first 4 bytes of the UID
for i in range(4):
buff.append(serNum[i])

# 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 = []
recvData.append(self.PICC_READ)
recvData.append(blockAddr)
pOut = self.CalulateCRC(recvData)
recvData.append(pOut[0])
recvData.append(pOut[1])
(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
else:
return None

def MFRC522_Write(self, blockAddr, writeData):
buff = []
buff.append(self.PICC_WRITE)
buff.append(blockAddr)
crc = self.CalulateCRC(buff)
buff.append(crc[0])
buff.append(crc[1])
(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):
buf.append(writeData[i])

crc = self.CalulateCRC(buf)
buf.append(crc[0])
buf.append(crc[1])
(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.MFRC522_Read(i)
else:
self.logger.error(“Authentication error”)

def MFRC522_Init(self):
self.MFRC522_Reset()

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)
self.AntennaOn()

=====================================================================================================================
================================

https://stackoverflow.com/questions/60886969/mfrc522-read-on-raspberry-pi-loading-time

https://www.freelancer.com/articles/global-response-to-coronavirus/help-the-world-health-organization?utm_campaign=20190925nps&utm_medium=email&utm_source=link1&ft_prog=MEE&ft_prog_id=850205101

https://mashable.com/shopping/march-28-diy-projects-on-sale/

https://stacksocial.com/sales/sunfounder-picar-v-kit-v2-0-for-raspberry-pi-4

https://stackoverflow.com/questions/60899128/control-raspberry-pi-from-another-computer

asked yesterday

627117717.pr
12

627117717.pr 13 hours ago

Categories: Uncategorized

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out /  Change )

Google photo

You are commenting using your Google account. Log Out /  Change )

Twitter picture

You are commenting using your Twitter account. Log Out /  Change )

Facebook photo

You are commenting using your Facebook account. Log Out /  Change )

Connecting to %s

This site uses Akismet to reduce spam. Learn how your comment data is processed.