def get_message(self):
device_pins = {
'miso':19,
'mosi':27,
'ss':18,
'sck':5,
'dio_0':26,
'reset':14
}
# device_spi = SPI(baudrate = 10000000,
# polarity = 0, phase = 0, bits = 8, firstbit = SPI.MSB,
# sck = Pin(device_pins['sck'], Pin.OUT, Pin.PULL_DOWN),
# mosi = Pin(device_pins['mosi'], Pin.OUT, Pin.PULL_UP),
# miso = Pin(device_pins['miso'], Pin.IN, Pin.PULL_UP))
device_spi = SPI(baudrate = 10000000,
polarity = 0, phase = 0, bits = 8, firstbit = SPI.MSB,
sck = Pin(device_pins['sck'], Pin.OUT, Pin.PULL_DOWN),
mosi = Pin(device_pins['mosi'], Pin.OUT, Pin.PULL_UP),
miso = Pin(device_pins['miso'], Pin.IN, Pin.PULL_UP))
lora = SX127x(device_spi, pins=device_pins)
print("Waiting for LoRa message.....")
while True:
if(lora.received_packet()):
payload = lora.read_payload()
status=str(payload)[18:-1]
return (status)
def __init__(self, header=None, period=0): #Se especifica la cabecera en caso de que solo se quiera procesar algo en especifico #y tambien un periodo por si se quiere hacer cierta accion de manera periodica self.header = header self.period = float(period) self.status = 1 self.cb = None self.controller = ESP32Controller() self.lora = self.controller.add_transceiver(SX127x(name = 'LoRa'), pin_id_ss = ESP32Controller.PIN_ID_FOR_LORA_SS, pin_id_RxDone = ESP32Controller.PIN_ID_FOR_LORA_DIO0)
def get_lora():
''' Setup and return a LoRa Esp32 controller'''
params = {
'frequency': 868E6, # 169E6, 433E6, 434E6, 866E6, 868E6*, 915E6
'tx_power_level': 5, # 2
'signal_bandwidth':
20.8E3, # 7.8E3, 10.4E3, 15.6E3, 20.8E3, 31.25E3, 41.7E3, 62.5E3, 125E3*, 250E3
'spreading_factor': 5,
'coding_rate': 5,
'preamble_length': 12,
'implicitHeader': False,
'sync_word': 0x12,
'enable_CRC': False
}
controller = ESP32Controller()
return controller.add_transceiver(
SX127x(name='LoraTx', parameters=params),
pin_id_ss=ESP32Controller.PIN_ID_FOR_LORA_SS,
pin_id_RxDone=ESP32Controller.PIN_ID_FOR_LORA_DIO0)
total_discharge):
for i in range(0, 5):
payload = '{} {} {} {} {} {} {}'.format(ds18_temp, pH_final, discharge,
tdsValue, temp_dht22,
hum_dht22, total_discharge)
# Mensagem a enviar pelo sx127x.py:
lora.println(payload)
sleep(5)
#####----- LoRa -----#####
controller = ESP32Controller()
lora = controller.add_transceiver(
SX127x(name='LoRa'),
pin_id_ss=ESP32Controller.PIN_ID_FOR_LORA_SS,
pin_id_RxDone=ESP32Controller.PIN_ID_FOR_LORA_DIO0)
#####----- DS18X20 -----#####
ds18_pin = Pin(5)
ds18_sensor = DS18X20(OneWire(ds18_pin))
addrs = ds18_sensor.scan()
addr = addrs.pop()
ds_read = ds18_sensor.convert_temp()
sleep_ms(750)
ds18_temp = ds18_sensor.read_temp(addr)
# ds18_temp_print = str('%3.2f C DS18X20' %temp_ds)
__DEBUG__ = True
print("Setting TTNconfig")
ttn_config = TTN(ttn_config['devaddr'], ttn_config['nwkey'], ttn_config['app'], country=ttn_config['country'])
print("TTN Country:", TTN.country)
print("Setting device_spi")
device_spi = SPI(device_config['spi_unit'], baudrate = 10000000,
polarity = 0, phase = 0, bits = 8, firstbit = SPI.MSB,
sck = Pin(device_config['sck'], Pin.OUT, Pin.PULL_DOWN),
mosi = Pin(device_config['mosi'], Pin.OUT, Pin.PULL_UP),
miso = Pin(device_config['miso'], Pin.IN, Pin.PULL_UP))
print("Setting lora")
lora = SX127x(device_spi, pins=device_config, lora_parameters=lora_parameters, ttn_config=ttn_config)
frame_counter = 0
def on_receive(lora, outgoing):
payload = lora.read_payload()
print("RX>>>", payload)
lora.on_receive(on_receive)
lora.receive()
print("Lora Configuration:")
print("Freq: ",TTN_FREQS_STR[0])
print(lora_parameters)
while True:
__SAMPLE_DATA__ = False
device_spi = SoftSPI(baudrate = 10000000,
polarity = 0, phase = 0, bits = 8, firstbit = SoftSPI.MSB,
sck = Pin(device_config['sck'], Pin.OUT, Pin.PULL_DOWN),
mosi = Pin(device_config['mosi'], Pin.OUT, Pin.PULL_UP),
miso = Pin(device_config['miso'], Pin.IN, Pin.PULL_UP))
else:
print("Configuring ESP8266")
device_spi = SoftSPI(baudrate = 10000000,
polarity = 0, phase = 0, bits = 8, firstbit = SoftSPI.MSB,
sck = Pin(device_config['sck'], Pin.OUT),
mosi = Pin(device_config['mosi'], Pin.OUT, Pin.PULL_UP),
miso = Pin(device_config['miso'], Pin.IN, Pin.PULL_UP))
wdt.feed()
lora = SX127x(device_spi, pins=device_config, parameters=lora_parameters)
wdt.feed()
# Sending to LoRa
def send(lora,topic,message):
payload = '{"topic":"'+topic+'", "msg":'+message+'}'
print("To LoRa --> {}".format(payload))
if module_config['has_oled']==1:
oled.fill(0)
oled.text("TX to LoRa:",0,0)
oled.text("{}".format(topic),0,10)
pos=20
x=12
res=[message[y-x:y] for y in range(x, len(message)+x,x)]
for y in res:
"""Los siguientes parametros se encuentran por defecto para configurarlos modifique el diccionario parametros despues de este ejemplo(por defecto)"""
# parameters = {'frequency': 866E6, 'tx_power_level': 2, 'signal_bandwidth': 125E3,
# 'spreading_factor': 8, 'coding_rate': 5, 'preamble_length': 8,
# 'implicitHeader': False, 'sync_word': 0x12, 'enable_CRC': False}
"""La estos parametros deben ser iguales Entre Esclavo y Maestro a continuación se muestran los rangos disponibles(pensado en modulo sx1276)"""
# BW (7.8E3, 10.4E3, 15.6E3, 20.8E3, 31.25E3, 41.7E3, 62.5E3, 125E3, 250E3)
# spreading_factor (6 to 12)
# coding_rate (5 to 8)
"""IMPORTANTE REVIZAR Payload pag 31 data sx127x """
#parametros = {'frequency': 869E6, 'tx_power_level': 2, 'signal_bandwidth': 125E3,'spreading_factor': 8, 'coding_rate': 5, 'preamble_length': 8,'implicitHeader': False, 'sync_word': 0x12, 'enable_CRC': False}
objeto = SX127x(name='LoRa1',
parameters={
'frequency': 866E6,
'tx_power_level': 14,
'signal_bandwidth': 125E3,
'spreading_factor': 10,
'coding_rate': 5,
'preamble_length': 8,
'implicitHeader': False,
'sync_word': 0x12,
'enable_CRC': True
})
controller = ESP32Controller(
) #Configuracion de Pines y SPI para modificarlos realizarlo en
#En esta seccion ocurre una herencia multiple del objeto lora
lora = controller.add_transceiver(
objeto,
pin_id_ss=ESP32Controller.PIN_ID_FOR_LORA_SS,
pin_id_RxDone=ESP32Controller.PIN_ID_FOR_LORA_DIO0)
# # Transceiver permite agregar numero del pin chip SELECT y pines de interrupciones para mas funciones del Modulo LoRa
# def add_transceiver(self,
import config_lora
from machine import Pin, SPI
from sx127x import SX127x
device_pins = {
'miso':19,
'mosi':27,
'ss':18,
'sck':5,
'dio_0':26,
'reset':16,
'led':2,
}
device_spi = SPI(baudrate = 10000000,
polarity = 0, phase = 0, bits = 8, firstbit = SPI.MSB,
sck = Pin(device_pins['sck'], Pin.OUT, Pin.PULL_DOWN),
mosi = Pin(device_pins['mosi'], Pin.OUT, Pin.PULL_UP),
miso = Pin(device_pins['miso'], Pin.IN, Pin.PULL_UP))
lora = SX127x(device_spi, pins=device_pins)
#example = 'sender'
example = 'receiver'
if __name__ == '__main__':
if example == 'sender':
LoRaSender.send(lora)
if example == 'receiver':
LoRaReceiver.receive(lora)
#import LoRaDuplexCallback
#import LoRaPingPong
import LoRaSender
import LoRaReceiver
import config_lora
from sx127x import SX127x
from controller_esp32 import ESP32Controller
controller = ESP32Controller()
lora = controller.add_transceiver(
SX127x(name='LoRa1'),
pin_id_ss=ESP32Controller.PIN_ID_FOR_LORA_SS,
pin_id_RxDone=ESP32Controller.PIN_ID_FOR_LORA_DIO0)
#LoRaDuplexCallback.duplexCallback(lora)
#LoRaPingPong.ping_pong(lora)
LoRaSender.send(lora)
#LoRaReceiver.receive(lora)
print("LoRa Receiver")
display = Display()
while True:
ident = "LoRa Receiver"
lora.receivedPacket()
lora.blink_led()
try:
payload = lora.read_payload()
display.show_text_wrap("{0} {1} RSSI: {2}".format(
ident, payload.decode(), lora.packetRssi()), 2)
#print("*** Received message ***\n{}".format(payload.decode()))
except Exception as e:
print(e)
#display.show_text("RSSI: {}\n".format(lora.packetRssi()), 10, 10)
#print("with RSSI: {}\n".format(lora.packetRssi))
controller = ESP32Controller()
lora = controller.add_transceiver(SX127x(name='LoRa'),
pin_id_ss=ESP32Controller.PIN_ID_FOR_LORA_SS,
pin_id_RxDone=ESP32Controller.PIN_ID_FOR_LORA_DIO0)
receive(lora)
'ss':18,
'reset':16,
'sck':5,
'miso':19,
'mosi':27,
}
lora_spi = SPI(
baudrate=10000000, polarity=0, phase=0,
bits=8, firstbit=SPI.MSB,
sck=Pin(lora_pins['sck'], Pin.OUT, Pin.PULL_DOWN),
mosi=Pin(lora_pins['mosi'], Pin.OUT, Pin.PULL_UP),
miso=Pin(lora_pins['miso'], Pin.IN, Pin.PULL_UP),
)
lora = SX127x(lora_spi, pins=lora_pins, parameters=lora_default)
# type = 'sender'
# type = 'receiver'
# type = 'ping_master'
# type = 'ping_slave'
type = 'receiver_callback'
if __name__ == '__main__':
if type == 'sender':
LoRaSender.send(lora)
if type == 'receiver':
LoRaReceiver.receive(lora)
if type == 'ping_master':
LoRaPing.ping(lora, master=True)
########## CONSTANTS ##########
IS_BEACON = False # Used for testing range
BLE_ENABLED = True # Used for testing
BLE_NAME = 'ulora2' if IS_BEACON else 'ulora' # Name BLE will use when advertising
# BLE_NAME = 'ulora2' if get_nodename() == "ESP_30aea4bfbe88" else "ulora" # NOTE: USE ONLY FOR DEV
SYNC_INTERVAL = 5000 # How often (ms) to send sync packet after last packet was sent
NODE_NAME = get_nodename()
########## LORA ##########
from config_lora import parameters, device_spi, device_pins
from sx127x import SX127x
# Restart machine if we get the 'invalid version' error
try:
lora = SX127x(device_spi, pins=device_pins, parameters=parameters)
except:
time.sleep(1) # this try/except can get caught in an uninterruptible loop, sleep gives us a chance
machine.reset()
def on_lora_rx():
global previous_sync_time
if lora.received_packet():
lora.blink_led()
payload = lora.read_payload()
print('[LORA] received payload: ', payload)
try:
payload_obj = json.loads(payload)
except (Exception, TypeError) as error:
