oss/RaspyRFM
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

clean up

Browse source 
refactoring
rcprotocols
This commit is contained in:
Stefan Seegel 2020-02-05 01:15:56 +01:00
parent aef9733f2e
commit cdfe345872
6 changed files with 721 additions and 210 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

5
apps/lacrosse.py
View file

@ -34,7 +34,7 @@ class BaudChanger(threading.Thread):
def run(self): def run(self):
while True: while True:
time.sleep(15) time.sleep(15)
if self.baud: if self.baud:
dr = 9.579 dr = 9.579
else: else:
@ -47,9 +47,8 @@ baudChanger = BaudChanger()
baudChanger.daemon = True baudChanger.daemon = True
baudChanger.start() baudChanger.start()
print "Waiting for sensors..."
while 1: while 1:
data = rfm.receive_packet(5) data = rfm.receive(5)
if data == None: if data == None:
continue continue

17
influx.py → apps/lacrossegw.py
View file

@ -1,7 +1,6 @@
#!/usr/bin/env python2.7 #!/usr/bin/env python2.7
from rfm69 import Rfm69 from raspyrfm import *
import rfm69
import sensors import sensors
from sensors import rawsensor from sensors import rawsensor
import sys import sys
@ -25,12 +24,12 @@ nodes = {
"f8": "Musikzimmer" "f8": "Musikzimmer"
} }
if Rfm69.Test(1): if raspyrfm_test(2, RFM69):
print("Found RaspyRFM twin") print("Found RaspyRFM twin")
rfm = Rfm69(1, 24) #when using the RaspyRFM twin rfm = RaspyRFM(2, RFM69) #when using the RaspyRFM twin
elif Rfm69.Test(0): elif raspyrfm_test(1, RFM69):
print("Found RaspyRFM single") print("Found RaspyRFM single")
rfm = Rfm69() #when using a single single 868 MHz RaspyRFM rfm = RaspyRFM(1, RFM69) #when using a single single 868 MHz RaspyRFM
else: else:
print("No RFM69 module found!") print("No RFM69 module found!")
exit() exit()
@ -50,14 +49,14 @@ try:
except: except:
print("mqtt init error") print("mqtt init error")
rfm.SetParams( rfm.set_params(
Freq = 868.300, #MHz center frequency Freq = 868.300, #MHz center frequency
Datarate = 9.579, #kbit/s baudrate Datarate = 9.579, #kbit/s baudrate
ModulationType = rfm69.FSK, #modulation ModulationType = rfm69.FSK, #modulation
Deviation = 30, #kHz frequency deviation OBW = 69.6/77.2 kHz, h = 6.3/3.5 Deviation = 30, #kHz frequency deviation OBW = 69.6/77.2 kHz, h = 6.3/3.5
SyncPattern = [0x2d, 0xd4], #syncword SyncPattern = [0x2d, 0xd4], #syncword
Bandwidth = 100, #kHz bandwidth Bandwidth = 100, #kHz bandwidth
#AfcBandwidth = 150, #AfcBandwidth = 150,
#AfcFei = 0x0E, #AfcFei = 0x0E,
RssiThresh = -100, #-100 dB RSSI threshold RssiThresh = -100, #-100 dB RSSI threshold
) )
@ -103,7 +102,7 @@ def writeInflux(payload):
print "Waiting for sensors..." print "Waiting for sensors..."
cache = {} cache = {}
while 1: while 1:
rxObj = rfm.ReceivePacket(7) rxObj = rfm.receive(7)
try: try:
sensorObj = rawsensor.CreateSensor(rxObj) sensorObj = rawsensor.CreateSensor(rxObj)

482
apps/rcprotocols.py Normal file
View file

@ -0,0 +1,482 @@
import re
from argparse import ArgumentParser
class RcProtocol:
def __init__(self):
self.__numbits = 0
self._ookdata = bytearray()
self.__bbuf = 0
self.__bval = 0
self._parser = ArgumentParser()
sympulses = []
for i in self._symbols:
sympulses += self._symbols[i]
sympulses.sort(reverse=True)
i = 0
while i<len(sympulses) - 1:
if (sympulses[i] == sympulses[i+1]):
del sympulses[i]
else:
i += 1
p1 = sympulses.pop(0)
p2 = sympulses.pop(0)
f = (1.0 * p1 / p2 - 1) / (1.0 * p1/p2 + 2)
self._minwidth = self._timebase - self._timebase * f
self._maxwidth = self._timebase + self._timebase * f
def _reset(self):
self.__numbits = 0
self._ookdata = bytearray()
self.__bbuf = 0
self.__bval = 0
def _add_pulses(self, numbits):
for num in numbits:
self.__bval ^= 1
for i in range(num):
self.__bbuf <<= 1
self.__bbuf |= self.__bval
self.__numbits += 1
if self.__numbits == 8:
self._ookdata.append(self.__bbuf)
self.__bbuf = 0
self.__numbits = 0
def _add_finish(self):
if (self.__numbits > 0):
self.__bval ^= 1
self._add_pulses([8 - self.__numbits])
def _add_symbols(self, symbols):
print(symbols)
for s in symbols:
sym = self._symbols[s]
for pulse in sym:
self._add_pulses([pulse])
def _match_symbol(self, pulsetrain, symbol):
if len(pulsetrain) != len(symbol):
return False
sumpulse = 0
sumstep = 0
for i, v in enumerate(symbol):
if not (self._minwidth <= 1.0 * pulsetrain[i] / v <= self._maxwidth):
return
sumpulse += pulsetrain[i]
sumstep += v
return (sumpulse, sumstep)
def _decode_symbols(self, pulsetrain):
#match symbols
dec = ""
pos = 0
sumpulse = 0
sumstep = 0
while pos < len(pulsetrain):
match = None
for s in self._symbols:
slen = len(self._symbols[s])
match = self._match_symbol(pulsetrain[pos:pos+slen], self._symbols[s])
if match:
dec += s
pos += slen
sumpulse += match[0]
sumstep += match[1]
break
if not match:
return None, None
if re.match("^" + self._pattern + "$", dec):
return dec, int(1.0 * sumpulse / sumstep)
return None, None
def decode(self, pulsetrain):
pass
def encode(self, args):
pass
class IT32(RcProtocol): #switch1
def __init__(self):
self._name = "it32"
self._timebase = 250
self._repetitions = 4
self._pattern = "[01]{32}"
self._symbols = {
'0': [1, 1, 1, 5],
'1': [1, 5, 1, 1],
}
RcProtocol.__init__(self)
self._parser.add_argument("-c", "--code")
self._parser.add_argument("-i", "--id", type=int, required=True)
self._parser.add_argument("-u", "--unit", type=int, required=True)
self._parser.add_argument("-s", "--state", type=int, required=True)
def __encode(self, code):
self._reset()
self._add_pulses([1, 11])
self._add_symbols(code)
self._add_pulses([1, 39])
self._add_finish()
return self._ookdata
def encode(self, args):
if args.code:
if re.match("^[01]{32}$", args.code):
return self.__encode(args.code)
code = ""
code += "{:026b}".format(args.id)
code += "0" #group
code += "1" if args.state != 0 else "0"
code += "{:04b}".format(args.unit - 1)
return self.__encode(code)
def decode(self, pulsetrain):
code, tb = self._decode_symbols(pulsetrain[0:-2])
if code:
return {
"protocol": self._name,
"code": code,
"timebase": tb,
"id": int(code[0:26], 2),
"group": int(code[26:27], 2),
"state": int(code[27:28], 2),
"unit": int(code[28:32], 2) + 1,
}
class ITTristate(RcProtocol): #old intertechno systems
def __init__(self):
self._name = "ittristate"
self._timebase = 300
self._repetitions = 4
self._pattern = "[01f]{12}"
self._symbols = {
'0': [1, 4, 1, 4],
'1': [4, 1, 4, 1],
'f': [1, 4, 4, 1],
}
RcProtocol.__init__(self)
self._parser.add_argument("-c", "--code")
self._parser.add_argument("-o", "--house")
self._parser.add_argument("-g", "--group", type=int)
self._parser.add_argument("-u", "--unit", type=int)
self._parser.add_argument("-s", "--state", type=int)
def decode(self, pulsetrain):
code, tb = self._decode_symbols(pulsetrain[0:-2])
if code:
return {
"protocol": self._name,
"code": code,
"timebase": tb,
}
def __encode(self, code):
self._reset()
self._add_symbols(code)
self._add_pulses([1, 31])
self._add_finish()
return self._ookdata
def __encode_int(self, ival, digits):
code = ""
for i in range(digits):
code += "f" if (ival & 0x01) > 0 else "0"
ival >>= 1
return code
def encode(self, args):
if args.code:
if re.match("^[01Ff]{12}$", args.code):
return self.__encode(args.code)
code = ""
code += self.__encode_int(ord(args.house[0]) - ord('A'), 4)
if args.group:
code += self.__encode_int(args.group - 1, 2)
code += self.__encode_int(args.unit - 1, 2)
else:
code += self.__encode_int(args.unit - 1, 4)
code += "0f"
code += "ff" if args.state > 0 else "f0"
return self.__encode(code)
class Switch15(RcProtocol): #e. g. logilight
def __init__(self):
self._name = "switch15"
self._timebase = 300
self._repetitions = 4
self._pattern = "[01]{24}"
self._symbols = {
'1': [3, 1],
'0': [1, 3],
}
RcProtocol.__init__(self)
self._parser.add_argument("-i", "--id", type=int, required=True)
self._parser.add_argument("-u", "--unit", type=int, required=True)
self._parser.add_argument("-s", "--state", type=int, required=True)
def decode(self, pulsetrain):
code, tb = self._decode_symbols(pulsetrain[0:-2])
if code:
state = int(code[20:21])
unit = int(code[21:24], 2)
all = False
if unit == 7:
unit = 1
elif unit == 3:
unit = 2
elif unit == 5:
unit = 3
elif unit == 6:
unit = 4
else:
unit = 0
state = not state
return {
"protocol": self._name,
"code": code,
"timebase": tb,
"id": int(code[0:20], 2),
"unit": unit,
"state": state,
}
def encode(self, args):
sym = '{:020b}'.format(args.id)
if args.unit == 1:
unit = 7
elif args.unit == 2:
unit = 3
elif args.unit == 3:
unit = 5
elif args.unit == 4:
unit = 6
else:
raise Exception("invalid unit")
sym += '1' if args.state > 0 else '0'
sym += '{:03b}'.format(unit)
self._add_symbols(sym)
self._add_pulses([1, 31])
self._add_finish()
return self._ookdata
class Emylo(Switch15): #e. g. logilight
def __init__(self):
Switch15.__init__(self)
self._name = "emylo"
def decode(self, pulsetrain):
code, tb = self._decode_symbols(pulsetrain[0:-2])
if code:
key = int(code[20:24], 2)
if key == 1:
key = 'A'
elif key == 2:
key = 'B'
elif key == 4:
key = 'C'
elif key == 8:
key = 'D'
else:
return
return {
"protocol": self._name,
"code": code,
"timebase": tb,
"id": int(code[0:20], 2),
"key": key,
}
class FS20(RcProtocol):
def __init__(self):
self._name = "fs20"
self._timebase = 200
self._repetitions = 4
self._pattern = "0000000000001[01]{45}"
self._symbols = {
'0': [2, 2],
'1': [3, 3],
}
RcProtocol.__init__(self)
self._parser.add_argument("-o", "--house", type=int, required=True)
self._parser.add_argument("-a", "--address", type=int, required=True)
self._parser.add_argument("-d", "--cmd", type=int, required=True)
def __encode_byte(self, b):
self._add_symbols('{:08b}'.format(b))
par = 0
while b:
par ^= 1
b &= b-1
self._add_symbols('1' if par != 0 else '0')
def encode(self, args):
self._reset()
self._add_symbols("0000000000001")
self.__encode_byte(args.house >> 8)
self.__encode_byte(args.house & 0xFF)
self.__encode_byte(args.address)
self.__encode_byte(args.cmd)
q = 0x06 + (args.house >> 8) + (args.house & 0xFF) + args.address + args.cmd
self.__encode_byte(q & 0xFF)
self._add_pulses([1, 100])
self._add_finish()
return self._ookdata
def decode(self, pulsetrain):
code, tb = self._decode_symbols(pulsetrain[0:-2])
if code:
return {
"protocol": self._name,
"code": code,
"timebase": tb,
"housecode": int(code[13:21] + code[22:30] , 2),
"address": int(code[31:39], 2),
"cmd": int(code[40:48], 2),
}
class Voltcraft(RcProtocol):
def __init__(self):
self._name = "voltcraft"
self._timebase = 600
self._repetitions = 4
self._pattern = "[01]{20}"
self._symbols = {
'0': [1, 2],
'1': [2, 1],
}
RcProtocol.__init__(self)
self._parser.add_argument("-i", "--id", type=int, required=True)
self._parser.add_argument("-u", "--unit", type=int, required=True)
self._parser.add_argument("-s", "--state", type=int, required=True)
def decode(self, pulsetrain):
code, tb = self._decode_symbols(pulsetrain[1:-1])
if code:
return {
"protocol": self._name,
"code": code,
"timebase": tb,
"id": int(code[0:12][::-1], 2),
"unit": int(code[12:14][::-1], 2) + 1,
"state": int(code[14:17][::-1], 2) #0=off, 1=alloff, 2=on, 3=allon, 5=bright, 7=dim
}
def encode(self, args):
if not (args.state in [0, 2]):
unit = 3
else:
unit = args.unit -1
symbols = "{:012b}".format(args.id)[::-1]
symbols += "{:02b}".format(unit)[::-1]
symbols += "{:03b}".format(args.state)[::-1]
symbols += "0"
symbols += "1" if (symbols[12] == "1") ^ (symbols[14] == "1") ^ (symbols[16] == "1") else "0"
symbols += "1" if (symbols[13] == "1") ^ (symbols[15] == "1") ^ (symbols[17] == "1") else "0"
self._reset()
self._add_pulses([1])
self._add_symbols(symbols)
self._add_pulses([132])
self._add_finish()
return self._ookdata
class Test(RcProtocol):
def __init__(self):
self._name = "test"
self._timebase = 600
self._repetitions = 4
self._pattern = "[01]{32}"
self._symbols = {
'1': [1, 2],
'0': [2, 1],
}
RcProtocol.__init__(self)
self._parser.add_argument("-i", "--id", type=int, required=True)
self._parser.add_argument("-u", "--unit", type=int, required=True)
self._parser.add_argument("-s", "--state", type=int, required=True)
def decode(self, pulsetrain):
code, tb = self._decode_symbols(pulsetrain[0:-2])
if code:
print(code)
return code
state = int(code[20:21])
unit = int(code[21:24], 2)
all = False
if unit == 7:
unit = 1
elif unit == 3:
unit = 2
elif unit == 5:
unit = 3
elif unit == 6:
unit = 4
else:
unit = 0
state = not state
return {
"protocol": self._name,
"code": code,
"timebase": tb,
"id": int(code[0:20], 2),
"unit": unit,
"state": state,
}
def encode(self, args):
sym = '{:020b}'.format(args.id)
if args.unit == 1:
unit = 7
elif args.unit == 2:
unit = 3
elif args.unit == 3:
unit = 5
elif args.unit == 4:
unit = 6
else:
raise Exception("invalid unit")
sym += '1' if args.state > 0 else '0'
sym += '{:03b}'.format(unit)
self._add_symbols(sym)
self._add_pulses([1, 31])
self._add_finish()
return self._ookdata
protocols = [
IT32(),
Switch15(),
ITTristate(),
Voltcraft(),
FS20(),
Emylo(),
Test(),
]
def encode(protocol, args):
for p in protocols:
if (protocol):
if p._name == protocol:
return (p.encode(p._parser.parse_args(args)), p._timebase, p._repetitions)
def decode(pulsetrain):
dec = None
for p in protocols:
dec = p.decode(pulsetrain)
if dec:
print(dec)
if not dec:
print(len(pulsetrain), pulsetrain)

240
apps/rcpulse.py
View file

@ -9,42 +9,36 @@ import bistate24
import fs20 import fs20
from argparse import ArgumentParser from argparse import ArgumentParser
import wave, struct import wave, struct
import threading
import rcprotocols
parser = ArgumentParser() parser = ArgumentParser()
parser.add_argument("-t", "--timebase", type=int, help=u"timebase in \u03bcs") parser.add_argument("-t", "--timebase", type=int, help=u"timebase in \u03bcs")
parser.add_argument("-r", "--repeats", type=int, help=u"number of repetitions") parser.add_argument("-r", "--repeats", type=int, help=u"number of repetitions")
parser.add_argument("-m", "--module", type=int, metavar="1-4", help=u"RaspyRFM module 1-4", default=1) parser.add_argument("-m", "--module", type=int, metavar="1-4", help=u"RaspyRFM module 1-4", default=1)
parser.add_argument("-f", "--frequency", type=float, help=u"frequency in MHz", default=433.92) parser.add_argument("-f", "--frequency", type=float, help=u"frequency in MHz", default=433.92)
parser.add_argument("-p", "--protocol", help=u"Protocol for sending")
parser.add_argument("-w", "--write", help=u"write wavefile") parser.add_argument("-w", "--write", help=u"write wavefile")
parser.add_argument("code", nargs='*', help="code, e. g. '000000000FFF', 'A 1 2 on' or '10111100011101011111111110001110'") args, remainargs = parser.parse_known_args()
args = parser.parse_args()
protos = [
it32,
tristate,
bistate24,
fs20,
]
txdata = None txdata = None
if len(args.code) > 0: if len(remainargs) > 0:
txdata = None txdata = rcprotocols.encode(args.protocol, remainargs)
for proto in protos:
data = proto.Encode(args.code)
if data:
txdata = data
break
if txdata is None: if txdata is None:
print("invalid code!") print("invalid code!")
exit() exit()
if not raspyrfm_test(args.module, RFM69):
print("Error! RaspyRFM not found")
exit()
rfm = RaspyRFM(args.module, RFM69) rfm = RaspyRFM(args.module, RFM69)
rfm.set_params( rfm.set_params(
Freq = args.frequency, #MHz Freq = args.frequency, #MHz
Datarate = 20.0, #kbit/s Datarate = 20.0, #kbit/s
Bandwidth = 200, #kHz Bandwidth = 300, #kHz
SyncPattern = [0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1F], SyncPattern = [],
RssiThresh = -105, #dBm RssiThresh = -105, #dBm
ModulationType = rfm69.OOK, ModulationType = rfm69.OOK,
OokThreshType = 1, #peak thresh OokThreshType = 1, #peak thresh
@ -53,163 +47,79 @@ rfm.set_params(
TxPower = 13 TxPower = 13
) )
wf = wave.open("out.wav", "wb")
def rxcb():
while True:
d = rfm.read_fifo_wait(64)
ba = bytearray()
for s in d:
mask = 0x80
while mask > 0:
if (s & mask) > 0:
ba.append(255)
else:
ba.append(0)
mask >>= 1
wf.writeframesraw(ba)
if args.write:
wf.setnchannels(1)
wf.setsampwidth(1)
wf.setframerate(20000)
rfm.set_params(
SyncPattern = [],
OokThreshType = 0, #fix thresh
OokFixedThresh = 85,
)
rfm.start_rx(rxcb)
wf.writeframes('')
wf.close()
print("WRITE!")
exit()
rfm.set_params(
SyncPattern = [],
Datarate = 1.63,
)
i=[
"01010011110011111110000111111111",
"01011101110011111110000111111111",
"01100011110011111110000111111111",
"01101101110011111110000111111111",
]
do=[]
b=0
db=0
def addpulse(h, l):
global do, b, db
for i in range(h):
db <<= 1
db |= 1
b += 1
if b == 8:
do.append(db)
db = 0
b = 0
for i in range(l):
db <<= 1
b += 1
if b == 8:
do.append(db)
db = 0
b = 0
for c in i[args.timebase]:
if c == '0':
addpulse(2, 1)
else:
addpulse(1, 2)
addpulse(1, 17)
#print(do, b)
rfm.send_packet(do * 3)
exit()
rfm.set_params(
Datarate = 20.0, #kbit/s
SyncPattern = [0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0F],
)
if txdata: if txdata:
rfm.set_params( rfm.set_params(
SyncPattern = [], SyncPattern = [],
Datarate = 1000.0 / (args.timebase if args.timebase else txdata[2]) Datarate = 1000.0 / (args.timebase if args.timebase else txdata[1])
) )
rep = (args.repeats if args.repeats else txdata[1]) rep = (args.repeats if args.repeats else txdata[2])
rfm.send_packet(txdata[0] * rep) rfm.send(txdata[0] * rep)
print("Code sent!") print("Code sent!")
exit() exit()
def Decode(pulses): trainbuf = []
for i in range(len(pulses)):
pulses[i] *= 50
dec = None class RxThread(threading.Thread):
for proto in protos: def __init__(self):
dec = proto.Decode(pulses) threading.Thread.__init__(self)
if dec:
print(dec) def __rxcb(self, rfm):
bit = False
s = "" cnt = 1
if len(pulses) == 66: train = []
for p in pulses: if args.write:
if (p>900): wf = wave.open(args.write, "wb")
s += "l" wf.setnchannels(1)
else: wf.setsampwidth(1)
s += "s" wf.setframerate(20000)
b = ""
while len(s) > 0:
if s[:2] == "sl":
b += "1"
elif s[:2] == "ls":
b += "0"
else: else:
b += "?" wf = None
s = s[2:]
#print(b)
#print(len(pulses), pulses)
#if not dec: while True:
# print("Len " + str(len(pulses)) + ": " + str(pulses)) fifo = rfm.read_fifo_wait(64)
ba = bytearray()
for b in fifo:
mask = 0x80
while mask != 0:
if (b & mask) != 0:
ba.append(245)
else:
ba.append(10)
if ((b & mask) != 0) == bit:
cnt += 1
else:
if cnt < 3: #<150 us
train *= 0 #clear
elif cnt > 50:
if not bit:
train.append(cnt)
if len(train) > 20:
trainbuf.append(list(train))
train *= 0 #clear
elif len(train) > 0 or bit:
train.append(cnt)
cnt = 1
bit = not bit
mask >>= 1
if wf:
wf.writeframesraw(ba)
wf.writeframes('')
def run(self):
rfm.start_receive(self.__rxcb)
rxthread = RxThread()
rxthread.daemon = True
rxthread.start()
while True: while True:
data = rfm.receive_packet(260) time.sleep(0.1)
s = "" if len(trainbuf) > 0:
train = trainbuf.pop()
for i, v in enumerate(train):
train[i] = v * 50
pulsecount = 4 rcprotocols.decode(train)
glitchcount = 0
bit = True
pulses = []
for d in data[0]:
s += format(d, '08b')
mask = 0x80
while mask > 0:
newbit = (d & mask) > 0
if glitchcount > 0:
glitchcount += 1
if newbit == bit:
pulsecount += glitchcount
glitchcount = 0
else:
if glitchcount == 3:
pulses.append(pulsecount)
if pulsecount > 50:
Decode(pulses)
pulses = []
bit = newbit
pulsecount = 3
glitchcount = 0
else:
if newbit == bit:
pulsecount += 1
else:
glitchcount = 1
mask >>= 1

66
raspyrfm/rfm69.py
View file

@ -6,40 +6,40 @@ import time
FXOSC = 32E6 FXOSC = 32E6
FSTEP = FXOSC / (1<<19) FSTEP = FXOSC / (1<<19)
#------ Raspberry RFM Module connection ----- # Raspberry RFM Module connection
# RaspyRFM single module # RaspyRFM single module
# Connect to pins 17-26 on raspberry pi # Connect to pins 17-26 on raspberry pi
#-------------------------------------------------# #--------------------------------#
# Raspi | Raspi | Raspi | RFM69 | RFM12 | PCB con # #Raspi|Raspi|Raspi|RFM69|RaspyRFM#
# Name | GPIO | Pin | Name | Name | Pin # #Name |GPIO |Pin |Name |PCB Pin #
#-------------------------------------------------# #--------------------------------#
# 3V3 | - | 17 | 3.3V | VDD | 1 # #3V3 | - | 17 |3.3V | 1 #
# - | 24 | 18 | DIO1 | FFIT | 2 # only when PCB jumper closed # - | 24 | 18 |DIO1 | 2 # only when PCB jumper closed
# MOSI | 10 | 19 | MOSI | SDI | 3 # #MOSI | 10 | 19 |MOSI | 3 #
# GND | - | 20 | GND | GND | 4 # #GND | - | 20 |GND | 4 #
# MISO | 9 | 21 | MISO | SDO | 5 # #MISO | 9 | 21 |MISO | 5 #
# - | 25 | 22 | DIO0 | nIRQ | 6 # # - | 25 | 22 |DIO0 | 6 #
# SCKL | 11 | 23 | SCK | SCK | 7 # #SCKL | 11 | 23 |SCK | 7 #
# CE0 | 8 | 24 | NSS | nSEL | 8 # #CE0 | 8 | 24 |NSS | 8 #
# CE1 | 7 | 26 | DIO2 | nFFS | 10 # only when PCB jumper closed #CE1 | 7 | 26 |DIO2 | 10 # only when PCB jumper closed
#-------------------------------------------------# #--------------------------------#
# RaspyRFM twin module with 10-pin connector # RaspyRFM twin module with 10-pin connector
# Connect to pins 17-26 on raspberry pi # Connect to pins 17-26 on raspberry pi
#-------------------------------------------------# #---------------------------------#
# Raspi | Raspi | Raspi | RFM69 | RFM12 | PCB con # #Raspi|Raspi|Raspi|RFM69 |RaspyRFM#
# Name | GPIO | Pin | Name | Name | Pin # #Name |GPIO |Pin |Name |PCB Pin #
#-------------------------------------------------# #---------------------------------#
# 3V3 | - | 17 | 3.3V | VDD | 1 # #3V3 | - | 17 |3.3V | 1 #
# - | 24 | 18 | DIO0_2| FFIT | 2 # # - | 24 | 18 |DIO0_2| 2 #
# MOSI | 10 | 19 | MOSI | SDI | 3 # #MOSI | 10 | 19 |MOSI | 3 #
# GND | - | 20 | GND | GND | 4 # #GND | - | 20 |GND | 4 #
# MISO | 9 | 21 | MISO | SDO | 5 # #MISO | 9 | 21 |MISO | 5 #
# - | 25 | 22 | DIO0_1| nIRQ | 6 # # - | 25 | 22 |DIO0_1| 6 #
# SCKL | 11 | 23 | SCK | SCK | 7 # #SCKL | 11 | 23 |SCK | 7 #
# CE0 | 8 | 24 | NSS1 | nSEL | 8 # #CE0 | 8 | 24 |NSS1 | 8 #
# CE1 | 7 | 26 | NSS2 | nFFS | 10 # #CE1 | 7 | 26 |NSS2 | 10 #
#-------------------------------------------------# #---------------------------------#
# RaspyRFM twin module with 12-pin connector # RaspyRFM twin module with 12-pin connector
# Connect to pins 15-26 on raspberry pi # Connect to pins 15-26 on raspberry pi
@ -441,7 +441,7 @@ class Rfm69(threading.Thread):
lfsr |= 1<<9 lfsr |= 1<<9
lfsr >>= 1 lfsr >>= 1
def send_packet(self, data): def send(self, data):
self.__mutex.acquire() self.__mutex.acquire()
self.__event.set() self.__event.set()
self.mode_standby() self.mode_standby()
@ -534,13 +534,13 @@ class Rfm69(threading.Thread):
if self.__mode == MODE_RX: if self.__mode == MODE_RX:
break; break;
def start_rx(self, cb): def start_receive(self, cb):
self.__start_rx() self.__start_rx()
cb() cb(self)
self.mode_standby() self.mode_standby()
self.__mutex.release() self.__mutex.release()
def receive_packet(self, length): def receive(self, length):
self.__start_rx() self.__start_rx()
result = self.read_fifo_wait(length) result = self.read_fifo_wait(length)

121
rcpulse.py Executable file
View file

@ -0,0 +1,121 @@
#!/usr/bin/env python2.7
from raspyrfm import *
import sys
import time
from argparse import ArgumentParser
parser = ArgumentParser()
parser.add_argument("-t", "--timebase", type=int, help=u"timebase in \u03bcs")
parser.add_argument("-r", "--repeats", type=int, help=u"number of repetitions")
parser.add_argument("code", nargs='*', help="code, e. g. '000000000FFF', 'A 1 2 on' or '10111100011101011111111110001110'")
args = parser.parse_args()
txdata = None
if len(args.code) > 0:
txdata = None
for proto in protos:
data = proto.Encode(args.code)
if data:
txdata = data
break
if txdata is None:
print("invalid code!")
exit()
rfm = RaspyRFM(1, RFM69)
rfm.set_params(
Freq = 868.35, #MHz
Datarate = 20.0, #kbit/s
Bandwidth = 200, #kHz
SyncPattern = [0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07],
RssiThresh = -105, #dBm
ModulationType = rfm69.OOK,
OokThreshType = 1, #peak thresh
OokPeakThreshDec = 3,
)
if txdata:
rfm.SetParams(
SyncPattern = [],
Datarate = 5.0
)
rep = (args.repeats if args.repeats else txdata[1])
rfm.SendPacket(txdata[0] * rep)
print("Code sent!")
exit()
def Decode(pulses):
if len(pulses) != 118:
return;
b = ""
for p in pulses:
if (p>=6) and (p<=10):
b += "s"
elif (p > 10) and (p<15):
b += "l"
else:
b += '?'
s = ""
while len(b) > 0:
if b[:2] == 'ss':
s += '0'
elif b[:2] == 'll':
s += '1'
else:
s += '?'
b = b[2:]
print(s)
print("SYNC " + s[1:13] + " HC1 " + s[13:22] + " HC2 " + s[22:31] +
" ADR " + s[31:40])
return
for i in range(len(pulses)):
pulses[i] *= 50
dec = None
for proto in protos:
dec = proto.Decode(pulses)
if dec:
print(dec)
if not dec:
print("Len " + str(len(pulses)) + ": " + str(pulses))
while True:
data = rfm.receive_packet(400)
s = ""
pulsecount = 3
glitchcount = 0
bit = True
pulses = []
for d in data[0]:
s += format(d, '08b')
mask = 0x80
while mask > 0:
newbit = (d & mask) > 0
if glitchcount > 0:
glitchcount += 1
if newbit == bit:
pulsecount += glitchcount
glitchcount = 0
else:
if glitchcount == 3:
pulses.append(pulsecount)
if pulsecount > 50:
Decode(pulses)
pulses = []
bit = newbit
pulsecount = 3
glitchcount = 0
else:
if newbit == bit:
pulsecount += 1
else:
glitchcount = 1
mask >>= 1