config_start = False End_discover = False End_normal = False power = 2 intent = 1 EnviatGateway = False neighbours = [[], []] neighbours_aux = [[], []] msg = "Config 2" msg_aux = "Config 2" rcv_data = False node_list = "" msg_alarm_ok = " " timer_to_send_GTW = Timer.Chrono() timer_to_send_alarm = Timer.Chrono() timer_token_ack = Timer.Chrono() timer_discover_end = Timer.Chrono() button = machine.Pin(Pin.exp_board.G17, mode=Pin.IN, pull=Pin.PULL_UP) #timer_to_send_GTW.start() Hello_received = False period = 2 counter = 1 i = 0 ## Initialize time rtc = machine.RTC() #(year, month, day[, hour[, minute[, second[, microsecond[, tzinfo]]]]]) rtc.init((2020, 07, 28, 11, 36))
ComInterface.the_socket.setsockopt(socket.SOL_SIGFOX, socket.SO_RX,
True)
try:
# send uplink data
pycom.rgbled(0x00ffff) # cyan
print("Sending with no response at: {}".format(
ComInterface.chrono.read()))
ComInterface.the_socket.send(data)
print("data sent at: {}: ".format(ComInterface.chrono.read()))
print('message RSSI: {}'.format(sigfox.rssi()))
#time.sleep(wait_time)
except OSError as e:
print("Error at: {}: ".format(ComInterface.chrono.read()))
print('Error number {}, {}'.format(e.args[0], e))
pycom.rgbled(0xff0000) # red
if e.args[0] == 11:
# Retry Logic
print('Error {}, {}'.format(e.args[0], e))
time.sleep(sleep_after)
return None
# Init Chrono
chrono = Timer.Chrono()
# Start Time
chrono.start()
ComInterface.initialize(chrono)
ComInterface.send_sigfox(bytes([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]), 30,
False)
from machine import Timer, Pin, PWM
from helpers import *
import _thread
import utime
import adc
from sht1x import SHT1X
from pms5003 import PMS5003, PMSData
import persistence
from datapoint import DataPoint
from ds3231 import DS3231
pycom.heartbeat(False)
VERSION = '0.7.0'
alive_timer = Timer.Chrono()
alive_timer.start()
def tear_down(timer, initial_time_remaining):
timer.stop()
elapsed_ms = int(timer.read() * 1000)
timer.reset()
time_remaining = initial_time_remaining - elapsed_ms
print('sleeping for {}ms ({})'.format(time_remaining, ertc.get_time()))
# deepsleep_pin = Pin('P10', mode=Pin.IN, pull=Pin.PULL_UP)
# machine.pin_deepsleep_wakeup(pins=[deepsleep_pin], mode=machine.WAKEUP_ALL_LOW, enable_pull=True)
machine.deepsleep(time_remaining)
from network import LoRa import socket import time pycom.wifi_on_boot(False) Hello_received = False end_discover = False CONFIG_MODE = 0 DISCOVER_MODE = 1 LISTEN_MODE = 2 NORMAL_MODE = 3 ALARM_MODE = 4 CHECK = 5 stop_config = False pycom.wifi_on_boot(False) timer2 = Timer.Chrono() timer3 = Timer.Chrono() timer_read_sensors = Timer.Chrono() timer_Disc_end = Timer.Chrono() timer_Disc_end.reset() timer_read_sensors.reset() discover_end_ack = False timer2.reset() missatge = False period = 500 pycom.wifi_on_boot(False) com = comu.Comunication() com.start_LoraRaw() #timer=Timer.Chrono() #timer.reset()
import time
from machine import Timer, RTC
import machine
import binascii
import network
import pycom
from network import LTE
from sensors import ds1820, hx711, bme280
import logger
import webserver
from wlanmanager import WLanManager
from config import Config
boottime = Timer.Chrono()
boottime.start()
_config = Config()
_wlan = network.WLAN(id=0)
lte = LTE()
_ds_positions = {
v: k
for k, v in _config.get_value('sensors', 'ds1820', 'positions').items()
}
_wm = WLanManager()
reset_causes = {
def start_measurement():
AP_TIME = 2 * 60
perf = Timer.Chrono()
pycom.heartbeat(False)
pycom.rgbled(0x000000)
perf.start()
while boottime.read() < AP_TIME:
# Measure all enabled sensors
data = {}
if ds1820 is not None:
for rom in ds1820.roms:
ds1820.start_conversion(rom=rom)
time.sleep_ms(750)
for rom in ds1820.roms:
try:
ds_measurement = ds1820.read_temp_async(rom=rom)
ds_name = binascii.hexlify(rom).decode('utf-8')
if ds_name in _ds_positions:
data[_ds_positions[ds_name]] = ds_measurement
except Exception as e:
log("Did not find rom" + str(e))
if bme280 is not None:
try:
(data['t'], data['p'],
data['h']) = bme280.read_compensated_data()
data['p'] = data['p'] / 100 # Pa to mBar
except Exception:
log("BME280 not measuring.")
if hx711 is not None:
data['weight_kg'] = hx711.get_value(times=5)
# Log measured values
perf.start()
if _csv is not None:
_csv.add_dict(data)
if _wlan.mode() == network.WLAN.STA and _wlan.isconnected(
) and _beep is not None:
log("beep")
_beep.add(data)
log(data)
perf.stop()
time_elapsed = perf.read()
perf.reset()
time_until_measurement = measurement_interval - time_elapsed
log('SecondsO elapsed: {:.2f}s, time until next measurement: {:.2f}s'.
format(time_elapsed, time_until_measurement))
# 10 Minuten nach dem Strom an soll der AC da sein.
log('boottime: ' + str(boottime.read()))
if machine.reset_cause() != machine.DEEPSLEEP_RESET and boottime.read(
) < AP_TIME:
log('sleep')
time.sleep_ms(int(abs(time_until_measurement) * 1000))
else:
lte.dettach()
_wlan.deinit()
log('deepsleep')
# machine.deepsleep(int(abs(time_until_measurement * 1000)))
machine.deepsleep(int(abs(10 * 1000)))
log('Unexpected exited while loop')
machine.reset()
def receive_data():
global index
global guard
global slot
global packet_size
lora = LoRa(mode=LoRa.LORA,
rx_iq=True,
frequency=freqs[my_sf - 5],
region=LoRa.EU868,
power_mode=LoRa.ALWAYS_ON,
bandwidth=my_bw,
sf=my_sf)
lora_sock = socket.socket(socket.AF_LORA, socket.SOCK_RAW)
lora_sock.setblocking(False)
guard = 1000 * guard
(overall_received, overall_sent) = (0, 0)
airt = int(airtime_calc(my_sf, 1, packet_size + 2, my_bw_plain) * 1000)
duty_cycle_limit_slots = math.ceil(100 * airt / (airt + 2 * guard))
print("duty cycle slots:", duty_cycle_limit_slots)
print("packet airtime (ms):", airt / 1000)
print("guard time (ms):", guard / 1000)
chrono = Timer.Chrono()
chrono.start()
i = 1
while (True):
print(i, "----------------------------------------------------")
print("Net size is:", index + 1)
chrono.reset()
round_start = chrono.read_us()
received = 0
acks = []
if (int(index) > duty_cycle_limit_slots):
round_length = math.ceil(int(index) * (airt + 2 * guard))
else:
round_length = math.ceil(duty_cycle_limit_slots *
(airt + 2 * guard))
lora.init(mode=LoRa.LORA,
rx_iq=True,
region=LoRa.EU868,
frequency=freqs[my_sf - 5],
power_mode=LoRa.ALWAYS_ON,
bandwidth=my_bw,
sf=my_sf)
rec_start = chrono.read_us()
pycom.rgbled(green)
while ((chrono.read_us() - round_start) <
round_length - 66000): # the following line may take up to 66ms
recv_pkg = lora_sock.recv(256)
if (len(recv_pkg) > 2):
recv_pkg_len = recv_pkg[1]
recv_pkg_id = recv_pkg[0]
if (int(recv_pkg_id) <= 35) and (int(recv_pkg_len)
== int(packet_size)):
dev_id, leng, msg = struct.unpack(
_LORA_RCV_PKG_FORMAT % recv_pkg_len, recv_pkg)
if (len(msg) == packet_size): # format check
received += 1
# print('Received from: %d' % dev_id)
# print(lora.stats())
acks.append(str(int(dev_id)))
pycom.rgbled(off)
print(received, "packets received")
rec_lasted = chrono.read_us() - rec_start
if (rec_lasted < round_length):
print("I'll sleep a bit to align with the round length")
time.sleep_us(int(round_length - rec_lasted))
print("Receiving lasted (ms):", (chrono.read_us() - rec_start) / 1000)
print("...should last (ms):", round_length / 1000)
proc_t = chrono.read_us()
ack_msg = ""
for n in range(int(index) + 1):
if n in slot:
id = str(slot[n])
if id in acks:
ack_msg = ack_msg + "1"
else:
ack_msg = ack_msg + "0"
if (ack_msg != ""):
ack_msg = str(hex(int(ack_msg, 2)))[2:]
print("proc time (ms):", (chrono.read_us() - proc_t) / 1000)
proc_t = chrono.read_us() - proc_t
if (i % sync_rate == 0): # SACK
sync_start = chrono.read_us()
pycom.rgbled(white)
time.sleep_us(int(guard * 3 /
2)) # let's make it long so all the nodes are up
lora.init(mode=LoRa.LORA,
tx_iq=True,
frequency=freqs[my_sf - 5],
region=LoRa.EU868,
power_mode=LoRa.ALWAYS_ON,
bandwidth=my_bw,
sf=my_sf,
tx_power=14)
data = str(index + 1) + ":" + str(int(
proc_t / 1000)) + ":" + ack_msg
pkg = struct.pack(_LORA_PKG_FORMAT % len(data), MY_ID, len(data),
data)
pycom.rgbled(red)
lora_sock.send(pkg)
print("Sent sync: " + data)
pycom.rgbled(off)
time.sleep_ms(13) # node time after sack
print("sync lasted (ms):", (chrono.read_us() - sync_start) / 1000)
print("round lasted (ms):", (chrono.read_us() - round_start) / 1000)
i += 1
def __init__(self):
self.chrono = Timer.Chrono()
self.chrono.start()
#remove all channels gateway doesn't use
for channel in range(16, 72):
lora.remove_channel(channel)
for channel in range(0, 7):
lora.remove_channel(channel)
#create an OTAA authentication parameters for ring lopy
dev_eui = ubinascii.unhexlify(
'70B3D54990435DFE') # these settings can be found from TTN
app_eui = ubinascii.unhexlify('70B3D57ED0028A4F')
app_key = ubinascii.unhexlify('CE46C01958A612D102F0D106AB415862')
if not lora.has_joined():
lora.join(activation=LoRa.OTAA, auth=(app_eui, app_key), timeout=0)
pycom.rgbled(green)
time.sleep(2.5)
handshk_time = Timer.Chrono()
handshk_time.start()
# wait until the module has joined the network
while not lora.has_joined():
pycom.rgbled(off)
time.sleep(0.1)
pycom.rgbled(red)
time.sleep(2.4)
print('Not yet joined...')
lora.nvram_save()
handshk_time.stop()
print("Total handshake time: {0}".format(handshk_time.read()))
print('Joined!')
pycom.rgbled(blue)
# create a LoRa socket
s = socket.socket(socket.AF_LORA, socket.SOCK_RAW)
def __init__(self):
from machine import Timer
self.chrono = Timer.Chrono()
self.chrono.start()
d["lat"] = lat
d["lon"] = lon
d["hdop"] = hdop
d["alt"] = alt
f.write(json.dumps(d))
f.write("\n")
f.close()
rgb.green(0x88)
rgb.red(0x88)
time.sleep(1)
rgb.green_off()
rgb.red_off()
rgb = RgbWrapper() #Setup LED for debug output
sd_en = False #Whether to try to write to SD card
chrono = Timer.Chrono() #Keep track of time since boot so can record how long between GPS readings
chrono.start()
last_gps_reading = 0 #When the last GPS reading was taken
try:
sd = SD()
os.mount(sd, SD_MOUNT_DIR)
sd_en = True
rgb.green(0x88)
rgb.red(0x88)
time.sleep(1)
rgb.green_off()
rgb.red_off()
except OSError:
sd_en = False #Make sure SD card access is disabled
print("SD Card enabled: " + str(sd_en))
