def start(self):
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(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")
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 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 on_rx_done(self):
BOARD.led_on()
wrkdir = '/home/pi/Desktop/'
# print("\nRxDone")
self.clear_irq_flags(RxDone=1)
payload = self.read_payload(nocheck=True)
print("Receive: ")
dataRaw = bytes(payload).decode("utf-8", 'ignore')
dataRec = dataRaw[2:-1].split(",")
print(dataRec) # Receive DATA
# print(argLen)
if argLen is 2:
filename = sensorName + ".csv"
filename = join('/home/pi/Desktop/',filename)
with open(filename, "a+") as csvfile:
wr = csv.writer(csvfile, quoting = csv.QUOTE_ALL)
wr.writerow(dataRec)
csvfile.closed
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
time.sleep(.5) # a tad to complete
print("Data Sent")
sys.stdout.flush()
lora.set_mode(MODE.SLEEP)
BOARD.teardown()
sys.exit()
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 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")
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 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, 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 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 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")
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 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 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 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 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 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_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 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")
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_rx_done(self):
global send_receive_flag
global lora_receive_msg
BOARD.led_on()
print("\nRxDone")
self.clear_irq_flags(RxDone=1)
payload = self.read_payload(nocheck=True)
lora_receive_msg = ''.join([chr(c) for c in payload])
print("Receive lora_receive_msg: {0}".format(lora_receive_msg))
#print(bytes(payload).decode())
self.set_mode(MODE.SLEEP)
self.reset_ptr_rx()
BOARD.led_off()
self.set_mode(MODE.RXCONT)
def on_tx_done(self):
global args
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)
BOARD.led_off()
sleep(1)
#self.write_payload([0x0e])
self.write_payload([0x0e, 0x00, 0x00, 0x00, 0x00, 0x00])
BOARD.led_on()
self.set_mode(MODE.TX)
sys.stdout.write("on_tx_done end")
def send_image(self):
if self.sending == 1:
# Normal packet
if self.i < self.n:
# Appending packet number, 1 byte
Z = bytearray([self.i, 0])
# Appending bytearray from picture, 253 bytes
Z[1:] = self.b[self.i * self.step:self.i * self.step +
self.step]
print "I'm on %d" % self.i
# Casting to List (needed)
E = list(Z)
# Increment Packet number
self.i += 1
# Init SPI transmission to radio
self.write_payload(E)
BOARD.led_on()
self.set_mode(MODE.TX)
# Last packet
elif self.i == self.n:
print "Sending remaining bytes....."
# Appending packet number, 1 byte
Z = bytearray([self.i, 0])
print "Packet: %d" % self.i
# Appending bytearray from picture, X remaining bytes
Z[1:] = self.b[self.i * 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
self.re_init()
print "Waiting for new pic..."
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_tx_done(self):
global args
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)
if args.single:
print
sys.exit(0)
BOARD.led_off()
sleep(args.wait)
self.write_payload([0x57,0x68,0x61,0x74,0x20,0x74,0x68,0x65,0x20,0x66,0x75,0x63,0x6B,0x21])
BOARD.led_on()
self.set_mode(MODE.TX)
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(payload)
BOARD.led_on()
self.set_mode(MODE.TX)
def on_rx_done(self):
BOARD.led_on()
print("\nRxDone")
self.clear_irq_flags(RxDone=1)
rssi_value = self.get_rssi_value()
status = self.get_modem_status()
print("\n [in on_rx_done] %d %d %d" %
(rssi_value, status['rx_ongoing'], status['modem_clear']))
payload = self.read_payload(nocheck=True)
data = ''.join([chr(c) for c in payload])
print 'data = ' + data
#print(bytes(payload).decode())
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()
self.clear_irq_flags(RxDone=1)
reader.read_package(self.read_payload(nocheck=True), True)
self.set_mode(MODE.SLEEP)
self.reset_ptr_rx()
BOARD.led_off()
self.set_mode(MODE.RXCONT)
if (reader.is_accepted):
self.db.connect()
self.db.publish_sensor_data(reader.data_pack, True)
self.db.disconnect()
def on_tx_done(self):
global send_receive_flag
global lora_send_msg
if send_receive_flag == "send":
send_msg = lora_send_msg
send_receive_flag = "receive"
self.set_mode(MODE.STDBY)
self.clear_irq_flags(TxDone=1)
sys.stdout.flush()
self.tx_counter += 1
BOARD.led_off()
data = [int(hex(ord(c)), 0) for c in send_msg]
#self.write_payload([0x0f])
self.write_payload(data)
BOARD.led_on()
self.set_mode(MODE.TX)
def on_rx_done(self):
BOARD.led_on()
# Listen for requests from server
self.clear_irq_flags(RxDone=1)
payload = self.read_payload(nocheck=True) # Receive INF
# Converts payload to readable string
mens = bytes(payload).decode("utf-8", 'ignore')
# Print RX data
print("RX: " + mens)
BOARD.led_off()
# Reply the TH data if "ENVI" is received
if mens == "ENVI":
time.sleep(2)
# Get TH data from BME280
t = bme280.temperature
h = bme280.humidity
t = round(t, 2)
h = round(h, 2)
t = str(t)
h = str(h)
# Create TX message with ";" as delimiter
TX_message = str(node) + ";" + t + ";" + h + ";"
print("TX: " + TX_message)
# Convert TX message to bytes
b = list()
b.extend(TX_message.encode())
# Send TX message to server
self.write_payload(b)
self.set_mode(MODE.TX)
if mens == "ACK":
print("The server received the last message you sent.")
# Set back client to receiver mode
time.sleep(2)
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)
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)
rawinput = input(">>> ")
data = [int(hex(ord(c)), 0) for c in rawinput]
#self.write_payload([0x0f])
self.write_payload(data)
BOARD.led_on()
self.set_mode(MODE.TX)
