LF RFID with Pico and RS-232

[FrankHenckens]

I am trying to detect a LF RFID tag with a Raspberry Pi Pico, a RS-232 module, a reader with an external antenna. When I run the code, it doesn't detect the RFID tag. I don't know why it does not detect the tag. Any help is wellcome.

The code:
from machine import UART, Pin
import utime

Initialize UART1 on TX pin GP8 and RX pin GP9

uart = UART(1, baudrate=9600, tx=Pin(8), rx=Pin(9))

Function to send command to RFID reader

def send_command(command):
uart.write(bytearray(command)) # Send command as bytearray
print(f"Command sent: {command}")
utime.sleep(0.1) # Short delay for processing

Function to read data from RFID reader

def read_rfid():
if uart.any(): # Check if there is data available
rfid_data = uart.read() # Read the data
print(f"Raw data received: {rfid_data}")
return rfid_data # Return the raw data
return None

Function to select antenna 1 for reading

def select_antenna_1():
# Command to select and tune antenna 1 (based on the documentation)
command = [0x04, 0xF2, 0xA0, 0x01, 0xB0] # Last byte is the BCC
send_command(command)

Function to poll for HDX/FDX transponders on antenna 1

def poll_for_tags():
command = [0x03, 0xEA, 0x11, 0xFC] # Poll HDX and use antenna 1
send_command(command)

Send the command to select antenna 1 and start reading RFID data

select_antenna_1()

while True:
# Poll for tags on the selected antenna
poll_for_tags()
tag = read_rfid() # Try reading RFID data
if tag:
print(f"RFID Tag Read: {tag}")
else:
print("Waiting for RFID tag...")

utime.sleep(2)  # Wait before polling again

[bidrohini]

You can use a logic analyzer to check the signal between the RFID reader and the Pico. This will help verify if commands are being sent and if the reader is responding.

[FrankHenckens]

UPDATE: I have a new code and now I have the communication with the antenna solved, but I get a tag-ID with tag in front of the antenna, but also without tag in front of the antenna. Help is welcome!

Code:
from machine import UART, Pin
import utime

Initialize UART1 with TX on GP0 and RX on GP1

uart = UART(0, baudrate=9600, tx=Pin(0), rx=Pin(1))

Function to send command to the reader

def send_command(command):
bcc = 0 # Block Check Character (BCC)
for byte in command:
bcc ^= byte # Calculate the XOR of the command bytes
command_with_bcc = command + bytes([bcc]) # Add the BCC to the end of the command
uart.write(command_with_bcc) # Send the command over UART
print(f"Command sent: {command_with_bcc}")

Function to check if Antenna 1 is selected

def select_antenna_1():
command = b'\x04\xF3\xFA\x00' # Command to select antenna 1
send_command(command)

Function to read RFID tag data

def read_rfid():
if uart.any(): # Check if there is data available from the reader
rfid_data = uart.read() # Read the data
print(f"Raw RFID data (length {len(rfid_data)}): {rfid_data}")

    # Controleer of de ontvangen gegevens voldoen aan een geldig formaat
    if len(rfid_data) == 5 and rfid_data.startswith(b'\x04'):  # Bijvoorbeeld controle op een startbyte
        tag_id = int.from_bytes(rfid_data, 'big')  # Convert bytes to integer
        print(f"RFID Tag ID: {tag_id}")
    else:
        print("Invalid or no tag data received.")
else:
    print("No data received from RFID reader")

Main loop to read RFID tags

while True:
select_antenna_1() # Select antenna 1
utime.sleep(5) # Verlengde pauze om lezer tijd te geven
read_rfid() # Try reading an RFID tag
utime.sleep(5) # Verlengde pauze voordat opnieuw wordt gelezen

[FrankHenckens]

The received tag data is ['0x3', '0xea', '0x2', '0xeb'], the tag number extracted is 15336171. But I get this value without tag, and with 2 different tags.

[robert-hh]

The first three bytes are identical to the command you have sent. Could it be that just the command is echoed followed by an error byte?
And these are 4 bytes, and you extract the number from a 5 byte message. So the size of the response message does not fit.
Do you have a documentation of the tag communication protocol? A link? A product name?

[FrankHenckens]

I have a file of the reader.
Therion Protocol Description V0.2.docx

[robert-hh]

So what I understand is: The data you received is the echoed command followed by error byte 0xeb, which is -21: Error reading the Nack Data in the reply of EM transponders.

mode byte 0x02 in the command tells, that it polls for FDX but did not select an antenna. Try 0x12 for the mode byte to poll for FDX on antenna 1. The 4th byte of the response should be 0, which means: No error.

[FrankHenckens]

I have a slightly different code where I play with the command. When I try 0x12 I get this: No valid tag data, so it does not read my tags.

import utime

# Initialize UART1 with TX on GP0 and RX on GP1
uart = UART(0, baudrate=9600, tx=Pin(0), rx=Pin(1))

# Functie om een commando te verzenden
def send_command(command):
    bcc = 0  # Block Check Character (BCC)
    for byte in command:
        bcc ^= byte  # XOR voor BCC berekening
    command_with_bcc = command + bytes([bcc])  # Voeg BCC toe
    uart.write(command_with_bcc)  # Verstuur het commando
    print(f"Command sent: {command_with_bcc}")

# Functie om antenne 1 te selecteren met het juiste commando
def select_antenna_1():
    command = bytearray([0x04, 0xF3, 0xFA, 0x00])  # Correct antenneselectiecommando
    send_command(command)

# Functie om te controleren of de antenne correct is geselecteerd
def confirm_antenna_selection():
    print("Wachten op bevestiging van antenneselectie...")
    utime.sleep(1)  # Wacht even om de reader tijd te geven om te reageren

    if uart.any():
        response = uart.read()  # Lees de respons
        print(f"Response ontvangen: {response}")

        # Controleer of de eerste vier bytes overeenkomen met het antenneselectiecommando
        if response[:4] == b'\x04\xF3\xFA\x00':  # Controleer de eerste 4 bytes
            print("Antenne 1 succesvol geselecteerd.")
            return True
        else:
            print(f"Onverwachte respons ontvangen: {response}")
            return False
    else:
        print("Geen respons ontvangen na antenneselectie.")
        return False

def read_iso_tag(mode):
    # Poll for FDX and/or HDX tags on specified antennas
    command = bytearray([0x03, 0xEA, mode])  # Mode defines which tags/antennas are polled
    send_command(command)
    utime.sleep(5)  
    if uart.any():
        response = uart.read()
        print(f"Tag data ontvangen (bytes): {[hex(byte) for byte in response]}")
        
        # Check the first byte of the response to identify FDX or HDX tag
        if response[0] == 0x0F or response[0] == 0x11:  
            tag_id = int.from_bytes(response[1:5], 'big')  
            print(f"FDX Tag Found, Tag Number: {tag_id}")
        elif response[0] == 0x11 or response[0] == 0x12:  
            tag_id = int.from_bytes(response[1:5], 'big')  
            print(f"HDX Tag Found, Tag Number: {tag_id}")
        else:
            print("No valid tag data received or polling unsuccessful.")
    else:
        print("No tag detected.")

# Main program to poll tags
while True:
    print("Antenne 1 selecteren...")
    select_antenna_1()
    utime.sleep(3)

    print("Bevestigen van antenneselectie...")
    if confirm_antenna_selection():
        # Poll for FDX tags on Antenna 
        print("ISO 11784/11785 tag lezen...")
        read_iso_tag(0x12)  
    else:
        print("Antenne selectie mislukt.")
    utime.sleep(5)```