r/raspberry_pi

Spent the last few weekends building out a hardware time reference using a Pi 4 (could use any Pi really as it uses almost no cpu power and memory) and it's been a fun rabbit hole.

Hardware:

• Pi 4 Model B 4GB
• GT-U7 GPS module (~$10 on Amazon) wired to GPIO. VCC/GND to pins 4/6, RX/TX swapped onto the UART pins 8 and 10, and PPS on pin 12
• Antenna sitting in a window

The PPS pin is where the accuracy comes from. NMEA serial data alone is good for ~50ms accuracy because of the variable lag between satellite reading and serial transmission. The PPS pulse is hardware-aligned to the actual GPS second within tens of nanoseconds, so chrony uses NMEA to figure out what time it is and PPS to figure out exactly when each second starts. Together you get sub-microsecond accuracy.

A few config things that helped:

• Disabled bluetooth in /boot/firmware/config.txt to free up the primary UART (the Pi 4 has the bluetooth chip wired to the good UART by default)
• Used isolcpus=3 nohz_full=3 rcu_nocbs=3 to dedicate one core to time-critical work and keep scheduler noise off it. (This is very much overkill but it will keep the core free if I want to run other services)
• gpsd reads NMEA and pushes to chrony via shared memory, chrony grabs the PPS directly from /dev/pps0

Current state per chronyc tracking:

• Stratum 1 (This is how many steps away you are from the gps source, NTP servers are usually 3 or 4)
• Last offset typically in the 50-500 nanosecond range
• RMS offset around 450ns
• System time within 0-45ns of NTP time
• Frequency stable around 9.7ppm fast (the Pi's crystal is consistently off but predictable)

I admittedly am more of a Pi programmer and not much of a web developer so I had help from Claude for the web portion. It looks way better and took way less time than what I couldn't came up on my own.

Disclaimer: This is a $10 GPS unit with an antenna sitting inside in a non-ideal window in my home. If you visit my site and it says it's not syncing to GPS and it's fallen back to NTP it happens sometimes but it recovers. This is for fun on my LAN and for nothing mission critical, just wanted to share.

The main lesson though: antenna placement matters way more than the GPS module quality. Spent more time moving the antenna around than doing anything else. Got from 1-2 satellites in a fix to consistently 8-11 just by finding a window with a clearer southern view.

Here is my repo for the project
https://github.com/BenLeikin/PiTime/

Hi, I have a Raspberry Pi 5 with 4GB of RAM. It has Debian 13 installed on a SanDisk SD card. The idea is to load FHD movies onto it and use it to watch them on my 43" TV. My question is whether the movies will play smoothly or if they'll stutter. I wanted to use VLC, but perhaps you can recommend a better player or one that doesn't use as many resources.

Thanks in advance!

My raspberry pi 4 keeps denying access to it. (for a headless set up) Even though I can guarantee, I have the password, right. I tried changing the password several times. Copying and pasting the password to make sure I have it right. I’ve tried using different computers and it’s all met with the same result. I’ve also formatted the card several times. And I can guarantee it’s on password authentication. Connecting it to a mobile app which controls it.

Hello, I am trying to get an RC522 to work with a Raspberry Pi Pico 2 W on Thonny, but no matter what I try, I cant get it to read my nfc cards. The code runs and the component lights up, but does nothing when i hold my cards up to it. My pin connections are attached as pictures so you can see how its wired, and my code is the following:

mfrc522.py:
# credit: https://github.com/danjperron/micropython-mfrc522

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

And main.py:

from mfrc522 import MFRC522

import utime

rfid_reader = MFRC522(sck=18, mosi=19, miso=16, rst=9, cs=17, baudrate=1000000, spi_id=0)

print("--- RFID Reader Initialized Successfully ---")

print("Place your 13.56MHz MIFARE card/fob flat against the reader...")

while True:

rfid_reader.init()

(card_status, tag_type) = rfid_reader.request(rfid_reader.REQIDL)

if card_status == rfid_reader.OK:

(card_status, card_id) = rfid_reader.SelectTagSN()

if card_status == rfid_reader.OK:

rfid_card = int.from_bytes(bytes(card_id), "little", False)

print("Detected Card ID: " + str(rfid_card))

utime.sleep_ms(300)

Any help would be amazing and greatly appriciated, Thank you!