class Gateway(object):
def __init__(self, nom="moi", nodes={}):
"""Initialise un objet en utilisant le mode gateway de node
Core."""
self.core = Node_Core(nom, 'G', nodes)
self.lora = 0
self.loraSocket = 0
self.sender = [] # List wich store tuple with senders and message.
self.serialPort = UART(1, 9600)
def getSerial(self):
return (self.serialPort)
def initSerial(self,
baudrate=9600,
bits=8,
parity=None,
stop=1,
pin=("P3", "P4")):
# timeou_char semble ne pas marcher.
self.serialPort.init(baudrate=baudrate,
bits=bits,
parity=parity,
stop=stop,
pins=pin)
def deinitSerial(self):
self.serialPort.deinit()
def writeSerial(self, data, target):
"""Write data on serial port. Target is the name of destinatory
(usefull for relaying messages between devices.
sended message has the following format :
"target\tdata\n" It could be catch with a readline.
As for lora return False if target is unknown node.
"""
try:
self.core._translateIntoKey(set_size(target))
except KeyError:
return (False)
self.serialPort.write(str(target))
self.serialPort.write('\t')
self.serialPort.write(str(data) + '\n')
return (True)
def readSerial(self):
"""Read a line with format described by writeSerial
return false if no data available"""
if (not self.serialPort.any()):
return (False)
data = self.serialPort.readline()
if (data != None):
data = data.split('\t')
return (data[0], data[1])
else:
return (False)
def getSenders(self):
return (self.sender)
def getOldestMsg(self):
"""Return oldest name, message received, see popOldestMsg"""
if (self.sender != []):
return (self.getSenders()[0])
else:
return ([])
def popOldestMsg(self):
"""Return and delete oldest name, message received, see popOldestMsg"""
if (self.sender != []):
tmp = self.getSenders()
return (tmp.pop(0))
else:
return ([])
def _addRcvMsg(self, name, msg):
self.getSenders().append([name, msg])
def getNodes(self):
return (self.core.getNodes())
def getUNodes(self):
"""Return list of unknown nodes"""
return (self.core.getUnknownNodes())
def getName(self):
return (self.core.getMyName())
def getKey(self):
return (self.core.getMyKey())
def setName(self, name):
return (self.core.setNodeName(name))
def setKey(self, key):
return (self.core.setMyKey(key))
def addNewNode(self, name, key):
return (self.core.addNode(name, key))
def setNodeKey(self, name, key):
return (self.core.changeNodeKey(name, key))
def startLoRa(self):
"""Init a LoRa connection with LoRa and LoRa socket."""
self.lora = LoRa(mode=LoRa.LORA,
frequency=863000000,
power_mode=LoRa.ALWAYS_ON,
tx_power=14,
bandwidth=LoRa.BW_250KHZ,
sf=7,
preamble=8,
coding_rate=LoRa.CODING_4_5,
tx_iq=False,
rx_iq=False)
self.loraSocket = socket.socket(socket.AF_LORA, socket.SOCK_RAW)
self.loraSocket.setblocking(False)
def stopLoRa(self):
"""Close a LoRa connection return True if closed false if
exception. Exception could be raise if LoRa is already
closed"""
try:
self.loraSocket.close()
self.lora.close()
return (True)
except:
return (False)
def sendMsg(self, data, target, encryption=False):
"""Send a message to target. Target should be a known
node return number of bytes sended."""
# On bloque antenne pour pas recevoir pendant émission.
try:
data = self.core.buildMsg(data, target, encryption)
except KeyError:
return (False)
else:
return (self.loraSocket.send(data))
def recvMsg(self, encryption=False):
"""Check received message and read it return read
data in an array, store readed messages in self.sender
return True if non empty message is received"""
# On réactive l'antenne pour la réception.
data = self.loraSocket.recv(512)
# On une limite de taille à la réception la voilà la fameuse limite. Je mesure une
#limite 64
if (len(data) == 0):
return (False)
try:
name, data = self.core.readMsg(data, encryption)
except KeyError:
return (False)
self._addRcvMsg(name, data)
return (True)
# Function adapted for callback use :
def callbackSendMsg(self, arg):
""" arg is a liste containing 3 args
data to send, target and the encryption mode"""
print(self.sendMsg(arg[0], arg[1], arg[2]))
def callbackWriteSerial(self, arg):
"""Arg is a list wich contains data to send, and the target.
see writeSerial.
"""
print(self.writeSerial(arg[0], arg[1]))
lora.join(activation=LoRa.OTAA, auth=(APP_EUI, APP_KEY), timeout=0)
# wait until the module has joined the network
while not lora.has_joined():
time.sleep(2.5)
print('Not yet joined...')
# create a LoRa socket
s = socket.socket(socket.AF_LORA, socket.SOCK_RAW)
# set the LoRaWAN data rate
s.setsockopt(socket.SOL_LORA, socket.SO_DR, 5)
# make the socket blocking
# (waits for the data to be sent and for the 2 receive windows to expire)
s.setblocking(True)
# send some data
s.send(bytes([0x01, 0x02, 0x03]))
# make the socket non-blocking
# (because if there's no data received it will block forever...)
s.setblocking(False)
# get any data received (if any...)
data = s.recv(64)
print(data)
s.close()
lora.close()
