def lorainit():
global lora
BOARD.setup()
lora = LoRa(verbose=False)
lora.set_mode(MODE.STDBY)
lora.set_freq(923.0) #set to 915MHz for SG use
def on_rx_done(self):
BOARD.led_on()
print("\nRxDone")
self.clear_irq_flags(RxDone=1)
payload = self.read_payload(nocheck=True)
print("bytesmessage:")
print(bytes(payload).decode("utf-8", 'ignore'))
print(payload)
message = []
for i in payload[4:13]:
message.append(chr(i))
print message
temp = message[0] + message[1]
hum = message[3] + message[4]
intens = message[6] + message[7] + message[8]
print temp
print hum
print intens
# print(int.from_bytes(payload, byteorder='little'))
# print(chr(int.from_bytes(b'\xf3\x25', byteorder='little')))
# .decode("utf-8", 'ignore')
self.set_mode(MODE.SLEEP)
self.reset_ptr_rx()
self.set_mode(MODE.RXCONT)
def controller_init(self, enablecontroller=None):
if enablecontroller != None:
self.enabled = enablecontroller
self.initialized = False
if self.enabled:
if int(Settings.Settings["Unit"]) > 0:
self.controllerport = Settings.Settings["Unit"]
try:
BOARD.setup()
gpios.HWPorts.remove_event_detect(BOARD.DIO0)
gpios.HWPorts.remove_event_detect(BOARD.DIO1)
gpios.HWPorts.remove_event_detect(BOARD.DIO2)
gpios.HWPorts.remove_event_detect(BOARD.DIO3)
except Exception as e:
misc.addLog(rpieGlobals.LOG_LEVEL_ERROR,
"LORA Direct preinit msg: " + str(e))
try:
self.lora = LoRaRcvCont(self.pkt_receiver)
self.connect()
self.initialized = True
misc.addLog(rpieGlobals.LOG_LEVEL_INFO,
"LORA Direct initialized")
except Exception as e:
self.initialized = False
misc.addLog(rpieGlobals.LOG_LEVEL_ERROR,
"LORA Direct init error: " + str(e))
return True
def receive(self,controller):
try:
self.lora.set_mode(MODE.RXCONT)
message = self.lora.on_rx_done()
if message == '$-$-$-cool$-$-$-':
message = ''
send2(controller)
elif message == '!resend!':
while (time.time() - start_time < 3):
for i in range(0,3):
self.lora.start(self.prev_msg[i])
else:
start_time = time.time()
while time.time()-start_time < 3:
message = message + self.lora.on_rx_done()
if len(message) < 48:
self.lora.start("!resend!")
return
self.msg_list.insert(END, 'user : '******''
except KeyboardInterrupt:
sys.stdout.flush()
print("Exit")
sys.stderr.write("KeyboardInterrupt\n")
finally:
sys.stdout.flush()
print("Exit")
lora.set_mode(MODE.SLEEP)
BOARD.teardown()
def start(self):
global send_receive_flag
global lora_send_msg
send_receive_flag = "receive"
while True:
if send_receive_flag == "receive":
self.set_mode(MODE.SLEEP)
self.set_dio_mapping([0] * 6)
self.reset_ptr_rx()
self.set_mode(MODE.RXCONT)
sleep(.5)
rssi_value = self.get_rssi_value()
else:
print("send_receive_flag == send : {0}".format(lora_send_msg))
self.set_mode(MODE.SLEEP)
self.set_dio_mapping([1, 0, 0, 0, 0, 0])
self.tx_counter = 0
BOARD.led_on()
self.write_payload([0x0f])
#self.write_payload([0x0f, 0x65, 0x6c, 0x70])
self.set_mode(MODE.TX)
'''
def on_rx_done(self):
BOARD.led_on()
print("\nRxDone")
print(self.get_irq_flags())
#print(map(hex, self.read_payload(nocheck=True)))
_buff = self.read_payload(nocheck=True)
print("received:")
self.print_buffer(_buff)
# send pOnG + 2 bytes
t = ord(self.get_rpi_temp())
_reply = [112, 79, 110, 71, 0, t]
#_buff = [0x70, 73]
print("to be replied:")
self.print_buffer(_reply)
self.set_mode(MODE.SLEEP)
self.set_dio_mapping([1,0,0,0,0,0])
self.set_payload_length(6)
ret = self.write_payload(_reply)
print ("returned by SPI:")
self.print_buffer(ret)
self.set_mode(MODE.TX)
print("reply sent")
def start(self):
self.tx_counter = 0
BOARD.led_on()
self.write_payload([0x0f])
self.set_mode(MODE.TX)
while True:
sleep(1)
def run(self):
BOARD.setup()
parser = LoRaArgumentParser("Continous LoRa receiver.")
lora = LoRaRcvCont(verbose=False)
args = parser.parse_args(lora)
lora.set_mode(MODE.STDBY)
lora.set_pa_config(pa_select=1)
lora.set_freq(434.0)
#lora.set_rx_crc(True)
#lora.set_coding_rate(CODING_RATE.CR4_6)
#lora.set_pa_config(max_power=0, output_power=0)
#lora.set_lna_gain(GAIN.G1)
#lora.set_implicit_header_mode(False)
#lora.set_low_data_rate_optim(True)
#lora.set_pa_ramp(PA_RAMP.RAMP_50_us)
#lora.set_agc_auto_on(True)
print("lora: {0}".format(lora))
assert (lora.get_agc_auto_on() == 1)
time.sleep(1)
try:
lora.start()
except KeyboardInterrupt:
sys.stdout.flush()
print("")
sys.stderr.write("KeyboardInterrupt\n")
finally:
sys.stdout.flush()
print("")
lora.set_mode(MODE.SLEEP)
print(lora)
BOARD.teardown()
def watchdog():
global c
if c != -1: # -1 = already off
if c == 0: # 0 = watchdog triggers
BOARD.led_off()
print("OFF")
c -= 1
def on_rx_done(self):
BOARD.led_on()
print("\nRxDone")
print(datetime.now())
#print(self.get_irq_flags())
#print(self.spi.xfer([0x1C, 0])[1]) # REG.LORA.MODEM_CONFIG_2
if not self.get_hop_channel()['crc_on_payload']:
print("No CRC in payload!")
if not self.get_irq_flags()['valid_header']:
print("Invalid header in payload!")
if self.get_irq_flags()['rx_timeout']:
print("rx timeout!")
if self.get_irq_flags()['crc_error']:
print("crc_error!")
self.clear_irq_flags(RxDone=1, ValidHeader=1)
payload = self.read_payload(nocheck=False)
print("pkt_rssi: ", self.get_pkt_rssi_value())
print("pkt_snr: ", self.get_pkt_snr_value())
print("Receive: ")
print(payload)
if (payload):
print("counter:", payload[0])
(t, h) = struct.unpack('<hh', bytearray(payload[1:5]))
print(t / 10.0, " C")
print(h / 10.0, "%rh")
global c
c = 60
time.sleep(2)
self.reset_ptr_rx()
self.set_mode(MODE.RXCONT)
def on_rx_done(self):
BOARD.led_on()
#print("\nRxDone")
self.clear_irq_flags(RxDone=1)
payload = self.read_payload(nocheck=True)
mens = payload[4:-1] #to discard \xff\xff\x00\x00 and \x00 at the end
mens = bytes(mens).decode("utf-8", 'ignore')
cipher = AES.new(self.key)
decodemens = base64.b64decode(mens)
decoded = cipher.decrypt(decodemens)
decoded = bytes(decoded).decode("utf-8", 'ignore')
print("== RECEIVE: ", mens, " | Decoded: ", decoded)
BOARD.led_off()
time.sleep(2) # Wait for the client be ready
msg_text = 'ACK ' # 16 char
cipher = AES.new(self.key)
encoded = base64.b64encode(cipher.encrypt(msg_text))
lista = list(encoded)
lista.insert(0, 0)
lista.insert(0, 0)
lista.insert(0, 255)
lista.insert(0, 255)
lista.append(0)
self.write_payload(lista)
#self.write_payload([255, 255, 0, 0, 65, 67, 75, 0]) # Send ACK
self.set_mode(MODE.TX)
print("== SEND: ", msg_text, " | Encoded: ",
encoded.decode("utf-8", 'ignore'))
print("\n")
self.var = 1
def start(self):
global args
self.set_freq(433)
sys.stdout.write("\rstart")
BOARD.led_on()
while True:
sleep(1)
def on_rx_done(self):
BOARD.led_on()
#print("\nRxDone")
self.clear_irq_flags(RxDone=1)
payload = self.read_payload(nocheck=True)
print("Receive: ")
print(bytes(payload).decode("utf-8", 'ignore')) # Receive DATA
BOARD.led_off()
#time.sleep(2) # Wait for the client be ready
#print ("Send: ACK")
data_str = "ACK"
print("Send: ", data_str)
data_bytes = list(bytes(data_str, encoding='utf-8'))
LOCAL_ADDR = 255
RECIEVER_ADDR = 0
DUMP = 0
message = [RECIEVER_ADDR, LOCAL_ADDR, DUMP]
message.append(len(data_bytes))
for i in range(len(data_bytes)):
message.append(data_bytes[i])
self.write_payload(message)
print(message)
# self.write_payload([0, 255, 0, 3, 0, 1, 0]) # Send ACK
self.set_mode(MODE.TX)
self.var = 1
def on_tx_done(self):
global args
self.set_mode(MODE.STDBY)
self.clear_irq_flags(TxDone=1)
BOARD.led_off()
sleep(args.wait)
if self.sending == 1:
self.send_image()
def on_tx_done(self):
print("\nTxDone")
print(self.get_irq_flags())
self.set_mode(MODE.SLEEP)
self.reset_ptr_rx()
BOARD.led_off()
self.set_dio_mapping([0] * 6)
self.set_mode(MODE.RXCONT)
def start(self, payload):
global args
print(self.get_freq())
print("Starting Transmission")
BOARD.led_on()
self.write_payload(payload)
self.set_mode(MODE.TX)
while True:
sleep(1)
def start(self):
global args
sys.stdout.write("\rstart")
self.tx_counter = 0
BOARD.led_on()
self.write_payload(payload)
self.set_mode(MODE.TX)
while True:
sleep(1)
def start(self):
global args
sys.stdout.write("\rstart")
self.tx_counter = 0
BOARD.led_on()
self.write_payload([0x0f])
self.set_mode(MODE.TX)
while True:
sleep(1)
def on_rx_done(self):
BOARD.led_on()
print("\nRxDone")
#print(self.get_irq_flags())
print(map(hex, self.read_payload(nocheck=True)))
self.set_mode(MODE.SLEEP)
self.reset_ptr_rx()
BOARD.led_off()
self.set_mode(MODE.RXCONT)
def on_rx_done(self):
BOARD.led_on()
print("\nRxDone")
self.clear_irq_flags(RxDone=1)
payload = self.read_payload(nocheck=True)
print(bytes(payload).decode("utf-8",'ignore'))
self.set_mode(MODE.SLEEP)
self.reset_ptr_rx()
BOARD.led_off()
self.set_mode(MODE.RXCONT)
def RX():
BOARD.led_on()
print("\nDados recebidos")
lora.clear_irq_flags(RxDone=1)
payload = lora.read_payload(nocheck=True)
print(bytes(payload).decode("utf-8", 'ignore'))
lora.set_mode(MODE.SLEEP)
lora.reset_ptr_rx()
BOARD.led_off()
lora.set_mode(MODE.RXCONT)
def on_rx_done(self):
BOARD.led_on()
print("\nRxDone")
self.clear_irq_flags(RxDone=1)
payload = self.read_payload(nocheck=True)
print(bytes(payload).decode())
self.set_mode(MODE.SLEEP)
self.reset_ptr_rx()
BOARD.led_off()
self.set_mode(MODE.RXCONT)
def send_image(self):
if self.sending == 1:
# Normal packet
if self.iteration < self.number_packets:
# Appending packet number, 1 byte
Z = bytearray([self.iteration, 0])
# Appending bytearray from picture, 253 bytes
Z[1:] = self.image_buffer[self.iteration *
self.step:self.iteration *
self.step + self.step]
print "I'm on %d" % self.iteration
# Casting to List (needed)
E = list(Z)
# Increment Packet number
self.iteration += 1
# Init SPI transmission to radio
self.write_payload(E)
BOARD.led_on()
self.set_mode(MODE.TX)
# Last packet
elif self.iteration == self.number_packets:
print "Sending remaining bytes....."
# Appending packet number, 1 byte
Z = bytearray([self.iteration, 0])
print "Packet: %d" % self.iteration
# Appending bytearray from picture, X remaining bytes
Z[1:] = self.image_buffer[self.iteration * self.step:]
# Casting to List (needed)
E = list(Z)
# Init SPI transmission do radio
self.write_payload(E)
BOARD.led_on()
self.set_mode(MODE.TX)
# Reset global variables
if self.first_time == 0:
self.re_init()
print "Waiting for new pic..."
else:
self.semi_re_init()
print "Sending picture second time..."
self.first_time = 0
def __init__(self, _verbosity=False):
BOARD.setup()
LoRa.__init__(self, _verbosity)
self.set_mode(MODE.SLEEP)
self.set_dio_mapping([1, 0, 0, 0, 0, 0])
self.tx_counter = 0
self.set_freq(LoRa_frequency)
self.set_agc_auto_on(True)
self.set_pa_config(pa_select=1, output_power=15)
self._end = False
def on_tx_done(self): # When Transmitting is done?
global args
self.set_mode(MODE.STDBY)
self.clear_irq_flags(TxDone=1)
if args.single:
print("args exit")
sys.exit(0)
BOARD.led_off()
print("Ending Transmission")
BOARD.teardown()
sys.exit(0)
def on_rx_done(self):
BOARD.led_on()
print("\nRxDone")
self.clear_irq_flags(RxDone=1)
payload = self.read_payload(nocheck=True)
data = ''.join([chr(c) for c in payload])
print data
#print(bytes(payload).decode())
self.set_mode(MODE.SLEEP)
self.reset_ptr_rx()
BOARD.led_off()
self.set_mode(MODE.RXCONT)
def tx(msg):
BOARD.setup()
lora = LoRaTransmit()
lora.set_freq(868.000000)
lora.set_pa_config(pa_select=1, max_power=5)
lora.set_bw(8)
lora.set_coding_rate(CODING_RATE.CR4_5)
try:
lora.send(msg)
finally:
lora.set_mode(MODE.SLEEP)
BOARD.teardown()
def on_rx_done(self):
BOARD.led_on()
print("\nRxDone")
print(self.get_irq_flags())
# self.get_payload_length
self.set_payload_length(8)
self.get_rx_nb_bytes
print(''.join(map(hex, self.read_payload(nocheck=True))).replace('0x', '').decode("hex"))
self.set_mode(MODE.SLEEP)
self.reset_ptr_rx()
BOARD.led_off()
self.set_mode(MODE.RXCONT)
def on_tx_done(self):
self.set_mode(MODE.STDBY)
self.clear_irq_flags(TxDone=1)
sys.stdout.flush()
self.tx_counter += 1
sys.stdout.write("\rtx #%d" % self.tx_counter)
sleep(0.01)
rawinput = "che khabar?\r\n"
data = [int(hex(ord(c)), 0) for c in rawinput]
self.write_payload(data)
BOARD.led_on()
self.set_mode(MODE.TX)
def __init__(self, verbose=False):
BOARD.setup()
BOARD.reset()
super(Transceiver, self).__init__(verbose)
self.set_mode(MODE.SLEEP)
self.config("long")
self.setmode("RX")
self.receiving = []
self.transmitting = []
self.txn = 0
self.rxn = None
assert(self.get_agc_auto_on() == 1)
def start(self):
global args
sys.stdout.write("\rstart")
self.tx_counter = 0
BOARD.led_on()
self.set_payload_length(8)
self.set_max_payload_length(100)
my_message = raw_input('Enter a message: ')
self.write_payload(toHex(my_message))
self.get_payload_length
self.set_mode(MODE.TX)
while True:
sleep(1)
def start(self):
global args
sys.stdout.write("\rStart")
self.tx_counter = 1
BOARD.led_on()
sys.stdout.write("\rtx #%d" % self.tx_counter)
message = "Hello > %d" % self.tx_counter
sys.stdout.write(", %s" % message)
payload = array('b', message)
self.write_payload(list(payload))
self.set_mode(MODE.TX)
while True:
sleep(1)
def on_rx_done(self):
BOARD.led_on()
#print("\nRxDone")
self.clear_irq_flags(RxDone=1)
payload = self.read_payload(nocheck=True)
print ("Receive: ")
print(bytes(payload).decode("utf-8",'ignore')) # Receive DATA
BOARD.led_off()
time.sleep(2) # Wait for the client be ready
print ("Send: ACK")
self.write_payload([255, 255, 0, 0, 65, 67, 75, 0]) # Send ACK
self.set_mode(MODE.TX)
self.var=1
def start(self):
global args
sys.stdout.write("\rstart")
self.tx_counter = 0
BOARD.led_on()
self.set_payload_length(8)
self.set_max_payload_length(100)
my_message = raw_input('Enter a message: ')
self.write_payload(toHex(my_message))
self.get_payload_length
self.set_mode(MODE.TX)
while True:
sleep(1)
def on_rx_done(self):
BOARD.led_on()
print("\nRxDone")
print(self.get_irq_flags())
# self.get_payload_length
self.set_payload_length(8)
self.get_rx_nb_bytes
print(''.join(map(hex, self.read_payload(nocheck=True))).replace(
'0x', '').decode("hex"))
self.set_mode(MODE.SLEEP)
self.reset_ptr_rx()
BOARD.led_off()
self.set_mode(MODE.RXCONT)
def start(self):
global args
sys.stdout.write("\rstart")
# self.tx_counter = 0
# self.write_payload([0x0f])
self.set_mode(MODE.TX)
sleep(10)
BOARD.del_events()
self.set_dio_mapping([0] * 6)
# BOARD.add_events(self._dio0, self._dio1, self._dio2, self._dio3, self._dio4, self._dio5)
while True:
sleep(1)
def main():
BOARD.setup()
receiver = MyLoRa()
try:
while True:
sleep(0.05)
irq_flags = receiver.get_irq_flags()
if irq_flags['rx_done'] == 1:
receiver.on_rx_done()
finally:
BOARD.teardown()
def on_tx_done(self):
global args
self.set_mode(MODE.STDBY)
self.clear_irq_flags()
sys.stdout.flush()
self.tx_counter += 1
sys.stdout.write("\rtx #%d" % self.tx_counter)
if args.single:
print
sys.exit(0)
BOARD.led_off()
sleep(args.wait)
self.write_payload([0x0f])
BOARD.led_on()
self.set_mode(MODE.TX)
def on_cad_done(self):
print("\non_CadDone")
print(self.get_irq_flags())
self.clear_irq_flags()
print(self.get_irq_flags())
self.set_mode(MODE.SLEEP)
rssi_value = self.get_rssi_value()
status = self.get_modem_status()
sys.stdout.flush()
sys.stdout.write("\r%d %d %d %s" % (rssi_value, status['rx_ongoing'], status['modem_clear'], self))
self.reset_ptr_rx()
BOARD.led_off()
self.set_dio_mapping([0] * 6)
self.set_mode(MODE.RXCONT)
print ("listo, saliendo de cad ===========")
def txRepeat(msg, num):
BOARD.setup()
lora = LoRaTransmit()
lora.set_freq(868.000000)
lora.set_pa_config(pa_select=1, max_power=5)
lora.set_bw(8)
lora.set_coding_rate(CODING_RATE.CR4_5)
try:
for i in range(0, num):
lora.send(msg)
try:
with timeout(seconds=2):
while lora.transmitting:
sleep(0.1)
except TimeoutError:
print("Sending timed out.")
sleep(1)
finally:
lora.set_mode(MODE.SLEEP)
BOARD.teardown()
def txMulti(msg):
BOARD.setup()
lora = LoRaTransmit()
lora.set_freq(868.000000)
lora.set_pa_config(pa_select=1, max_power=5)
lora.set_bw(8)
lora.set_coding_rate(CODING_RATE.CR4_5)
try:
while len(msg) > 0:
part = msg[:256]
msg = msg[256:]
lora.send(part[1:])
try:
with timeout(seconds=3):
while lora.transmitting:
sleep(0.1)
except TimeoutError:
print("Sending timed out.")
finally:
lora.set_mode(MODE.SLEEP)
BOARD.teardown()
#
# You can be released from the requirements of the license by obtaining a commercial license. Such a license is
# mandatory as soon as you develop commercial activities involving pySX127x without disclosing the source code of your
# own applications, or shipping pySX127x with a closed source product.
#
# You should have received a copy of the GNU General Public License along with pySX127. If not, see
# <http://www.gnu.org/licenses/>.
import sys
from time import sleep
from SX127x.LoRa import *
from SX127x.LoRaArgumentParser import LoRaArgumentParser
from SX127x.board_config import BOARD
BOARD.setup()
parser = LoRaArgumentParser("A simple LoRa beacon")
parser.add_argument('--single', '-S', dest='single', default=False, action="store_true", help="Single transmission")
parser.add_argument('--wait', '-w', dest='wait', default=1, action="store", type=float, help="Waiting time between transmissions (default is 0s)")
class LoRaBeacon(LoRa):
tx_counter = 0
def __init__(self, verbose=False):
super(LoRaBeacon, self).__init__(verbose)
self.set_mode(MODE.SLEEP)
self.set_dio_mapping([1,0,0,0,0,0])
""" Beacon Class """ """ Thomas Verbeke - [email protected] Send out data + counter value Tested with Embed LoRa Module (SX1276 Semtech chip) """ import sys from time import sleep from SX127x.LoRa import * from SX127x.board_config import BOARD, GPIO BOARD.setup() # setup GPIO's class LoRaBeacon(LoRa): tx_counter = 0 def __init__(self, verbose=False): super(LoRaBeacon, self).__init__(verbose) self.set_mode(MODE.SLEEP) self.set_dio_mapping([1,0,0,0,0,0]) #DIO0 is set to TxDone """ DIO Mapping DIO5 DIO4 DIO3 DIO2 DIO1 DIO0 ModeReady CadDetected CadDone FhssChangeChannel RxTimeout TxDone """ def on_rx_done(self): # will not be called trough DIO (because it is mapped to TxDone)
*ETSI compliance is imposed with duty cycle limit/ band
*Payload header for packet filtering (iterative algortihm)
*Optional ACK in receive window
*MAC commands to change SF/Channel/Power
*Can be used in star of stars network configuration but direct node to node communication is also possible
# ADD FIXED PACKET LENGTH, IQ inversion, hopperiod, timeout, freq, power, over current protection
"""
import time
from math import ceil, floor
from time import sleep
from SX127x.LoRa import *
from SX127x.board_config import BOARD
BOARD.setup()
""" 868 ISM BANDS
BAND / DutyCycle / MaxPower / Channel Configuration Options / LoRaWAN use
=============================================================================================================================================================================
h1.2 / 1% / 14 dBm / 15 x 125 or 10x 250 or 4x500 / 5X125 kHz
h1.4 / 1% / 14 dBm / 3x 125 or 1x250 or 1x 500** / 3X125 or 2x125 and 1x250 kHz
h1.5 / 0.1% / 14 dBm / 2x 125 or 1x250 / 1XFSK
h1.6 / 10% / 27 dBm / 1x 125 / Reception Window channel
h1.7 / 100% / 7 dBm / 1x 125 / not used
Band h1.6 is used as the BEACON channel or reception channel
Band h1.7 is used as last resort channel when device has used up all of its available duty cycle resources
** Modify Tx filter settings needed: done by writing "0xE1" in register 0x3D
