david/cat-tracker
1
1
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

dev #1

Merged
david merged 25 commits from dev into main 2025-04-28 14:20:45 -07:00
Conversation 0 Commits 25 Files Changed 21 +122 -98
5 changed files with 122 additions and 98 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files
Showing only changes of commit e16cf6f686 - Show all commits

0
__init__.py Normal file
View File

102
common.py Normal file
View File

@ -0,0 +1,102 @@
import spidev
import RPi.GPIO as GPIO
from util import sleep, get_addr
from init_regs_value import init_regs_value
from regs_addr import regs_addr
CONFIG_REGS = regs_addr["CONFIG_REGS"]
STROBES = regs_addr["STROBES"]
STATUS = regs_addr["STATUS"]
MEMORY = regs_addr["MEMORY"]
MASKS = regs_addr["MASKS"]
ACCESS = regs_addr["ACCESS"]
SRES = STROBES["SRES"]
SNOP = STROBES["SNOP"]
VERSION = STATUS["VERSION"]
MARCSTATE = STATUS["MARCSTATE"]
def write_reg(spi, addr, value):
"""Write single byte to a register"""
spi.xfer2([addr, value])
sleep(0.1)
def read_register(spi, addr):
READ_SINGLE = get_addr("READ_SINGLE")
# Send address | 0x80 (read), then 0x00 dummy to clock in response
response = spi.xfer2([READ_SINGLE | addr, 0x00])
sleep(0.1)
return response[1]
def spi_write_burst(spi, addr, data):
"""Write multiple bytes using burst write"""
WRITE_BURST = get_addr("WRITE_BURST")
tbuf = [addr | WRITE_BURST] + data
spi.xfer2(tbuf)
sleep(0.1)
def spi_read_burst(spi, addr, length):
"""Read multiple bytes using burst read"""
READ_BURST = get_addr("READ_BURST")
rbuf = [addr | READ_BURST] + [0x00] * length
response = spi.xfer2(rbuf)
sleep(0.1)
return response[1:] # Skip status byte
def strobe(spi, command):
"""Send a command strobe to CC2500"""
spi.xfer2([command])
sleep(0.1)
def init_cc_2500(spi):
for reg_name, value in init_regs_value.items():
addr = get_addr(reg_name)
write_reg(spi, addr, value)
def setup_spi():
spi = spidev.SpiDev()
spi.open(0, 0) # Bus 0, CE0 (Pin 24)
spi.max_speed_hz = 100_000 # Safe start speed
spi.mode = 0b00 # SPI mode 0
return spi
def setup_gpio(GDO0_PIN=17, GDO2_PIN=27):
GPIO.setmode(GPIO.BCM)
GPIO.setup(GDO0_PIN, GPIO.IN, pull_up_down=GPIO.PUD_DOWN)
GPIO.setup(GDO2_PIN, GPIO.IN, pull_up_down=GPIO.PUD_DOWN)
sleep(0.1)
def reset(spi):
# print("Sending SRES (reset)...")
spi.xfer2([SRES])
sleep(0.5)
# print("Sending SNOP (no-op)...")
status = spi.xfer2([SNOP])[0]
print(f"Status byte: 0x{status:02X}")
# print("Reading MARCSTATE...")
marc = spi.xfer2([MARCSTATE| 0x80, 0x00])[0]
print(f"Marcstate byte: 0x{marc:02X}")
print("Reading VERSION register...")
version = read_register(spi, VERSION)
print(f"CC2500 VERSION register: 0x{version:02X}")
# if version != 0x2F:
# raise Exception("Expected Version was 0x0F!! Quitting")
def test_read_write_reg(spi, dbg=False):
FIFOTHR = get_addr("FIFOTHR")
initial_val = read_register(spi, FIFOTHR)
test_value = initial_val + 1
write_reg(spi, FIFOTHR, test_value)
check = read_register(spi, FIFOTHR)
write_reg(spi, FIFOTHR, initial_val)
if((check != test_value) or dbg):
print("initial value ", initial_val)
print("test value ", test_value)
print("check ",check)
if(not dbg):
raise Exception("Test Read+Write failed")
return check == test_value

40
main.py
View File

@ -1,6 +1,7 @@
import spidev
from util import *
from util import print_gdo_state, sleep, get_addr, dump_regs
from receive import receive_packet
from common import reset, setup_spi, setup_gpio, read_register, test_read_write_reg, init_cc_2500, write_reg, SRES, SNOP, MARCSTATE, VERSION
debug = True
GDO0_PIN=17
@ -18,42 +19,17 @@ def menu():
if __name__ == "__main__":
init_gpio(GDO0_PIN, GDO2_PIN)
spi = spidev.SpiDev()
spi.open(0, 0) # Bus 0, CE0 (Pin 24)
# spi.max_speed_hz = 8_000_000 # Safe start speed
spi.max_speed_hz = 100_000 # Safe start speed
spi.mode = 0b00 # SPI mode 0
stop = False
setup_gpio(GDO0_PIN, GDO2_PIN)
print_gdo_state(GDO0_PIN, GDO2_PIN)
# print("Sending SRES (reset)...")
spi.xfer2([SRES])
sleep(0.5)
# print("Sending SNOP (no-op)...")
status = spi.xfer2([SNOP])[0]
print(f"Status byte: 0x{status:02X}")
# print("Reading MARCSTATE...")
marc = spi.xfer2([MARCSTATE| 0x80, 0x00])[0]
print(f"Marcstate byte: 0x{marc:02X}")
print("Reading VERSION register...")
version = read_register(spi, VERSION)
print(f"CC2500 VERSION register: 0x{version:02X}")
spi = setup_spi()
reg_name = ""
reg_hex_val = ""
try:
# if version != 0x0F:
# raise Exception("Expected Version was 0x0F!! Quitting")
reset(spi)
test_read_write_reg(spi)
init_regs(spi)
init_cc_2500(spi)
stop = False
while not stop:
menu()
cmd = int(input("$: "))

2
transmit.py
View File

@ -1,4 +1,4 @@
from util import strobe, get_addr
from . import strobe, get_addr
def burst_write(spi, addr, data):
"""Write multiple bytes to FIFO or registers"""

76
util.py
View File

@ -1,29 +1,13 @@
from init_regs_value import init_regs_value
from regs_addr import regs_addr
import RPi.GPIO as GPIO
import time
CONFIG_REGS = regs_addr["CONFIG_REGS"]
STROBES = regs_addr["STROBES"]
STATUS = regs_addr["STATUS"]
MEMORY = regs_addr["MEMORY"]
MASKS = regs_addr["MASKS"]
ACCESS = regs_addr["ACCESS"]
SRES = STROBES["SRES"]
SNOP = STROBES["SNOP"]
VERSION = STATUS["VERSION"]
MARCSTATE = STATUS["MARCSTATE"]
def init_gpio(GDO0_PIN=17, GDO2_PIN=27):
# Use BCM numbering
GPIO.setmode(GPIO.BCM)
# Set up GPIO 23 and 24 as inputs
# GPIO.setup(GDO0_PIN, GPIO.IN)
# GPIO.setup(GDO2_PIN, GPIO.IN)
GPIO.setup(GDO0_PIN, GPIO.IN, pull_up_down=GPIO.PUD_DOWN)
GPIO.setup(GDO2_PIN, GPIO.IN, pull_up_down=GPIO.PUD_DOWN)
def rr(spi, addr):
READ_SINGLE = get_addr("READ_SINGLE")
# Send address | 0x80 (read), then 0x00 dummy to clock in response
response = spi.xfer2([READ_SINGLE | addr, 0x00])
sleep(0.1)
return response[1]
def print_gdo_state(GDO0_PIN=17, GDO2_PIN=27):
gdo0 = GPIO.input(GDO0_PIN) # Reads 1 or 0
@ -31,7 +15,6 @@ def print_gdo_state(GDO0_PIN=17, GDO2_PIN=27):
print(f"GDO0 (GPIO{GDO0_PIN}): {gdo0}, GDO2 (GPIO{GDO2_PIN}): {gdo2}")
sleep(0.1)
def get_addr(name):
addr = ""
stop = False
@ -44,58 +27,21 @@ def get_addr(name):
raise Exception("Failed to find address for "+name)
return addr
def strobe(spi, command):
"""Send a command strobe to CC2500"""
spi.xfer2([command])
sleep(0.1)
def write_reg(spi, addr, value):
"""Write single byte to a register"""
spi.xfer2([addr, value])
sleep(0.1)
def read_register(spi, addr):
READ_SINGLE = get_addr("READ_SINGLE")
# Send address | 0x80 (read), then 0x00 dummy to clock in response
response = spi.xfer2([READ_SINGLE | addr, 0x00])
sleep(0.1)
return response[1]
def disable_crc(spi):
spi.xfer2([CONFIG_REGS["PKTCTRL0"], 0x01])
def init_regs(spi):
for reg_name, value in init_regs_value.items():
addr = get_addr(reg_name)
write_reg(spi, addr, value)
def test_read_write_reg(spi, dbg=False):
FIFOTHR = get_addr("FIFOTHR")
initial_val = read_register(spi, FIFOTHR)
test_value = initial_val + 1
write_reg(spi, FIFOTHR, test_value)
check = read_register(spi, FIFOTHR)
write_reg(spi, FIFOTHR, initial_val)
if((check != test_value) or dbg):
print("initial value ", initial_val)
print("test value ", test_value)
print("check ",check)
if(not dbg):
raise Exception("Test Read+Write failed")
return check == test_value
def dump_regs(spi, cfgonly = False):
if cfgonly:
for reg_name, reg_addr in CONFIG_REGS.items():
for reg_name, reg_addr in regs_addr["CONFIG_REGS"].items():
name :str = reg_name
value = read_register(spi, reg_addr)
value = rr(spi, reg_addr)
print((name+":").ljust(15) +hex(value).ljust(4)+"\t"+str(value))
else:
for reg_type, reg_data in regs_addr.items():
for reg_name, reg_addr in reg_data.items():
name :str = reg_name
value = read_register(spi, reg_addr)
value = rr(spi, reg_addr)
print((name+":").ljust(15) +hex(value).ljust(4)+"\t"+str(value))
# def disable_crc(spi):
# spi.xfer2([CONFIG_REGS["PKTCTRL0"], 0x01])
def sleep(t):
return time.sleep(t)