def on_receive(lora, payload):
lora.blink_led()
now = millisecond()
try:
payload = payload.decode()
sender_NODE_NAME, sender_msgCount, sent_millisecond = parse_message(
payload)
key = '{}_{}'.format(sender_NODE_NAME, sender_msgCount)
item = messages.get(key)
if item: # matched message, calculate elipse time, and remove item.
item['pong'] = now
item['elipse'] = item['pong'] - item['ping']
item['done'] = True
message = "*** Pong after {} ms ***".format(item['elipse'])
print(message)
print(item)
del messages[key]
else: # new message, send it back.
print("*** Received message ***\n{}".format(payload))
message = gen_message(sender_NODE_NAME, sender_msgCount,
millisecond())
sendMessage(lora, message)
except Exception as e:
print(e)
print("with RSSI {}\n".format(lora.packetRssi()))
def gate_working(self):
self.sendMessage("empty")
onoff = "OFF"
print("prepare create socket")
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
print("already create socket")
s.bind(('', 80))
print("bind")
s.listen(5)
print("listen")
while True:
#阻塞，等待webserver请求
conn, addr = s.accept()
print('Got a connection from %s' % str(addr))
request = conn.recv(1024)
request = str(request)
print('Content = %s' % request)
#解析请求并发送控制继电器指令
led_on = request.find('/?led=on')
led_off = request.find('/?led=off')
if led_on == 6:
print('LED ON')
onoff = 'ON'
if led_off == 6:
print('LED OFF')
onoff = 'OFF'
temp_msg = "RELAY" + onoff
self.sendMessage(temp_msg)
#等待lora响应
self.lora.receive()
print("wait lora callback")
#阻塞等待lora回调完毕
#解析在回调中进行，结果放到对象的字符串里
now = config_lora.millisecond()
while (self.flag == 0):
if config_lora.millisecond() - now > 3000:
print("Callback time out.")
break
pass
self.flag = 0
print(self.buff)
#没找到关闭回调的命令，手动发送个无意义的进入发送模式屏蔽回调
self.sendMessage("empty")
#响应web请求
response = webserver.web_page(self.relay_status)
conn.send('HTTP/1.1 200 OK\n')
conn.send('Content-Type: text/html\n')
conn.send('Connection: close\n\n')
conn.sendall(response)
conn.close()
def lora_timeout(self):
print("wait lora callback")
now = config_lora.millisecond()
while (self.flag == 0):
if config_lora.millisecond() - now > 5000:
print("Callback time out.")
break
self.flag = 0
def do_loop(lora):
global msgSendSucces
lastSendTime = 0
interval = 0
while True:
now = config_lora.millisecond()
if now < lastSendTime: lastSendTime = now
if (now - lastSendTime > interval):
lastSendTime = now # timestamp the message
interval = (lastSendTime % INTERVAL) + INTERVAL_BASE # 2-3 seconds
#message = "{} {}".format(config_lora.NODE_NAME, msgCount)
message = "temperatura: 20;HumedadSuelo: 70;HumedadAire: 50"
sendMessage(lora, message) # send message
lora.receive() # go into receive mode
if (now - lastSendTime > INTERVAL_BASE_RESEND) and msgSendSucces == 1:
#message = "{} {}".format(config_lora.NODE_NAME, msgCount)
message = "temperatura: 20;HumedadSuelo: 70;HumedadAire: 50"
sendMessage(lora, message) # send message
lora.receive() # go into receive mode
def do_loop(lora):
global msgCount
lastSendTime = 0
interval = 0
while True:
now = millisecond()
if now < lastSendTime: lastSendTime = now
if (now - lastSendTime > interval):
lastSendTime = now # timestamp the message
interval = (lastSendTime % INTERVAL) + INTERVAL_BASE # 2-3 seconds
message = gen_message(NODE_NAME, msgCount, now)
sendMessage(lora, message) # send message
key = '{}_{}'.format(NODE_NAME, msgCount)
messages[key] = {
'node': NODE_NAME,
'msgCount': msgCount,
'ping': now,
'pong': None,
'done': False,
'elipse': None
}
msgCount += 1
lora.receive() # go back into receive mode
def sendMeasurements(self, temp, humS, humA):
"""
-----------------------------------------------------------------------
Datagrama mensaje
-------------------------------------------------------------------------------
|Servidor(0)/Nodo(1)||Restransmitir||ID receptor||ID emisor||Saltos|| Datos ||
-------------------------------------------------------------------------------
*Servidor/Nodo: 0 - El mesaje fue emitido por un servidor
1 - El mensaje fue emitido por un nodo
*Restransmitir: 0 - Los nodos no retransmiten el mensaje
1 - Los nodos retransmiten el mensaje
*ID receptor:ID del receptor del mensaje
*ID emisor: ID del emisor del mensaje
*Saltos: retransmisiones que tuvo el mensaje hasta llegar el receptor
Datos: datos que se quieren transmitir
-----------------------------------------------------------------------
"""
firstTime = 0
lastSendTime = 0
# message = "{} {}".format(config_lora.NODE_NAME, msgCount)
self.lora.receive()
while True:
now = config_lora.millisecond()
if now < lastSendTime: lastSendTime = now
if firstTime == 0:
message = "temperatura: " + str(
temp) + ";HumedadSuelo: " + str(
humS) + ";HumedadAire: " + str(humA)
self.sendMessage(self.lora, message) # send message
self.msgSendFlag = 1
firstTime = 1
if (now - lastSendTime >
self.INTERVAL_BASE_RESEND) and self.msgSendFlag == 1:
lastSendTime = now # timestamp the message
#message = "{} {}".format(config_lora.NODE_NAME, msgCount)
#message = "temperatura: 20;HumedadSuelo: 70;HumedadAire: 50"
message = "temperatura: " + str(
temp) + ";HumedadSuelo: " + str(
humS) + ";HumedadAire: " + str(humA)
self.sendMessage(self.lora, message) # send message
self.lora.receive() # go into receive mode
if self.msgSendFlag == 0:
break
def __init__(self,
gateway_eui=None,
rssi=None,
pay_load=None,
time_stamp=None):
self.gateway_eui = gateway_eui
self.rssi = rssi
self.pay_load = pay_load
self.time = time_stamp if time_stamp else millisecond()
def __init__(self,
frm=None,
to=None,
via=None,
message=None,
time_stamp=None):
self.frm = frm
self.to = to
self.via = via
self.message = message
self.time = time_stamp if time_stamp else millisecond()
def update_link(self, gateway_eui, node_eui, rssi):
if node_eui is not None:
self.links[(gateway_eui, node_eui)] = (rssi, millisecond())
# receive notice from other gateway, and the node doesn't show on this gateway, probably out of range.
if gateway_eui != self.eui:
if is_link_expired(self.eui, node_eui):
self.delete_link(self.eui, node_eui)
self.notice_link(self.eui, node_eui, to_add=False)
print('******** Links *********\n', self.links)
print('******* Networks *******\n', self.get_networks())
def main():
transceiver = lora.lora()
lastSendTime = 0
while True:
now = config_lora.millisecond()
if now < lastSendTime: lastSendTime = now
if (now - lastSendTime > INTERVAL):
lastSendTime = now
#transceiver.sendMeasurements(temp, humS, humA)
transceiver.sendMeasurements(randint(1, 99), randint(1, 99),
randint(1, 99))
print("Sendiang message")
def do_loop(lora):
global msgCount
lastSendTime = 0
interval = 0
while True:
now = config_lora.millisecond()
if now < lastSendTime: lastSendTime = now
if (now - lastSendTime > interval):
lastSendTime = now # timestamp the message
interval = (lastSendTime % INTERVAL) + INTERVAL_BASE # 2-3 seconds
message = "{} {}".format(config_lora.NODE_NAME, msgCount)
sendMessage(lora, message) # send message
msgCount += 1
lora.receive() # go into receive mode
def sendMeasurements(self, temp, humS, humA):
firstTime = 0
lastSendTime = 0
datos = "{}{}{}".format(*str(float(temp))) + "{}{}{}".format(
*str(float(humS))) + "{}{}{}".format(*str(float(humA)))
if self.IDSERVIDOR == 1001:
message = str(1) + str(1) + str(1001) + str(self.IDNODO) + str(
0
) + "buscando servidor" #emite mensaje de confirmacion de recepcion
self.sendMessage(self.lora, message) # send message
self.lora.receive()
else:
while True:
now = config_lora.millisecond()
if now < lastSendTime: lastSendTime = now
if firstTime == 0:
lastSendTime = now
message = str(1) + str(0) + str(self.IDSERVIDOR) + str(
self.IDNODO) + str(
0) + datos #envia los datos al servidor
self.sendMessage(self.lora, message) # send message
self.msgSendFlag = 1
firstTime = 1
elif (now - lastSendTime >
self.INTERVAL_BASE_RESEND) and self.msgSendFlag == 1:
lastSendTime = now # timestamp the message
message = str(1) + str(1) + str(self.IDSERVIDOR) + str(
self.IDNODO
) + str(
0
) + datos #envia los datos al servidor haciendo uso de los otros nodos
self.sendMessage(self.lora, message) # send message
self.lora.receive() # go into receive mode
if self.msgSendFlag == 0:
break
def do_loop(lora):
global msgCount
lastSendTime = 0
interval = 0
while True:
now = millisecond()
if now < lastSendTime: lastSendTime = now
if (now - lastSendTime > interval):
lastSendTime = now # timestamp the message
interval = (lastSendTime % INTERVAL) + INTERVAL_BASE # 2-3 seconds
message = "{} {}".format(NODE_NAME, msgCount)
sendMessage(lora, message) # send message
msgCount += 1
# parse for a packet, and call onReceive with the result:
receive(lora)
def sendMeasurements(lora, temp, humS, humA):
global msgSendSucces
lastSendTime = 0
#message = "{} {}".format(config_lora.NODE_NAME, msgCount)
lora.receive()
while True:
now = config_lora.millisecond()
if now < lastSendTime: lastSendTime = now
if (now - lastSendTime > INTERVAL_BASE_RESEND) and msgSendSucces == 1:
lastSendTime = now # timestamp the message
#message = "{} {}".format(config_lora.NODE_NAME, msgCount)
#message = "temperatura: 20;HumedadSuelo: 70;HumedadAire: 50"
message = "temperatura: " + temp + ";HumedadSuelo: " + humS + ";HumedadAire: " + humA
sendMessage(lora, message) # send message
lora.receive() # go into receive mode
elif msgSendSucces == 0:
break
def is_link_expired(self, gateway_eui, node_eui):
last_status = self.links.get((gateway_eui, node_eui))
if last_status:
rssi, last_seen_time = last_status
return abs(millisecond() -
last_seen_time) > LINK_EXPIRATION_SECONDS * 1000
