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()
# 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])
def on_rx_done(self):
print("\nRxDone")
where it will wait for the next packet to arrive.
TODO:
*test current implementation
*add packet SNR and other values of received packets
*add LED for debugging
"""
from time import sleep
from SX127x.LoRa import *
from SX127x.LoRaArgumentParser import LoRaArgumentParser
from SX127x.board_config import BOARD
BOARD.setup()
parser = LoRaArgumentParser("Continous LoRa receiver.")
class LoRaRcvCont(LoRa):
def __init__(self, verbose=False):
super(LoRaRcvCont, self).__init__(verbose)
self.set_mode(MODE.SLEEP)
self.set_dio_mapping([0] * 6)
""" DIO Mapping DIO5 DIO4 DIO3 DIO2 DIO1 DIO0
ModeReady CadDetected CadDone FhssChangeChannel RxTimeout RxDone
"""
#DIO0 is set to RxDone (on_rx_done callback will be called on interrupt)
def on_rx_done(self):
#
# 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/>.
from time import sleep
from SX127x.LoRa import *
from SX127x.LoRaArgumentParser import LoRaArgumentParser
from SX127x.board_config import BOARD
BOARD.setup()
parser = LoRaArgumentParser("Continous LoRa receiver.")
class LoRaRcvCont(LoRa):
def __init__(self, verbose=False):
super(LoRaRcvCont, self).__init__(verbose)
self.set_mode(MODE.SLEEP)
self.set_dio_mapping([0] * 6)
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
# 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
sbcommend = 0
bjcommend = 1
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])
# self.set_freq(433.5)
#!/usr/bin/env python3
import sys
from time import sleep
from SX127x.LoRa import *
from SX127x.LoRaArgumentParser import LoRaArgumentParser
from SX127x.board_config_ada import BOARD
import LoRaWAN
from LoRaWAN.MHDR import MHDR
from random import randrange
import reset_ada
import helium
import keys
BOARD.setup()
parser = LoRaArgumentParser("LoRaWAN sender")
class LoRaWANotaa(LoRa):
def __init__(self, verbose = False):
super(LoRaWANotaa, self).__init__(verbose)
def on_rx_done(self):
print("RxDone")
self.clear_irq_flags(RxDone=1)
payload = self.read_payload(nocheck=True)
print(payload)
self.set_mode(MODE.SLEEP)
self.get_all_registers()
print(self)
lorawan = LoRaWAN.new([], keys.appkey)
lorawan.read(payload)
print(lorawan.get_payload())
#!/usr/bin/env python3
from time import sleep
from SX127x.LoRa import *
from SX127x.LoRaArgumentParser import LoRaArgumentParser
from SX127x.board_config import BOARD
import LoRaWAN
BOARD.setup()
parser = LoRaArgumentParser("LoRaWAN receiver")
class LoRaWANrcv(LoRa):
def __init__(self, verbose=False):
super(LoRaWANrcv, self).__init__(verbose)
def on_rx_done(self):
print("RxDone")
self.clear_irq_flags(RxDone=1)
payload = self.read_payload(nocheck=True)
print("".join(format(x, '02x') for x in bytes(payload)))
lorawan = LoRaWAN.new(nwskey, appskey)
lorawan.read(payload)
print(lorawan.get_mhdr().get_mversion())
print(lorawan.get_mhdr().get_mtype())
print(lorawan.get_mic())
print(lorawan.compute_mic())
print(lorawan.valid_mic())
print("".join(list(map(chr, lorawan.get_payload()))))
print("\n")
# btemperli, 14.2.2021
import sys
from time import sleep
from SX127x.LoRa import *
from SX127x.LoRaArgumentParser import LoRaArgumentParser
from SX127x.board_config_ada import BOARD
import keys
import counter
import LoRaWAN
from LoRaWAN.MHDR import MHDR
import reset_ada
BOARD.setup()
parser = LoRaArgumentParser("LoRaWAN sendReceive")
class LoRaWanSystem(LoRa):
def __init__(self, devaddr=[], nwkey=[], appkey=[], verbose=False):
super(LoRaWanSystem, self).__init__(verbose)
self.devaddr = devaddr
self.nwkey = nwkey
self.appkey = appkey
def on_rx_done(self):
print("RxDone")
self.clear_irq_flags(RxDone=1)
payload = self.read_payload(nocheck=True)
print("".join(format(x, '02x') for x in bytes(payload)))
#!/usr/bin/env python3
import sys
from time import sleep
from SX127x.LoRa import *
from SX127x.LoRaArgumentParser import LoRaArgumentParser
from SX127x.board_config import BOARD
import LoRaWAN, json
from LoRaWAN.MHDR import MHDR
from random import randrange
BOARD.setup()
parser = LoRaArgumentParser("LoRaWAN sender")
class LoRaWANotaa(LoRa):
def __init__(self, verbose=False):
super(LoRaWANotaa, self).__init__(verbose)
def on_rx_done(self):
print("RxDone")
self.clear_irq_flags(RxDone=1)
payload = self.read_payload(nocheck=True)
print(payload)
lorawan = LoRaWAN.new(nwskey, appskey)
lorawan.read(payload)
print(lorawan.get_payload())
print(lorawan.get_mhdr().get_mversion())
sys.exit(0)
def show(self, a):
from SX127x.board_config import BOARD
import pymysql
from SX127x.LoRaArgumentParser import LoRaArgumentParser
try:
conn = pymysql.connect(host='localhost',
user='******',
password='******',
db='pi',
charset='utf8',
cursorclass=pymysql.cursors.DictCursor)
except pymysql.err.Error as msg:
print("Connection error: ", msg)
sys.exit()
parser = LoRaArgumentParser("Lora tester")
BOARD.setup()
class LoRaRcvCont(LoRa):
def __init__(self, localAddress, clientsAddress, connection, verbose=False):
super(LoRaRcvCont, self).__init__(verbose)
hexlit = lambda n:int(n, 16)
self.localAddress = localAddress
self.clientsAddress = []
self.connection = connection
self.cc = self.connection.cursor()
self.hexlit = hexlit
for i in clientsAddress:
self.clientsAddress.append(self.hexlit(i))
self.set_mode(MODE.SLEEP)
self.set_dio_mapping([0] * 6)
#!/usr/bin/env python
from time import sleep
from SX127x.LoRa import *
from SX127x.LoRaArgumentParser import LoRaArgumentParser
from SX127x.board_config import BOARD
import httpfuncs
BOARD.setup()
parser = LoRaArgumentParser("Continous LoRa Gateway.")
# global sending
sending = 0
class FinalApp(LoRa):
tx_counter = 0
# sbcommend = 0
# bjcommend = 0
lastcommend = []
commend = []
def __init__(self, verbose=False):
super(FinalApp, self).__init__(verbose)
self.set_mode(MODE.SLEEP)
self.set_dio_mapping([0] * 6)
self.set_freq(433.5)
def on_rx_done(self):
print("\nRxDone")
self.clear_irq_flags(RxDone=1)
#
# 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 time
from SX127x.LoRa import *
from SX127x.LoRaArgumentParser import LoRaArgumentParser
from SX127x.board_config import BOARD
BOARD.setup()
BOARD.reset()
parser = LoRaArgumentParser("Continous LoRa receiver.")
class mylora(LoRa):
def __init__(self, verbose=False):
super(mylora, self).__init__(verbose)
self.set_mode(MODE.SLEEP)
self.set_dio_mapping([0] * 6)
def on_rx_done(self):
BOARD.led_on()
#print("\nRxDone")
self.clear_irq_flags(RxDone=1)
payload = self.read_payload(nocheck=True) # Receive INF
print("Receive: ")
mens = bytes(payload).decode("utf-8", 'ignore')
#!/usr/bin/env python3
from time import sleep
from SX127x.LoRa import *
from SX127x.LoRaArgumentParser import LoRaArgumentParser
from SX127x.board_config import BOARD
BOARD.setup()
parser = LoRaArgumentParser("LoRa sender.")
class LoRaSender(LoRa):
def __init__(self, verbose=False):
super(LoRaSender, self).__init__(verbose)
self.set_mode(MODE.SLEEP)
self.set_dio_mapping([1, 0, 0, 0, 0,
0]) # DIO0 = 1 = tx_done (0 = rx_done)
def on_rx_done(self):
print("\nRxDone")
print(self.get_irq_flags())
print(map(hex, self.read_payload(nocheck=True)))
self.set_mode(MODE.SLEEP)
self.reset_ptr_rx()
self.set_mode(MODE.RXCONT)
def on_tx_done(self):
global args
self.set_mode(MODE.STDBY)
self.clear_irq_flags(TxDone=1)
