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 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