From ab699236f53605028de01c0101711308ee1cf890 Mon Sep 17 00:00:00 2001 From: Catalin Ioana Date: Thu, 14 Feb 2019 11:13:41 +0200 Subject: [PATCH 01/92] lib/lora_mesh: updated Pymesh example, as release v1.20.0.rc7 --- lib/lora_mesh/loramesh.py | 132 +++++++++++++++----------------------- lib/lora_mesh/main.py | 50 +++++++-------- 2 files changed, 77 insertions(+), 105 deletions(-) diff --git a/lib/lora_mesh/loramesh.py b/lib/lora_mesh/loramesh.py index 6caa3a3..79a7ddc 100644 --- a/lib/lora_mesh/loramesh.py +++ b/lib/lora_mesh/loramesh.py @@ -5,20 +5,20 @@ import ubinascii import pycom -__version__ = '1' +__version__ = '2' class Loramesh: """ Class for using Lora Mesh - openThread """ - STATE_NOT_CONNECTED = const(0) - STATE_CHILD = const(1) - STATE_ROUTER = const(2) - STATE_LEADER = const(3) - #STATE_CHILD_SINGLE = const(4) - STATE_LEADER_SINGLE = const(4) + STATE_DISABLED = const(0) + STATE_DETACHED = const(1) + STATE_CHILD = const(2) + STATE_ROUTER = const(3) + STATE_LEADER = const(4) + STATE_LEADER_SINGLE = const(5) - # rgb LED color for each state: not connected, child, router, leader and single leader - RGBLED = [0x0A0000, 0x0A0A0A, 0x000A00, 0x00000A, 0x07070A] + # rgb LED color for each state: disabled, detached, child, router, leader and single leader + RGBLED = [0x0A0000, 0x0A0000, 0x0A0A0A, 0x000A00, 0x0A000A, 0x000A0A] # address to be used for multicasting MULTICAST_MESH_ALL = 'ff03::1' @@ -33,25 +33,37 @@ def __init__(self, lora=None): self.lora = LoRa(mode=LoRa.LORA, region=LoRa.EU868, bandwidth=LoRa.BW_125KHZ, sf=7) else: self.lora = lora - self.lora.mesh() + self.mesh = self.lora.Mesh() self.rloc = '' self.ip_eid = '' self.ip_link = '' self.single = True - self.state_id = STATE_NOT_CONNECTED + self.state = STATE_DISABLED + + def _state_update(self): + """ Returns the Thread role """ + self.state = self.mesh.state() + if self.state < 0: + self.state = self.STATE_DISABLED + return self.state + + def _rloc_ip_net_addr(self): + """ returns the family part of RLOC IPv6, without last word (2B) """ + self.net_addr = ':'.join(self.rloc.split(':')[:-1]) + ':' + return self.net_addr def _update_ips(self): """ Updates all the unicast IPv6 of the Thread interface """ - ip_all = self.lora.cli('ipaddr') - ips = ip_all.split('\r\n') - try: - rloc16 = int(self.lora.cli('rloc16'), 16) - except Exception: - rloc16 = 0xFFFF + ips = self.mesh.ipaddr() + self.rloc16 = self.mesh.rloc() for line in ips: if line.startswith('fd'): # Mesh-Local unicast IPv6 - if int(line.split(':')[-1], 16) == rloc16: + try: + addr = int(line.split(':')[-1], 16) + except Exception: + continue + if addr == self.rloc16: # found RLOC # RLOC IPv6 has x:x:x:x:0:ff:fe00:RLOC16 self.rloc = line @@ -63,87 +75,47 @@ def _update_ips(self): self.ip_link = line def is_connected(self): - """ Returns true if it is connected if its Child, Router or Leader """ + """ Returns true if it is connected as either Child, Router or Leader """ connected = False - state = self.state() - if state == STATE_CHILD or state == STATE_ROUTER or state == STATE_LEADER: + self.state = self.mesh.state() + if self.state in (STATE_CHILD, STATE_ROUTER, STATE_LEADER, STATE_LEADER_SINGLE): connected = True return connected - def state(self): - """ Returns the Thread role """ - state_code = STATE_NOT_CONNECTED - try: - state = self.lora.cli('state') - - if state.startswith('child'): - state_code = STATE_CHILD - elif state.startswith('router'): - state_code = STATE_ROUTER - elif state.startswith('leader'): - state_code = STATE_LEADER - self.single = False - single_str = self.lora.cli('singleton') - if single_str.startswith('true'): - self.single = True - state_code = STATE_LEADER_SINGLE - - self.state_id = state_code - except Exception: - pass - return state_code - def led_state(self): """ Sets the LED according to the Thread role """ - pycom.rgbled(self.RGBLED[self.state()]) + if self.state == STATE_LEADER and self.mesh.single(): + pycom.rgbled(self.RGBLED[self.STATE_LEADER_SINGLE]) + else: + pycom.rgbled(self.RGBLED[self.state]) def ip(self): """ Returns the IPv6 RLOC """ self._update_ips() return self.rloc - def parent_ip(self): - """ Returns the IP of the parent, if it's child node """ - ip = None - state = self.state() - if state == STATE_CHILD or state == STATE_ROUTER: - try: - ip_words = self.ip().split(':') - parent_rloc = int(self.lora.cli('parent').split('\r\n')[1].split(' ')[1], 16) - ip_words[-1] = hex(parent_rloc)[2:] - ip = ':'.join(ip_words) - except Exception: - pass - return ip + def neighbors(self): + """ Returns a list with all properties of the neighbors """ + return self.mesh.neighbors() def neighbors_ip(self): - """ Returns a list with IP of the neighbors (children, parent, other routers) """ - state = self.state() - neigh = [] - if state == STATE_ROUTER or state == STATE_LEADER: - ip_words = self.ip().split(':') - # obtain RLOC16 neighbors - neighbors = self.lora.cli('neighbor list').split(' ') - for rloc in neighbors: - if len(rloc) == 0: - continue - try: - ip_words[-1] = str(rloc[2:]) - nei_ip = ':'.join(ip_words) - neigh.append(nei_ip) - except Exception: - pass - elif state == STATE_CHILD: - neigh.append(self.parent_ip()) - return neigh + """ Returns a list with IPv6 (as strings) of the neighbors """ + neighbors = self.neighbors() + nei_list = [] + net_ip = self._rloc_ip_net_addr() + if neighbors is not None: + for nei_rec in neighbors: + nei_ip = net_ip + hex(nei_rec.rloc16)[2:] + nei_list.append(nei_ip) + return nei_list def ipaddr(self): """ Returns a list with all unicast IPv6 """ - return self.lora.cli('ipaddr').split('\r\n') + return self.mesh.ipaddr() def cli(self, command): """ Simple wrapper for OpenThread CLI """ - return self.lora.cli(command) + return self.mesh.cli(command) def ping(self, ip): """ Returns ping return time, to an IP """ @@ -161,7 +133,7 @@ def ping(self, ip): def blink(self, num = 3, period = .5, color = None): """ LED blink """ if color is None: - color = self.RGBLED[self.state()] + color = self.RGBLED[self.state] for i in range(0, num): pycom.rgbled(0) time.sleep(period) diff --git a/lib/lora_mesh/main.py b/lib/lora_mesh/main.py index 70be763..bd714a9 100644 --- a/lib/lora_mesh/main.py +++ b/lib/lora_mesh/main.py @@ -17,8 +17,7 @@ mesh = Loramesh(lora) -# waiting until it connected to Mesh network and -# it has some valid neighbors +# waiting until it connected to Mesh network while True: mesh.led_state() print("%d: State %s, single %s"%(time.time(), mesh.cli('state'), mesh.cli('singleton'))) @@ -26,35 +25,21 @@ if not mesh.is_connected(): continue - neigbors = mesh.neighbors_ip() - if len(neigbors) == 0: - print('No neighbor') - continue - - print('Neighbors found: %s'%neigbors) + print('Neighbors found: %s'%mesh.neighbors()) break # create UDP socket s = socket.socket(socket.AF_LORA, socket.SOCK_RAW) myport = 1234 s.bind(myport) -pack_num = 1 -msg = "Hello World! MAC: " + MAC + ", pack: " -ip = mesh.ip() - -while True: - mesh.led_state() - print("%d: State %s, single %s, IP %s"%(time.time(), mesh.cli('state'), mesh.cli('singleton'), mesh.ip())) - - # check if topology changes, maybe RLOC IPv6 changed - new_ip = mesh.ip() - if ip != new_ip: - print("IP changed from: %s to %s"%(ip, new_ip)) - ip = new_ip +# handler responisble for receiving packets on UDP Pymesh socket +def receive_pack(): # listen for incomming packets - rcv_data, rcv_addr = s.recvfrom(128) - if len(rcv_data)>0: + while True: + rcv_data, rcv_addr = s.recvfrom(128) + if len(rcv_data) == 0: + break rcv_ip = rcv_addr[0] rcv_port = rcv_addr[1] print('Incomming %d bytes from %s (port %d)'%(len(rcv_data), rcv_ip, rcv_port)) @@ -66,11 +51,26 @@ except Exception: pass mesh.blink(7, .3) - continue + +pack_num = 1 +msg = "Hello World! MAC: " + MAC + ", pack: " +ip = mesh.ip() +mesh.mesh.rx_cb(receive_pack) + +# infinite main loop +while True: + mesh.led_state() + print("%d: State %s, single %s, IP %s"%(time.time(), mesh.cli('state'), mesh.cli('singleton'), mesh.ip())) + + # check if topology changes, maybe RLOC IPv6 changed + new_ip = mesh.ip() + if ip != new_ip: + print("IP changed from: %s to %s"%(ip, new_ip)) + ip = new_ip # update neighbors list neigbors = mesh.neighbors_ip() - print("%d Neighbors %s"%(len(neigbors), neigbors)) + print("%d neighbors, IPv6 list: %s"%(len(neigbors), neigbors)) # send PING and UDP packets to all neighbors for neighbor in neigbors: From 40a7aada9bfea2c852208a6ae6b0cbe901856f6a Mon Sep 17 00:00:00 2001 From: Emmanuel Florent Date: Mon, 18 Feb 2019 13:56:45 +0100 Subject: [PATCH 02/92] add option to alter Espressif IDF build --- pycom-docker-fw-build/Dockerfile | 5 +++-- pycom-docker-fw-build/README.md | 14 +++++++++----- pycom-docker-fw-build/assets/build | 20 +++++++++++++++++--- 3 files changed, 29 insertions(+), 10 deletions(-) diff --git a/pycom-docker-fw-build/Dockerfile b/pycom-docker-fw-build/Dockerfile index 9a63452..8c233ef 100644 --- a/pycom-docker-fw-build/Dockerfile +++ b/pycom-docker-fw-build/Dockerfile @@ -1,11 +1,12 @@ FROM ubuntu:bionic -RUN apt-get update && apt-get -y install wget git build-essential python python-serial && \ +RUN apt-get update && apt-get -y install wget git build-essential python \ + python-serial libncurses5 libncurses5-dev flex bison gperf && \ mkdir /opt/frozen/ && cd /opt && \ wget -q https://dl.espressif.com/dl/xtensa-esp32-elf-linux64-1.22.0-80-g6c4433a-5.2.0.tar.gz && \ tar -xzvf xtensa-esp32-elf-linux64-1.22.0-80-g6c4433a-5.2.0.tar.gz && \ git clone --recursive https://github.com/pycom/pycom-esp-idf.git && \ cd pycom-esp-idf && git submodule update --init && cd .. && \ - git clone --recursive https://github.com/pycom/pycom-micropython-sigfox.git + git clone --recursive https://github.com/pycom/pycom-micropython-sigfox.git ADD assets/build /usr/bin/build diff --git a/pycom-docker-fw-build/README.md b/pycom-docker-fw-build/README.md index c178072..1208248 100644 --- a/pycom-docker-fw-build/README.md +++ b/pycom-docker-fw-build/README.md @@ -11,16 +11,20 @@ where board in `WIPY LOPY SIPY GPY FIPY LOPY4` and your-project-version-code is ### example: -If you have your MicroPython project in the current directory `.` just type: - +For building against a specific revision (ex:v1.20.0.rc7 idf_v3.1) you can use: ``` -sudo docker run -v `pwd`:/opt/frozen -it goinvent/pycom-fw build LOPY4 myproject +sudo docker run -v `pwd`:/opt/frozen -it goinvent/pycom-fw build FIPY myproject v1.20.0.rc7 idf_v3.1 ``` -For building against a specific revision (ex:v1.20.0.rc0 idf_v3.1) you can use: + +### Altering Espressif IDF options: + +Have a file `sdkconfig.defaults` similar to https://github.com/pycom/pycom-esp-idf/blob/master/examples/wifi/scan/sdkconfig in your local frozen directory (ex: .), then use the same command: + ``` -sudo docker run -v `pwd`:/opt/frozen -it goinvent/pycom-fw build FIPY myproject v1.20.0.rc0 idf_v3.1 +sudo docker run -v `pwd`:/opt/frozen -it goinvent/pycom-fw build FIPY myproject v1.20.0.rc7 idf_v3.1 ``` +Beginning the build the `sdkconfig.defaults` overrides. ### note: diff --git a/pycom-docker-fw-build/assets/build b/pycom-docker-fw-build/assets/build index 8c50d73..a2300cd 100755 --- a/pycom-docker-fw-build/assets/build +++ b/pycom-docker-fw-build/assets/build @@ -51,25 +51,39 @@ function prepare_dev() { cd /opt/pycom-esp-idf git checkout $2 git submodule update --init + + if [ -f /opt/frozen/sdkconfig.defaults ] + then + cd examples/wifi/scan/ + cp /opt/frozen/sdkconfig.defaults sdkconfig.defaults + make defconfig + make bootloader + make -j4 all + echo "IDF build options:" + cat sdkconfig + fi fi } function build() { BOARD=$1 PROJECT=$2 - export PATH=$PATH:/opt/xtensa-esp32-elf/bin/ - export IDF_PATH=/opt/pycom-esp-idf board=`echo "$BOARD" | tr '[:upper:]' '[:lower:]'` cd /opt/pycom-micropython-sigfox/esp32/ && make clean BOARD=$BOARD && cd ../mpy-cross && make clean && make && cd ../esp32 && cp /opt/frozen/*.py ./frozen/Base/ && mv ./frozen/Base/main.py ./frozen/Base/_main.py - make release BOARD=$BOARD RELEASE_DIR=/tmp + make TARGET=boot COPY_IDF_LIBS=1 BOARD=$BOARD RELEASE_DIR=/tmp + cat /opt/pycom-esp-idf/examples/wifi/scan/sdkconfig.defaults + make release COPY_IDF_LIBS=1 BOARD=$BOARD RELEASE_DIR=/tmp mv /tmp/*.tar.gz /opt/frozen/$board-firmware-$PROJECT.tar.gz echo "Firmware $board-firmware-$PROJECT.tar.gz ready !" } +export PATH=$PATH:/opt/xtensa-esp32-elf/bin/ +export IDF_PATH=/opt/pycom-esp-idf + [[ $boards =~ (^|[[:space:]])$1($|[[:space:]]) ]] && echo "#goinvent " || usage From 43f4d6ad3435c0e99b1d77ab29fac668bfc0b853 Mon Sep 17 00:00:00 2001 From: iwahdan88 Date: Thu, 28 Feb 2019 15:56:12 +0100 Subject: [PATCH 03/92] Updated sqnsupgrade README --- lib/sqnsupgrade/README.md | 1 + 1 file changed, 1 insertion(+) diff --git a/lib/sqnsupgrade/README.md b/lib/sqnsupgrade/README.md index e6f5a77..81c9509 100644 --- a/lib/sqnsupgrade/README.md +++ b/lib/sqnsupgrade/README.md @@ -41,6 +41,7 @@ sqnsupgrade.run('upgdiff_38638-to-39529.dup') If you are updating the Sequans firmware on your module for the first time, please use instead the file upgdiff_33080-to-39529.dup (1.2M) from the same archive. Similar upgrade packages are available for the NB-IoT firmwares. +{% hint style="danger" %} When using differential upgrade packages (ex: upgdiff_XXXX-to-XXXX.dup) you **CANNOT** use updater.elf file {% endhint %} ## Via SD card From 55cd3e8b8433363a1933ef889887a94821e59cf6 Mon Sep 17 00:00:00 2001 From: iwahdan88 Date: Thu, 28 Feb 2019 16:25:03 +0100 Subject: [PATCH 04/92] Fixing hint style lib/sqnsupgrade README.md --- lib/sqnsupgrade/README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/lib/sqnsupgrade/README.md b/lib/sqnsupgrade/README.md index 81c9509..43dc5cb 100644 --- a/lib/sqnsupgrade/README.md +++ b/lib/sqnsupgrade/README.md @@ -41,7 +41,7 @@ sqnsupgrade.run('upgdiff_38638-to-39529.dup') If you are updating the Sequans firmware on your module for the first time, please use instead the file upgdiff_33080-to-39529.dup (1.2M) from the same archive. Similar upgrade packages are available for the NB-IoT firmwares. -{% hint style="danger" %} When using differential upgrade packages (ex: upgdiff_XXXX-to-XXXX.dup) you **CANNOT** use updater.elf file {% endhint %} +>#####When using differential upgrade packages (ex: upgdiff_XXXX-to-XXXX.dup) you **CANNOT** use updater.elf file. ## Via SD card From daa921e6801de0e010a4fb395b12ab1bce2d37ac Mon Sep 17 00:00:00 2001 From: iwahdan88 Date: Thu, 28 Feb 2019 16:27:36 +0100 Subject: [PATCH 05/92] Fixing hint style lib/sqnsupgrade README.md --- lib/sqnsupgrade/README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/lib/sqnsupgrade/README.md b/lib/sqnsupgrade/README.md index 43dc5cb..46c6880 100644 --- a/lib/sqnsupgrade/README.md +++ b/lib/sqnsupgrade/README.md @@ -41,7 +41,7 @@ sqnsupgrade.run('upgdiff_38638-to-39529.dup') If you are updating the Sequans firmware on your module for the first time, please use instead the file upgdiff_33080-to-39529.dup (1.2M) from the same archive. Similar upgrade packages are available for the NB-IoT firmwares. ->#####When using differential upgrade packages (ex: upgdiff_XXXX-to-XXXX.dup) you **CANNOT** use updater.elf file. +>When using differential upgrade packages (ex: upgdiff_XXXX-to-XXXX.dup) you **CANNOT** use updater.elf file. ## Via SD card From 5c84b4b75dcf27d501cad5a563b264fb41fb6ffa Mon Sep 17 00:00:00 2001 From: Emmanuel Florent Date: Sat, 2 Mar 2019 17:50:02 +0100 Subject: [PATCH 06/92] remove sdkconfig feature not needed --- pycom-docker-fw-build/Dockerfile | 3 +-- pycom-docker-fw-build/README.md | 14 +++++--------- pycom-docker-fw-build/assets/build | 20 +++----------------- 3 files changed, 9 insertions(+), 28 deletions(-) diff --git a/pycom-docker-fw-build/Dockerfile b/pycom-docker-fw-build/Dockerfile index 8c233ef..226afbf 100644 --- a/pycom-docker-fw-build/Dockerfile +++ b/pycom-docker-fw-build/Dockerfile @@ -1,7 +1,6 @@ FROM ubuntu:bionic -RUN apt-get update && apt-get -y install wget git build-essential python \ - python-serial libncurses5 libncurses5-dev flex bison gperf && \ +RUN apt-get update && apt-get -y install wget git build-essential python python-serial && \ mkdir /opt/frozen/ && cd /opt && \ wget -q https://dl.espressif.com/dl/xtensa-esp32-elf-linux64-1.22.0-80-g6c4433a-5.2.0.tar.gz && \ tar -xzvf xtensa-esp32-elf-linux64-1.22.0-80-g6c4433a-5.2.0.tar.gz && \ diff --git a/pycom-docker-fw-build/README.md b/pycom-docker-fw-build/README.md index 1208248..c178072 100644 --- a/pycom-docker-fw-build/README.md +++ b/pycom-docker-fw-build/README.md @@ -11,20 +11,16 @@ where board in `WIPY LOPY SIPY GPY FIPY LOPY4` and your-project-version-code is ### example: -For building against a specific revision (ex:v1.20.0.rc7 idf_v3.1) you can use: +If you have your MicroPython project in the current directory `.` just type: + ``` -sudo docker run -v `pwd`:/opt/frozen -it goinvent/pycom-fw build FIPY myproject v1.20.0.rc7 idf_v3.1 +sudo docker run -v `pwd`:/opt/frozen -it goinvent/pycom-fw build LOPY4 myproject ``` - -### Altering Espressif IDF options: - -Have a file `sdkconfig.defaults` similar to https://github.com/pycom/pycom-esp-idf/blob/master/examples/wifi/scan/sdkconfig in your local frozen directory (ex: .), then use the same command: - +For building against a specific revision (ex:v1.20.0.rc0 idf_v3.1) you can use: ``` -sudo docker run -v `pwd`:/opt/frozen -it goinvent/pycom-fw build FIPY myproject v1.20.0.rc7 idf_v3.1 +sudo docker run -v `pwd`:/opt/frozen -it goinvent/pycom-fw build FIPY myproject v1.20.0.rc0 idf_v3.1 ``` -Beginning the build the `sdkconfig.defaults` overrides. ### note: diff --git a/pycom-docker-fw-build/assets/build b/pycom-docker-fw-build/assets/build index a2300cd..8c50d73 100755 --- a/pycom-docker-fw-build/assets/build +++ b/pycom-docker-fw-build/assets/build @@ -51,39 +51,25 @@ function prepare_dev() { cd /opt/pycom-esp-idf git checkout $2 git submodule update --init - - if [ -f /opt/frozen/sdkconfig.defaults ] - then - cd examples/wifi/scan/ - cp /opt/frozen/sdkconfig.defaults sdkconfig.defaults - make defconfig - make bootloader - make -j4 all - echo "IDF build options:" - cat sdkconfig - fi fi } function build() { BOARD=$1 PROJECT=$2 + export PATH=$PATH:/opt/xtensa-esp32-elf/bin/ + export IDF_PATH=/opt/pycom-esp-idf board=`echo "$BOARD" | tr '[:upper:]' '[:lower:]'` cd /opt/pycom-micropython-sigfox/esp32/ && make clean BOARD=$BOARD && cd ../mpy-cross && make clean && make && cd ../esp32 && cp /opt/frozen/*.py ./frozen/Base/ && mv ./frozen/Base/main.py ./frozen/Base/_main.py - make TARGET=boot COPY_IDF_LIBS=1 BOARD=$BOARD RELEASE_DIR=/tmp - cat /opt/pycom-esp-idf/examples/wifi/scan/sdkconfig.defaults - make release COPY_IDF_LIBS=1 BOARD=$BOARD RELEASE_DIR=/tmp + make release BOARD=$BOARD RELEASE_DIR=/tmp mv /tmp/*.tar.gz /opt/frozen/$board-firmware-$PROJECT.tar.gz echo "Firmware $board-firmware-$PROJECT.tar.gz ready !" } -export PATH=$PATH:/opt/xtensa-esp32-elf/bin/ -export IDF_PATH=/opt/pycom-esp-idf - [[ $boards =~ (^|[[:space:]])$1($|[[:space:]]) ]] && echo "#goinvent " || usage From f6cd5e41805d520f2e5086a0a9bec7d52f91c7af Mon Sep 17 00:00:00 2001 From: Catalin Ioana Date: Mon, 4 Mar 2019 22:29:36 +0200 Subject: [PATCH 07/92] lib/lora_mesh: added Border Router example --- lib/lora_mesh/loramesh.py | 18 +++++- lib/lora_mesh/main_border_router.py | 90 +++++++++++++++++++++++++++++ 2 files changed, 105 insertions(+), 3 deletions(-) create mode 100644 lib/lora_mesh/main_border_router.py diff --git a/lib/lora_mesh/loramesh.py b/lib/lora_mesh/loramesh.py index 79a7ddc..d41fe86 100644 --- a/lib/lora_mesh/loramesh.py +++ b/lib/lora_mesh/loramesh.py @@ -39,6 +39,7 @@ def __init__(self, lora=None): self.ip_link = '' self.single = True self.state = STATE_DISABLED + self.ip_others = [] def _state_update(self): """ Returns the Thread role """ @@ -54,6 +55,7 @@ def _rloc_ip_net_addr(self): def _update_ips(self): """ Updates all the unicast IPv6 of the Thread interface """ + self.ip_others = [] ips = self.mesh.ipaddr() self.rloc16 = self.mesh.rloc() for line in ips: @@ -73,6 +75,8 @@ def _update_ips(self): elif line.startswith('fe80'): # Link-Local self.ip_link = line + else: + self.ip_others.append(line) def is_connected(self): """ Returns true if it is connected as either Child, Router or Leader """ @@ -89,10 +93,18 @@ def led_state(self): else: pycom.rgbled(self.RGBLED[self.state]) - def ip(self): + # returns the IP ML-EID or the ip having this prefix + def ip(self, prefix = None): """ Returns the IPv6 RLOC """ - self._update_ips() - return self.rloc + ip = self._update_ips() + if prefix is None: + return self.ip_eid + # we need to check al IPs from self.ip_others that may start with prefix + p = prefix.split("::")[0] + for ip in self.ip_others: + if ip.startswith(p): + return ip + return None def neighbors(self): """ Returns a list with all properties of the neighbors """ diff --git a/lib/lora_mesh/main_border_router.py b/lib/lora_mesh/main_border_router.py new file mode 100644 index 0000000..c7dc83a --- /dev/null +++ b/lib/lora_mesh/main_border_router.py @@ -0,0 +1,90 @@ +from network import LoRa +import ubinascii +from loramesh import Loramesh +import pycom +import time +import socket +import struct + +BORDER_ROUTER_HEADER_FORMAT = '!BHHHHHHHHH' + +pycom.wifi_on_boot(False) +pycom.heartbeat(False) +border_router_net = "2001:dead:beef:caff::/64" + +lora = LoRa(mode=LoRa.LORA, region=LoRa.EU868, bandwidth=LoRa.BW_125KHZ, sf=7) +#mesh = lora.Mesh() +MAC = str(ubinascii.hexlify(lora.mac()))[2:-1] +print("LoRa MAC: %s"%MAC) + +mesh = Loramesh(lora) + +# waiting until it connected to Mesh network +while True: + mesh.led_state() + print("%d: State %s, single %s"%(time.time(), mesh.cli('state'), mesh.cli('singleton'))) + time.sleep(2) + if not mesh.is_connected(): + continue + + print('Neighbors found: %s'%mesh.neighbors()) + print('IPs: %s'%mesh.mesh.ipaddr()) + print('BRs: %s'%mesh.mesh.border_router()) + break + +#add BR +if int(MAC, 16) == 8: + if len(mesh.mesh.border_router()) == 0: + mesh.mesh.border_router(border_router_net, 1) + print("Set Border Router with prefix %s"%border_router_net) + +# create UDP socket for Border Router interface +br_socket = socket.socket(socket.AF_LORA, socket.SOCK_RAW) +myport = 1234 +print("Please wait until BR gets propagated to the Leader ...") +while True: + ip = mesh.ip(border_router_net) + #ip = mesh.ip() + if ip is not None: + br_socket.bind((ip, myport)) + #s.bind(myport) + print("Created socked for (%s, %d)"%(ip, myport)) + break + time.sleep(1) + +eid_sock = socket.socket(socket.AF_LORA, socket.SOCK_RAW) +myport = 1235 +ip = mesh.ip()# ipv6 EID +if ip is not None: + eid_sock.bind((ip, myport)) + #s.bind(myport) + print("Created socked for (%s, %d)"%(ip, myport)) + +# handler responisble for receiving packets on UDP Pymesh socket +def receive_pack(dummy): + # listen for incomming packets + sock = eid_sock + while True: + rcv_data, rcv_addr = sock.recvfrom(128) + if len(rcv_data) == 0: + rcv_data, rcv_addr = br_socket.recvfrom(128) + if len(rcv_data) == 0: + break + print("Data from Border Router socket") + sock = br_socket + rcv_ip = rcv_addr[0] + rcv_port = rcv_addr[1] + print('Incomming %d bytes from %s (port %d)'%(len(rcv_data), rcv_ip, rcv_port)) + if sock == br_socket and len(rcv_data) >= struct.calcsize(BORDER_ROUTER_HEADER_FORMAT): + br_header = struct.unpack(BORDER_ROUTER_HEADER_FORMAT, rcv_data) + print("IP dest: %X:%X:%X:%X:%X:%X:%X:%X (port %d)"%( + br_header[1],br_header[2],br_header[3],br_header[4], + br_header[5],br_header[6],br_header[7],br_header[8], br_header[9])) + print(rcv_data[struct.calcsize(BORDER_ROUTER_HEADER_FORMAT):]) + else: + print(rcv_data) + if not rcv_data.startswith("ACK"): + print("Sent ACK back") + sock.sendto('ACK', (rcv_ip, rcv_port)) + +mesh.mesh.rx_cb(receive_pack, None) From a1b8b9da35a483e132a4ae0de9dbaa1cc5cb4610 Mon Sep 17 00:00:00 2001 From: iwahdan88 Date: Tue, 5 Mar 2019 11:31:34 +0100 Subject: [PATCH 08/92] Updated README.md --- lib/sqnsupgrade/README.md | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/lib/sqnsupgrade/README.md b/lib/sqnsupgrade/README.md index 46c6880..80b6548 100644 --- a/lib/sqnsupgrade/README.md +++ b/lib/sqnsupgrade/README.md @@ -4,11 +4,11 @@ _Note: This article is only related to GPy, FiPy, and G01 boards_ **Important**: When upgrading your modem for the first time, even if you have updated it in the past with the old firmware update method, you **MUST** use the "recovery" upgrade method described below. Otherwise you will risk breaking your module. -Please also use the file upgdiff_33080-to-39529.dup (1.2M) from the archive. +Please also use the file CATM1-39529.dup from the archive. ```python import sqnsupgrade -sqnsupgrade.run('upgdiff_33080-to-39529.dup', 'updater.elf') +sqnsupgrade.run('CATM1-39529.dup', 'updater.elf') ``` Please read the following instructions carefully as there are some significant changes compared to the previous updater version. @@ -18,7 +18,7 @@ Most importantly, the updater is now integrated in the latest stable firmware re Please start with the following steps: 1. Upgrade the Pycom Firmware Updater tool to latest version -2. Select Firmware Type `stable` in the communication window to upgrade to version `v1.18.1.r1` +2. Select Firmware Type `stable` in the communication window to upgrade to version `v1.18.2.r1` You can find the different versions of firmwares available here: http://software.pycom.io/downloads/sequans2.html​ @@ -38,7 +38,7 @@ To upgrade from the previous CAT-M1 firmware 38638 you can simply upload the upg import sqnsupgrade sqnsupgrade.run('upgdiff_38638-to-39529.dup') ``` -If you are updating the Sequans firmware on your module for the first time, please use instead the file upgdiff_33080-to-39529.dup (1.2M) from the same archive. +If you are updating the Sequans firmware on your module for the first time, please use the file CATM1-39529.dup along with the 'updater.elf' from the same archive. Similar upgrade packages are available for the NB-IoT firmwares. >When using differential upgrade packages (ex: upgdiff_XXXX-to-XXXX.dup) you **CANNOT** use updater.elf file. From 6544105e031bf9b1e78f8ac4170d3eb2f93a34bb Mon Sep 17 00:00:00 2001 From: Catalin Ioana Date: Fri, 8 Mar 2019 12:07:29 +0200 Subject: [PATCH 09/92] lib/lora_mesh: Updated Border Router example --- lib/lora_mesh/main_border_router.py | 103 +++++++++++++++++----------- 1 file changed, 63 insertions(+), 40 deletions(-) diff --git a/lib/lora_mesh/main_border_router.py b/lib/lora_mesh/main_border_router.py index c7dc83a..29a06d7 100644 --- a/lib/lora_mesh/main_border_router.py +++ b/lib/lora_mesh/main_border_router.py @@ -7,10 +7,11 @@ import struct BORDER_ROUTER_HEADER_FORMAT = '!BHHHHHHHHH' +BORDER_ROUTER_MAGIC_BYTE = 0xBB pycom.wifi_on_boot(False) pycom.heartbeat(False) -border_router_net = "2001:dead:beef:caff::/64" +border_router_net = "2001:dead:beef:cafe::/64" lora = LoRa(mode=LoRa.LORA, region=LoRa.EU868, bandwidth=LoRa.BW_125KHZ, sf=7) #mesh = lora.Mesh() @@ -29,62 +30,84 @@ print('Neighbors found: %s'%mesh.neighbors()) print('IPs: %s'%mesh.mesh.ipaddr()) - print('BRs: %s'%mesh.mesh.border_router()) break -#add BR +sockets = [] +#add BR for a certain MAC address +# or in a certain condition (Wifi/BLE/cellular connection to Internet) if int(MAC, 16) == 8: if len(mesh.mesh.border_router()) == 0: - mesh.mesh.border_router(border_router_net, 1) + mesh.mesh.border_router(border_router_net, 0) print("Set Border Router with prefix %s"%border_router_net) -# create UDP socket for Border Router interface -br_socket = socket.socket(socket.AF_LORA, socket.SOCK_RAW) -myport = 1234 -print("Please wait until BR gets propagated to the Leader ...") -while True: - ip = mesh.ip(border_router_net) - #ip = mesh.ip() - if ip is not None: - br_socket.bind((ip, myport)) - #s.bind(myport) - print("Created socked for (%s, %d)"%(ip, myport)) - break - time.sleep(1) - -eid_sock = socket.socket(socket.AF_LORA, socket.SOCK_RAW) + # create UDP socket for Border Router interface + br_socket = socket.socket(socket.AF_LORA, socket.SOCK_RAW) + myport = 1234 + print("Please wait until BR gets propagated to the Leader ...") + while True: + ip = mesh.ip(border_router_net) + if ip is not None: + br_socket.bind((ip, myport)) + print("Created socked for (%s, %d)"%(ip, myport)) + break + time.sleep(1) + sockets.append(br_socket) + +eid_socket = socket.socket(socket.AF_LORA, socket.SOCK_RAW) myport = 1235 -ip = mesh.ip()# ipv6 EID +#ip = mesh.ip()# ipv6 EID +ip = "::" # in this case, socket can be bind just on a port, like: eid_socket.bind(myport) if ip is not None: - eid_sock.bind((ip, myport)) - #s.bind(myport) + eid_socket.bind((ip, myport)) + #eid_socket.bind(myport) print("Created socked for (%s, %d)"%(ip, myport)) +sockets.append(eid_socket) -# handler responisble for receiving packets on UDP Pymesh socket -def receive_pack(dummy): - # listen for incomming packets - sock = eid_sock +# handler responsible for receiving packets on UDP Pymesh socket +def receive_pack(sockets): + # listen for incoming packets on all sockets while True: - rcv_data, rcv_addr = sock.recvfrom(128) - if len(rcv_data) == 0: - rcv_data, rcv_addr = br_socket.recvfrom(128) - if len(rcv_data) == 0: - break - print("Data from Border Router socket") - sock = br_socket + is_new_data = False + for sock in sockets: + # check if data received on all sockets + rcv_data, rcv_addr = sock.recvfrom(128) + if len(rcv_data) > 0: + is_new_data = True + break # out of for sock + if not is_new_data: + break # out of while True rcv_ip = rcv_addr[0] rcv_port = rcv_addr[1] - print('Incomming %d bytes from %s (port %d)'%(len(rcv_data), rcv_ip, rcv_port)) - if sock == br_socket and len(rcv_data) >= struct.calcsize(BORDER_ROUTER_HEADER_FORMAT): + print('Incoming %d bytes from %s (port %d)'%(len(rcv_data), rcv_ip, rcv_port)) + + #check if data is for the external of the Pymesh (for The Cloud) + if rcv_data[0] == BORDER_ROUTER_MAGIC_BYTE and len(rcv_data) >= struct.calcsize(BORDER_ROUTER_HEADER_FORMAT): br_header = struct.unpack(BORDER_ROUTER_HEADER_FORMAT, rcv_data) - print("IP dest: %X:%X:%X:%X:%X:%X:%X:%X (port %d)"%( + print("IP dest: %x:%x:%x:%x:%x:%x:%x:%x (port %d)"%( br_header[1],br_header[2],br_header[3],br_header[4], br_header[5],br_header[6],br_header[7],br_header[8], br_header[9])) - print(rcv_data[struct.calcsize(BORDER_ROUTER_HEADER_FORMAT):]) - else: - print(rcv_data) + rcv_data = rcv_data[struct.calcsize(BORDER_ROUTER_HEADER_FORMAT):] + + print(rcv_data) + + # send some ACK if not rcv_data.startswith("ACK"): print("Sent ACK back") sock.sendto('ACK', (rcv_ip, rcv_port)) -mesh.mesh.rx_cb(receive_pack, None) +mesh.mesh.rx_cb(receive_pack, sockets) + +print('IPs: %s'%mesh.mesh.ipaddr()) +print('BRs: %s'%mesh.mesh.border_router()) + +""" +Example of usage: +* send data to the cloud +eid_socket.sendto("01234567890123456789", ("1::2", 1235)) +* send data to the EID ip of another Node inside Pymesh +eid_socket.sendto("0123456789", ("fdde:ad00:beef:0:4623:91c8:64b2:d9ec", 1235)) +* send data to the Leader +eid_socket.sendto("0123456789", ("fdde:ad00:beef:0:0:ff:fe00:fc00", 1235)) +* send data to the RLOC of another Node inside Pymesh +eid_socket.sendto("0123456789", ("fdde:ad00:beef:0:0:ff:fe00:6800", 1235)) +""" From ef15fee19371acf664b50a5b9d2e2decaa42c207 Mon Sep 17 00:00:00 2001 From: Catalin Ioana Date: Tue, 19 Mar 2019 11:42:50 +0200 Subject: [PATCH 10/92] Added Pymesh sample scripts --- lib/pymesh/README.md | 150 +++++ lib/pymesh/ble.py | 57 ++ lib/pymesh/lib/L76GNSS.py | 94 +++ lib/pymesh/lib/gps.py | 83 +++ lib/pymesh/lib/loramesh.py | 778 ++++++++++++++++++++++ lib/pymesh/lib/mesh_interface.py | 154 +++++ lib/pymesh/lib/mesh_internal.py | 577 ++++++++++++++++ lib/pymesh/lib/meshaging.py | 151 +++++ lib/pymesh/lib/msgpack/__init__.py | 59 ++ lib/pymesh/lib/msgpack/_version.py | 1 + lib/pymesh/lib/msgpack/exceptions.py | 41 ++ lib/pymesh/lib/msgpack/fallback.py | 951 +++++++++++++++++++++++++++ lib/pymesh/lib/pycoproc.py | 292 ++++++++ lib/pymesh/lib/pytrack.py | 16 + lib/pymesh/main.py | 467 +++++++++++++ 15 files changed, 3871 insertions(+) create mode 100644 lib/pymesh/README.md create mode 100644 lib/pymesh/ble.py create mode 100644 lib/pymesh/lib/L76GNSS.py create mode 100644 lib/pymesh/lib/gps.py create mode 100644 lib/pymesh/lib/loramesh.py create mode 100644 lib/pymesh/lib/mesh_interface.py create mode 100644 lib/pymesh/lib/mesh_internal.py create mode 100644 lib/pymesh/lib/meshaging.py create mode 100644 lib/pymesh/lib/msgpack/__init__.py create mode 100644 lib/pymesh/lib/msgpack/_version.py create mode 100644 lib/pymesh/lib/msgpack/exceptions.py create mode 100644 lib/pymesh/lib/msgpack/fallback.py create mode 100644 lib/pymesh/lib/pycoproc.py create mode 100644 lib/pymesh/lib/pytrack.py create mode 100644 lib/pymesh/main.py diff --git a/lib/pymesh/README.md b/lib/pymesh/README.md new file mode 100644 index 0000000..fac8322 --- /dev/null +++ b/lib/pymesh/README.md @@ -0,0 +1,150 @@ +# Pymesh micropython code + +This project exemplifies the use of Pycom's proprietary LoRa Mesh network - **Pymesh**. +These scripts were created and tested on Lopy4 and Fipy, using the minimum release as [1.20.0.rc8](https://forum.pycom.io/topic/4499/firmware-release-candidate-v1-20-0-rc8). + +Official Pymesh docs: https://docs.pycom.io/firmwareapi/pycom/network/lora/pymesh.html + +Simple Pymesh example: https://docs.pycom.io/tutorials/lora/lora-mesh.html + +Forum Pymesh announcements: https://forum.pycom.io/topic/4449/pymesh-updates + +## Overview +These scripts were created to prototype different features of Pymesh. + +They are quite monolithic, as they were developed on par with firmware Pymesh development. Multiple improvement are foreseen to be further performed, into areas like modularity (BLE RPC is the main candidate). Also lots of code is executed in micropython threads, which have limited memory (they should be moved in the *main loop*). Maybe queues for RX/TX on Pymesh should be added, with automatic retransmissions until ACK. + +### Important features +* Start Pymesh over LoRa on 863Mhz, bandwidth 250kHz, spreading-factor 7 (check MeshInternal constructor). +* Pymesh parameters are automatically saved in NVM, so in the next restart/deepsleep, the node will try to maintain its IP addresses and connections with neighbour nodes. +* Start BLE server with name `PyGo (mac: ` + * BLE is used with an RPC protocol, packed using `msgpack` library . +* Internal CLI for controlling/triggering Pymesh features, as explained bellow. + +## Color coding LED + +The LED color represents the state of the node in the Mesh network. + + Magenta - LEADER + Green - ROUTER + White - CHILD, + Red - Searching / Detached from any Pymesh + Cyan - SINGLE LEADER (no other Router in the same Pymesh) + +## Internal CLI +``` +>mac +1 +``` +Shows LoRa MAC, this address is used as unique identifier in the Pymesh. Bellow there's a section on how to set MAC specific MAC address (useful for debugging, the MAC could be consecutive small numbers like `0x1`, `0x2`, `...`) + +``` +>mml +mesh_mac_list [1, 6, 2] +``` +Shows the list of all MAC Nodes included into Pymesh. Inquires Leader if doesn't have this info (or if too old). In about 5 sec, a new call will return the latest list. + +``` +>mp +Send pack: 0xF3 to IP fdde:ad00:beef:0:0:ff:fe00:fc00 +last_mesh_pairs [[2, 6, -87], [1, 6, -77]] +``` +Shows Mesh Pairs list, with each direct connected nodes (by their MAC address) and the averaged RSSI value. + +``` +>mni +last_mesh_node_info {1: {"ip": 2048, "l": {"lng": 5.45313, "lat": 51.45}, "a": 10, "r": 3, "nn": 1, "nei": [[6, 55296, 3, -76, 23]]}, 6: {"ip": 55296, "l": {"lng": 5.45313, "lat": 51.45}, "a": 7, "r": 3, "nn": 2, "nei": [[2, 50176, 3, -89, 28], [1, 2048, 3, -77, 23]]}, 2: {"ip": 50176, "l": {"lng": 5.45313, "lat": 51.45}, "a": 7, "r": 3, "nn": 1, "nei": [[6, 55296, 3, -86, 25]]}} +``` +Shows the properties for all the nodes in this Pymesh, together with its neighbors. + +``` +>s +(to)<1 +(txt)>>>>>>> +Added new message for 1: Hello World! +Send pack: 0x10 to IP fdde:ad00:beef:0::1 +True +>Incoming 13 bytes from fdde:ad00:beef:0:f67b:3d1e:f07:8341 (port 1234): +PACK_MESSAGE_ACK received +1945883 ================= ACK RECEIVED :) :) :) +``` +Sends text messages to another Node inside Pymesh. The messaging waits for ACK from the destination node. If not received, it's resent after minimum 15 seconds. + +*Sorry for the messy output and debug info.* + +``` +ws +(to)<1 +ACK? mac 1, id 12345 => 1 +True +``` +Shows if a message was acknowledged by the destination Node. + +``` +>rm +{'b': (b'Hello World!',), 'id': 12345, 'ts': 3301, 'from': 6} +``` +Shows the received messages. + +``` +f +(MAC to)<1 +(packsize)<500 +(filename, Enter for dog.jpg)< +... +Incoming 6 bytes from fdde:ad00:beef:0:160b:8542:2190:c864 (port 1234): +PACK_FILE_SEND_ACK received +6165 Bytes sent, time: 27 sec +Done sending 6165 B in 27 sec +``` +Sends a file already stored in `/flash` (by default `/flash/dog.jpg`), specifying to which Node and in what chunk size (it can't be bigger than 500 Bytes, limit set in firmware). + +At destination, the file is stored as `/flash/dog_rcv.jpg`. +Picture files could be stored on Lopy4/Fipy using either Pymakr (over USB) or FTP. + +*The file transfer is done naively, the file is not checked at destination, nor individual chunks right order is not verified. These should be addressed in further improvements.* + +``` +>gs +(lat)<2.3 +(lon)<4.5 +Gps: (2.3, 4.5) +``` +Sets localisation coordinates; useful where no Pytrack is used. + +``` +>gg +Gps: (2.2, 1.1) +``` +Shows latest GPS coordinates. + +``` +> rst +1 +``` +Resets the Pymesh parameters saved in NVM, and resets the Node. + +``` +> rb +``` +Resets BLE RPC buffer. + +## LoRa MAC address Set/Read + +### Set LoRa Mac +```python +fo = open("/flash/sys/lpwan.mac", "wb") +mac_write=bytes([0,0,0,0,0,0,0,20]) +fo.write(mac_write) +fo.close() +``` + +### Read LoRa MAC address +```python +>>> from network import LoRa +>>> lora = LoRa(mode=LoRa.LORA, region=LoRa.EU868, frequency = 863000000, bandwidth=LoRa.BW_125KHZ, sf=7) +>>> import ubinascii +>>> ubinascii.hexlify(lora.mac()) +b'0000000000000006' +``` diff --git a/lib/pymesh/ble.py b/lib/pymesh/ble.py new file mode 100644 index 0000000..1712176 --- /dev/null +++ b/lib/pymesh/ble.py @@ -0,0 +1,57 @@ +VERSION = "1.0.0" + +# Copyright (c) 2019, Pycom Limited. +# +# This software is licensed under the GNU GPL version 3 or any +# later version, with permitted additional terms. For more information +# see the Pycom Licence v1.0 document supplied with this file, or +# available at https://www.pycom.io/opensource/licensing + +from network import Bluetooth + +import msgpack + +class BleCommunication: + + def __init__(self, mesh_mac): + self.status = { + 'connected' : False + } + + bluetooth = Bluetooth(modem_sleep=False) + bluetooth.set_advertisement(name='PyGo (mac:' + str(mesh_mac) + ')', service_uuid=0xec00) + + bluetooth.callback(trigger=Bluetooth.CLIENT_CONNECTED | Bluetooth.CLIENT_DISCONNECTED, handler=self.conn_cb) + bluetooth.advertise(True) + + srv_rx = bluetooth.service(uuid=0xec00, isprimary=True) + self.chr_rx = srv_rx.characteristic(uuid=0xec0e, value=0) + + srv_tx = bluetooth.service(uuid=0xed00, isprimary=True) + self.chr_tx = srv_tx.characteristic(uuid=0xed0e, value=0) + + self.unpacker = None + + def conn_cb(self, bt_o): + #global ble_connected + events = bt_o.events() + if events & Bluetooth.CLIENT_CONNECTED: + self.status['connected'] = True + print("Client connected") + elif events & Bluetooth.CLIENT_DISCONNECTED: + self.status['connected'] = False + + if self.on_disconnect: + self.on_disconnect() + + print("Client disconnected") + pass + + def unpacker_set(self, unpacker): + self.unpacker = unpacker + + def close(self): + bluetooth = Bluetooth() + bluetooth.disconnect_client() + bluetooth.deinit() + pass diff --git a/lib/pymesh/lib/L76GNSS.py b/lib/pymesh/lib/L76GNSS.py new file mode 100644 index 0000000..77f2931 --- /dev/null +++ b/lib/pymesh/lib/L76GNSS.py @@ -0,0 +1,94 @@ + +# Copyright (c) 2019, Pycom Limited. +# +# This software is licensed under the GNU GPL version 3 or any +# later version, with permitted additional terms. For more information +# see the Pycom Licence v1.0 document supplied with this file, or +# available at https://www.pycom.io/opensource/licensing + +from machine import Timer +import time +import gc +import binascii + + +class L76GNSS: + + GPS_I2CADDR = const(0x10) + + def __init__(self, pytrack=None, sda='P22', scl='P21', timeout=None): + if pytrack is not None: + self.i2c = pytrack.i2c + else: + from machine import I2C + self.i2c = I2C(0, mode=I2C.MASTER, pins=(sda, scl)) + + self.chrono = Timer.Chrono() + + self.timeout = timeout + self.timeout_status = True + + self.reg = bytearray(1) + self.i2c.writeto(GPS_I2CADDR, self.reg) + + def _read(self): + self.reg = self.i2c.readfrom(GPS_I2CADDR, 64) + return self.reg + + def _convert_coords(self, gngll_s): + lat = gngll_s[1] + lat_d = (float(lat) // 100) + ((float(lat) % 100) / 60) + lon = gngll_s[3] + lon_d = (float(lon) // 100) + ((float(lon) % 100) / 60) + if gngll_s[2] == 'S': + lat_d *= -1 + if gngll_s[4] == 'W': + lon_d *= -1 + return(lat_d, lon_d) + + def coordinates(self, debug=False): + lat_d, lon_d, debug_timeout = None, None, False + if self.timeout is not None: + self.chrono.reset() + self.chrono.start() + nmea = b'' + while True: + if self.timeout is not None and self.chrono.read() >= self.timeout: + self.chrono.stop() + chrono_timeout = self.chrono.read() + self.chrono.reset() + self.timeout_status = False + debug_timeout = True + if not self.timeout_status: + gc.collect() + break + nmea += self._read().lstrip(b'\n\n').rstrip(b'\n\n') + gngll_idx = nmea.find(b'GNGLL') + gpgll_idx = nmea.find(b'GPGLL') + if gngll_idx < 0 and gpgll_idx >= 0: + gngll_idx = gpgll_idx + if gngll_idx >= 0: + gngll = nmea[gngll_idx:] + e_idx = gngll.find(b'\r\n') + if e_idx >= 0: + try: + gngll = gngll[:e_idx].decode('ascii') + gngll_s = gngll.split(',') + lat_d, lon_d = self._convert_coords(gngll_s) + except Exception: + pass + finally: + nmea = nmea[(gngll_idx + e_idx):] + gc.collect() + break + else: + gc.collect() + if len(nmea) > 410: # i suppose it can be safely changed to 82, which is longest NMEA frame + nmea = nmea[-5:] # $GNGL without last L + time.sleep(0.1) + self.timeout_status = True + if debug and debug_timeout: + print('GPS timed out after %f seconds' % (chrono_timeout)) + return(None, None) + else: + return(lat_d, lon_d) diff --git a/lib/pymesh/lib/gps.py b/lib/pymesh/lib/gps.py new file mode 100644 index 0000000..5f4c8c2 --- /dev/null +++ b/lib/pymesh/lib/gps.py @@ -0,0 +1,83 @@ + +# Copyright (c) 2019, Pycom Limited. +# +# This software is licensed under the GNU GPL version 3 or any +# later version, with permitted additional terms. For more information +# see the Pycom Licence v1.0 document supplied with this file, or +# available at https://www.pycom.io/opensource/licensing + +__version__ = '1' +""" +* initial version +""" + +import time +from pytrack import Pytrack +from L76GNSS import L76GNSS +from machine import Timer + +class Gps: + # Pycom office GPS coordinates + lat = 51.45 + lon = 5.45313 + + l76 = None + _timer = None + #is_set = False + + @staticmethod + def set_location(latitude, longitude): + dlat = str(type(latitude)) + dlon = str(type(longitude)) + if dlat == dlon == "": + Gps.lon = longitude + Gps.lat = latitude + is_set = True + else: + print("Error parsing ", latitude, longitude) + + @staticmethod + def get_location(): + return (Gps.lat, Gps.lon) + + @staticmethod + def init_static(): + is_pytrack = True + try: + py = Pytrack() + Gps.l76 = L76GNSS(py, timeout=30) + #l76.coordinates() + Gps._timer = Timer.Alarm(Gps.gps_periodic, 30, periodic=True) + print("Pytrack detected") + except: + is_pytrack = False + print("Pytrack NOT detected") + #TODO: how to check if GPS is conencted + return is_pytrack + + @staticmethod + def gps_periodic(alarm): + t0 = time.ticks_ms() + coord = Gps.l76.coordinates() + if coord[0] != None: + Gps.lat, Gps.lon = coord + print("New coord ", coord) + dt = time.ticks_ms() - t0 + print(" =====>>>> gps_periodic ", dt) + + @staticmethod + def terminate(): + if Gps._timer is not None: + Gps._timer.cancel() + pass + +""" +from pytrack import Pytrack +from L76GNSS import L76GNSS +py = Pytrack() +l76 = L76GNSS(py, timeout=30) +t0 = time.ticks_ms() +l76.coordinates() +y = time.ticks_ms() - t0 +y +""" diff --git a/lib/pymesh/lib/loramesh.py b/lib/pymesh/lib/loramesh.py new file mode 100644 index 0000000..cc139f9 --- /dev/null +++ b/lib/pymesh/lib/loramesh.py @@ -0,0 +1,778 @@ + +# Copyright (c) 2019, Pycom Limited. +# +# This software is licensed under the GNU GPL version 3 or any +# later version, with permitted additional terms. For more information +# see the Pycom Licence v1.0 document supplied with this file, or +# available at https://www.pycom.io/opensource/licensing + +from network import LoRa +import socket +import time +import utime +import ubinascii +import pycom + +from struct import * +from gps import Gps + +__version__ = '6' +""" +__version__ = '6' +* added IPv6 unicast addresses as fdde:ad00:beef:0:: +""" + +class Loramesh: + """ Class for using Lora Mesh - openThread """ + + STATE_DISABLED = const(0) + STATE_DETACHED = const(1) + STATE_CHILD = const(2) + STATE_ROUTER = const(3) + STATE_LEADER = const(4) + STATE_LEADER_SINGLE = const(5) + + # rgb LED color for each state: disabled, detached, child, router, leader and single leader + #RGBLED = [0x0A0000, 0x0A0000, 0x0A0A0A, 0x000A00, 0x00000A, 0x0A000A] + RGBLED = [0x0A0000, 0x0A0000, 0x0A0A0A, 0x000A00, 0x0A000A, 0x000A0A] + + # TTN conf mode + #RGBLED = [0x200505, 0x200505, 0x202020, 0x052005, 0x200020, 0x001818] + + # for outside/bright sun + #RGBLED = [0xFF0000, 0xFF0000, 0x808080, 0x00FF00, 0x0000FF, 0xFF00FF] + + # mesh node state string + STATE_STRING_LIST = ['Disabled','Detached', 'Child', 'Router', 'Leader'] + + # address to be used for multicasting + MULTICAST_MESH_ALL = 'ff03::1' + MULTICAST_MESH_FTD = 'ff03::2' + + MULTICAST_LINK_ALL = 'ff02::1' + MULTICAST_LINK_FTD = 'ff02::2' + + # Leader has an unicast IPv6: fdde:ad00:beef:0:0:ff:fe00:fc00 + LEADER_DEFAULT_RLOC = 'fc00' + + def __init__(self, lora): + """ Constructor """ + self.lora = lora + self.mesh = lora.Mesh() #start Mesh + + # get Lora MAC address + #self.MAC = str(ubinascii.hexlify(lora.mac()))[2:-1] + self.MAC = int(str(ubinascii.hexlify(lora.mac()))[2:-1], 16) + + #last 2 letters from MAC, as integer + self.mac_short = self.MAC & 0xFFFF #int(self.MAC[-4:], 16) + print("LoRa MAC: %s, short: %s"%(hex(self.MAC), self.mac_short)) + + self.rloc16 = 0 + self.rloc = '' + self.net_addr = '' + self.ip_eid = '' + self.ip_link = '' + self.state = STATE_DISABLED + + # a dictionary with all direct neighbors + # key is MAC for each neighbor + # value is pair (age, mac, rloc16, role, rssi) + #self.neigh_dict = {} + self.router_data = RouterData() + self.router_data.mac = self.MAC + + # a dictionary with all routers direct neighbors + # key is MAC for each router + # value is pair (age, rloc, neigh_num, (age, mac, rloc16, role, rssi)) + #self.leader_dict = {} + self.leader_data = LeaderData() + self.leader_data.mac = self.MAC + + # set of all MACS from whole current Mesh Network + self.macs = set() + self.macs_ts = -65535 # very old + + # list of all pairs (direct radio connections) inside Mesh + self.connections = list() + self.connections_ts = -65535 # very old + + # set a new unicast address + self.unique_ip_prefix = "fdde:ad00:beef:0::" + command = "ipaddr add " + self.ip_mac_unique(self.mac_short) + self.mesh.cli(command) + + def ip_mac_unique(self, mac): + ip = self.unique_ip_prefix + hex(mac & 0xFFFF)[2:] + return ip + + def update_internals(self): + self._state_update() + self._rloc16_update() + self._update_ips() + self._rloc_ip_net_addr() + + def _rloc16_update(self): + self.rloc16 = self.mesh.rloc() + return self.rloc16 + + def _update_ips(self): + """ Updates all the unicast IPv6 of the Thread interface """ + ips = self.mesh.ipaddr() + for line in ips: + if line.startswith('fd'): + # Mesh-Local unicast IPv6 + try: + addr = int(line.split(':')[-1], 16) + except Exception: + continue + if addr == self.rloc16: + # found RLOC + # RLOC IPv6 has x:x:x:x:0:ff:fe00:RLOC16 + self.rloc = line + elif ':0:ff:fe00:' not in line: + # found Mesh-Local EID + self.ip_eid = line + elif line.startswith('fe80'): + # Link-Local + self.ip_link = line + + def is_connected(self): + """ Returns true if it is connected if its Child, Router or Leader """ + connected = False + if self.state in (STATE_CHILD, STATE_ROUTER, STATE_LEADER, STATE_LEADER_SINGLE): + connected = True + return connected + + def _state_update(self): + """ Returns the Thread role """ + self.state = self.mesh.state() + if self.state < 0: + self.state = self.STATE_DISABLED + return self.state + + def _rloc_ip_net_addr(self): + """ returns the family part of RLOC IPv6, without last word (2B) """ + self.net_addr = ':'.join(self.rloc.split(':')[:-1]) + ':' + return self.net_addr + + def state_string(self): + if self.state >= len(self.STATE_STRING_LIST): + return 'none' + return self.STATE_STRING_LIST[self.state] + + def led_state(self): + """ Sets the LED according to the Thread role """ + if self.state == STATE_LEADER and self.mesh.single(): + pycom.rgbled(self.RGBLED[self.STATE_LEADER_SINGLE]) + else: + pycom.rgbled(self.RGBLED[self.state]) + + def ip(self): + """ Returns the IPv6 RLOC """ + return self.rloc + + # def parent_ip(self): + # # DEPRECATED, unused + # """ Returns the IP of the parent, if it's child node """ + # ip = None + # state = self.state + # if state == STATE_CHILD or state == STATE_ROUTER: + # try: + # ip_words = self.rloc.split(':') + # parent_rloc = int(self.lora.cli('parent').split('\r\n')[1].split(' ')[1], 16) + # ip_words[-1] = hex(parent_rloc)[2:] + # ip = ':'.join(ip_words) + # except Exception: + # pass + # return ip + + + # def neighbors_ip(self): + # # DEPRECATED, unused + # """ Returns a list with IP of the neighbors (children, parent, other routers) """ + # state = self.state + # neigh = [] + # if state == STATE_ROUTER or state == STATE_LEADER: + # ip_words = self.rloc.split(':') + # # obtain RLOC16 neighbors + # neighbors = self.lora.cli('neighbor list').split(' ') + # for rloc in neighbors: + # if len(rloc) == 0: + # continue + # try: + # ip_words[-1] = str(rloc[2:]) + # nei_ip = ':'.join(ip_words) + # neigh.append(nei_ip) + # except Exception: + # pass + # elif state == STATE_CHILD: + # neigh.append(self.parent_ip()) + # return neigh + + # def cli(self, command): + # """ Simple wrapper for OpenThread CLI """ + # return self.mesh.cli(command) + + def ipaddr(self): + """ returns all unicast IPv6 addr """ + return self.mesh.ipaddr() + + def ping(self, ip): + """ Returns ping return time, to an IP """ + res = self.cli('ping ' + str(ip)) + # '8 bytes from fdde:ad00:beef:0:0:ff:fe00:e000: icmp_seq=2 hlim=64 time=236ms\r\n' + # 'Error 6: Parse\r\n' + # no answer + ret_time = -1 + try: + ret_time = int(res.split('time=')[1].split('ms')[0]) + except Exception: + pass + return ret_time + + def blink(self, num = 3, period = .5, color = None): + """ LED blink """ + if color is None: + color = self.RGBLED[self.state] + for _ in range(num): + pycom.rgbled(0) + time.sleep(period) + pycom.rgbled(color) + time.sleep(period) + self.led_state() + + def neighbors_update(self): + """ update neigh_dict from cli:'neighbor table' """ + """ >>> print(lora.cli("neighbor table")) + | Role | RLOC16 | Age | Avg RSSI | Last RSSI |R|S|D|N| Extended MAC | + +------+--------+-----+----------+-----------+-+-+-+-+------------------+ + | C | 0x2801 | 219 | 0 | 0 |1|1|1|1| 0000000000000005 | + | R | 0x7400 | 9 | 0 | 0 |1|0|1|1| 0000000000000002 | + + """ + x = self.mesh.neighbors() + print("Neighbors Table: %s"%x) + + if x is None: + # bad read, just keep previous neigbors + return + + # clear all pre-existing neigbors + self.router_data = RouterData() + self.router_data.mac = self.MAC + self.router_data.rloc16 = self.rloc16 + self.router_data.role = self.state + self.router_data.ts = time.time() + self.router_data.coord = Gps.get_location() + + for nei_rec in x: + # nei_rec = (role=3, rloc16=10240, rssi=0, age=28, mac=5) + age = nei_rec.age + if age > 300: + continue # shouln't add neighbors too old + role = nei_rec.role + rloc16 = nei_rec.rloc16 + # maybe we shouldn't add Leader (because this info is already available at Leader) + # if rloc16 == self.leader_rloc(): + # continue + rssi = nei_rec.rssi + mac = nei_rec.mac + neighbor = NeighborData((mac, age, rloc16, role, rssi,)) + self.router_data.add_neighbor(neighbor) + #print("new Neighbor: %s"%(neighbor.to_string())) + #except: + # pass + # add own info in dict + #self.neigh_dict[self.MAC] = (0, self.rloc16, self.state, 0) + print("Neighbors: %s"%(self.router_data.to_string())) + return + + def leader_add_own_neigh(self): + """ leader adds its own neighbors in leader_dict """ + self.leader_data.add_router(self.router_data) + return + + def neighbors_pack(self): + """ packs in a struct all neighbors as (MAC, RLOC16, Role, rssi, age) """ + data = self.router_data.pack() + + return data + + def routers_neigh_update(self, data_pack): + """ unpacks the PACK_ROUTER_NEIGHBORS, adding them in leader_dict """ + # key is MAC for each router + # value is pair (age, rloc, neigh_num, (age, mac, rloc16, role, rssi)) + router = RouterData(data_pack) + self.leader_data.add_router(router) + return + + def leader_dict_cleanup(self): + """ cleanup the leader_dict for old entries """ + #print("Leader Data before cleanup: %s"%self.leader_data.to_string()) + self.leader_data.cleanup() + print("Leader Data : %s"%self.leader_data.to_string()) + + def routers_rloc_list(self, age_min, resolve_mac = None): + """ return list of all routers IPv6 RLOC16 + if mac parameter is present, then returns just the RLOC16 of that mac, if found + """ + mac_ip = None + data = self.mesh.routers() + print("Routers Table: ", data) + '''>>> print(lora.cli('router table')) + | ID | RLOC16 | Next Hop | Path Cost | LQ In | LQ Out | Age | Extended MAC | + +----+--------+----------+-----------+-------+--------+-----+------------------+ + | 12 | 0x3000 | 63 | 0 | 0 | 0 | 0 | 0000000000000002 |''' + + if data is None: + # bad read + return () + + net_addr = self.net_addr + routers_list = [] + for line in data: + # line = (mac=123456, rloc16=20480, id=20, path_cost=0, age=7) + age = line.age + if age > 300: + continue # shouldn't add/resolve very old Routers + rloc16 = line.rloc16 + + # check if it's own rloc16 + if rloc16 == self.rloc16: + continue + + if resolve_mac is not None: + if resolve_mac == line.mac: + mac_ip = rloc16 + break + + # look for this router in Leader Data + # if doesn't exist, add it to routers_list with max ts + # if it exists, just add it with its ts + last_ts = self.leader_data.get_mac_ts(line.mac) + if time.time() - last_ts < age_min: + continue # shouldn't add/resolve very "recent" Routers + + ipv6 = net_addr + hex(rloc16)[2:] + routers_list.append((last_ts, ipv6)) + + if resolve_mac is not None: + print("Mac found in Router %s"%str(mac_ip)) + return mac_ip + + # sort the list in the ascending values of timestamp + routers_list.sort() + + print("Routers list %s"%str(routers_list)) + return routers_list + + def leader_data_pack(self): + """ creates packet with all Leader data, leader_dict """ + self.leader_data.rloc16 = self.rloc16 + data = self.leader_data.pack() + return data + + def leader_data_unpack(self, data): + self.leader_data = LeaderData(data) + print("Leader Data : %s"%self.leader_data.to_string()) + return self.leader_data.ok + + def neighbor_resolve_mac(self, mac): + mac_ip = self.router_data.resolve_mac(mac) + return mac_ip + + def resolve_mac_from_leader_data(self, mac): + mac_ip = self.leader_data.resolve_mac(mac) + print("Mac %x found as IP %s"%(mac, str(mac_ip))) + return mac_ip + + def macs_get(self): + """ returns the set of the macs, hopefully it was received from Leader """ + #print("Macs: %s"%(str(self.macs))) + return (self.macs, self.macs_ts) + + def macs_set(self, data): + MACS_FMT = '!H' + field_size = calcsize(MACS_FMT) + #print("Macs pack: %s"%(str(data))) + n, = unpack(MACS_FMT, data) + #print("Macs pack(%d): %s"%(n, str(data))) + index = field_size + self.macs = set() + + for _ in range(n): + mac, = unpack(MACS_FMT, data[index:]) + self.macs.add(mac) + #print("Macs %d, %d: %s"%(index, mac, str(self.macs))) + index = index + field_size + + self.macs_ts = time.time() + pass + + def connections_get(self): + """ returns the list of all connections inside Mesh, hopefully it was received from Leader """ + return (self.connections, self.connections_ts) + + def connections_set(self, data): + CONNECTIONS_FMT = '!HHb' + field_size = calcsize(CONNECTIONS_FMT) + n, = unpack('!H', data) + index = calcsize('!H') + self.connections = list() + for _ in range(n): + #(mac1, mac2, rssi) + record = unpack(CONNECTIONS_FMT, data[index:]) + self.connections.append(record) + index = index + field_size + self.connections_ts = time.time() + pass + + def node_info_get(self, mac): + """ returns the RouterData or NeighborData for the specified mac """ + #try to find it as router or a neighbor of a router + node, role = self.leader_data.node_info_mac(mac) + if node is None: + return {} + # try to create dict for RPC answer + data = {} + data['ip'] = node.rloc16 + data['r'] = node.role + if role is self.STATE_CHILD: + data['a'] = node.age + elif role is self.STATE_ROUTER: + data['a'] = time.time() - node.ts + data['l'] = {'lng':node.coord[1], 'lat':node.coord[0]} + data['nn'] = node.neigh_num() + nei_macs = node.get_macs_set() + data['nei'] = list() + for nei_mac in nei_macs: + nei = node.dict[nei_mac] + data['nei'].append((nei.mac, nei.rloc16, nei.role, nei.rssi, nei.age)) + return data + + def node_info_set(self, data): + (role, ) = unpack('!B', data) + + if role is self.STATE_ROUTER: + router = RouterData(data[1:]) + self.leader_data.add_router(router) + print("Added as router %s"%router.to_string()) + elif role is self.STATE_CHILD: + node = NeighborData(data[1:]) + router = RouterData(node) + self.leader_data.add_router(router) + print("Added as Router-Neigh %s"%router.to_string()) + pass + +class NeighborData: + """ class for storing info about a Neighbor """ + #self.neigh_dict[mac] = (mac(2B), rloc16(2B), role(1B), rssi(signed char), age (1B)) + PACKING_FMT = '!HHBbB' + + def __init__(self, data = None): + self.mac = 0 + self.age = 0xFFFF + self.rloc16 = 0 + self.role = 0 + self.rssi = -150 + + if data is None: + return + + datatype = str(type(data)) + #print('NeighborData __init__ %s'%str(data)) + if datatype == "": + self._init_tuple(data) + elif datatype == "": + self._init_bytes(data) + #print('NeighborData done __init__') + + def _init_tuple(self, data): + #print('_init_tuple %s'%str(data)) + (self.mac, self.age, self.rloc16, self.role, self.rssi) = data + return + + def _init_bytes(self, data): + #print('NeighborData._init_bytes %s'%str(data)) + self.mac, self.rloc16, self.role, self.rssi, self.age = unpack(self.PACKING_FMT, + data[:self.pack_fmt_size()]) + return + + def pack(self): + data = pack(self.PACKING_FMT, self.mac & 0xFFFF, self.rloc16, self.role, self.rssi, self.age) + return data + + def to_string(self): + x = 'MAC 0x%X, rloc16 0x%x, role %d, rssi %i, age %d'%(self.mac, + self.rloc16, self.role, self.rssi, self.age) + return x + + def pack_fmt_size(self): + return calcsize(self.PACKING_FMT) + +class RouterData: + #self.neigh_dict[mac] = (age, rloc16, role, rssi) + + # MAC, rloc16, lat, lon, neighbors number + PACK_HEADER_FMT = '!HHffB' + + def __init__(self, data = None): + self.mac = 0 + self.rloc16 = 0 + self.role = 0 + self.ts = 0 + self.dict = {} + self.pack_index_last = 0 + self.coord = (0.0, 0.0) + + if data is None: + return + + datatype = str(type(data)) + if datatype == "": + self._init_bytes(data) + elif datatype == "": + self._init_neighbordata(data) + + + def _init_bytes(self, data_pack): + + #print('RouterData._init_bytes %s'%str(data_pack)) + index = calcsize(self.PACK_HEADER_FMT) + (self.mac, self.rloc16, lat, lon, neigh_num) = \ + unpack(self.PACK_HEADER_FMT, data_pack[: index]) + + self.coord = (lat, lon) + + self.role = Loramesh.STATE_ROUTER # forcer role as Router + + self.ts = time.time() + + for _ in range(neigh_num): + neighbor = NeighborData(data_pack[index:]) + + index = index + neighbor.pack_fmt_size() + + #(mac, rloc16, role, rssi, age) = unpack('!QHBBB', data_pack[index : index_new]) + + # don't add connection from Router to Leader (Leader already knows this) + if neighbor.rloc16 == self.rloc16: + continue + #record = record + (age, mac, rloc16, role, rssi) + self.dict[neighbor.mac] = neighbor + + self.pack_index_last = index + return + + def _init_neighbordata(self, data): + """ data is NeighborData """ + self.mac = data.mac + self.rloc16 = data.rloc16 + self.role = data.role + self.ts = time.time() + return + + def add_neighbor(self, neighbor): + self.dict[neighbor.mac] = neighbor + #print("add_neighbor type: %s"%str(type(neighbor))) + return + + def neigh_num(self): + return len(self.dict) + + def pack(self): + data = pack(self.PACK_HEADER_FMT, self.mac & 0xFFFF, \ + self.rloc16, self.coord[0], self.coord[1], len(self.dict)) + for mac, nei in self.dict.items(): + data = data + nei.pack() + return data + + def clear(self): + self.dict.clear() + return + + def to_string(self): + x = 'Router MAC 0x%X, rloc16 0x%x, coord %s, neigh_num %d, ts %d\n'\ + %(self.mac, self.rloc16, str(self.coord), len(self.dict), self.ts) + for mac, nei in self.dict.items(): + #print("type: %s, %s"%(str(type(nei)),str(nei))) + x = x + nei.to_string() + '\n' + return x + + def resolve_mac(self, mac): + """ returns the NeighborData for a specified mac """ + try: + nei = self.dict[mac] + except: + nei = None + return nei + + def as_dict(self): + dict = {} + dict['mac'] = self.mac + dict['ip'] = self.rloc16 + dict['role'] = self.role + dict['age'] = time.time() - self.ts + dict['loc'] = self.coord[0] + dict['ble'] = self.coord[1] + return dict + + def get_all_pairs(self): + lst = list() + for mac, nei in self.dict.items(): + # consider all neighbors with mac smaller than parent's + # so to not have pair (x, y) and (y, x) + if mac < self.mac: + pair = (mac, self.mac, nei.rssi) + lst = lst + [pair] + # else: + # break + return lst + + def get_macs_set(self): + """ returns set of all MACs neighbors """ + macs = set() + for mac, _ in self.dict.items(): + macs.add(mac) + return macs + +class LeaderData: + PACK_HEADER_FMT = '!QHB' + + def __init__(self, data = None): + self.routers_num = 0 + self.mac = 0 + self.rloc16 = 0 + self.ts = 0 + self.dict = {} + self.ok = False + + if data is None: + return + + datatype = str(type(data)) + if datatype == "": + self._init_bytes(data) + pass + + def _init_bytes(self, data_pack): + + #print('LeaderData._init_bytes %s'%str(data_pack)) + index = calcsize(self.PACK_HEADER_FMT) + (self.mac, self.rloc16, routers_num) = unpack(self.PACK_HEADER_FMT, data_pack[: index]) + self.ts = time.time() + + for _ in range(routers_num): + router = RouterData(data_pack[index:]) + + index = index + router.pack_index_last + + self.dict[router.mac] = router + self.ok = True + pass + + def add_router(self, router_data): + self.dict[router_data.mac] = router_data + return + + def cleanup(self): + for mac, router in self.dict.items(): + if time.time() - router.ts > 300: + print("Deleted old Router %d"%mac) + del self.dict[mac] + return + + def pack(self): + data = pack(self.PACK_HEADER_FMT, self.mac, self.rloc16, len(self.dict)) + for mac, value in self.dict.items(): + data = data + value.pack() + return data + + def to_string(self): + x = 'Leader data: MAC %X, rloc16 %x, routers_num %d\n'%(self.mac, self.rloc16, len(self.dict)) + for mac, router in self.dict.items(): + x = x + router.to_string() + return x + + def node_info_mac(self, mac): + # first check if the MAC is a known router + router = self.dict.get(mac, None) + if router is not None: + return (router, Loramesh.STATE_ROUTER) + + # next check if MAC is a neighbor of a router + child = None + for _, router in self.dict.items(): + child = router.resolve_mac(mac) + if child is not None: + return (child, Loramesh.STATE_CHILD) + return (None, None) + + def node_info_mac_pack(self, mac): + node, role = self.node_info_mac(mac) + if node is None: + print("Node is None %d"%mac) + return bytes() + # pack type: RouterData or Child (basicaly NeighborData) + data = pack('!B', role) + data = data + node.pack() + return data + + def resolve_mac(self, mac): + """ returns the RLOC of the mac, if found """ + mac_ip = None + data, _ = self.node_info_mac(mac) + if data is not None: + mac_ip = data.rloc16 + return mac_ip + + def records_num(self): + return len(self.dict) + + def as_list(self): + lst = list() + for mac, router in self.dict.items(): + record = router.as_dict() + lst = lst + [record] + return lst + + def get_mesh_connections(self): + lst = list() + for mac, router in self.dict.items(): + record = router.get_all_pairs() + lst = lst + record + return lst + + def get_connections_pack(self): + connections = self.get_mesh_connections() + print("Connections ", connections) + data = pack('!H', len(connections)) + for record in connections: + (mac1, mac2, rssi) = record + data = data + pack('!HHb', mac1, mac2, rssi) + return data + + def get_macs_set(self): + macs = set() + for mac, router in self.dict.items(): + macs.add(mac) + macs = macs.union(router.get_macs_set()) + return macs + + def get_macs_pack(self): + macs = self.get_macs_set() + data = pack('!H', len(macs)) + for mac in macs: + data = data + pack('!H', mac) + #print("Macs pack:%s"%(str(data))) + return data + + def get_mac_ts(self, mac): + # return the ts (last time Leader received pack) of a Router + router = self.dict.get(mac, None) + if router is None: + # if this mac is not a router, just return ts as the oldest + return 0 + return router.ts + diff --git a/lib/pymesh/lib/mesh_interface.py b/lib/pymesh/lib/mesh_interface.py new file mode 100644 index 0000000..ba2451a --- /dev/null +++ b/lib/pymesh/lib/mesh_interface.py @@ -0,0 +1,154 @@ + +# Copyright (c) 2019, Pycom Limited. +# +# This software is licensed under the GNU GPL version 3 or any +# later version, with permitted additional terms. For more information +# see the Pycom Licence v1.0 document supplied with this file, or +# available at https://www.pycom.io/opensource/licensing + +import time +from machine import Timer +#import _thread + +from mesh_internal import MeshInternal +#from meshaging import Meshaging + +__version__ = '3' +""" +* added file send/receive debug + +__version__ = '2' +* add sending messages + +__version__ = '1' +* initial version, lock and get_mesh_members(), get_mesh_pairs +""" + +class MeshInterface: + """ Class for Mesh interface, + all modules that uses Mesh should call only this class methods """ + + INTERVAL = const(10) + + def __init__(self, meshaging, lock): + self.lock = lock #_thread.allocate_lock() + self.meshaging = meshaging + self.mesh = MeshInternal(self.meshaging) + + self._timer = Timer.Alarm(self.periodic_cb, self.INTERVAL, periodic=True) + + # just run this ASAP + self.periodic_cb(None) + + pass + + def periodic_cb(self, alarm): + # wait lock forever + if self.lock.acquire(): + print("============ MESH THREAD >>>>>>>>>>> ") + t0 = time.ticks_ms() + + self.mesh.process() + self.mesh.process_messages() + self.lock.release() + + print(">>>>>>>>>>> DONE MESH THREAD ============ %d\n"%(time.ticks_ms() - t0)) + + pass + + def timer_kill(self): + with self.lock: + self._timer.cancel() + + def get_mesh_mac_list(self): + mac_list = list() + if self.lock.acquire(): + mac_list = list(self.mesh.get_all_macs_set()) + self.lock.release() + #print("get_mesh_mac_list: %s"%str(mac_list)) + return mac_list + + def get_mesh_pairs(self): + mesh_pairs = [] + if self.lock.acquire(): + mesh_pairs = self.mesh.get_mesh_pairs() + self.lock.release() + #print("get_mesh_pairs: %s"%str(mesh_pairs)) + return mesh_pairs + + def set_gps(self, lng, lat): + with open('/flash/gps', 'w') as fh: + fh.write('%d;%d'.format(lng, lat)) + + def is_connected(self): + is_connected = None + if self.lock.acquire(): + is_connected = self.mesh.is_connected() + self.lock.release() + return is_connected + + def ip(self): + ip = None + if self.lock.acquire(): + ip = self.mesh.ip() + self.lock.release() + return ip + + def get_node_info(self, mac): + data = {} + if self.lock.acquire(): + data = self.mesh.node_info(mac) + self.lock.release() + return data + + def send_message(self, data): + ## WARNING: is locking required for just adding + ret = False + + # check input parameters + try: + mac = int(data['to']) + payload = data['b'] + id = int(data['id']) + ts = int(data['ts']) + except: + ret = True + if ret: + # wrong input params + return False + + if self.lock.acquire(): + ret = self.meshaging.send_message(mac, payload, id, ts) + # send messages ASAP + self.mesh.process_messages() + self.lock.release() + + return ret + + def mesage_was_ack(self, mac, id): + ret = False + if self.lock.acquire(): + ret = self.meshaging.mesage_was_ack(mac, id) + self.lock.release() + #print("mesage_was_ack (%X, %d): %d"%(mac, id, ret)) + return ret + + def get_rcv_message(self): + """ returns a message that was received, {} if none is received """ + message = None + if self.lock.acquire(): + message = self.meshaging.get_rcv_message() + self.lock.release() + if message is not None: + (mac, id, ts, payload) = message + return {'from':mac, + 'b':payload, + 'id':id, + 'ts':ts} + return {} + + def send_file(self, ip, packsize, filename): + t = 0 + with self.lock: + self.mesh.send_file(ip, packsize, "/flash/" + filename) + return (t > 0) diff --git a/lib/pymesh/lib/mesh_internal.py b/lib/pymesh/lib/mesh_internal.py new file mode 100644 index 0000000..d36c039 --- /dev/null +++ b/lib/pymesh/lib/mesh_internal.py @@ -0,0 +1,577 @@ + +# Copyright (c) 2019, Pycom Limited. +# +# This software is licensed under the GNU GPL version 3 or any +# later version, with permitted additional terms. For more information +# see the Pycom Licence v1.0 document supplied with this file, or +# available at https://www.pycom.io/opensource/licensing + +from network import LoRa +import socket +import time +import utime +import ubinascii +import pycom +from machine import Timer +from struct import * + +from loramesh import Loramesh +from meshaging import Meshaging, Message + +__version__ = '6' +""" +__version__ = '6' +* refactorized file send/receive in state machines + +__version__ = '5' +* added file send/receive debug + +__version__ = '4' +* add sending messages + +__version__ = '3' +* initial version, in ble project +""" + + +class MeshInternal: + """ Class for internal protocol inside Mesh network """ + +################################################################################ + + # port number opened by all nodes for communicating neighbors + PORT_MESH_INTERNAL = const(1234) + + # each packet starts with Type(1B) and Length(2B) + PACK_HEADER_FMT = '!BH' +################################################################################ + # packs sent by Leader (received by Routers) + + # packet type for Leader to inquire Routers for their neighbors + PACK_LEADER_ASK_NEIGH = const(0x80) + + # packet type for Leader to respond to with all its data + # answer of PACK_ROUTER_ASK_LEADER_DATA + PACK_LEADER_DATA = const(0x81) + + PACK_LEADER_MACS = const(0x82) + PACK_LEADER_CONNECTIONS = const(0x83) + PACK_LEADER_MAC_DETAILS = const(0x84) +################################################################################ + # packs sent by Routers (received by Leader) + + # packet type for Routers (containing their neighbors) sent to Leader + # answer of PACK_LEADER_ASK_NEIGH + PACK_ROUTER_NEIGHBORS = const(0xF0) + + # packet type for Router to interrogate Leader data + PACK_ROUTER_ASK_LEADER_DATA = const(0xF1) + + PACK_ROUTER_ASK_MACS = const(0xF2) + PACK_ROUTER_ASK_CONNECTIONS = const(0xF3) + PACK_ROUTER_ASK_MAC_DETAILS = const(0xF4) + +################################################################################ + + # packet holding a message + PACK_MESSAGE = const(0x10) + + # packet holding a message ACK + PACK_MESSAGE_ACK = const(0x11) + +################################################################################ + + # constants for file sending + #FILE_SEND_PACKSIZE = const(750) + PACK_FILE_SEND = const(0x20) + PACK_FILE_SEND_ACK = const(0x21) + +################################################################################ + + # timeout for Leader to interrogate Routers + LEADER_INTERVAL = const(30) # seconds + +################################################################################ + + def __init__(self, meshaging, lora=None): + """ Constructor """ + if lora is None: + # lora = LoRa(mode=LoRa.LORA, region=LoRa.EU868, + # bandwidth=LoRa.BW_125KHZ, sf=7) + lora = LoRa(mode=LoRa.LORA, region=LoRa.EU868, frequency = 863000000, bandwidth=LoRa.BW_250KHZ, sf=7) + + self.lora = lora + # enable Thread interface + self.mesh = Loramesh(self.lora) + + self.MAC = self.mesh.MAC + self.sock = None + self.leader_ts = -self.LEADER_INTERVAL + self.router_ts = 0 + self.leader_data_ok = False + self.interrogate_leader_ts = -self.LEADER_INTERVAL + self.messages = meshaging + self.send_table = {} + self.rx_cb_registered = False + self.file_packsize = 0 + self.file_size = 0 + self.send_f = None + pass + + def create_socket(self): + """ create UDP socket """ + self.sock = socket.socket(socket.AF_LORA, socket.SOCK_RAW) + self.sock.bind(self.PORT_MESH_INTERNAL) + print("Socket created on port %d" % self.PORT_MESH_INTERNAL) + + def process_messages(self): + """ consuming message queue """ + for mac, mess in self.messages.dict.items(): + if mess.state == Message.MESS_STATE_IP_PENDING: + mess.ip = self.mesh.ip_mac_unique(mac) + mess.mac = self.mesh.MAC + mess.last_tx_ts = time.time() + self.send_message(mess) + mess.state = Message.MESS_STATE_SENT + elif mess.state == Message.MESS_STATE_SENT: + # try to resend + if time.time() - mess.last_tx_ts > 15: + print("Re-transmit %x %s" % (mac, mess.ip)) + mess.last_tx_ts = time.time() + self.send_message(mess) + pass + + def is_connected(self): + # if detached erase all leader_data + # return true if either child, router or leader + return self.mesh.is_connected() + + def led_state(self): + self.mesh.led_state() + + def ip(self): + return self.mesh.ip() + + # def _process_router(self): + # print("Process Router") + # # just update internal neighbor table + # self.mesh.neighbors_update() + # # add itself and neighbors in the leader data + # self.mesh.leader_add_own_neigh() + + def _process_leader(self): + print("Process Leader") + + """ + if state == self.mesh.STATE_LEADER_SINGLE: + # no neighbors routers, so nothing left to do + return + """ + # cleanup old entries + self.mesh.leader_dict_cleanup() + + if time.time() - self.leader_ts < self.LEADER_INTERVAL: + return + + # ask each router + self.leader_ts = time.time() + router_list = self.mesh.routers_rloc_list(60) + router_num = min(len(router_list), 5) + idx = 0 + for router_pair in router_list[:router_num]: + (age, router) = router_pair + self.send_pack(self.PACK_LEADER_ASK_NEIGH, '', router) + print("Leader inquire Router %s" % router) + idx = idx + 1 + if idx < router_num: + time.sleep(.5) + + def process(self): + self.mesh.update_internals() + self.mesh.led_state() + print("%d: MAC %s, State %s, Single %s" % (time.time(), + hex(self.MAC), self.mesh.state_string(), str(self.mesh.mesh.single()))) + print(self.mesh.ipaddr()) + leader = self.mesh.mesh.leader() + if leader is not None: + print("Leader: mac %s, rloc %s, net: %s" % + (hex(leader.mac), hex(leader.rloc16), hex(leader.part_id))) + if not self.mesh.is_connected(): + return # nothing to do + + # create socket + if self.sock is None: + self.create_socket() + + if not self.rx_cb_registered: + self.rx_cb_registered = True + self.mesh.mesh.rx_cb(self.receive_all_data, None) + + # update internal neighbor table + self.mesh.neighbors_update() + + self.mesh.leader_add_own_neigh() + + # if file to be sent + if self.send_f is not None: + data, ip = self.send_f.process(None) + if len(data) > 0: + self.send_pack(self.PACK_FILE_SEND, data, ip) + + if self.mesh.state == self.mesh.STATE_LEADER: + self._process_leader() + # elif self.mesh.state == self.mesh.STATE_LEADER: + # self._process_leader() + # else: + # print("No Router or Leader with neigh") + return + + # def resolve_mac(self, mac): + # """ convert a MAC address into an IP, returns None if MAC not in this Mesh """ + # mac_ip = None + # try: + # mac = int(mac) + # except: + # return None + + # # check if mac is own address ;) + # if mac == self.MAC: + # print("Resolved own address") + # mac_ip = self.mesh.rloc16 + # return mac_ip + + # # first, Maybe the mac is a neighbor + # mac_ip = self.mesh.neighbor_resolve_mac(mac) + # if mac_ip is not None: + # print("Mac %x found as neighbor %x" % (mac, mac_ip.rloc16)) + # return mac_ip.rloc16 + + # # TODO: check if mac is in router table (don't need to interrogate server) + # mac_ip = self.mesh.routers_rloc_list(300, mac) + + # if mac_ip is None: + # # interrogate Leader and wait for Leader answer + # self.require_leader_data() + + # # search for MAC + # mac_ip = self.mesh.resolve_mac_from_leader_data(mac) + + # if mac_ip is not None: + # print("Mac %x found as IP %x" % (mac, mac_ip)) + # # return results + # return mac_ip + + # def require_leader_data(self): + # # if current Node is Leader, we already have latest Leader Data + # if self.mesh.state in (self.mesh.STATE_LEADER, self.mesh.STATE_LEADER_SINGLE): + # return True + + # # maybe we have a recent Leader Data + # if (time.time() - self.interrogate_leader_ts < self.LEADER_INTERVAL and + # self.mesh.leader_data.records_num() > 0): + # return True + + # leader_ip = self.mesh._rloc_ip_net_addr() + self.mesh.LEADER_DEFAULT_RLOC + + # self.send_pack(self.PACK_ROUTER_ASK_LEADER_DATA, '', leader_ip) + # return False + + def _check_to_send(self, pack_type, ip): + send_it = True + try: + # invent some small hash, to uniquely identify packet + key = (100 * pack_type) + int(ip[-4:], 16) + except: + # just send it + #print("just send it, ? ", ip) + send_it = False + if not send_it: + return True + + now = time.time() + try: + timestamp = self.send_table[key] + if now - timestamp < 35: + send_it = False + else: + self.send_table[key] = now + except: + #print("%s not in send_table"%str(key)) + send_it = True + + if send_it: + # mark packet as sent now + self.send_table[key] = now + #print("Packet sent now") + return send_it # packet already send + + def send_pack(self, pack_type, data, ip, port=PORT_MESH_INTERNAL): + if self.sock is None: + return False + + print("Send pack: 0x%X to IP %s" % (pack_type, ip)) + + # check not to send same (packet, destination) too often + # if not self._check_to_send(pack_type, ip): + # print("NO send") + # return False + + sent_ok = True + header = pack('!BH', pack_type, len(data)) + + try: + self.sock.sendto(header + data, (ip, port)) + #self.mesh.blink(2, .1) + except Exception as ex: + print("Socket.sendto exception: {}".format(ex)) + sent_ok = False + return sent_ok + + def get_type(self, data): + + (pack_type, len1) = unpack(self.PACK_HEADER_FMT, + data[:calcsize(self.PACK_HEADER_FMT)]) + data = data[calcsize(self.PACK_HEADER_FMT):] + + len2 = len(data) + if len1 != len2: + print("PACK_HEADER lenght not ok %d %d" % (len1, len2)) + print(data) + return + + return (pack_type, data) + + def get_mesh_pairs(self): + """ Returns the list of all pairs of nodes directly connected inside mesh """ + # try to obtain if we already have them + (pairs, pairs_ts) = self.mesh.connections_get() + + if len(pairs) or time.time() - pairs_ts > 30: + # if there's none or too old, require new one from Leader + leader_ip = self.mesh._rloc_ip_net_addr() + self.mesh.LEADER_DEFAULT_RLOC + self.send_pack(self.PACK_ROUTER_ASK_CONNECTIONS, '', leader_ip) + + return pairs + + def get_all_macs_set(self): + """ Returns the set of all distinct MACs of all nodes inside mesh """ + # try to obtain if we already have them + (macs, macs_ts) = self.mesh.macs_get() + + if len(macs) == 0 or time.time() - macs_ts > 30: + # if there's none or too old, require new one from Leader + leader_ip = self.mesh._rloc_ip_net_addr() + self.mesh.LEADER_DEFAULT_RLOC + self.send_pack(self.PACK_ROUTER_ASK_MACS, '', leader_ip) + + return macs + + def node_info(self, mac): + """ Returns the info about a specified Node inside mesh """ + # try to obtain if we already have them + node_data = self.mesh.node_info_get(mac) + + if len(node_data) == 0 or node_data['a'] > 120 or \ + node_data.get('nn', None) is None: + # if there's none or too old, require new one from the node + node_ip = self.mesh.ip_mac_unique(mac) + payload = pack('!H', mac) + self.send_pack(self.PACK_ROUTER_ASK_MAC_DETAILS, + payload, node_ip) + + return node_data + + def send_message(self, message): + """ actuall sending of a message on socket """ + return self.send_pack(self.PACK_MESSAGE, message.pack(self.MAC), message.ip) + + def receive_all_data(self, arg): + """ receives all packages on socket """ + + while True: + rcv_data, rcv_addr = self.sock.recvfrom(1024) + if len(rcv_data) == 0: + break # out of while, no packet + rcv_ip = rcv_addr[0] + rcv_port = rcv_addr[1] + print('Incomming %d bytes from %s (port %d):' % + (len(rcv_data), rcv_ip, rcv_port)) + # print(rcv_data) + + # check packet type + (type, rcv_data) = self.get_type(rcv_data) + # LEADER + if type == self.PACK_ROUTER_NEIGHBORS: + print("PACK_ROUTER_NEIGHBORS received") + self.mesh.routers_neigh_update(rcv_data) + # no answer + # elif type == self.PACK_ROUTER_ASK_LEADER_DATA: + # print("PACK_ROUTER_ASK_LEADER_DATA received") + # # send answer with Leader data + # pack = self.mesh.leader_data_pack() + # self.send_pack(self.PACK_LEADER_DATA, pack, rcv_ip) + + # ROUTER + elif type == self.PACK_LEADER_ASK_NEIGH: + print("PACK_LEADER_ASK_NEIGH received") + payload = self.mesh.neighbors_pack() + #time.sleep(.2) + self.send_pack(self.PACK_ROUTER_NEIGHBORS, payload, rcv_ip) + # elif type == self.PACK_LEADER_DATA: + # print("PACK_LEADER_DATA received") + # if self.mesh.leader_data_unpack(rcv_data): + # self.interrogate_leader_ts = time.time() + + # ALL NODES + elif type == self.PACK_MESSAGE: + print("PACK_MESSAGE received") + # add new pack received + message = Message(rcv_data) + message.ip = rcv_ip + self.messages.add_rcv_message(message) + # send back ACK + self.send_pack(self.PACK_MESSAGE_ACK, message.pack_ack(self.MAC), rcv_ip) + + + elif type == self.PACK_MESSAGE_ACK: + print("PACK_MESSAGE_ACK received") + # mark message as received + self.messages.rcv_ack(rcv_data) + + elif type == self.PACK_ROUTER_ASK_MACS: + print("PACK_ROUTER_ASK_MACS received") + payload = self.mesh.leader_data.get_macs_pack() + self.send_pack(self.PACK_LEADER_MACS, payload, rcv_ip) + + elif type == self.PACK_LEADER_MACS: + print("PACK_LEADER_MACS received") + self.mesh.macs_set(rcv_data) + + elif type == self.PACK_ROUTER_ASK_CONNECTIONS: + print("PACK_ROUTER_ASK_CONNECTIONS received") + payload = self.mesh.leader_data.get_connections_pack() + self.send_pack(self.PACK_LEADER_CONNECTIONS, payload, rcv_ip) + + elif type == self.PACK_LEADER_CONNECTIONS: + print("PACK_LEADER_CONNECTIONS received") + self.mesh.connections_set(rcv_data) + + elif type == self.PACK_ROUTER_ASK_MAC_DETAILS: + print("PACK_ROUTER_ASK_MAC_DETAILS received") + (mac_req, ) = unpack('!H', rcv_data) + print(mac_req) + payload = self.mesh.leader_data.node_info_mac_pack(mac_req) + if len(payload) > 0: + self.send_pack(self.PACK_LEADER_MAC_DETAILS, + payload, rcv_ip) + else: + print("No info found about MAC %d"%mac_req) + + elif type == self.PACK_LEADER_MAC_DETAILS: + print("PACK_LEADER_MAC_DETAILS received") + self.mesh.node_info_set(rcv_data) + + elif type == self.PACK_FILE_SEND: + print("PACK_FILE_SEND received") + self.send_pack(self.PACK_FILE_SEND_ACK, '123', rcv_ip) + chunk = len(rcv_data) + self.file_size += chunk + #print("\r%7d " % size, end="") + print("size: %d, chunk %d" % (self.file_size, chunk)) + if chunk > self.file_packsize: + # started receiving a new file + self.file = open('/flash/dog_rcv.jpg', "wb") + self.file.write(rcv_data) + self.file_packsize = chunk + elif chunk < self.file_packsize: + # done receiving the file + self.file.write(rcv_data) + self.file.close() + self.file_packsize = 0 + self.file_size = 0 + else: + #middle of the file, just write data + self.file.write(rcv_data) + + elif type == self.PACK_FILE_SEND_ACK: + print("PACK_FILE_SEND_ACK received") + data, _ = self.send_f.process(rcv_data) + if len(data) > 0: + self.send_pack(self.PACK_FILE_SEND, data, rcv_ip) + + else: + print("Unknown packet, type: 0x%X" % (type)) + print(rcv_data) + + # blink some LEDs + #self.mesh.blink(3, .1) + pass + + def send_file(self, ip, packsize, filename): + self.send_f = Send_File(packsize, filename, ip) + data, _ = self.send_f.process(None) + self.send_pack(self.PACK_FILE_SEND, data, ip) + +class Send_File: + INIT = const(1) + WAIT_ACK = const(2) + DONE = const(3) + + RETRIES_MAX = const(3) + + def __init__(self, packsize, filename, ip): + self.buffer = bytearray(packsize) + self.mv = memoryview(self.buffer) + self.ip = ip + self.chunk = 0 + try: + self.file = open(filename, "rb") + except: + print("File %s can't be opened !!!!"%filename) + self.state = DONE + return + self.size = 0 + self.packsize = packsize + + self.start = time.time() + self.state = INIT + + def process(self, last_response): + if self.state == INIT: + self.chunk = self.file.readinto(self.buffer) + self.state = WAIT_ACK + self.retries = 0 + self.size = self.chunk + self.start = time.time() + + elif self.state == WAIT_ACK: + if last_response is not None: + # got ACK, send next chunk + self.chunk = self.file.readinto(self.buffer) + self.size = self.size + self.chunk + print("%d Bytes sent, time: %4d sec" % (self.size, time.time() - self.start)) + if self.chunk == 0: + self._end_transfer() + + self.retries = 0 + else: + print("No answer, so retry?") + if time.time() - self.last_ts < 5: + #if we just sent the retry, don't resend anything, still wait for answer + print("No retry, too soon") + return ('', self.ip) + self.retries = self.retries + 1 + + if self.retries > RETRIES_MAX: + self._end_transfer() + + elif self.state == DONE: + self.chunk = 0 + + self.last_ts = time.time() + return (self.mv[:self.chunk], self.ip) + + def _end_transfer(self): + self.state = DONE + print("Done sending %d B in %s sec"%(self.size, time.time() - self.start)) + self.file.close() + \ No newline at end of file diff --git a/lib/pymesh/lib/meshaging.py b/lib/pymesh/lib/meshaging.py new file mode 100644 index 0000000..ed2d47f --- /dev/null +++ b/lib/pymesh/lib/meshaging.py @@ -0,0 +1,151 @@ + +# Copyright (c) 2019, Pycom Limited. +# +# This software is licensed under the GNU GPL version 3 or any +# later version, with permitted additional terms. For more information +# see the Pycom Licence v1.0 document supplied with this file, or +# available at https://www.pycom.io/opensource/licensing + +import time +from struct import * + +__version__ = '1' +""" +* initial version +""" + + +class Meshaging: + """ class that manages sending/receiving messages inside Mesh network """ + + PROCESS_INTERVAL = const(5) + + on_rcv_message = None + on_rcv_ack = None + + def __init__(self, lock): + #self.mesh = mesh + self.lock = lock + self.dict = {} + self.rcv_dict = {} + self.rcv_mess_new = None + # maybe a periodic process function + #self._timer = Timer.Alarm(self.periodic_cb, self.INTERVAL, periodic=True) + + def send_message(self, mac, payload, id, ts): + """ send a new message """ + already = None + try: + already = self.dict[mac] + except: + pass + if already is not None: + print('old message deleted for %X' % mac) + message = Message((mac, payload, id, ts)) + self.dict[mac] = message + print("Added new message for %X: %s" % (mac, payload)) + return True + + def add_rcv_message(self, message): + """ received a new message """ + message.ts = time.time() + self.rcv_dict[message.mac] = message + self.rcv_mess_new = message + + if self.on_rcv_message: + self.on_rcv_message(message) + + return True + + def rcv_ack(self, data): + """ just received an ACK for a previously sent message """ + message = Message() + message.unpack_ack(data) + + # check if message was really in send buffer + if message.mac in self.dict: + self.dict[message.mac].state = Message.MESS_STATE_ACK + + if self.on_rcv_ack: + self.on_rcv_ack(message) + else: + print(message.mac, self.dict) + pass + + def mesage_was_ack(self, mac, id): + """ return True/False if a message was ACK """ + done = False + try: + message = self.dict[mac] + if id == message.id: + if message.state == Message.MESS_STATE_ACK: + done = True + except: + pass + print("ACK? mac %x, id %d => %d" % (mac, id, done)) + return done + + def get_rcv_message(self): + """ returns first message that was received, None if none received """ + if len(self.rcv_dict) == 0: + return None + + # get first message + (mac, mess) = list(self.rcv_dict.items())[0] + return (mac, mess.id, mess.ts, mess.payload) + + +class Message: + + PACK_MESSAGE = '!QHH' # mac, id, payload size, and payload(char[]) + PACK_MESSAGE_ACK = '!QH' # mac, id + + #MESS_STATE_INIT = const(1) + MESS_STATE_IP_PENDING = const(2) + MESS_STATE_SENT = const(3) + MESS_STATE_ACK = const(4) + + """ class that holds a message and its properties """ + + def __init__(self, data=None): + self.local_ts = time.time() + self.ip = None + self.last_tx_ts = 0 + + if data is None: + return + + datatype = str(type(data)) + if datatype == "": + self._init_tuple(data) + elif datatype == "": + self._init_bytes(data) + # limit id to 2B + self.id = self.id & 0xFFFF + + def _init_tuple(self, data): + # (mac, payload, id, ts) + (self.mac, self.payload, self.id, self.ts) = data + self.state = MESS_STATE_IP_PENDING + return + + def _init_bytes(self, data): + #print('NeighborData._init_bytes %s'%str(data)) + self.mac, self.id, n = unpack(self.PACK_MESSAGE, data) + self.payload = unpack('!' + str(n) + 's', + data[calcsize(self.PACK_MESSAGE):]) + return + + def pack(self, sender_mac): + n = len(self.payload) + data = pack(self.PACK_MESSAGE, sender_mac, self.id, n) + data = data + pack('!' + str(n) + 's', self.payload) + return data + + def pack_ack(self, sender_mac): + data = pack(self.PACK_MESSAGE_ACK, sender_mac, self.id) + return data + + def unpack_ack(self, data): + (self.mac, self.id) = unpack(self.PACK_MESSAGE_ACK, data) + pass diff --git a/lib/pymesh/lib/msgpack/__init__.py b/lib/pymesh/lib/msgpack/__init__.py new file mode 100644 index 0000000..96a710a --- /dev/null +++ b/lib/pymesh/lib/msgpack/__init__.py @@ -0,0 +1,59 @@ +# coding: utf-8 +from msgpack._version import version +from msgpack.exceptions import * + +from ucollections import namedtuple + + +class ExtType(namedtuple('ExtType', 'code data')): + """ExtType represents ext type in msgpack.""" + def __new__(cls, code, data): + if not isinstance(code, int): + raise TypeError("code must be int") + if not isinstance(data, bytes): + raise TypeError("data must be bytes") + if not 0 <= code <= 127: + raise ValueError("code must be 0~127") + return super(ExtType, cls).__new__(cls, code, data) + + +import os +from msgpack.fallback import Packer, unpackb, Unpacker + + +def pack(o, stream, **kwargs): + """ + Pack object `o` and write it to `stream` + + See :class:`Packer` for options. + """ + packer = Packer(**kwargs) + stream.write(packer.pack(o)) + + +def packb(o, **kwargs): + """ + Pack object `o` and return packed bytes + + See :class:`Packer` for options. + """ + return Packer(**kwargs).pack(o) + + +def unpack(stream, **kwargs): + """ + Unpack an object from `stream`. + + Raises `ExtraData` when `stream` contains extra bytes. + See :class:`Unpacker` for options. + """ + data = stream.read() + return unpackb(data, **kwargs) + + +# alias for compatibility to simplejson/marshal/pickle. +load = unpack +loads = unpackb + +dump = pack +dumps = packb diff --git a/lib/pymesh/lib/msgpack/_version.py b/lib/pymesh/lib/msgpack/_version.py new file mode 100644 index 0000000..d28f0de --- /dev/null +++ b/lib/pymesh/lib/msgpack/_version.py @@ -0,0 +1 @@ +version = (0, 5, 6) diff --git a/lib/pymesh/lib/msgpack/exceptions.py b/lib/pymesh/lib/msgpack/exceptions.py new file mode 100644 index 0000000..11c1598 --- /dev/null +++ b/lib/pymesh/lib/msgpack/exceptions.py @@ -0,0 +1,41 @@ +class UnpackException(Exception): + """Deprecated. Use Exception instead to catch all exception during unpacking.""" + + +class BufferFull(UnpackException): + pass + + +class OutOfData(UnpackException): + pass + + +class UnpackValueError(UnpackException): + """Deprecated. Use ValueError instead.""" + + +class ExtraData(UnpackValueError): + def __init__(self, unpacked, extra): + self.unpacked = unpacked + self.extra = extra + + def __str__(self): + return "unpack(b) received extra data." + + +class PackException(Exception): + """Deprecated. Use Exception instead to catch all exception during packing.""" + + +class PackValueError(PackException): + """PackValueError is raised when type of input data is supported but it's value is unsupported. + + Deprecated. Use ValueError instead. + """ + + +class PackOverflowError(PackValueError): + """PackOverflowError is raised when integer value is out of range of msgpack support [-2**31, 2**32). + + Deprecated. Use ValueError instead. + """ diff --git a/lib/pymesh/lib/msgpack/fallback.py b/lib/pymesh/lib/msgpack/fallback.py new file mode 100644 index 0000000..c4f0543 --- /dev/null +++ b/lib/pymesh/lib/msgpack/fallback.py @@ -0,0 +1,951 @@ +"""Fallback pure Python implementation of msgpack""" + +import sys +import struct + +if sys.version_info[0] == 3: + PY3 = True + int_types = int + Unicode = str + xrange = range + def dict_iteritems(d): + return d.items() +else: + PY3 = False + int_types = (int, long) + Unicode = unicode + def dict_iteritems(d): + return d.iteritems() + +from uio import BytesIO as StringIO +newlist_hint = lambda size: [] + + +from msgpack.exceptions import ( + BufferFull, + OutOfData, + UnpackValueError, + PackValueError, + PackOverflowError, + ExtraData) + +from msgpack import ExtType + + +EX_SKIP = 0 +EX_CONSTRUCT = 1 +EX_READ_ARRAY_HEADER = 2 +EX_READ_MAP_HEADER = 3 + +TYPE_IMMEDIATE = 0 +TYPE_ARRAY = 1 +TYPE_MAP = 2 +TYPE_RAW = 3 +TYPE_BIN = 4 +TYPE_EXT = 5 + +DEFAULT_RECURSE_LIMIT = 511 + + +def _check_type_strict(obj, t, type=type, tuple=tuple): + if type(t) is tuple: + return type(obj) in t + else: + return type(obj) is t + + +def _get_data_from_buffer(obj): + try: + view = memoryview(obj) + except TypeError: + # try to use legacy buffer protocol if 2.7, otherwise re-raise + if not PY3: + view = memoryview(buffer(obj)) + print("using old buffer interface to unpack %s; " + "this leads to unpacking errors if slicing is used and " + "will be removed in a future version" % type(obj), + RuntimeWarning) + else: + view = memoryview(bytes([obj])) + # raise + + # @TODO: not sure what is is for... + # if view.itemsize != 1: + # raise ValueError("cannot unpack from multi-byte object") + return view + + +def unpack(stream, **kwargs): + print( + "Direct calling implementation's unpack() is deprecated, Use msgpack.unpack() or unpackb() instead.", + PendingDeprecationWarning) + data = stream.read() + return unpackb(data, **kwargs) + + +def unpackb(packed, **kwargs): + """ + Unpack an object from `packed`. + + Raises `ExtraData` when `packed` contains extra bytes. + See :class:`Unpacker` for options. + """ + unpacker = Unpacker(None, **kwargs) + unpacker.feed(packed) + try: + ret = unpacker._unpack() + except OutOfData: + raise UnpackValueError("Data is not enough.") + if unpacker._got_extradata(): + raise ExtraData(ret, unpacker._get_extradata()) + return ret + + +class Unpacker(object): + """Streaming unpacker. + + arguments: + + :param file_like: + File-like object having `.read(n)` method. + If specified, unpacker reads serialized data from it and :meth:`feed()` is not usable. + + :param int read_size: + Used as `file_like.read(read_size)`. (default: `min(16*1024, max_buffer_size)`) + + :param bool use_list: + If true, unpack msgpack array to Python list. + Otherwise, unpack to Python tuple. (default: True) + + :param bool raw: + If true, unpack msgpack raw to Python bytes (default). + Otherwise, unpack to Python str (or unicode on Python 2) by decoding + with UTF-8 encoding (recommended). + Currently, the default is true, but it will be changed to false in + near future. So you must specify it explicitly for keeping backward + compatibility. + + *encoding* option which is deprecated overrides this option. + + :param callable object_hook: + When specified, it should be callable. + Unpacker calls it with a dict argument after unpacking msgpack map. + (See also simplejson) + + :param callable object_pairs_hook: + When specified, it should be callable. + Unpacker calls it with a list of key-value pairs after unpacking msgpack map. + (See also simplejson) + + :param str encoding: + Encoding used for decoding msgpack raw. + If it is None (default), msgpack raw is deserialized to Python bytes. + + :param str unicode_errors: + (deprecated) Used for decoding msgpack raw with *encoding*. + (default: `'strict'`) + + :param int max_buffer_size: + Limits size of data waiting unpacked. 0 means system's INT_MAX (default). + Raises `BufferFull` exception when it is insufficient. + You should set this parameter when unpacking data from untrusted source. + + :param int max_str_len: + Limits max length of str. (default: 2**31-1) + + :param int max_bin_len: + Limits max length of bin. (default: 2**31-1) + + :param int max_array_len: + Limits max length of array. (default: 2**31-1) + + :param int max_map_len: + Limits max length of map. (default: 2**31-1) + + + example of streaming deserialize from file-like object:: + + unpacker = Unpacker(file_like, raw=False) + for o in unpacker: + process(o) + + example of streaming deserialize from socket:: + + unpacker = Unpacker(raw=False) + while True: + buf = sock.recv(1024**2) + if not buf: + break + unpacker.feed(buf) + for o in unpacker: + process(o) + """ + + def __init__(self, file_like=None, read_size=0, use_list=True, raw=True, + object_hook=None, object_pairs_hook=None, list_hook=None, + encoding=None, unicode_errors=None, max_buffer_size=0, + ext_hook=ExtType, + max_str_len=2147483647, # 2**32-1 + max_bin_len=2147483647, + max_array_len=2147483647, + max_map_len=2147483647, + max_ext_len=2147483647): + + if encoding is not None: + print( + "encoding is deprecated, Use raw=False instead.", + PendingDeprecationWarning) + + if unicode_errors is None: + unicode_errors = 'strict' + + if file_like is None: + self._feeding = True + else: + if not callable(file_like.read): + raise TypeError("`file_like.read` must be callable") + self.file_like = file_like + self._feeding = False + + #: array of bytes fed. + self._buffer = bytearray() + #: Which position we currently reads + self._buff_i = 0 + + # When Unpacker is used as an iterable, between the calls to next(), + # the buffer is not "consumed" completely, for efficiency sake. + # Instead, it is done sloppily. To make sure we raise BufferFull at + # the correct moments, we have to keep track of how sloppy we were. + # Furthermore, when the buffer is incomplete (that is: in the case + # we raise an OutOfData) we need to rollback the buffer to the correct + # state, which _buf_checkpoint records. + self._buf_checkpoint = 0 + + self._max_buffer_size = max_buffer_size or 2**31-1 + if read_size > self._max_buffer_size: + raise ValueError("read_size must be smaller than max_buffer_size") + self._read_size = read_size or min(self._max_buffer_size, 16*1024) + self._raw = bool(raw) + self._encoding = encoding + self._unicode_errors = unicode_errors + self._use_list = use_list + self._list_hook = list_hook + self._object_hook = object_hook + self._object_pairs_hook = object_pairs_hook + self._ext_hook = ext_hook + self._max_str_len = max_str_len + self._max_bin_len = max_bin_len + self._max_array_len = max_array_len + self._max_map_len = max_map_len + self._max_ext_len = max_ext_len + self._stream_offset = 0 + + if list_hook is not None and not callable(list_hook): + raise TypeError('`list_hook` is not callable') + if object_hook is not None and not callable(object_hook): + raise TypeError('`object_hook` is not callable') + if object_pairs_hook is not None and not callable(object_pairs_hook): + raise TypeError('`object_pairs_hook` is not callable') + if object_hook is not None and object_pairs_hook is not None: + raise TypeError("object_pairs_hook and object_hook are mutually " + "exclusive") + if not callable(ext_hook): + raise TypeError("`ext_hook` is not callable") + + def feed(self, next_bytes): + assert self._feeding + view = _get_data_from_buffer(next_bytes) + if (len(self._buffer) - self._buff_i + len(view) > self._max_buffer_size): + raise BufferFull + + # Strip buffer before checkpoint before reading file. + if self._buf_checkpoint > 0: + # del self._buffer[:self._buf_checkpoint] + self._buffer = self._buffer[self._buf_checkpoint:] + + + self._buff_i -= self._buf_checkpoint + self._buf_checkpoint = 0 + + self._buffer += view + + def _consume(self): + """ Gets rid of the used parts of the buffer. """ + self._stream_offset += self._buff_i - self._buf_checkpoint + self._buf_checkpoint = self._buff_i + + def _got_extradata(self): + return self._buff_i < len(self._buffer) + + def _get_extradata(self): + return self._buffer[self._buff_i:] + + def read_bytes(self, n): + return self._read(n) + + def _read(self, n): + # (int) -> bytearray + self._reserve(n) + i = self._buff_i + self._buff_i = i+n + return self._buffer[i:i+n] + + def _reserve(self, n): + remain_bytes = len(self._buffer) - self._buff_i - n + + # Fast path: buffer has n bytes already + if remain_bytes >= 0: + return + + if self._feeding: + self._buff_i = self._buf_checkpoint + raise OutOfData + + # Strip buffer before checkpoint before reading file. + if self._buf_checkpoint > 0: + del self._buffer[:self._buf_checkpoint] + self._buff_i -= self._buf_checkpoint + self._buf_checkpoint = 0 + + # Read from file + remain_bytes = -remain_bytes + while remain_bytes > 0: + to_read_bytes = max(self._read_size, remain_bytes) + read_data = self.file_like.read(to_read_bytes) + if not read_data: + break + assert isinstance(read_data, bytes) + self._buffer += read_data + remain_bytes -= len(read_data) + + if len(self._buffer) < n + self._buff_i: + self._buff_i = 0 # rollback + raise OutOfData + + def _read_header(self, execute=EX_CONSTRUCT): + typ = TYPE_IMMEDIATE + n = 0 + obj = None + self._reserve(1) + b = self._buffer[self._buff_i] + self._buff_i += 1 + if b & 0b10000000 == 0: + obj = b + elif b & 0b11100000 == 0b11100000: + obj = -1 - (b ^ 0xff) + elif b & 0b11100000 == 0b10100000: + n = b & 0b00011111 + typ = TYPE_RAW + if n > self._max_str_len: + raise UnpackValueError("%s exceeds max_str_len(%s)", n, self._max_str_len) + obj = self._read(n) + elif b & 0b11110000 == 0b10010000: + n = b & 0b00001111 + typ = TYPE_ARRAY + if n > self._max_array_len: + raise UnpackValueError("%s exceeds max_array_len(%s)", n, self._max_array_len) + elif b & 0b11110000 == 0b10000000: + n = b & 0b00001111 + typ = TYPE_MAP + if n > self._max_map_len: + raise UnpackValueError("%s exceeds max_map_len(%s)", n, self._max_map_len) + elif b == 0xc0: + obj = None + elif b == 0xc2: + obj = False + elif b == 0xc3: + obj = True + elif b == 0xc4: + typ = TYPE_BIN + self._reserve(1) + n = self._buffer[self._buff_i] + self._buff_i += 1 + if n > self._max_bin_len: + raise UnpackValueError("%s exceeds max_bin_len(%s)" % (n, self._max_bin_len)) + obj = self._read(n) + elif b == 0xc5: + typ = TYPE_BIN + self._reserve(2) + n = struct.unpack_from(">H", self._buffer, self._buff_i)[0] + self._buff_i += 2 + if n > self._max_bin_len: + raise UnpackValueError("%s exceeds max_bin_len(%s)" % (n, self._max_bin_len)) + obj = self._read(n) + elif b == 0xc6: + typ = TYPE_BIN + self._reserve(4) + n = struct.unpack_from(">I", self._buffer, self._buff_i)[0] + self._buff_i += 4 + if n > self._max_bin_len: + raise UnpackValueError("%s exceeds max_bin_len(%s)" % (n, self._max_bin_len)) + obj = self._read(n) + elif b == 0xc7: # ext 8 + typ = TYPE_EXT + self._reserve(2) + L, n = struct.unpack_from('Bb', self._buffer, self._buff_i) + self._buff_i += 2 + if L > self._max_ext_len: + raise UnpackValueError("%s exceeds max_ext_len(%s)" % (L, self._max_ext_len)) + obj = self._read(L) + elif b == 0xc8: # ext 16 + typ = TYPE_EXT + self._reserve(3) + L, n = struct.unpack_from('>Hb', self._buffer, self._buff_i) + self._buff_i += 3 + if L > self._max_ext_len: + raise UnpackValueError("%s exceeds max_ext_len(%s)" % (L, self._max_ext_len)) + obj = self._read(L) + elif b == 0xc9: # ext 32 + typ = TYPE_EXT + self._reserve(5) + L, n = struct.unpack_from('>Ib', self._buffer, self._buff_i) + self._buff_i += 5 + if L > self._max_ext_len: + raise UnpackValueError("%s exceeds max_ext_len(%s)" % (L, self._max_ext_len)) + obj = self._read(L) + elif b == 0xca: + self._reserve(4) + obj = struct.unpack_from(">f", self._buffer, self._buff_i)[0] + self._buff_i += 4 + elif b == 0xcb: + self._reserve(8) + obj = struct.unpack_from(">d", self._buffer, self._buff_i)[0] + self._buff_i += 8 + elif b == 0xcc: + self._reserve(1) + obj = self._buffer[self._buff_i] + self._buff_i += 1 + elif b == 0xcd: + self._reserve(2) + obj = struct.unpack_from(">H", self._buffer, self._buff_i)[0] + self._buff_i += 2 + elif b == 0xce: + self._reserve(4) + obj = struct.unpack_from(">I", self._buffer, self._buff_i)[0] + self._buff_i += 4 + elif b == 0xcf: + self._reserve(8) + obj = struct.unpack_from(">Q", self._buffer, self._buff_i)[0] + self._buff_i += 8 + elif b == 0xd0: + self._reserve(1) + obj = struct.unpack_from("b", self._buffer, self._buff_i)[0] + self._buff_i += 1 + elif b == 0xd1: + self._reserve(2) + obj = struct.unpack_from(">h", self._buffer, self._buff_i)[0] + self._buff_i += 2 + elif b == 0xd2: + self._reserve(4) + obj = struct.unpack_from(">i", self._buffer, self._buff_i)[0] + self._buff_i += 4 + elif b == 0xd3: + self._reserve(8) + obj = struct.unpack_from(">q", self._buffer, self._buff_i)[0] + self._buff_i += 8 + elif b == 0xd4: # fixext 1 + typ = TYPE_EXT + if self._max_ext_len < 1: + raise UnpackValueError("%s exceeds max_ext_len(%s)" % (1, self._max_ext_len)) + self._reserve(2) + n, obj = struct.unpack_from("b1s", self._buffer, self._buff_i) + self._buff_i += 2 + elif b == 0xd5: # fixext 2 + typ = TYPE_EXT + if self._max_ext_len < 2: + raise UnpackValueError("%s exceeds max_ext_len(%s)" % (2, self._max_ext_len)) + self._reserve(3) + n, obj = struct.unpack_from("b2s", self._buffer, self._buff_i) + self._buff_i += 3 + elif b == 0xd6: # fixext 4 + typ = TYPE_EXT + if self._max_ext_len < 4: + raise UnpackValueError("%s exceeds max_ext_len(%s)" % (4, self._max_ext_len)) + self._reserve(5) + n, obj = struct.unpack_from("b4s", self._buffer, self._buff_i) + self._buff_i += 5 + elif b == 0xd7: # fixext 8 + typ = TYPE_EXT + if self._max_ext_len < 8: + raise UnpackValueError("%s exceeds max_ext_len(%s)" % (8, self._max_ext_len)) + self._reserve(9) + n, obj = struct.unpack_from("b8s", self._buffer, self._buff_i) + self._buff_i += 9 + elif b == 0xd8: # fixext 16 + typ = TYPE_EXT + if self._max_ext_len < 16: + raise UnpackValueError("%s exceeds max_ext_len(%s)" % (16, self._max_ext_len)) + self._reserve(17) + n, obj = struct.unpack_from("b16s", self._buffer, self._buff_i) + self._buff_i += 17 + elif b == 0xd9: + typ = TYPE_RAW + self._reserve(1) + n = self._buffer[self._buff_i] + self._buff_i += 1 + if n > self._max_str_len: + raise UnpackValueError("%s exceeds max_str_len(%s)", n, self._max_str_len) + obj = self._read(n) + elif b == 0xda: + typ = TYPE_RAW + self._reserve(2) + n, = struct.unpack_from(">H", self._buffer, self._buff_i) + self._buff_i += 2 + if n > self._max_str_len: + raise UnpackValueError("%s exceeds max_str_len(%s)", n, self._max_str_len) + obj = self._read(n) + elif b == 0xdb: + typ = TYPE_RAW + self._reserve(4) + n, = struct.unpack_from(">I", self._buffer, self._buff_i) + self._buff_i += 4 + if n > self._max_str_len: + raise UnpackValueError("%s exceeds max_str_len(%s)", n, self._max_str_len) + obj = self._read(n) + elif b == 0xdc: + typ = TYPE_ARRAY + self._reserve(2) + n, = struct.unpack_from(">H", self._buffer, self._buff_i) + self._buff_i += 2 + if n > self._max_array_len: + raise UnpackValueError("%s exceeds max_array_len(%s)", n, self._max_array_len) + elif b == 0xdd: + typ = TYPE_ARRAY + self._reserve(4) + n, = struct.unpack_from(">I", self._buffer, self._buff_i) + self._buff_i += 4 + if n > self._max_array_len: + raise UnpackValueError("%s exceeds max_array_len(%s)", n, self._max_array_len) + elif b == 0xde: + self._reserve(2) + n, = struct.unpack_from(">H", self._buffer, self._buff_i) + self._buff_i += 2 + if n > self._max_map_len: + raise UnpackValueError("%s exceeds max_map_len(%s)", n, self._max_map_len) + typ = TYPE_MAP + elif b == 0xdf: + self._reserve(4) + n, = struct.unpack_from(">I", self._buffer, self._buff_i) + self._buff_i += 4 + if n > self._max_map_len: + raise UnpackValueError("%s exceeds max_map_len(%s)", n, self._max_map_len) + typ = TYPE_MAP + else: + raise UnpackValueError("Unknown header: 0x%x" % b) + return typ, n, obj + + def _unpack(self, execute=EX_CONSTRUCT): + typ, n, obj = self._read_header(execute) + + if execute == EX_READ_ARRAY_HEADER: + if typ != TYPE_ARRAY: + raise UnpackValueError("Expected array") + return n + if execute == EX_READ_MAP_HEADER: + if typ != TYPE_MAP: + raise UnpackValueError("Expected map") + return n + # TODO should we eliminate the recursion? + if typ == TYPE_ARRAY: + if execute == EX_SKIP: + for i in xrange(n): + # TODO check whether we need to call `list_hook` + self._unpack(EX_SKIP) + return + ret = newlist_hint(n) + for i in xrange(n): + ret.append(self._unpack(EX_CONSTRUCT)) + if self._list_hook is not None: + ret = self._list_hook(ret) + # TODO is the interaction between `list_hook` and `use_list` ok? + return ret if self._use_list else tuple(ret) + if typ == TYPE_MAP: + if execute == EX_SKIP: + for i in xrange(n): + # TODO check whether we need to call hooks + self._unpack(EX_SKIP) + self._unpack(EX_SKIP) + return + if self._object_pairs_hook is not None: + ret = self._object_pairs_hook( + (self._unpack(EX_CONSTRUCT), + self._unpack(EX_CONSTRUCT)) + for _ in xrange(n)) + else: + ret = {} + for _ in xrange(n): + key = self._unpack(EX_CONSTRUCT) + ret[key] = self._unpack(EX_CONSTRUCT) + if self._object_hook is not None: + ret = self._object_hook(ret) + return ret + if execute == EX_SKIP: + return + if typ == TYPE_RAW: + if self._encoding is not None: + obj = obj.decode(self._encoding, self._unicode_errors) + elif self._raw: + obj = bytes(obj) + else: + obj = struct.pack("b"*len(obj),*obj).decode('utf8') + # obj = obj.decode('utf_8') + # obj = obj + return obj + if typ == TYPE_EXT: + return self._ext_hook(n, bytes(obj)) + if typ == TYPE_BIN: + return bytes(obj) + assert typ == TYPE_IMMEDIATE + return obj + + def __iter__(self): + return self + + def __next__(self): + try: + ret = self._unpack(EX_CONSTRUCT) + self._consume() + return ret + except OutOfData: + self._consume() + raise StopIteration + + next = __next__ + + def skip(self, write_bytes=None): + self._unpack(EX_SKIP) + if write_bytes is not None: + print("`write_bytes` option is deprecated. Use `.tell()` instead.", DeprecationWarning) + write_bytes(self._buffer[self._buf_checkpoint:self._buff_i]) + self._consume() + + def unpack(self, write_bytes=None): + ret = self._unpack(EX_CONSTRUCT) + if write_bytes is not None: + print("`write_bytes` option is deprecated. Use `.tell()` instead.", DeprecationWarning) + write_bytes(self._buffer[self._buf_checkpoint:self._buff_i]) + self._consume() + return ret + + def read_array_header(self, write_bytes=None): + ret = self._unpack(EX_READ_ARRAY_HEADER) + if write_bytes is not None: + print("`write_bytes` option is deprecated. Use `.tell()` instead.", DeprecationWarning) + write_bytes(self._buffer[self._buf_checkpoint:self._buff_i]) + self._consume() + return ret + + def read_map_header(self, write_bytes=None): + ret = self._unpack(EX_READ_MAP_HEADER) + if write_bytes is not None: + print("`write_bytes` option is deprecated. Use `.tell()` instead.", DeprecationWarning) + write_bytes(self._buffer[self._buf_checkpoint:self._buff_i]) + self._consume() + return ret + + def tell(self): + return self._stream_offset + + +class Packer(object): + """ + MessagePack Packer + + usage: + + packer = Packer() + astream.write(packer.pack(a)) + astream.write(packer.pack(b)) + + Packer's constructor has some keyword arguments: + + :param callable default: + Convert user type to builtin type that Packer supports. + See also simplejson's document. + + :param bool use_single_float: + Use single precision float type for float. (default: False) + + :param bool autoreset: + Reset buffer after each pack and return its content as `bytes`. (default: True). + If set this to false, use `bytes()` to get content and `.reset()` to clear buffer. + + :param bool use_bin_type: + Use bin type introduced in msgpack spec 2.0 for bytes. + It also enables str8 type for unicode. + + :param bool strict_types: + If set to true, types will be checked to be exact. Derived classes + from serializeable types will not be serialized and will be + treated as unsupported type and forwarded to default. + Additionally tuples will not be serialized as lists. + This is useful when trying to implement accurate serialization + for python types. + + :param str encoding: + (deprecated) Convert unicode to bytes with this encoding. (default: 'utf-8') + + :param str unicode_errors: + Error handler for encoding unicode. (default: 'strict') + """ + def __init__(self, default=None, encoding=None, unicode_errors=None, + use_single_float=False, autoreset=True, use_bin_type=False, + strict_types=False): + if encoding is None: + encoding = 'utf_8' + else: + print( + "encoding is deprecated, Use raw=False instead.", + PendingDeprecationWarning) + + if unicode_errors is None: + unicode_errors = 'strict' + + self._strict_types = strict_types + self._use_float = use_single_float + self._autoreset = autoreset + self._use_bin_type = use_bin_type + self._encoding = encoding + self._unicode_errors = unicode_errors + self._buffer = StringIO() + if default is not None: + if not callable(default): + raise TypeError("default must be callable") + self._default = default + + def _pack(self, obj, nest_limit=DEFAULT_RECURSE_LIMIT, + check=isinstance, check_type_strict=_check_type_strict): + default_used = False + if self._strict_types: + check = check_type_strict + list_types = list + else: + list_types = (list, tuple) + while True: + if nest_limit < 0: + raise PackValueError("recursion limit exceeded") + if obj is None: + return self._buffer.write(b"\xc0") + if check(obj, bool): + if obj: + return self._buffer.write(b"\xc3") + return self._buffer.write(b"\xc2") + if check(obj, int_types): + if 0 <= obj < 0x80: + return self._buffer.write(struct.pack("B", obj)) + if -0x20 <= obj < 0: + return self._buffer.write(struct.pack("b", obj)) + if 0x80 <= obj <= 0xff: + return self._buffer.write(struct.pack("BB", 0xcc, obj)) + if -0x80 <= obj < 0: + return self._buffer.write(struct.pack(">Bb", 0xd0, obj)) + if 0xff < obj <= 0xffff: + return self._buffer.write(struct.pack(">BH", 0xcd, obj)) + if -0x8000 <= obj < -0x80: + return self._buffer.write(struct.pack(">Bh", 0xd1, obj)) + if 0xffff < obj <= 0xffffffff: + return self._buffer.write(struct.pack(">BI", 0xce, obj)) + if -0x80000000 <= obj < -0x8000: + return self._buffer.write(struct.pack(">Bi", 0xd2, obj)) + if 0xffffffff < obj <= 0xffffffffffffffff: + return self._buffer.write(struct.pack(">BQ", 0xcf, obj)) + if -0x8000000000000000 <= obj < -0x80000000: + return self._buffer.write(struct.pack(">Bq", 0xd3, obj)) + if not default_used and self._default is not None: + obj = self._default(obj) + default_used = True + continue + raise PackOverflowError("Integer value out of range") + if check(obj, (bytes, bytearray)): + n = len(obj) + if n >= 2**32: + raise PackValueError("%s is too large" % type(obj).__name__) + self._pack_bin_header(n) + return self._buffer.write(obj) + if check(obj, Unicode): + if self._encoding is None: + raise TypeError( + "Can't encode unicode string: " + "no encoding is specified") + obj = obj.encode(self._encoding, self._unicode_errors) + n = len(obj) + if n >= 2**32: + raise PackValueError("String is too large") + self._pack_raw_header(n) + return self._buffer.write(obj) + if check(obj, memoryview): + n = len(obj) * obj.itemsize + if n >= 2**32: + raise PackValueError("Memoryview is too large") + self._pack_bin_header(n) + return self._buffer.write(obj) + if check(obj, float): + if self._use_float: + return self._buffer.write(struct.pack(">Bf", 0xca, obj)) + return self._buffer.write(struct.pack(">Bd", 0xcb, obj)) + if check(obj, ExtType): + code = obj.code + data = obj.data + assert isinstance(code, int) + assert isinstance(data, bytes) + L = len(data) + if L == 1: + self._buffer.write(b'\xd4') + elif L == 2: + self._buffer.write(b'\xd5') + elif L == 4: + self._buffer.write(b'\xd6') + elif L == 8: + self._buffer.write(b'\xd7') + elif L == 16: + self._buffer.write(b'\xd8') + elif L <= 0xff: + self._buffer.write(struct.pack(">BB", 0xc7, L)) + elif L <= 0xffff: + self._buffer.write(struct.pack(">BH", 0xc8, L)) + else: + self._buffer.write(struct.pack(">BI", 0xc9, L)) + self._buffer.write(struct.pack("b", code)) + self._buffer.write(data) + return + if check(obj, list_types): + n = len(obj) + self._pack_array_header(n) + for i in xrange(n): + self._pack(obj[i], nest_limit - 1) + return + if check(obj, dict): + return self._pack_map_pairs(len(obj), dict_iteritems(obj), + nest_limit - 1) + if not default_used and self._default is not None: + obj = self._default(obj) + default_used = 1 + continue + raise TypeError("Cannot serialize %r" % (obj, )) + + def pack(self, obj): + try: + self._pack(obj) + except: + self._buffer = StringIO() # force reset + raise + ret = self._buffer.getvalue() + if self._autoreset: + self._buffer = StringIO() + elif USING_STRINGBUILDER: + self._buffer = StringIO(ret) + return ret + + def pack_map_pairs(self, pairs): + self._pack_map_pairs(len(pairs), pairs) + ret = self._buffer.getvalue() + if self._autoreset: + self._buffer = StringIO() + elif USING_STRINGBUILDER: + self._buffer = StringIO(ret) + return ret + + def pack_array_header(self, n): + if n >= 2**32: + raise PackValueError + self._pack_array_header(n) + ret = self._buffer.getvalue() + if self._autoreset: + self._buffer = StringIO() + elif USING_STRINGBUILDER: + self._buffer = StringIO(ret) + return ret + + def pack_map_header(self, n): + if n >= 2**32: + raise PackValueError + self._pack_map_header(n) + ret = self._buffer.getvalue() + if self._autoreset: + self._buffer = StringIO() + elif USING_STRINGBUILDER: + self._buffer = StringIO(ret) + return ret + + def pack_ext_type(self, typecode, data): + if not isinstance(typecode, int): + raise TypeError("typecode must have int type.") + if not 0 <= typecode <= 127: + raise ValueError("typecode should be 0-127") + if not isinstance(data, bytes): + raise TypeError("data must have bytes type") + L = len(data) + if L > 0xffffffff: + raise PackValueError("Too large data") + if L == 1: + self._buffer.write(b'\xd4') + elif L == 2: + self._buffer.write(b'\xd5') + elif L == 4: + self._buffer.write(b'\xd6') + elif L == 8: + self._buffer.write(b'\xd7') + elif L == 16: + self._buffer.write(b'\xd8') + elif L <= 0xff: + self._buffer.write(b'\xc7' + struct.pack('B', L)) + elif L <= 0xffff: + self._buffer.write(b'\xc8' + struct.pack('>H', L)) + else: + self._buffer.write(b'\xc9' + struct.pack('>I', L)) + self._buffer.write(struct.pack('B', typecode)) + self._buffer.write(data) + + def _pack_array_header(self, n): + if n <= 0x0f: + return self._buffer.write(struct.pack('B', 0x90 + n)) + if n <= 0xffff: + return self._buffer.write(struct.pack(">BH", 0xdc, n)) + if n <= 0xffffffff: + return self._buffer.write(struct.pack(">BI", 0xdd, n)) + raise PackValueError("Array is too large") + + def _pack_map_header(self, n): + if n <= 0x0f: + return self._buffer.write(struct.pack('B', 0x80 + n)) + if n <= 0xffff: + return self._buffer.write(struct.pack(">BH", 0xde, n)) + if n <= 0xffffffff: + return self._buffer.write(struct.pack(">BI", 0xdf, n)) + raise PackValueError("Dict is too large") + + def _pack_map_pairs(self, n, pairs, nest_limit=DEFAULT_RECURSE_LIMIT): + self._pack_map_header(n) + for (k, v) in pairs: + self._pack(k, nest_limit - 1) + self._pack(v, nest_limit - 1) + + def _pack_raw_header(self, n): + if n <= 0x1f: + self._buffer.write(struct.pack('B', 0xa0 + n)) + elif self._use_bin_type and n <= 0xff: + self._buffer.write(struct.pack('>BB', 0xd9, n)) + elif n <= 0xffff: + self._buffer.write(struct.pack(">BH", 0xda, n)) + elif n <= 0xffffffff: + self._buffer.write(struct.pack(">BI", 0xdb, n)) + else: + raise PackValueError('Raw is too large') + + def _pack_bin_header(self, n): + if not self._use_bin_type: + return self._pack_raw_header(n) + elif n <= 0xff: + return self._buffer.write(struct.pack('>BB', 0xc4, n)) + elif n <= 0xffff: + return self._buffer.write(struct.pack(">BH", 0xc5, n)) + elif n <= 0xffffffff: + return self._buffer.write(struct.pack(">BI", 0xc6, n)) + else: + raise PackValueError('Bin is too large') + + def bytes(self): + return self._buffer.getvalue() + + def reset(self): + self._buffer = StringIO() diff --git a/lib/pymesh/lib/pycoproc.py b/lib/pymesh/lib/pycoproc.py new file mode 100644 index 0000000..f06c46a --- /dev/null +++ b/lib/pymesh/lib/pycoproc.py @@ -0,0 +1,292 @@ + +# Copyright (c) 2019, Pycom Limited. +# +# This software is licensed under the GNU GPL version 3 or any +# later version, with permitted additional terms. For more information +# see the Pycom Licence v1.0 document supplied with this file, or +# available at https://www.pycom.io/opensource/licensing + +from machine import Pin +from machine import I2C +import time +import pycom + +__version__ = '0.0.2' + +""" PIC MCU wakeup reason types """ +WAKE_REASON_ACCELEROMETER = 1 +WAKE_REASON_PUSH_BUTTON = 2 +WAKE_REASON_TIMER = 4 +WAKE_REASON_INT_PIN = 8 + +class Pycoproc: + """ class for handling the interaction with PIC MCU """ + + I2C_SLAVE_ADDR = const(8) + + CMD_PEEK = const(0x0) + CMD_POKE = const(0x01) + CMD_MAGIC = const(0x02) + CMD_HW_VER = const(0x10) + CMD_FW_VER = const(0x11) + CMD_PROD_ID = const(0x12) + CMD_SETUP_SLEEP = const(0x20) + CMD_GO_SLEEP = const(0x21) + CMD_CALIBRATE = const(0x22) + CMD_BAUD_CHANGE = const(0x30) + CMD_DFU = const(0x31) + + REG_CMD = const(0) + REG_ADDRL = const(1) + REG_ADDRH = const(2) + REG_AND = const(3) + REG_OR = const(4) + REG_XOR = const(5) + + ANSELA_ADDR = const(0x18C) + ANSELB_ADDR = const(0x18D) + ANSELC_ADDR = const(0x18E) + + ADCON0_ADDR = const(0x9D) + ADCON1_ADDR = const(0x9E) + + IOCAP_ADDR = const(0x391) + IOCAN_ADDR = const(0x392) + + INTCON_ADDR = const(0x0B) + OPTION_REG_ADDR = const(0x95) + + _ADCON0_CHS_POSN = const(0x02) + _ADCON0_ADON_MASK = const(0x01) + _ADCON1_ADCS_POSN = const(0x04) + _ADCON0_GO_nDONE_MASK = const(0x02) + + ADRESL_ADDR = const(0x09B) + ADRESH_ADDR = const(0x09C) + + TRISC_ADDR = const(0x08E) + + PORTA_ADDR = const(0x00C) + PORTC_ADDR = const(0x00E) + + WPUA_ADDR = const(0x20C) + + WAKE_REASON_ADDR = const(0x064C) + MEMORY_BANK_ADDR = const(0x0620) + + PCON_ADDR = const(0x096) + STATUS_ADDR = const(0x083) + + EXP_RTC_PERIOD = const(7000) + + def __init__(self, i2c=None, sda='P22', scl='P21'): + if i2c is not None: + self.i2c = i2c + else: + self.i2c = I2C(0, mode=I2C.MASTER, pins=(sda, scl)) + + self.sda = sda + self.scl = scl + self.clk_cal_factor = 1 + self.reg = bytearray(6) + self.wake_int = False + self.wake_int_pin = False + self.wake_int_pin_rising_edge = True + + # Make sure we are inserted into the + # correct board and can talk to the PIC + try: + self.read_fw_version() + except Exception as e: + raise Exception('Board not detected: {}'.format(e)) + + # init the ADC for the battery measurements + self.poke_memory(ANSELC_ADDR, 1 << 2) + self.poke_memory(ADCON0_ADDR, (0x06 << _ADCON0_CHS_POSN) | _ADCON0_ADON_MASK) + self.poke_memory(ADCON1_ADDR, (0x06 << _ADCON1_ADCS_POSN)) + # enable the pull-up on RA3 + self.poke_memory(WPUA_ADDR, (1 << 3)) + # make RC5 an input + self.set_bits_in_memory(TRISC_ADDR, 1 << 5) + # set RC6 and RC7 as outputs and enable power to the sensors and the GPS + self.mask_bits_in_memory(TRISC_ADDR, ~(1 << 6)) + self.mask_bits_in_memory(TRISC_ADDR, ~(1 << 7)) + + if self.read_fw_version() < 6: + raise ValueError('Firmware out of date') + + + def _write(self, data, wait=True): + self.i2c.writeto(I2C_SLAVE_ADDR, data) + if wait: + self._wait() + + def _read(self, size): + return self.i2c.readfrom(I2C_SLAVE_ADDR, size + 1)[1:(size + 1)] + + def _wait(self): + count = 0 + time.sleep_us(10) + while self.i2c.readfrom(I2C_SLAVE_ADDR, 1)[0] != 0xFF: + time.sleep_us(100) + count += 1 + if (count > 500): # timeout after 50ms + raise Exception('Board timeout') + + def _send_cmd(self, cmd): + self._write(bytes([cmd])) + + def read_hw_version(self): + self._send_cmd(CMD_HW_VER) + d = self._read(2) + return (d[1] << 8) + d[0] + + def read_fw_version(self): + self._send_cmd(CMD_FW_VER) + d = self._read(2) + return (d[1] << 8) + d[0] + + def read_product_id(self): + self._send_cmd(CMD_PROD_ID) + d = self._read(2) + return (d[1] << 8) + d[0] + + def peek_memory(self, addr): + self._write(bytes([CMD_PEEK, addr & 0xFF, (addr >> 8) & 0xFF])) + return self._read(1)[0] + + def poke_memory(self, addr, value): + self._write(bytes([CMD_POKE, addr & 0xFF, (addr >> 8) & 0xFF, value & 0xFF])) + + def magic_write_read(self, addr, _and=0xFF, _or=0, _xor=0): + self._write(bytes([CMD_MAGIC, addr & 0xFF, (addr >> 8) & 0xFF, _and & 0xFF, _or & 0xFF, _xor & 0xFF])) + return self._read(1)[0] + + def toggle_bits_in_memory(self, addr, bits): + self.magic_write_read(addr, _xor=bits) + + def mask_bits_in_memory(self, addr, mask): + self.magic_write_read(addr, _and=mask) + + def set_bits_in_memory(self, addr, bits): + self.magic_write_read(addr, _or=bits) + + def get_wake_reason(self): + """ returns the wakeup reason, a value out of constants WAKE_REASON_* """ + return self.peek_memory(WAKE_REASON_ADDR) + + def get_sleep_remaining(self): + """ returns the remaining time from sleep, as an interrupt (wakeup source) might have triggered """ + c3 = self.peek_memory(WAKE_REASON_ADDR + 3) + c2 = self.peek_memory(WAKE_REASON_ADDR + 2) + c1 = self.peek_memory(WAKE_REASON_ADDR + 1) + time_device_s = (c3 << 16) + (c2 << 8) + c1 + # this time is from PIC internal oscilator, so it needs to be adjusted with the calibration value + try: + self.calibrate_rtc() + except Exception: + pass + time_s = int((time_device_s / self.clk_cal_factor) + 0.5) # 0.5 used for round + return time_s + + def setup_sleep(self, time_s): + try: + self.calibrate_rtc() + except Exception: + pass + time_s = int((time_s * self.clk_cal_factor) + 0.5) # round to the nearest integer + if time_s >= 2**(8*3): + time_s = 2**(8*3)-1 + self._write(bytes([CMD_SETUP_SLEEP, time_s & 0xFF, (time_s >> 8) & 0xFF, (time_s >> 16) & 0xFF])) + + def go_to_sleep(self, gps=True): + # enable or disable back-up power to the GPS receiver + if gps: + self.set_bits_in_memory(PORTC_ADDR, 1 << 7) + else: + self.mask_bits_in_memory(PORTC_ADDR, ~(1 << 7)) + # disable the ADC + self.poke_memory(ADCON0_ADDR, 0) + + if self.wake_int: + # Don't touch RA3, RA5 or RC1 so that interrupt wake-up works + self.poke_memory(ANSELA_ADDR, ~((1 << 3) | (1 << 5))) + self.poke_memory(ANSELC_ADDR, ~((1 << 6) | (1 << 7) | (1 << 1))) + else: + # disable power to the accelerometer, and don't touch RA3 so that button wake-up works + self.poke_memory(ANSELA_ADDR, ~(1 << 3)) + self.poke_memory(ANSELC_ADDR, ~(1 << 7)) + + self.poke_memory(ANSELB_ADDR, 0xFF) + + # check if INT pin (PIC RC1), should be used for wakeup + if self.wake_int_pin: + if self.wake_int_pin_rising_edge: + self.set_bits_in_memory(OPTION_REG_ADDR, 1 << 6) # rising edge of INT pin + else: + self.mask_bits_in_memory(OPTION_REG_ADDR, ~(1 << 6)) # falling edge of INT pin + self.mask_bits_in_memory(ANSELC_ADDR, ~(1 << 1)) # disable analog function for RC1 pin + self.set_bits_in_memory(TRISC_ADDR, 1 << 1) # make RC1 input pin + self.mask_bits_in_memory(INTCON_ADDR, ~(1 << 1)) # clear INTF + self.set_bits_in_memory(INTCON_ADDR, 1 << 4) # enable interrupt; set INTE) + + self._write(bytes([CMD_GO_SLEEP]), wait=False) + # kill the run pin + Pin('P3', mode=Pin.OUT, value=0) + + def calibrate_rtc(self): + # the 1.024 factor is because the PIC LF operates at 31 KHz + # WDT has a frequency divider to generate 1 ms + # and then there is a binary prescaler, e.g., 1, 2, 4 ... 512, 1024 ms + # hence the need for the constant + self._write(bytes([CMD_CALIBRATE]), wait=False) + self.i2c.deinit() + Pin('P21', mode=Pin.IN) + pulses = pycom.pulses_get('P21', 100) + self.i2c.init(mode=I2C.MASTER, pins=(self.sda, self.scl)) + idx = 0 + for i in range(len(pulses)): + if pulses[i][1] > EXP_RTC_PERIOD: + idx = i + break + try: + period = pulses[idx][1] - pulses[(idx - 1)][1] + except: + period = 0 + if period > 0: + self.clk_cal_factor = (EXP_RTC_PERIOD / period) * (1000 / 1024) + if self.clk_cal_factor > 1.25 or self.clk_cal_factor < 0.75: + self.clk_cal_factor = 1 + + def button_pressed(self): + button = self.peek_memory(PORTA_ADDR) & (1 << 3) + return not button + + def read_battery_voltage(self): + self.set_bits_in_memory(ADCON0_ADDR, _ADCON0_GO_nDONE_MASK) + time.sleep_us(50) + while self.peek_memory(ADCON0_ADDR) & _ADCON0_GO_nDONE_MASK: + time.sleep_us(100) + adc_val = (self.peek_memory(ADRESH_ADDR) << 2) + (self.peek_memory(ADRESL_ADDR) >> 6) + return (((adc_val * 3.3 * 280) / 1023) / 180) + 0.01 # add 10mV to compensate for the drop in the FET + + def setup_int_wake_up(self, rising, falling): + """ rising is for activity detection, falling for inactivity """ + wake_int = False + if rising: + self.set_bits_in_memory(IOCAP_ADDR, 1 << 5) + wake_int = True + else: + self.mask_bits_in_memory(IOCAP_ADDR, ~(1 << 5)) + + if falling: + self.set_bits_in_memory(IOCAN_ADDR, 1 << 5) + wake_int = True + else: + self.mask_bits_in_memory(IOCAN_ADDR, ~(1 << 5)) + self.wake_int = wake_int + + def setup_int_pin_wake_up(self, rising_edge = True): + """ allows wakeup to be made by the INT pin (PIC -RC1) """ + self.wake_int_pin = True + self.wake_int_pin_rising_edge = rising_edge diff --git a/lib/pymesh/lib/pytrack.py b/lib/pymesh/lib/pytrack.py new file mode 100644 index 0000000..929c225 --- /dev/null +++ b/lib/pymesh/lib/pytrack.py @@ -0,0 +1,16 @@ + +# Copyright (c) 2019, Pycom Limited. +# +# This software is licensed under the GNU GPL version 3 or any +# later version, with permitted additional terms. For more information +# see the Pycom Licence v1.0 document supplied with this file, or +# available at https://www.pycom.io/opensource/licensing + +from pycoproc import Pycoproc + +__version__ = '1.4.0' + +class Pytrack(Pycoproc): + + def __init__(self, i2c=None, sda='P22', scl='P21'): + Pycoproc.__init__(self, i2c, sda, scl) diff --git a/lib/pymesh/main.py b/lib/pymesh/main.py new file mode 100644 index 0000000..fed324b --- /dev/null +++ b/lib/pymesh/main.py @@ -0,0 +1,467 @@ +VERSION = "1.0.0" + +# Copyright (c) 2019, Pycom Limited. +# +# This software is licensed under the GNU GPL version 3 or any +# later version, with permitted additional terms. For more information +# see the Pycom Licence v1.0 document supplied with this file, or +# available at https://www.pycom.io/opensource/licensing + +import time +import json +import pycom +import _thread +import sys +import select +import _thread +import machine +from machine import Timer +from machine import Pin + +from network import Bluetooth + +import msgpack +import ble + +from mesh_interface import MeshInterface +from gps import Gps + +from meshaging import Meshaging + +class RXWorker: + def __init__(self, ble_comm): + self.HEADSIZE = 20 + self.INTERVAL = .1 + self.q = b'' + self.ble_comm = ble_comm + self.chr = ble_comm.chr_rx + self.call_cnt = 0 + + # mutex for self.q usage + self.q_lock = _thread.allocate_lock() + + self._timer = Timer.Alarm(self.interval_cb, self.INTERVAL, periodic=True) + + def put(self, bytes): + with self.q_lock: + self.q = self.q + bytes + + # chunks = [ self.q[i:i+self.HEADSIZE] for i in range(0, len(self.q), self.HEADSIZE) ] + # for chunk in chunks: + # self.chr.value(chunk) + + #self.chr.value('') + #self.chr.value(bytes) + + def interval_cb(self, alarm): + self.call_cnt = self.call_cnt + 1 + if self.call_cnt >= 10: + # print('%d: rx worker interval.... %d'%(time.time(), len(self.q))) + self.call_cnt = 0 + + if len(self.q) == 0: + return + + if not self.ble_comm.status['connected']: + #unpacker._buffer = bytearray([]) + with self.q_lock: + self.q = b'' + return + try: + with self.q_lock: + head = self.q[:self.HEADSIZE] + tail = self.q[self.HEADSIZE:] + self.q = tail + #print('consuming {}, {}', head, tail) + + if self.chr and len(head) > 0: + self.chr.value(head) + #print('sending', list(head)) + except: + pass + + def timer_kill(self): + self._timer.cancel() + +class TXWorker: + def __init__(self, ble_comm): + self.ble_comm = ble_comm + self.chr = ble_comm.chr_tx + self.last_value = b'' + self.on_write = lambda value : 1 + + self.chr.callback(trigger=Bluetooth.CHAR_WRITE_EVENT | Bluetooth.CHAR_READ_EVENT, handler=self.cb_handler) + + def cb_handler(self, chr): + events = chr.events() + if events & Bluetooth.CHAR_WRITE_EVENT: + self.last_value = chr.value() + #print("Write request with value = {}".format(self.last_value)) + + self.on_write(self.last_value) + else: + #print('Read request on char 1') + return self.last_value + +class RPCHandler: + def __init__(self, rx_worker, tx_worker, mesh, ble_comm): + self.rx_worker = rx_worker + self.tx_worker = tx_worker + self.mesh = mesh + self.unpacker = msgpack.Unpacker(raw=False) + self.error = False + ble_comm.unpacker_set(self.unpacker) + + tx_worker.on_write = self.feed + + def feed(self, message): + #print('feeding (rpc)', message) + self.unpacker.feed(message) + try: + [self.resolve(x) for x in self.unpacker] + except Exception as e: + sys.print_exception(e) + print('error in unpacking... reset') + self.unpacker._buffer = bytearray() + self.error = True + + + + def resolve(self, obj): + #print('resolving: ', obj) + obj = list(obj) + type = obj[0] + + if type == 'call': + uuid = obj[1] + fn_name = obj[2] + args = obj[3] + fn = getattr(self, fn_name) + + if not fn: + print('fn {} not defined'.format(fn_name)) + return + + try: + result = fn(*args) + result = json.loads(json.dumps(result)) + print('calling RPC: {} - {}'.format(fn_name, result)) + + message = msgpack.packb(['call_result', uuid, result]) + except Exception as e: + print('could not send result: {}'.format(result)) + return + + + #print('result', result) + #print('message', message) + self.rx_worker.put(message) + + def demo_fn(self, *args): + global last_mesh_pairs, last_mesh_members + return { + 'p': last_mesh_pairs, + 'm': last_mesh_members, + } + + def demo_echo_fn(self, *args): + return args + + def mesh_is_connected(self): + # True if Node is connected to Mesh; False otherwise + is_connected = self.mesh.is_connected() + return is_connected + + def mesh_ip(self): + # get IP RLOC16 in string + ip = self.mesh.ip() + return ip + + def set_gps(self, lng, lat): + print('settings gps!') + Gps.set_location(lat, lng) + # with open('/flash/gps', 'w') as fh: + # fh.write('{};{}'.format(lng, lat)) + + def get_mesh_mac_list(self): + """ returns list of distinct MAC address that are in this mesh network + [mac1, mac2, mac 3] """ + last_mesh_mac_list = self.mesh.get_mesh_mac_list() + return last_mesh_mac_list + + def get_mesh_pairs(self, *args): + """ returns list of pairs that is a mesh connection + [ + ('mac1', 'mac2', rssi), + ('mac1', 'mac3', rssi), + #... + ] """ + last_mesh_pairs = self.mesh.get_mesh_pairs() + return last_mesh_pairs + + + def get_node_info(self, mac_id): + global last_mesh_node_info + """ Returns the debug info for a specified mac address + takes max 10 sec + { + 'ip': 4c00, # last 2bytes from the ip v6 RLOC16 address + 'r': 3, # not_connected:0 | child:1 | leader:2 | router:3 + 'a': 100, # age[sec], time since last info about this node + 'nn' : 20 # neighbours number + 'nei': { # neighbours enumerated, if any + (mac, ip, role, rssi, age), + (mac, ip, role, rssi, age) + } + 'l': { # location, if available + 'lng': 7, + 'lat': 20, + }, + 'b' : { # BLE infos + 'a': 100 # age, seconds since last ping with that device, None if properly disconnected + 'id': '' # 16byte + 'n': '', # name, max. 16 chars + } + } """ + #res = self.mesh.get_node_info(mac_list[0]) + try: + mac = int(mac_id) + node_info = last_mesh_node_info.get(mac, {}) + if len(node_info) == 0: + node_info = mesh.get_node_info(mac) + return node_info + except: + return {} + + + def send_message(self, data): + """ sends a message with id, to m(MAC) + return True if there is buffer to store it (to be sent)""" + """ data is dictionary data = { + 'to': 0x5, + 'b': 'text', + 'id': 12345, + 'ts': 123123123, + }""" + print("%d: Send Msg ---------------------->>>>>>>> "%time.ticks_ms()) + return self.mesh.send_message(data) + + def send_message_was_sent(self, mac, msg_id): + """ checks for ACK received for msg_id + returns True if message was delivered to last node connected to BLE mobile """ + error = False + try: + mac_int = int(mac) + msg_id_int = int(msg_id) + except: + error = True + if error: + return False + # mesh.mesage_was_ack(5, 12345) + return self.mesh.mesage_was_ack(mac, msg_id) + + def receive_message(self): + """ + return { + 'b': 'text', + 'from': 'ble_device_id', + 'ts': 123123123, + 'id': '', + } """ + return self.mesh.get_rcv_message() + +class Watchdog: + def __init__(self, meshaging, mesh): + self.INTERVAL = 10 + self.meshaging = meshaging + self.mesh = mesh + self._timer = Timer.Alarm(self.interval_cb, self.INTERVAL, periodic=True) + + def timer_kill(self): + self._timer.cancel() + + def interval_cb(self, *args, **kwargs): + global rpc_handler, rx_worker, tx_worker, mesh, ble_comm + + #print("watchdog!") + + if rpc_handler.error: + rpc_handler = RPCHandler(rx_worker, tx_worker, mesh, ble_comm) + print("********** Restarted RPC Handler") + + +################################################################################ +# Main code + +pycom.heartbeat(False) +mesh_lock = _thread.allocate_lock() +meshaging = Meshaging(mesh_lock) +mesh = MeshInterface(meshaging, mesh_lock) + +def on_rcv_message(message): + message_data = { + 'mac' : message.mac, + 'payload' : message.payload, + 'ts' : message.ts, + 'id' : message.id, + } + + if message.payload == '🐕': + pycom.rgbled(0xff00ff) + + msg = msgpack.packb(['notify', 'msg', message_data]) + rx_worker.put(msg) + print("%d ================= RECEIVED :) :) :) "%time.ticks_ms()) +mesh.meshaging.on_rcv_message = on_rcv_message + +def on_rcv_ack(message): + message_data = { + 'id' : message.id, + } + + msg = msgpack.packb(['notify', 'msg-ack', message_data]) + rx_worker.put(msg) + print("%d ================= ACK RECEIVED :) :) :) "%time.ticks_ms()) +mesh.meshaging.on_rcv_ack = on_rcv_ack + +ble_comm = ble.BleCommunication(mesh.mesh.mesh.MAC) + +def ble_on_disconnect(): + rpc_handler = RPCHandler(rx_worker, tx_worker, mesh, ble_comm) +ble_comm.on_disconnect = ble_on_disconnect + +rx_worker = RXWorker(ble_comm) +tx_worker = TXWorker(ble_comm) + +rpc_handler = RPCHandler(rx_worker, tx_worker, mesh, ble_comm) + +Gps.init_static() + +print("done !") + +last_mesh_pairs = [] +last_mesh_mac_list = [] +last_mesh_node_info = {} + +watchdog = Watchdog(meshaging, mesh) + +try: + while True: + + # print("============ MAIN LOOP >>>>>>>>>>>") + # t0 = time.ticks_ms() + # mesh_mac_list = mesh.get_mesh_mac_list() + # if len(mesh_mac_list) > 0: + # last_mesh_mac_list = mesh_mac_list + # print('mesh_mac_list ', json.dumps(last_mesh_mac_list)) + + # mesh_pairs = mesh.get_mesh_pairs() + # if len(mesh_pairs) > 0: + # last_mesh_pairs = mesh_pairs + # print('last_mesh_pairs', json.dumps(last_mesh_pairs)) + + # # ask node_info for each from the mac list + # for mac in mesh_mac_list: + # node_info = mesh.get_node_info(mac) + # if len(node_info) > 0: + # last_mesh_node_info[mac] = node_info + # print('last_mesh_node_info', json.dumps(last_mesh_node_info)) + # print(">>>>>>>>>>> DONE MAIN LOOP ============ %d\n"%(time.ticks_ms() - t0)) + + # time.sleep(15) + + #todo: if RPC parsing/execution error, then + + + cmd = input('>') + + if cmd == 'rb': + print('resetting unpacker buffer') + rpc_handler = RPCHandler(rx_worker, tx_worker, mesh, ble_comm) + + elif cmd == 'mac': + print(mesh.mesh.mesh.MAC) + + elif cmd == 'mml': + #t0 = time.ticks_ms() + mesh_mac_list = mesh.get_mesh_mac_list() + if len(mesh_mac_list) > 0: + last_mesh_mac_list = mesh_mac_list + print('mesh_mac_list ', json.dumps(last_mesh_mac_list)) + + elif cmd == 'mni': + for mac in last_mesh_mac_list: + node_info = mesh.get_node_info(mac) + time.sleep(.5) + if len(node_info) > 0: + last_mesh_node_info[mac] = node_info + print('last_mesh_node_info', json.dumps(last_mesh_node_info)) + #print(">>>>>>>>>>> DONE MAIN LOOP ============ %d\n"%(time.ticks_ms() - t0)) + + elif cmd == 'mp': + mesh_pairs = mesh.get_mesh_pairs() + if len(mesh_pairs) > 0: + last_mesh_pairs = mesh_pairs + print('last_mesh_pairs', json.dumps(last_mesh_pairs)) + + elif cmd == 's': + to = int(input('(to)<')) + txt = input('(txt)<') + data = { + 'to': to, + 'b': txt or 'Hello World!', + 'id': 12345, + 'ts': int(time.time()), + } + print(rpc_handler.send_message(data)) + + elif cmd == 'ws': + to = int(input('(to)<')) + print(rpc_handler.send_message_was_sent(to, 12345)) + + elif cmd == 'rm': + print(rpc_handler.receive_message()) + + elif cmd == 'gg': + print("Gps:", (Gps.lat, Gps.lon)) + + elif cmd == 'gs': + lat = float(input('(lat)<')) + lon = float(input('(lon)<')) + Gps.set_location(lat, lon) + print("Gps:", (Gps.lat, Gps.lon)) + + elif cmd == 'f': + try: + to = int(input('(MAC to)<')) + packsize = int(input('(packsize)<')) + filename = input('(filename, Enter for dog.jpg)<') + if len(filename) == 0: + filename = 'dog.jpg' + ip = mesh.mesh.mesh.ip_mac_unique(to) + except: + continue + mesh.send_file(ip, packsize, filename) + + elif cmd == 'exit': + print('exit!') + break + + elif cmd == "rst": + print("Mesh Reset... ") + mesh.mesh.mesh.mesh.deinit() + #mesh.mesh.lora.Mesh() + machine.reset() + pass + +except KeyboardInterrupt: + print('Got Ctrl-C') +except Exception as e: + sys.print_exception(e) +finally: + mesh.timer_kill() + watchdog.timer_kill() + rx_worker.timer_kill() + ble_comm.close() + Gps.terminate() + print('Cleanup code, all Alarms cb should be stopped') From 389757ab43f3e63865b9e294df7441b4973f9b85 Mon Sep 17 00:00:00 2001 From: Christian Ehlers Date: Tue, 19 Mar 2019 22:02:22 +0100 Subject: [PATCH 11/92] Update Sequans firmware updater to Version 1.2.4 --- lib/sqnsupgrade/sqnsbr.py | 14 +- lib/sqnsupgrade/sqnsbrz.py | 9 +- lib/sqnsupgrade/sqnstp.py | 29 +++- lib/sqnsupgrade/sqnsupgrade.py | 246 ++++++++++++++++++++++++--------- lib/sqnsupgrade/test_sd.py | 10 -- 5 files changed, 217 insertions(+), 91 deletions(-) delete mode 100644 lib/sqnsupgrade/test_sd.py diff --git a/lib/sqnsupgrade/sqnsbr.py b/lib/sqnsupgrade/sqnsbr.py index abe94b1..9e69f21 100644 --- a/lib/sqnsupgrade/sqnsbr.py +++ b/lib/sqnsupgrade/sqnsbr.py @@ -1,9 +1,9 @@ - # Copyright (c) 2016, Pycom Limited. - # - # This software is licensed under the GNU GPL version 3 or any - # later version, with permitted additional terms. For more information - # see the Pycom Licence v1.0 document supplied with this file, or - # available at https://www.pycom.io/opensource/licensing +# Copyright (c) 2018, Pycom Limited. +# +# This software is licensed under the GNU GPL version 3 or any +# later version, with permitted additional terms. For more information +# see the Pycom Licence v1.0 document supplied with this file, or +# available at https://www.pycom.io/opensource/licensing class bootrom(object): import binascii @@ -49,4 +49,4 @@ def read(self, size=0): else: return self.BOOTROM[fpointer:self.__fpointer] - BOOTROM=binascii.a2b_base64(b"""VVBHUgMAAACc2AAAAQAEABgAYm9vdHJvbSB1cGdyYWRlIHBhY2thZ2UAdG9vYgAAAAIAAAABc2JwawAAvqgAAABQAAAZiEG97ANJAAAYSAABM5IAkgBib29vc3FuMQAAAAAAAQABAAAAAAAAAAABI0VnAGAAAABgvphHCCACWQgMAGQFAAJCAAQLTgMACEYX//9YEI//QQgEAgEIAAFPAgFdhCJNAIFah7hB3vgARgAgAUQQEAASEAAKhCEQEAAYhCAQEAAZRBAhHxIQAAqEIRAQABiEIhAQABmEIa5EhCAQEAAIZBIAAmYQgAdkEgADZBMAAoQgZBMAA2QVAAJmEIADZBUAA0kAAXVkFAACRCgAAP5WWBCAFGQUAANJAAFIZBAAAkYgD/D+VpIwXBCAJE4SAApkFeACZhCAB1gQgAFkFeADZBUAAlgQgANkFQADZBIkAkYQAP9kEiQDRhP//1gQj/9JAAACQBD4Aowo3QEFDoAIQG7AAIdATwIAnYT81QNZvYAChgid/Ex4QAeBJlm9gAGBHdU0QQMcAAUIAAFPAv/zQIh0AAUUAARHJib2WSkPb00Zf+mACPo0SQAAogUEAAkElAAITQX/3YkoBBSAA/uEiDBApIQAgAlJAACStYpQBQAITQX/zgQVAAGeTECgBAC1SkkAAIVMpf/EBQSAA1FEgByPiE8HABiPjAU6AAIFKgABtbRRSgAMj+FPMgAHj+FPMgAHt9HV7xEogADV7BMogADV6QQkgARGAAYAWAAAAIAoRQD//4IwglBBkIgAUTCC0AVAgABA/MwGTvIAA4J5nEwVQAAAnARBWkAJibWJ0UFaQAIFQIAAibWJ0UwZ//JJAABdBVCAAOI5TvP/4kkAAFZBKUAIibJVDYABTVj/cYNITwMAB0cABgBZCAAI3RBHAAYLWQgOqEcQBhhZGIzMQSlIA7fQjYRNCP/+R/AG8Fn/gBBGAAAAWAAAAEIOACFH0AYRWd6MyEfAAACDnEcABgRZCA04gBqAO90QRQD//4IwglCYSIM+UCABaOIiTvIAA4BBAzAAAJwCibOJ0UwBf/tJAAAM4gFO8//wSQAAB0EpQAhAuMgA3RlBOMACQUjACUEZ0ABBOUACQUlACUEp0ADdHkkAAFNJAAEcZBQAAkQoAAD+VlgQgBRkFAADSQAAHWQQAAJGIA/w/laSMFwQgCROEgAKZBXgAmYQgAdYEIABZBXgA2QVAAJYEIADZBUAA4YAtbDdEWQAAOFlAEACRAAAQFUYAANBEEQMhAFVKAAYk8NBIEgMhARVOADAk+ZBMEwMQwjIJEMITCSLk2QIAgFkAAAJTwP/+92egR5JAAEJSQAABEgAADyAnkkAAA3vAgQxIHcEQAY1wkAGAaXAAQIEBf8AgD5GYCAAhoGGBEVQAFA5A1QIUVqAAYYAOQNUCFFagAE5A1QIUVqAATkDVAhFUAAwRRAAnzkTVAmGY0kAAHgCAwAJRCAA/6bITAGABowqTDF//N2IgOHdhIYEAROACYZAhmFFUABQOQNUCFFagAGGADkDVAhFUAAwORNUCVFagAI5I1QJSQAAUwIDAAmmef5GThMAJIYEhiaGYEkAADcBE4ADASOAAYZhSQAAMEkAAEimeEQgAO9MIP/RRRAAUIZgSQAAJEUQADGGQoZhSQAAHkkAADZI///CSQAAUUUQAOsREwAIAROAAhETAHIBE4AEERMAcIYhERMAcxETAHRkAAAIZAAACd2IhgRFUABQOQNUCFFagAE5A1QIRVAAMDkTVAlRWoACOSNUCREzAGQRQwBgAVMAYE9T//7dnoBehgSGJYZAhmFFUABQOQNUCFFagAGGADkDVAhFUAAwORNUCVFagAI5I1QJSf//4QIDAAlCEAALThP/+t2CgD5GYCAAhoFFUABQhgQ5A1QIUVqAAQEDgAg5A1QIUVqAATkDVAhRWoABOQNUCFFagAE5A1QIRVAAMAETgAU5E1QJAROAB1FagAI5E1QJUVqAAjkTVAlRWoACORNUCVFagAI5E1QJATOABkn//6PdgUcABgtZCA6oRxAGAFkYhb5HIAYAWSkDsIuyDT8AAR04AAGPpE8W//tHAAYLWQgOqN0QSAABRkAAAAlAAAAJQAAACTuP7DxFsAABSAABXEAAAAk7j+w8RbAAAkgAAVRAAAAJO4/sPEWwAANIAAFMQAAACTuP7DxFsAAESAABREAAAAk7j+w8RbAABUgAATxAAAAJO4/sPEWwAAZIAAE0QAAACTuP7DxFsAAHSAABLEAAAAk7j+w8RbAACEgAASRAAAAJO4/sPEWwAAlIAAEcQAAACTuP7DxFsAAKSAABFEAAAAk7j+w8RbAAC0gAAQxAAAAJO4/sPEWwAAxIAAEEQAAACTuP7DxFsAANSAAA/EAAAAk7j+w8RbAADkgAAPRAAAAJO4/sPEWwAA9IAADsQAAACTuP7DxFsAAQSAAA5EAAAAk7j+w8RbAAEUgAANxAAAAJO4/sPEWwABJIAADUQAAACTuP7DxFsAATSAAAzEAAAAk7j+w8RbAAFEgAAMRAAAAJO4/sPEWwABVIAAC8QAAACTuP7DxFsAAWSAAAtEAAAAk7j+w8RbAAF0gAAKxAAAAJO4/sPEWwABhIAACkQAAACTuP7DxFsAAZSAAAnEAAAAk7j+w8RbAAGkgAAJRAAAAJO4/sPEWwABtIAACMQAAACTuP7DxFsAAcSAAAhEAAAAk7j+w8RbAAHUgAAHxAAAAJO4/sPEWwAB5IAAB0QAAACTuP7DxFsAAfSAAAbEAAAAk7j+w8RbAAIEgAAGRAAAAJO4/sPEWwACFIAABcQAAACTuP7DxFsAAiSAAAVEAAAAk7j+w8RbAAI0gAAExAAAAJO4/sPEWwACRIAABEQAAACTuP7DxFsAAlSAAAPEAAAAk7j+w8RbAAJkgAADRAAAAJO4/sPEWwACdIAAAsQAAACTuP7DxFsAAoSAAAJGQCZAKWH04DAAhG8AYAWPeAAEoAPACEIUwAwAhG8AYAWPeAAEoAPABkAyQClhZOAwAIRvAGAFj3inhKADwAh2tIAAACg1+DPmWCAAJVjAAgT4MABkkAABQF/4AAOg/vvEkAABK1kIAb3TA6D++Eg9mD+juP7ARkAAAEkgBL8HgBAAAAAEsAeAEAAAAAQAAACUAAAAn8AIDAyAlGAAYGWAAMiEkAAU5J//tvRgAGDFgAAsA4EBoCwQVQA3/33SH8gIAmRgAGBlgADJBJAAE6ZEJEAmQiZAJkMqQCRgAGBlgADKiAJkkAAS3VAMAEZBIAQ92eZAIAQ92eZAIAApYE3Z78AI4BXAAAAUn///H8gPwAZCIAAmQzAAJAMYAS/kb+X2QTAAOWFEn//+38gPxARnAGAFhzhfBGkAYAWJSJCIsnRmAG8FhjAACASYAngAZJAA9ZgAaAKUkAAF2ABoApSQAAaZp3RiAGAFghCRBGAAYAWAAJBDgggApGAAYMWAACvIDhZgAAB0YQBgBYEIj8OAOECkQPAAD/hlhjQABkYiQDhABkAwADZAMEA0ZgBgtYYwywRnAGC1hzjMiFIUagBgxYpQLA4sfoDaAxQASADIAgSf//n6AxonKMCTgVAgrV82QSAAJEAwAA/g9kAgADZAAACGQAAAlkEgBD/MD8AEYABgZYAAzkSQAAnPyA+hDdnvwASQAAE/yA/ABJAAAa/ID8AEkAAC/8gPwASQAAKPyA/ABJAAAZ/ICIIGYAAB/iAegGZAABIVAAACDV+t2eiCBmAAAf4gHoBmQAAQFQAAAg1frdnoggZgAAH+IB6AZkAAMBUAAAINX63Z5kAAAM3Z5kAAHhZAAA4WQAAAzdnoAgPAwaTsAF/ABJAAmS/IDdnvwAgMAgAwAAwAtaCAoFhA1J///vKAMAAUn//+vV9PyA/EOAwIEhgOKAH4Qg+kVJAA6SxgOAH9UMRAAAMBAPgADVFMMTWpAKDlqQEAeMAUBjJHfO+dX35mrpBFBBgDfVA1BBgDCvANXzgB9JAA6HgMCgOcAOpnjiBkBgPBvBCZvGxwdEAAAwSf//tI7h1frGB47BOA+YEEn//6zV+vzDOh+UPO/8Om+svEYQBgZYEI0E7/Q7AMQAgUBEAABbOw/EIEn//5c8DBwASQAO74QqgF9J//+oRAAAXUn//4v6EIE/Sf//h7GLhOCFYSgFAAFOAgCoWgglDMcESf//e9VTEHSAABR0gAFIAACZTnIAjFoAZD5e8ABl6Ble8ABI6A9e8ABF6GBe8AAwTvMAiF7wADrpYFoAQVhIAACBWgBhVFoAYzZaCFh71UBaAG87XvAAcOgHXvAAaOlGWgBpGdVuWgBzN17wAHToDVoIcGid9LTGRgAGBlgADQBJ//9EgAbVLFoAdRtaAHgh1Vi05ozETnQADPodSf//Lf46hCqASUn//0GE4NWjgAfV+SADAAOd9En//x/VFZ30tAaEKtUOnfS0BoQo1Qqd9LQG1Qa0Bp30Sf//GNUF+iCASUn//yOAx9XhjMdmAwAHUGAACKAB1dZaCDALABSAAMkEELSAANUdBBSAAcEaBCSAAcIFhCr+VBQUgAGASaBRUBD/0IggqFHVDFoICgWEDUn//uMgBX//Sf/+30j//1uE4Uj//1jsDDpvrITsGN2ehAQ8D+qzhAA8D+qx3Z78AEkAAoiEIEAAgAb8gPxgPA3qs1oAARLAHFoAAgRIAAFUhOBGkAYMWJSDeEagBgtYpQzYSAABK4QARhAGDFgQh8w8M9V+PEPVfYDAgSHVTUYABgZYAA0cSf/++EYABgxYAAeYRhAGBlgQjwiER0kADWHAB0YABgZYAA00SAAA3Dwd6rtSEIA0PB/qrsEHRgAGBlgADVBJ//7ZPAPVfTwT1X7+REYABgZYAA1wPB/qr0n//sw8DeqvXPAEAekHRgAGBlgADYxIAAC3RgAGDFgAB8w8D+qwSAAA9cYKoUmgseKi6QaIJIwB4gPp+NUMtEFaKAEGoUygjdr21QNaKAT0gMHV8c4PRgAGBlgADaxJ//6dPA3qsjwd6rpJAAucSAAA1KAxPB3qsaH0igE8D+quPH/qr88NRgAGBlgADcxJ//6FhAE8D+qzPH/qrtV3LgeqtKBzyAZGMAYKWDGCpNUFRjAGBlgxjQyAR0YABgZYAA3kSf/+a7QGPC3qr1oIBB9c8QQB6Q9GAAYGWAAOAEn//l2EATwP6rM8DeqvPA/qrtVNRgAGDFgAA3g8D+qwhAI8L+qsPA/qs9VBoTM8DeqyPE/qsOKA6AM8T+qyRjP//1Axj/9AEgwCRvAAAFj3gACIROIv/p7pE0YACABYAAAA4gLpDUYABgBYAAAA4gLoDkbwBwBY94AA4i/oCEYABgZYAA4oSf/+GtUgPBPVfUADJAFAAAQWSQAB7cgIRgAGBlgADkxJ//4K1RCEALYG1USNaEy1ABm0q6Ay2PsEJYABgAygcd0iyPWEA9U0QGOkAEYABgZYAA5woHJJ//3vtEZaIAQUtAaMA2YQAAOgMYwDZgAAA4gBjAyI4Dwd6qxQA4AM4gHp5NURUAMADEYQBgZYEI6ESQAMRsjmRrAGC1i1jMhQwwAQ1cY8Deqz5gPoBIQBPA/qs/zg/GCFYIEggUGAwYUBTmIAuDwN6rPmA07yALM8LequwhXiRjwN6rHpCogGikY8D+qxPC/qroAKSAAAq4gCPA/qsYrCiSI8v+quPH3qr05yAJQuB6q04uZAczwawCqEHzwP6aI8DeqwPA/poYQiRgAGDFgAA0A8zemjPH/pnzyf6Z5JAA5N5gKAIOkMRgAGBlgADog8LemkSf/9dYQDPA/qszwN6aM8HeqwigyIAdUKPA3qsIApgEdJAAqCPA3qsIgHPB3qsTwP6rA8DeqviseKB4kniOE8D+qvPH/qsciYLheqtMEJPgeqtEYABgxYAANASQAVa+bE6SuACUYQBgZYEI6whERJAAuyyCI8D+mfPA/pnvowRgAGDFgAA0BGIAYGWCEOuEQwADg+h6q0SQANsoAgwA1GAAYGWAAOwDwt6aRJ//0ghAM8D+qz1RlJ//39LgeqtE4C/1w8DeqvjsSOBDwP6q88DeqxjSSMBDwP6rFI//9OSf/96Uj//0o8DeqzWgADBUAFGAHVAoQf/OD8QTx96rFGYAYMWGMHmECgnADnSPCBgSE8b+qw6QNSk4AHiMeASfEBgAaJJ0kAC0RGAAYMWAAHmEYQBgZYEI8IgElJAAtMyBznJ+gFPK/qsYQB1Rc8D+qzUnOANIQfPA/qsjx/6q88b+qwSQAAvEYABgZYAA7sSf/8voQC1QKEAPzB/CHwgYDBRgAGBlgADxDxAUn//LBQcwAgCBMAAUYABgZYAA8gSf/8pkxj//hGAAYKWAADvEn//J78ofxVgOCmAEaQBPSmeVCUiwBAAIEEFJ+AAVoIAgemOqZ7QACBBMgJRgAGBlgADyhJ//yEhADVXIQAsEb6UEkABdjIBkYABgZYAA9Y1fJQY4AURgAGBlgAD4iwRkn//7aAJkYABgZYAA+QSf//r7AOSQAjGoAmsA76UEkAIyiwDrBG+lBJACMjRmAGDFhjC9CERLAOsEFJACMasA6AJkkAIzlGAAYGWAAPmIAmSf//joAGRhAGDFgQi/BJAAo3sAKcfPpASQAJV0kACfr1AkxUgAdGAAYGWAAPpNWrRgAGBlgAD8hJ//wqPG/rwYQB/NX8AfCBPA3rwcgHSQAFeFYAAAGWANUR8QFGAAYGWAAP5En//BQ8DevBRhAGDFgQi/BJAAoEhAH8gfwASQAJyYQAPA/rwfyA/AA8PeQAtECKQ0YwBgpYMY7AtkCAw4RAPE3kfuJE6BahGZckxA+0gKFd4oXpBIqFtoDVCMEDhAC2AUADCKCMBNUGjEFQMYAg1eiEAPyA/GFGkAYMWJSMBDhUggKAwIDi0h2EYUChmAyEQIQGgIKBYRAPgASwQYAKSQAIAwAFgACEQBAPgASwQYAKhGKAghB/gAVJAAf2OHSaCvzh/CBGYAYKWGMO3ITgPA3kfuLg6BUEA3/6lgTADYQAgECAJkn//8iEADwd684EI3/+SQAH8IzhUGMAINXp/KD8IDxN5J+EoITMRnAGClhzjsDUHYBnQjKYcwUBgCJNAEAVwgQEAYAktgLBE4RMRgAGClgADsBCAohzBCAAIzwN5ACIArYB1QWModXkhADVAoQB/KD8ZfGB8IaBYLBHsAa2X0n//2KA4MBy8AdGEAYMWBCMBDgQggJQw4AY8YIAL4AYgCxJ//948AeFIUCUgAwE34AABI+AAYXGUK+AIIeFTtIARaG68AZAABg3wQKKwYRAQPaYBoAJgCqEYYCCQGa8GxDvgCBJAAdvoPmEIvAGEBUAAJ1ZxQY4BRQIkgiOodX7gEWACYAqjGKEgfWDSQAHW/UDgAmAKIBmgEWAhUkAB1PwBkDWmAGJBojA9oaACbBFgEqEYoSAEc+AFEkAB0QABQABlgTI9NW88gLwB4AsSf//IoALtD9J//plgAvxAbRfSQAJZ1wAAAHVAfzl/AO2HzwN5ADxgfCFsESwBUn//uTICEYABgdYAAAcPB3kANUfRA//nxAPgAjwBIQhQACADLCDsEKEZISASQAHDQAfgA1aEMIJWhDvE0YABgdYAAA81QZGEAYHWBCABNUMSf/6vUYQBgZYEI/81QVGEAYHWBCAELQf8gFJAAkR/IOcRoRAGCAAAUwA//7dnvwAPG3r0EkAJTWEKEAQBDb6FEJggHOABvyA/EGBIfCBSf//8IDA8AGE6EkAJSNAEBwWhOFAc4AMWpABDk6SAAlakAIESAAAkoFHgSfVBoVAgSrVA4EnhUCEIPABSQAlEkn/+VOmsaZwQCFACEAhBwSmckAhBQSmc/6PptCWeP7PrtCmtab0QCFACEAhDwSm9v8LQCENBKb3lyD+n6bQ/s+u0AAjABEAMwAQQCFACEAhDwQAMwASQBCkAkAhDQQAMwAT/p+m0P7mrtAAIwAVADMAFEAhQAhAIQ8EADMAFkAhDQQAMwAX/p+m0P8erxAAIwAJADMACEAhQAhAIQ8EADMACkAhDQQAMwAL/p+m0EBxnBJAdRwEl/iv0AAjABkAMwAYQCFACEAhDwQAMwAaQCENBAAzABv+n4RgrtAAIwARADMAEEAhQAhAIQ8EADMAEkAhDQQAMwAT/p+m0ECRhAQQkQAASf/41fzB/ENJACP5PA/r0MgIRgAGB1gAAFRJ//nn1WeEQICihN+YQgAwgBEAQIAQQDHACEAxkwQAQIASUCEAJEAxkQQAQIAT/uevWAAwgBUAQIAUQDHACEAxkwQAQIAWQDGRBABAgBf+56+YADCAGQBAgBhAMcAIQDGTBABAgBoAEIAbQDGRBP5fr0haKNjNgB9J//7+sAJJ//77sARJ//74RnAGC1hzjPBGkAYLWJSNAEx0gB20B0kAI1FaB/8WobqoO1pgAQ5aYAIMhCDOCkkAIy5aAAEEWggCBIAg1QKAJqA7SQAjeozw1eT8w/xABJAAAoDgWpgBKLQASQAkCIFAtAc8bevQSQAkAoSIQAAQFvo0gGZCMARzABGAHQABgBwAIYAeQBDACEAQgwQAAYAfQBCJBEBFEFb+R0BEiAymiP8XrwgEk4ADWpgBKLQHSQAj3oFAtAc8bevQSQAj2ISIQAAQFvo0gGZCMARzABGAIQABgCAAIYAiQBDACEAQgwQAAYAjQBCJBEBFEFb+R0BEiAymiP8XrwiEAfzA/AHwgUn//n2AwPABSQAjsQATAA0AIwAMQBDACEAQiwQAIwAOADMAHEAQiQQAIwAP/leESEAgCBaEQUABAAwAIwAdpwhAIUAIQCEPBAAzAB4AEwAfQCENBP6PplD+Zf4OhCBAAIAG/IH8QYEh8IFJ//5IgMDwAUkAI3wAIwAhADMAIEAhQAhAIQ8EhCgAMwAiQAAFVgADACNAIQ0E/oeE4aaQQHOoDP6+yinwAYApSQAjaKa1pvRAIUAIQCEPBKb2pjdAIQ0E/oemEEAUqAxAE4QSQAAcEv4PlgCuEKYxpnBAAEAIQAAHBKZyQAAFBKZz/g+mQP/Pl/ivwPzB/ACEIEn//7T8gPwhgOHwgUn//fmAwPABSQAjLYQoQDAEFoRBADMAHUAhAAxAE4AMAAMAHABDAB5AMcAIQDGDBAADAB9AMZEE/sem2AADACD+XQAzACEAQwAiQDHACEAxgwQAAwAjQDGRBP7HphgAQwAJQDCAAkBxiAL+xQADAAhAQkAIAFMACkBCAwQAAwALQEIVBP8HpiD+1kAACBL+jv6Hxw+mNaZ0QABACEAABwSmdkAABQSmd/4PpkD/z6/AAAMACQATAAhAAEAIQAAHBAATAAqWkEAABQQAEwAL/g+ugMMQpjWmdEAAQAhAAAcEpnZAAAUEpnf+D6ZAQDCMEq7A/KH8AfCBSf//gfABhCFJ//8u/IH8IoAfSf/9bTxN69CEAPq0gGRCMBRzABGAGQAhgBhAEMAIQBCLBAAhgBpAEIkEACGAG/5Xpkg4H4AIjAFaCAbqsAJJ//1OhMCE4bAEQAAYfAAAf/BUEwAHQAAEDpYEwA6ABkkAIoGwQkAggHxUEAAHphBAE4QM/keuUIzBWmgw50ZgBgtYYwzwRnAGC1hzjQBMY4AWoDNaB/8RoLHCDrBEQBCAfAAQ//hUMAAHQBCMDpZMwQO0Jt0ijNDV64QAPF3r0ICAmOgAEYAZACGAGEAQwAhAEIsEACGAGlAAACRAEIkEACGAG/5XrwhaCNjt/KI8LeQ5hKBGMAYKWDGNrNIKQBGUoKEJTEBABJwM3Z6ModX3hADdnkZQBgtYUo44RhAGC1gQjpjRCAAigBhMIAAHUFKAINX5hADdnoAF3Z78AEn//9igAfyAoIEAEAAIptBAEYQSrlCggQAQAAimEP4OyP7dnvwAgMBJ///woHEAAwAIpoj+F64IoLEAEwAIphD+DsD+/ID8IEZgBgtYYw44RnAGC1hzjphMY4AJoHTBA4AG3SFQYwAg1fj8oLQgAACAFJYEwP2mCJYC3Z60IAAAgAhYAAACEACACN2etCAAAIAUVAAAYFoIYPzdnvxAgSAAAAAYgUFJ//+FtMmA4AADADDABIAJSf//6wQkgAWEABADADBAESg3oLzCAvpAoPugOv6flpBaCAEFWCEACNUFWggCBFghABhYAQCAEAMADJYIrjBAAKAJlgCSMK40lmeEAhATACAQIwAMEAMAEKA9WggECAADABBYAAAgEAMAEIQGEAMACIQBEAMAMPzA/EBGYAYLWGMOOEZwBgtYc46YTGOAFgADABhJ//80oEfJDKCzBJAAAcIIgAbdIsAFgAaAKUn//51QYwAg1ev8wPwASf//lvyA/EC0wIEgAAMAEIDhli7ADQADABiWJsgJRgAGB1gAAIwAFIAYSf/2r4AJl/hJ//91r/D8wIQA3Z7IDDxd/APaC/wAgAE8HfwCSQAE/oQB/ICEAN2e3Z7IBzwN59u2ATwN59rdnoQA3Z78AYQEgD9AL4AASf/69MAJtB+0IFoX/waMBMADSQAALPyB5jDpJvwgRiP//1AhD/9AIQRcOHAKAo4kgMBJAB4uTHBAFIAGRhAGB1gQgMiEQ0kABNnADYAGRhAGB1gQgMSEQ0kABNDAA4Qf1QKEAfyghB/dnvxChOCAwIEh94NJ///SPE3r0eLkTAfAF6ZzoPKMIYxhUCT//FwxgAGMgbACQBMEgIhGED+ACDxP69FJAAHv8IHVAveB8AH8wvxBRmAGC1hjDQBGkAYLWJSNEExkgBCE4LRGgAewQd0iwAfxAUn//8rAA4zh1faMyNXx/MGEQIBgtkGAArRBjAGUl7ZBpxiXN/6ntkEoIYABTiX/9t2etCCmyKaJjCK2IEABDQTdngAA/GWA4EYAf/9QAA/A8IRGAAD9UAAP//GCgSK2f/SD8IW0H+MgTvIBmYVgtD8IBIAB4ilO8wGUQBAMCVTAAAdAsKykWsAH9MgFhAGuOUgAAYVaAAjohMBayAEJgAmwSUn//7f2CYkgiMnwAoUAUKAABfACpgTjAOgWUAUAAbBJSf//p/UJTFXABowBiArIB9UKAAUAAI0BiUDV7Fq4DxOmeMkQWsgBBEgAAVVawAIESAABVoDJKAMAAU4F//5IAAFKCKAAAfCHRgAGB1gAAMw4ADAAVNUAB7V/QAA0DpYEQLMYG04CATWwB0n//4PxA0CABABABRAJlg9aAAEdwBhaCAInsAdJ//91gcCwBwSjgAFJ//9v8QOIAUHFAACwSPAHSf//VvEHiAHwh9UThAHwiNUOsAdJ//9dgcCwSPAHSf//R/EHh4CIAfCH1QOFwIOO8AfwgYVB8AjiCk7zAO3wAfCHXPaABoQArjlO8gDdRvAGAlj3gUQ4B7UBQPA8AN0PALgADAEyATIBigAMsEnwAUn//x7xB4IJiAGEIPCHgKGAAQhIAAGUz0AxgzVVEgB/lyKMoYAjQAiA5E5F//SJJVrYBRmnOMwWUPB/wUBHgAaOIYiBzA/yBOJP6QxQ8GAAQEeABogkThMAn/EF4i9O8wCb9AmgeY6B5oiIKE7yAJRG8AYCWPeB2DhHkQFA8jwASgA8AAAQABYBEAAaARABEAEQAB6uCEgAAH+sCNV8tgHVerZhqAnVd7BJ8AFJ//7I8QeAqYgBhCDwh4CBgAEIMoABlE9VAYB/ltpAEIM1jIFACADkTjX/9ZbEwwP+S/4DiST0CaD5joGSAeaIQAAH5IhokCHoUEbwBgJY94JcOEeQAEDyPADdDwgMjBCMjIwUrhjVQawY1T+2A9U9tiOoGdU6QMWkATzt+9JQNgADRABAAGYxgAOKDuIDoHnpQGZHAANGAAYMWAAMEIgEgEM4AKAKgCnzgUkAAunzAUAhuAA8L/vSWtgCNQSTgAGwB0n//niJCTjEAArVK/ABgEmmwPACgIi0IIAHOBCOAoBrSf/+cYEg4yvoB1rIAQaJDo1BSP//E4AKT8IACqZ5wQbxCONB6ANQBQABthyBaUBlmBqBJkj//meACdUGtB/VBIAKgSvV6vzlkgD8QkagBgtYpQ3A8IGAwYEi4snoMoQgCAMAAeMm6StAIAwJQBEEpFQgAAdaIAf2wCRaAAjwRlAGC1hSjRBMVQAHtAVMAIAGjLDV+oTg1QKA5YAGsENJ//4IiMDzA8cJiGbwAaB6gEahOUn//hjzA4jD1dCEANUChAH8wvwARgggAAAQAAiAwFoYCwhGAAYHWAAA0En/8/6EIUYIIAEQEAwdhACuMvyA/CCU31gxgARGaCAARnQQAJbYhKBQYwBQjPhGSCAA0guZLq7gmS85ABQAlSETAgAAjKHV9J4RlgAQAgBkhAEQAgBgAFIAYJdozf3BDEYEEACMCNIImOiU2aTYODCUCIyh1fn8oPxBgSGBQoDj9IGAw5o+5tFAFQAAiAnpB/pAhGGO0En//7/V9YBG8wFJ//+6/MHdnjwN/AjACaACwAf8AN0ghAA8D/wI/ICEADwP/AjdnoQC3Z6AAd2e3Z48DfwEwCv8AEkAGLc8HfwFwROEwEYABgdYAAEMPG/kzUn/84aABjwd/AVGIAYKWCEP9EkAGK48HfwEwQ9GAAYHWAABDEn/83Q8DfwERhAGC1gQgAxJABie/IDdnvwASf//vYQAPgeTBIQAPA/8BDwP/AU+B/AcPA38BowBPA/8BvyA/ACEADwP/AU8D/wESf//pYQBPgeTBPyALieTBMpA/ECBIDwN/AiAwcgeRnAGC1hzjcBGoAYLWKUN4Ex1ABWhezwN/AbQDrRHgAmAJt0iWggCBTx//AjVB8gEPA38Bqg7jPDV7DwN/AiAJqCBgAndIk4EAA2EADwP/AU8D/wESf//bIQBPgeTBNUGmnDBBIgJSf//xC4nkwSAAvzAgALdnjwN/AXIBjwd/ARAAAQG3Z6EAd2e/ACAwUn//088b/wE/IAuB/AcyAX8AEn//1r8gN2ehCBGCCADEhAEh4QhEBB4Ed2e/GCBQYDigMBJ//JGgWBABSxXwgNAJYgB4uJAI7wbgSLCCIAGgCpJAAExiMmJSYrpPJ38Ck6TADD6EEkAAlw8D/wKwCNGGCADUBCJAIRBEiCAQxKQgAeAQaTOw/9GE///UBCP//4OtgKEAhIBAAiEAKwTRhggAoQBEgEAChIBAAysFxAAiBHVB4AGgCqAR0kAAP3VW49hQAMsAsAFgAaEIUn/8fyYN0AQLALBBIQhSf/x9Ua4IANQtYkARsP//0SA//9Qxg//gavHQOMHgcfoA0Tg//8CBYADQBUwAkCQABM8DfwKQcSQCIgcqEFAEzACqEI8HfwJrEAS4AAB+iBJ//HNPB38CoAKiDykSY0hSf/xxVqYAgOFIEn/8cxABIATEgaAAzwN/AmALmYAEAA8D/wJgAZJ//G2AlWAAkxU//6K7olOiM7VwfzgPB38CVQAkAFaCAEr/CFGeCADUHOJAKW7PA38CpexQAAYgIREZhCYAKyBWBCIALCBrECogaiC+iCMwUn/8YpaaAIDhMBJ//GRljGsO6V63v88DfwJZgAQATwP/An8oTwN/AlmABABPA/8Cd2e/AA8LfwKwj6AwTozDABQEQAMOjCMIDoTBACMXDoRBCBGKCADOjAMAFARCWQ6MIwgnEQ6EIQAUDEJTDoRhCBQEAAIUDEJNDoQhAA6EYQgjAxQIQkcOgAAADoBACBJ//+cPB38CaY0ZhCHxFQgAARYEJABlAP+V1QAB8D+DzwP/An8gEYABgdYAAEkRBAAxEYgBgdYIQEsSQAZxPwARjP//4OAUDGP/0BAjAK5lFAQAED+zryREiAAJ6jBgAH6MEn/8RL8gIhAgKDSBBgSgAHV/d2e/AHwgYhBTBEABygwgAEYMAAB1frwAfyBgCCaiCgwgAHL/YAC3Z6AoIhA0ggIMoABCACAAZoYwPrVAoQA3Z4IUAABCCCAAdIF4qLpBoQB3Z7N94AF3Z6EH92ehKDSC4BhKECAAThAFAggMYAAwwmModX2xQaIoIQgEBL//92e3Z78QIDAgSHAN2YRABCA4skSSf//xOYD6QwgAwAAWggwCSADAAFaCHgFjML64NUDzwKE6oCGhACAxCgyAAHDHJaYUBF/0OYq6ARQMf/Q1Q5QEX+f5jroBFAx/6nVB1Ahf7/mWugJUDH/yeJn6AVCMBxzgAPV4k6SAAO2yfzA/ACEYEYABgtYAA4gRBAD6EYgBgJYIQmaPD4cAEkAAFf8gPwAPAwcAEQQA+iMATwOHABGIAYCWCEJmkYABgtYAA4ghGBJAABD/IDdnkZQBgtYUo4gRhAGC1gQjjjRL6CpTCAABIy41fu0RaBtAAEADKAsQDAEBMsGEDEACKBqyRrdngAxAAiWzsMLtGKay+Ijig+oLIQBqO0QAQAI3Z5GL/8AiEFAEQQGjgGIAagsqK3dnvwAoCvdIfyA3Z60AIQgEBAACKBByf/dnvxggMCBYoFDgSG04En///OgMYSBQAIADIAgSf/vl0QBlidEMAPohEAUswACFKMAA0IEgGlJABIdgKBGMAD/gIFQIY//zQriQekIhGCEQKi0qPWEA7Yn1Q5AMggCyw5GL/8AiEGOAUARBAaIIKh0qLWEARADgAjVFkYgAQCZGpKBtoe0h5sM4iRAEDwBhAOodKk1EAOACKA5wP+MQYhDkkG2R/zgjB9mEAAfPA3kwkYgBhlYIQD/ikDiQekFiCA8H+TC3Z6EAN2e/ACEBIAgSf/vPUYoIAVGAe/KUBEGAFAACbioCYQBEAEGABABBgz8gPwARgAGB1gAATRJ//A/1QD8QKGHgUEEEwANgSLBDQQDAArIGYOGugmEIUAQiAy5iriMuIvVEAQTAAmDgIThuwi4CkAThAyAR90jFAMADcjogAfVO4OGugq4DeMi6QuDhkAVCAFJ//5zhAC5CriMuYvVLAQTAAyb0eLpQHS8GogBgEdAFSQBiydJ//5hTpIADoOGuA1AFSQBgElJ//5YFJMADLgKuIvVEIOGvQy4CoinvYzYAxSTAAwEIwAL4kDoBIjiFHMAC4QA/MDAKaBHwSeEQKiPqIWogqiGoIrCBJaUFCAADEQggACojVAghTAUIIAbFCCAFBQggBOEQYQAFCCG8IRftgGoCagLFACACBQAgA4UAIAPFCCG8d2ehB7dnsAMoEfBCvwAhECDgbqKuou6jEn//8z8gIQe3Z78QIEgwCqhx8cogMFOFAAF/4qFQNUJQKCQCl7wgDCNQegDl5/GBVADf/jmCOgWBBOADcELBFOACdYIg4m6CbgK3SKEABQDgA0Uo4ACFGOACYAJSf//ydUChB78wMI+ICEAAFooMTtaODg5wDn8QIRAqIYEIAAIygiDgEYwBgRYMYbgu4i6igQgAAnKB0YgBgRYIQdIFCAACYOAuwiA4YDAhCG4CkQgG8zdI4EghBxOkgAahUAUkwAHgCcUpIANgAZJ//+ggODADYOGugm4CoAp3SIUowAH1QWEGt2ehB7dnoAH/MAAAE4CB038ZATgAAdO4gdKBJAAA06SB0YFwAAAoIHyg0/DAAROIwc+tE5aKAsEhEy2TqHEgaCEAPGCBLcADgSHAA+BR/YD8IG0DuYfTvIHKkbwBgJY9420OAeBAUDwPADdDwA+AUIBugIcAmACyANGA8IEPASyBOIFGgUkBcYGHAYgBnAGugdsCUwJUAp+Cs4LigvSDFgMcA0SDVgNVA5CBAcAAsgMhAzVRE5iBooIHgABjsFAEKAMiWGNCOcQ6fZUEAACwRtEEIsfTLDAGIQAgCCAQEkACs36LxAfgBxEH/+LEB+AHRQHAAawR4RCSQAKwBQHAAaEAdVIhCAUFwAEBBcACMEEhF8UIIAMlgTACkAFoAiWAUAALRz6L0AABDfBCkYABgdYAAFMFAaABvoNtg7Vi1QFgA9aCAg+k2QEFwAJVAWAD4wIyQQUBwAJ1QniIOgHjwRGAAYHWAABgNXmhCFAAIAMFAcABYQAgCCAQEkACZwUBwAGFAaADFQFggDIA4QL1QKECYUAtg6BaEj//11OYgYWCA4AAY7BQAAgDIlgjQjnEOn2VAWA/xS3AARaAAgHRgAGB1gAAWTVt0QA4ABABYACwAZGAAYHWAABlNWtBAcACMAEQhWgC7YgVAWCAMAPQRWgCQQHAAawR4RCEL+AHBEfgB1JAAo7FAcABoQChQC2DoFo1QpOYgXaCA4AAY7BQAAgDIlgjQhc9AAg6fUEBwAIwAMUsAABBAcABFQAAgDAF0AFoAkQD4AdQAXACRAPgB5BFeAJBAcABrBHhEQQv4AcER+AH0kACgoUBwAGhAOFALYOgWjVCk5iBakIDgABjsFAACAMiWCNCOcQ6fYEBwAIwAdUFYD/qEJAFaAJqEMEBwAEVAACAMAPQRWgCQQHAAawR4RCEL+AHBEfgB1JAAneFAcABoQEhQC2DoFoBAcABFQQBADBJ+cQ6AtOYgV3CB4AAY7BQBCgDIlhjQjV9QQXAAgUtwAQwQMUsIAFVAACAMAWQRWgCQQHAAawR4RCEL+AHBEfgB1JAAmxFAcABoVg1QcEBwAIwAWoRNUDgWCBC4QFtg4EBwAEVAAEAMA2BCcAEOJGgYJAwzwaTsIAKwRHAAjEEaAkwA+gZZqKoGZARggA4iSIAugDmorVAoBMgDxJ//viBAcABFQAAgDACQQHAAaAPIBMSQAJeRQHAAYEBwAQisxAMDABQc4wABQ3ABAEBwAQTgMFEoQAFAcAEIQGtg4EBwAEVAAIAMAxTmIFBoBchKAEFwAIjKEIMQABwQ6hD8QMBAcAEAQQgAjiAegGnEEUFwAQODIACMMC3uwEBwAEVAACAMANgEUEBwAGgDzzhfWESQAJOhQHAAbzBfUEisVBzhQAwwdIAATYBBcACMECqA+EABQHABCEB7YOBAcABFQAEADAMk5iBMiAXISgBBcACIyhCDEAAcEPBECACcQMBAcAEAQQgAriAegGnEEUFwAQODIACMMC3usEBwAEVAACAMANgEUEBwAGgDzzhfWESQAI+xQHAAbzBfUEisVBzhQAwwhIAASZBBcACMEDFACACYQItg4EBwAEVBACAMEZ5xDoC05iBIkIHgABjsFAEKAMiWGNCNX1AhcADUywgAhGAAYHWAABsEj//i2FAIFoBBcACMEIQgAkCxQAgAuEARQAgAyEAIAggEBJAAi+FAcABhQGgAxIAALgTmIEXggOAAGOwUAAIAyJYI0IXPQAIOn1QBXgCUQA/wBAIC0eQBCvAEAFgAKIIkEQgQCFYIQKFRcABoELFRaADLYOBAcAA8gPgA0UloADqcQVxoAAqYEUtwAOFIcAD4QCSAAEpIQAgCCAQEkAB54UBwAGFAaADIQLtg7wAo4F5gJO8wQeBAcAAcATVAQAB0C1gA1mhAAH+gpI//3LTmIEEAgOAAGOwUAAIAyJYI0I5wPp9lQFgAFAFYQJFAcAAVQAgANRJH/9WgACIVoAAyFaAAEEhA3VI1AnAExGAAYHWAADtLYChAmoEkYABgdYAAM0qBGEBagT+gO2DvACWggGEJNjgRJIAAPc+gDVCEYABgdYAAHEFAaABvoNtg5AsIgJgRJI//0SVAQAB0C1gA1mhAAHXPQAIOgLTmIDwggOAAGOwUAAIAyJYI0I1fREAP//QFWAE0AALh/QB0YABgdYAAHYSP/9Y4QOtg7wAoUAFFcAEIFoWggGBEgAA6KED7YOBDcAEE4yAhziZ0AzvBriw0AzPBtOMgOUgAmAPIBD84RJ//pE8wQEBwAQisNBzgwAiuOJI5rDFDcAEEj//MZOYgN/CA4AAY7BQAAgDIlgjQjnDun2VCWAH0AFlAlAFagJUCEBAZYnll9QNwBcjAGMJFzxAR+omagatiOTbo8O6APmH+kHRgAGB1gAAfhI//0OhAAUBwAa+gG2DgQnABcEBwAa4gLoH+cD6AtOYgNJCB4AAY7BQBCgDIlhjQjV9ZxBFBcAGkYQBgdYEIu0OACBAVQVgAdQAAA4OBcBCZNjjwPV34QgBAcAGuYT6A+cgRQnABpGIAYHWCELtDgBAQFQAAA4OBcBCdXvUAcFMBQHABsUBwAThAcUBwAVUBcAcIQA+kNQNwBsUEcAVFBXAvBJAAOX8IHAB0YABgdYAAIcSP/8tfABFAcAGvoCtg4EJwAYBEcAGYbBiIIENwAa4mRO8gCRBBcAFQUHABNAGwQMjiFAVYQCQFgUQKYppWnjAOgLTmIC3ggOAAGOwUAAIAyJYI0I1e/msOgMQLWADYsAnBlQMYA4FAcAGjhXDQnV1lpYEB2dQuMF6AtOYgLCCB4AAY7BQBCgDIlhjQjV9UC1gA2LAMM/VBWAA1ABgDc4VwEBjCOTYo8C1TJaUBEEnUfVIZ1D4wXoC05iAqMIHgABjsFAEKAMiWGNCNX1QRWADVQYgAeMI0C4jAlSAH/91RVOYgKPCB4AAY7BQBCgDIlhjQjjBen2QRWADVQYgH+MK0C4nAlSAH/5iQCEoIhh4oPoCkYABgdYAAI4FAaABvoNtg7VEI4hWh//BEj//3gEBwAanMFQAAA4FDcAGjhXAQnV8rQOWggdBEj/+6ACBwE4yAdGAAYHWAACVEj//AhQBwUwUXcAbFFnAvAUBwAbFAcAE4QJFAcAFYB3gLaEAVAXAHBQRwBUFX+ABRVvgARJAALI8IEFb4AEBX+ABcAHRgAGB1gAAnxI//viUDcAUKBcoB+2A1AQgDiEBqgaoJ2EAkAXBCCAd1BHAFiAtkkAAqnwgcAHRgAGB1gAAphI//vH+gO2DvACWggGBEgAAgr6BLYO5sbpKlzzgQLpJxSWgAMUdoAEFcaAABRmgAGADRS3AA4UhwAPgCpJAAPbtA4EloADBHaABAXGgAAEZoABBLcADgSHAA9aAAsESP/7J4QfFAcG8Uj/+yKEAAQXABUUBwbxhAFAEAQMBFcAE44hQDWEAkAyjECmmaYY4wIDAYAB6AtOYgHGCA4AAY7BQAAgDIlgjQjV7YBigvDAJlQQAPDJI5kQhCFAQJAMjoFAFZACQBCIDYg3QBKEQKbJpggDAIABmFPjAegLTmIBowgOAAGOwUAAIAyJYI0I1elAtYgNiwIUJwbxBBcG8UC1jA2LA4hhFDcG8RUHABDIBPoJSP/7QVQQACDBB4QfFAcG8YQLSP/7OFQQAEDBB0YABgdYAAKwSP/7LJYfFAcAEvoFtg4EFwASwSDjAegLTmIBaggOAAGOwUAAIAyJYI0I1fWEAUAABAwEJwAQjgFABYACiAIUBwAQBAcG8UC1hA2LAYggFBcG8QQHABAUBwby+ga2DgQnABaEAUAgCAwEVwAUjkFANYgCQDKMQKZZphjjAQMBgAGAYegLTmIBNAgOAAGOwUAAIAyJYI0I1exUIADwgvDKJpkIhCFAQJAMjoFAJZACQCEMDYhXQCKIQKZRphADAQABmJnjAugLTmIBEwgOAAGOwUAAIAyJYI0I1ekEJwbxQLWMDYhDiwMUJwbxBCcG8UC1hA2LAYgiFBcG8VQQAEDBB0YABgdYAALMSP/6qJYfFAcAEvoHFQcAEbYOBBcAEsEg4wHoC05iAOQIDgABjsFAACAMiWCNCNX1hAFAAAQMBCcAEY4BQAWAAogCFAcAEQQHBvFAtYQNiwGIIBQXBvH6CLYOTnIAxQRXABFABRwB4gXoIAQXAAuaKOIg6AoEFwbwwQdGAAYHWAAC5Ej/+mcEVwAMBBcADeKg6ASKBQRXAAqKoIihBBcAEOIgQBA8GtUFQFSUAQQXABDi4QQHABBAE7wbigEUBwAQiuGACZipCDKAARgwAAHa/AQHABCJIU4D+cz6BEj/+j1OcgCCBAcAEBAEgAD6BI7htg6NIUj/+b0EBwACwE1c9AAg6ArGcAgOAAGOwUAAIAyJYI0I1fWALaANQCUcAYgCqA2AbqAfiAKoH8ITBAcABEAUiAHABgQHAAZJAASt1QUEBwAGSQADxRQHAAYUBoAMBAcABMgPRAD/AEBV4AlAEC0eQFKvAIihQAWAAkBSgQDVAoCrBAcABtAMRgAGB1gAAwQUBoAG+g22DoFHSP/5cYUAgUeBaPoLtg4EBwACwBwEBwAEwBlc9AAg6ArGHAgOAAGOwUAAIAyJYI0I1fUEBwAHTLAACEYABgdYAAMcSP/5wYUAgWj6DLYO1QOEHdUChAHwgYANFJaAA6nEFcaAAKmBBAcAChS3AA4UhwAPyAtMo4AUtA7mHegQ5hrpBPACWgAEDIANgClAJRwBSf/3/cAE+g62DtVSgC0Ej4ADoAmhzIsAoApAdRwBiAioCqANgE6IB6gNoBeIB6gXoBLAGMcXBAcABAQWgAPACAQHAAaKJ4BHSQAEGNUHBAcABoongEdJAAMuFAcABhQGgAyDjrgBuQ/AA0QAAEC0TogBhCBaKAsERBAAgIggWiATBYQAWigOBEQAAQCIARQGgAtOgwADxwTwAloIBAzwAcgJhBvVCIQe3Z6EHtUEhBzVAvAB/OSSAMAWoEfBFAQgAAnCEfwABBCADYDAwQQEAAAK3SKDhroJuAqgd90ihACoN/yAhB7dnvxohMCA5jh/mQmMwVpoEP2AwUEQiCBMaIAKCwMAATh/wQGM4Th/wQnV97XEhi84b8UBzgaPoU8T//xIAAE247LoAoJRhMFPEwAatANEUABAnES2I4RBhCCvQK6BrEG0A52EtsOvQK6BrEGEAbYESAABGDh/mQHPBIzBTGj//IThggfVBI2BWwAQCjk/wQGV+YrzTnT/+UgAAQbHB04CAQNbEAEESAAA/1CfgCCE4BJ0gAGGATh0wQE4r8EBQTTAIIjqjYESeYABWwgP9oTgTHEAEDkAnQFPAgAKOTTBAVCpgAE4pMEJOHLNCYzh1fHADVoAARGF30dQBgdZWovcR0AGB1lKDBzVEIKlgoVE4AAT1QtE4AEAR1AGB1lailpHQAYHWUoKmuLSgPJAczwahgFBCBwMtQNRiH//WggBCFz4A1XpBoQBSAAAtFoAAgqEQIJlh5+Ap4EihYGHPNUWXPgCUdXwTyIASlCpf/9AJQgCiFI5L5kBj8FBKQATOS+ZCU8iAD7i5ulCCqmAAUCzJAHhTlV1gP+FoOkOQPcoB+gIOSqpATiqKQFU2QD/1QSFQETQAGBBZhQMQSEkDUC2LAyJ1ovLQvXkJEEkSECD1kHvLAEQ2QAAEXkAARKpAAGJz0/j//dRI3//QSZIDECpCAJOov+6k8HV+4BS1bxMaIBCAmmAADhgmQHVvkChYAJMrj+9QJOkGkBTJAFAhFhAQSYUDEDfpCBAsqQA43HoBji2lQGLy08mAApBJhQMiZJaCAEJXPgDVdUJjKFBKQQI1exaCAIGXPgCUU7y/3a1w0C1CAg4WSoItcODionLEHkAAbXDiXJBJEgBkcITJYAB1YXCCkAkCEBEAABArhARcQABEyEAAbQDQQBAQLeDtuSEANUHhB/VBU8j/s5I//7Q/Oj8YQUQAAcFMAABtKCDkVAp//u8Fo6hoMSFQUEyiAAEiIAVoIMEmIAMBOiADQVIgApARRAMmlmOQVAx/v9AhSAMjoFB4QQAQSEMALkOuw8FeIALBViAEwVogBSPAfSBUNd//0GE0ABBlyQA5m/oDacpp6pAcgwMUEGACEBDEAyIh4gkjHCMokBAoAJASpBAAQIAAaegpeFAEMANinDOBK/RSAAAylRDABBOQgEHl5+Ah8YR4mboB6cpjKFAQgwMiCSMaEBFGAyOgf8OiIdAEJgNimbmb+gNp6mn6kEDDAxQYYAIQGOYDIjQiCaMcIyi9gFAcJgCQHscQKe4ALOAAaX5VQMAEEAQrA2Ka08CALqXn+JmgWPoEwECgAGNaEEIDAzjZogw6QOModUJAQKAAoyiQLgsDIgrULGAEEA1GAyOYf7OQQGcAEBxeAHi8EAQmA1ANZgB6HZAeBwBQPucBugKBGiG8MYHRkAGB1hCAuRIAACggM1OkwAUQGocAeLkiM3oRlDzAAGKh1CxAAGAxwnHgAGOwRnFgAHO+9U24yfoI0C8HAGK6eLkiW3pA4DL1S+Kh41hUcEAAYHnCMWAAVD3//8YzgAB6frjJIhH6CCKiYDOndEIswABGLOAAUxs//yISdUTQGScAeLkiM3oEFDzAAGKh1CxAAGAxwnHgAGOwRnFgAHO+4hHQGFAAeaD6Qun8a/Rp/Kv0ozDjEOn8K/QjoPV9YDixFoBAwABEQEAAVpAAgSMQdVSpzKMQq861U5AYUABp/Gv0afyr9KOg6fz5oNRAQADULMAA6/T6QSAy4BQ1fGA4oBQxDmmtK68WkACBJy81TOnNZy9rz3VL1UDAEBPAwASQGUYDI7B/45BAxwAQQtAQABoAAAAuAABAngAAUj//y9GQAYHWEICzKkG+o22kdUYVEMAQMwIQGUYDI7B/46ZN0j//uKXroSLzvJGQAYHWEICsNXr4rPoBOJSTvP+xUBBjAlAMZBhiqSEgUBCDAyOgf5mnSm2gEBZlAGdEUApCAGDkYylUCEBAakDqUGohLmOu4/84fxgQHBACZbBWigBFaYIiGBEAP/w4gPoBEQfAA+IYZhf4gHoBEQPAA+IIEABhgRIAADLhAFOEgDI5lDpBETg//HVYohBTBEABwgAgAGIYIjj1fpEAP/w4gPoBEQPAA+IYERA//FAQ5AXQAGCBEgAAKymCABggAxAgYAApgkAUIANQUQAAKYKiRRA2gAApguJDUDGgACmDIkMQLYAAKYNAECADkClgACmDoloQJUAAKYPiUtBNIAAAACACIkqQSmAAAAAgAmJ6UEZAAAAAIAKidNBCIAAAACAC4myiBCJkYjAiBCIpgAwgA+IwIiFiKaIZIiFiIOMMIjkTBf/vEABuHdAA7j3XPEVsOkGUCFqUFDwlbDVr4ChwlWaEYgF5hDpQKeIpgqZM6bJjDCIZJmjiGAAAP/zmTeIg4hgAAD/9IiDiGAAAP/1iIOIYAAA//aIg4hgAAD/94iDiGAAAP/4iIOIYAAA//mIg4hgAAD/+oiDiGAAAP/7iIOIYAAA//yIg4hgAAD//YiDiGAAAP/+iIOIYAAA//+Ig4hgmePVvmYBAA+IoJafiEXSBggCgAGIYIjj1ftEAP/xQBGAd0ADgPdAAZ4E/OD8IE4SAYNEMP8AQEBgCUBRgR5AQgMA/saIhUBCDQD/I0YwBgdYMYzcwhBUAIADwA0IAIABQAATH1AABAA4AYICQEARA45B1fGfzIDHUQF//EYwBgdYMYzcQAgYAYgBXPAAIE7zAP+gMVCDAIj/BZdgQSJgCVBShABRKQcAORGWAkACQAk4UcoCkoiXIEBYlAOWALOgUEIFADhBkgJQAAYAOAGCAkBSxAP/Zf9FlyhBIuAJUEIEAFEpBwA5EZICQALACThBygKSqJdoQEiQA5YAs6FQUoUAOFGWAlAABgA4AYICQEJEA/8t/wWXYEEiYAlQUoQAUSkHADkRlgJAAkAJOFHKApKIlyBAWJQDlgCzolBCBQA4QZICUAAGADgBggJAUsQD/2X/RZcoQSLgCVBCBABRKQcAORGSAkACwAk4QcoCkqiXaEBIkAOWALOjUFKFADhRlgJQAAYAOAGCAkBCRAP/Lf8Fl2BBImAJUFKEAFEpBwA5EZYCQAJACThRygKSiJcgQFiUA5YAs6RQQgUAOEGSAlAABgA4AYICQFLEA/9l/0WXKEEi4AlQQgQAUSkHADkRkgJAAsAJOEHKApKol2hASJADlgCzpVBShQA4UZYCUAAGADgBggJAQkQD/y3/BUACQAmXYEEiYAmWAFBShABRKQcAUAAGADgBggI5EZYCkog4UcoCUGMAIJcgQFiUA1BCBQC1pjhBkgJAUsQD/2X/RUACwAmWAFAABgA5MYICQSLgCZYokqhRKQcAURAEAJdoOEHKAjgBxgJQUoUAOFGWAv8F/y1AQkwDSP/+/mYxAB+I41QxAB+dvFEhgARGUAYHWFKM3EAJGAGIB+YE6SCicf5lQADACZYAUAAGADkyggJBEOAJlgiSKFEYhwBRAAQAlkg4QsYCOALCAlAQhQA4EoYC/wX/DUBCTAPV3ZaPVDGAHMITjGSI40YQBgdYEIzcCAOAAUAAEx9QAAQAOACCAo5BQEARA8r1/yNAEmAJRCD/AEAQkwBAMREeiCP/FkAAkQDVAoAB/KBGAAYQWAAM9IQgrkBEEF+oqEHdnvwARgAGEFgADPRCQIgkRmAGFlhjDKSnQKDBzQPiZOgSjGiIA+IG6fhGAAYJWAAM3EQwX7CEiERQG8xJ/+JQhADVE4QhrkCcY2YQgANQIIAM4kPoCVAggAiOaIhAimGvUKjRqEGMCPyA/ABG8AYQWPeM9FAA//jiD+kHRvAGFlj3jKTiD+kIRgAGCVgADSRJ/+Im1R+gwYRAECD/+FAhgAiIQKZQyQWgUYgjjCioQUYgBhBYIQz0oFGMKIgi4iDoA4BB1fqmUMkFoEGUSYwoqEH8gPxAhMBEkAIYRnAGFlhzjMBCEyQkmLeYD1AQgGAUAQZIiCdEIAgAjMRJ//A1WmgM8oQDPA4aSfzA/AG2H/GBSQAK9VoIAQe0H/EBSQAQftUHWggDBrQf8QFJAAaI/IH8AOYEgMDoCEYABglYAA+UOBAaAtUFRhAGCVgQjUhGAAYJWAANUEn/4cKEA8YFjsKEAEAAGAb8gPwhn8WAB0n/6iWAwMAnPA/kykYABgpYAA/USQAMl4AHSf/qLPCBgCdGAAYJWAANfPIBSf/hoDwMGk5MYEALRgAGCVgADaRJ/+GWhAA8DhpOgAZJ/+omhAHVAfyh/ACgB0n/6kv8gPwgoceAwcYHgAeOwUn/6jqXsdX6/KD8QLShBKAAB8UTpYqA4YjFQJMIAExkgAuACkn/6igYAwABpHqMIax61faEAdUCgAX8wAAA/ED6E0kACumAwE4FABZJAAsvgAZJAAs8wA9GAAYJWAAN6En/4VCEwUScf/9GoAYJWKUPlNUhSQAGt4DA1faABkkABwDmxMAn6Bw4FRoCRgAGCVgADgBJ/+E25sToFzgVGgJGAAYJWAAOREn/4SyABkn//1SAwFpoAeQ4FRoC1RBGEAYJWBCNSNXjRhAGCVgQjUjV6OnzRhAGCVgQjUhGAAYJWAAOcEn/4Q7mxOgkPA3k1kbwBgRY94m8OBeYAEDwvADdDz4EFB5EHH///g5CADwIPA/k1vzAQAAkAkIAQAjVBkAAJAJEEYAA/g88D+TWhOjVD0YABglYAA6AgCZJ/+DiPA3k1oTiQAAkAjwP5NaABkkABlDIB0YABglYAA6sSf/g0YAHSQANkdWi/AA8HBpJRiAGFlghDMDmI+kMRgAGCVgADshEEABnRiAGCVghDtzVEFAwhkg4QQ4CxA1GAAYJWAAOyEQQAGhGIAYJWCEO7EkACK+MITgBDgo8HhpJ/ID8AKAKSf//0/yA/EC0wYDhpEoEoAAHQJMEAExkgAiACigTAAFJ/+nN1fmgOkn//7+EAfzA/AA8bBpJRhAGFlgQjMDOCUYABglYAA8ESf/geoAG1SXmxOkMRgAGCVgADshEEABbRiAGCVghDxDVE54xUGMGRzwOGkk4AJoCyA1GAAYJWAAOyEQQAF5GIAYJWCEPIEkACF6EQDggmgr8gPxAgSGA4gSgAAdJ///GwBJQYABgEnSAArbJFASAAojmTGOACIAKSf/o+BgDAAHV+YQB/MD8IFzxCAGA4ukMgCJGAAYJWAAPJEQgCABJ/+ArhADVC4DBSf//oMAHUBAAYKgytiat8oQB/KAAAPwAPD3kOYSgRkAGClhCDazTHJStmZQAEAAYobFMYMAUgMA8DeT3jgHmBOgpRvAGBFj3i8Q4B4AAQPA8AEoAPAAMLjI4jKHV5YQA1SBGAAYKWAANrIhAoBfAEkYQBglYEI+kSf/uasgLPG4aTtUIwf3VBloYAQXV+VoQAvg8XBpO3gSABkn/6G+EAfyA/ABGAAYJWAAPrEn/39BJAAuT/ID8AEYABglYAA+4SQAJf04FAA1JAAvcwAlGAAYJWAAPrEn/37tJAAt+SQAL60kADbVJAAMgRgAGCVgAD8xJAAlmTgwJgEYABglYAA/YSQAJXk4MCXj8gDxMGk/EGPwAhFyEpERhAABAIRRWjEFAQghAtERUMQADywzgwukMnsHAA4AD1fK2QZwk1QaABN2ehADVAoAD/ID8AEQAAJRJAAqvyAhGAAYJWAAP5En/33bVA0kABVv8gPwELgBpSDxsGlHAB0YABgpYAAzItACIwIAf+jBJ/+R1PAwaUJYEwAmAP0YABgpYAAAgSf/fV9UJRgAGClgAAEiAP4BGSf/fTjwMGlCWDsAHRgAGClgAAGhJ/99E/IT8A4DAPB4aUMAdBBAACIgBoENmEIADiCCMODweGk9J/+kDRgAGClgADMi0ADwcGk+KwIoghAE8HhpPPG4aUT4AaUhJ/+g7Sf//Uy4AaUjAEEYABgpYAAzItAA8HBpRiCA8HhpRPBwaT4gBPA4aT4QrgEFEMJppRgAGClgAAKBJ/98CSQAE1Dwd5NCWBEIQzAlAEIJkPB/k0Dwd5NZCEMgJQACCRDwP5NaEC7BFPgeTVD4Hk1WwBEkACYnwBEkADKjwgUkADLlJAAyj8IJJAASvyAZGYAYKWGMCpNUFRmAGClhjAJRJAAlv8IPxAfICgGb0A/UFRgAGClgAAMhJ/97DSQAM2loAAwxJAAmO8IHxAUYABgpYAAEMSf/etTwsGlHKCEYABgpYAAEkSf/erNUQBAEACIhAoFNGAAYKWAABOGYQgAOIIqBNoJZJ/96cPAwaT8AFPA/k0zwP5M5JAAr6RgAGClgAAUxEEADKRiAGClghAVxJAAaE/YD9IYACgCWAcYBQyGhBKBQGTyIAk0Ug//9BKRQGTyIA90YAD/9QAA//QSAUBvvg+ghACcgagkBAAoANRzAGClk5gXQ4CYAAiBJTIAAgTyIAC0AoSAxACIANQBLIDP6HQDjIDEEQwAlBQUSXQSCAE0EBwAlDOkgkQEJACEBSQARBAswGgBRPAgALiKFAIoQGjgHKBUAizAZOIwGgirNBAsSXltlAQkAIQyhIJP7nQEHIBoBQxAyIYUARhAaOQckHQDHIBo+CQCgMG5IAQABACP6HhgCAEIAi3Z6SAEA4AAZOMwCIRDD//0AxgAZOMgCHRjAP/1Axj/9AAYAG+8D6aEA5ABpQAYAAQDIMDUcgBgpZKQF0ODkMAIgDUzAAIE8zAIdAIggGTiMBRUAYhAZWIIABhgDVYJIAzQSEAUAQFDdEAP//QAAEBsBqRgAP/1AAD/9AQAQG+qD6CEACkBqAgEAAgA1GUAYKWFKBdDgCgACIgFMyACBPMwDDikFBEMAJQSCAE4YBkgBBUUZ3QFHACUNKyCRBOcAIQEmUBEBSUAaAFcUKiIFAIgQGjgHKBUAiUAZOIwENipRBMkS3ltlAUsAIQynIJP7vQFHIBoBTxQuIYUARhAaOQckGQDHIBo/iQCmMG0AAQAj+h4AigBDdnoRAhgCAEIAi3Z6ECF0iAQBAMEgagANI//+BkgBdIoEAhmhACcgagkBI//8QXECBAIQIhKBAApAbgIDVm0ASgA1BQkwMQUoEBEFoAA1BWkAJQZtW90AIgA1AKEwM/odBigATQkzgJEF7wAhBIUAJQBvIBEAAkAaAeUBSzAzADIg0QADQBo5hyAdAAJAGwARQPP/+iDSbDEFiVBeWkUMrYCRAAEAI/hdAIEgGgDbCCIgUQCBQBo4hTiIAiZIAQDHACP5fQUDACZbpQCLACUJaDCSXCYKl/uRDUghzQEHACYiVQFIUBooSQioIJMUFRFEAAIhFkgBAUkAJiEVAUAgGzV1MAQBSgEGGAEj//35AEMwMQVgQDUBQwAlBapR3QAhMDEBIkA3/B0EggBNAMcAIQCJACUMLSCRAAYgEQCBABoKWQDjMDMIOiAFAIAQGUUt//8oIQCBABsIFUUt//ogBkgBBEEABQTiUF5chQinIJEAAQAj+J0BACAaCE8QNiAFAQAQGj4HMCEBACAbEBVEJ//6IAZIAQUpACJqCQQhQBIIlSP/+/EBCQAiW2UE4zAyIZEE5jAZPMv+onomGAEj//ySEQYYASP//IEAgSAZOIv94UBt//ogUSP//c5IAUAr//oiBSP/+8pIAUAp//oihSP/+X5IA/CBGYAYLWGMMOEZwBgtYc4yQTGOAB7QGjMhL4AAD1fr8oPwg/TBMY4AFojLdINX8/KD8AoQogMCwAUkAB4DICEYABgpYAAJ0Sf/cb9UqxgzxAUYABgpYAAKgOgAAADoAgCCEBNUZRgAGClgAAqhJ/9xc8gFHAAYKWQgCwIAQOwBABIAiOwDAJKaAroimga6JpgKuCoQHEg+ABLABSQAHR/yC/ACEAcEQRgAGClgAAshGEAYKWBCELEYgBgpYIQRMSf/cM4QASf//tvyA/AJaGAEGIAAAAFoAPxJGAAYKWAAC3EYQBgpYEIQsRiAGClghBDRJ/9wahMDVJ7ABhCNJAAcegMDICEYABgpYAAJ0Sf/cDNUaRhAGCvABWBCC8KZIrkBGEAYKWBCC8aZIrkFGEAYKWBCC8qZIrkKEAxIPgASwAUkABvSABkn//3X8gvwigOGAwJ4VSf/kV+bi8IHpBSADAABaAD0RRhAGClgQhCxGIAYKWCEEPEYABgpYAAL0Sf/b09UTjMGABrBDhEBJ/+ptth/wAyAAAADACkYABgpYAAMUgCZJ/9vAhMDVAoTBgAZJ//9Axg+0P0YABgpYAANISf/bsvABSf/kefABtD9J/+Tm/KL8AYTB8oHBEEYABgpYAALIRhAGClgQhCxGIAYKWCEEREn/25iEwIAGSf//GsYF8AGEIEkACi78gfxhhMCBIPGBRsAGCljGBAw4hhsCQLMMCIAISf/p7LVJgOCAKoAIgEdJ/+nsyBgCFIACTHCACDgFHABUAAD9Wgg9D0YABgpYAAQMiWAENYABQAUcAIon8gHdI9UOjMFaaATZRgAGClgAA2S0KUn/21aEAEn//tn84fxEgOCOBUn/47zwgUQRwgBGAAYKWAADhEn/20TwAUQRwgBJ/+R6sAWEKkkABkXIBkYABgpYAAJ01R7zBUYgBgpYIQO0OwFEBIADOwBEJKZQrkCECRIPgAywBUkABiWwAkQQAMhJAAYohSDIJkYABgpYAAPASf/bFvzEsAKEIRKfgAZJAAYHpjBaAAr5WgAN97AChCFJAAX+Ai+ABpgyAAB//1oIDRJaKMgWRgAGClgAA+xJ/9r38AKEIEQgAMhJ/+lL9gLV21oACvBc8QDI6eHV645BlpGEABIvgAaAJzgDCAiwAkn//1LV5/wARgAGC1gADJBGEAYLWBCMsEn//lD8gN2e/AG2H/GBSf/aPLQf8QFJAAAD/IFlAwACRwAAAGUDAAO0waHJBICAAgSQgAMEoIAEBLCABQTAgAbdAPwBhAawQYRASf/fGYDAyAhGAAYKWAAEUEn/2qXVEvYBRhAGClgQhHyABoRISf/pD8AIRgAGClgABIhJ/9qUhMCABvyB/ABJ///dwAMAAAAI/ID8QoFASf//1YDAwDeFIUCUqAyMCoTgCBAAAUAQpALJBIzhWngD+gATAAlAAKgOlgTIA88m1SNacAMiOwNMADsPzCDPBwAfgAlAEKQSEB+ACYAnRgAGClgABLCI/0n/2loAA4AKgD9AkCQS+kCABhCTgApJ/97l1QvVCoQB1QhacAP+OwNMADsPzCDV4/zC/ACAwEn//47AEIQhQCCYDIwKhCAIMAAB/tbLBIwhWhgD+54LXAAAAfyARgu5pjxcHAFQAAyg2AxGAQhjPFwcAlAABe/YBTwMHASSH92ehADdnvwigOCwQ7ACSQAEt4DHhAOqMfACSQAH0/CB8QGABoRIRmAGGFhjDMxJ/+iSUAOADEYQBgpYEITYRCAAgEn/6IiABoQg+kBJ/+hPRgu5plAADKC2BkYBCGNQAAXvqDGEAagyFGOAI0YABgtYAAAMoEWpxkIQzAioRfyi/EDu4IRApsmnCEAxwAhAMZMEpwuMJP7nAED//kAxkQSxCDgyCAqMRFooQO+AZERgADCAowQhgA605QRCgAlAUUQLiIdAcUwLoFn/fUAiiV+IREBQyAtAQJwL/y1AEgR/jGSIIo7BFBGAD87kUAAAUDsAXACAPzsP3CBGkAYKWJSFCLCIOHSaAjghGgJAShgLiEdAeiwL/+VASmQL/+VAWtACQEtQEv8tiOKYvEAxXABAKUQDQCFAAkBJRAJAURADQEgIC0AoNAv+pUBIWAv+pYhFjMFAeYwAiEOC9oJyWmBACYJRgtWCMIK0ggKCh9XKtl8VYIAHqcwVQIAFFVCABhUAgAEVEIACFSCAA4RAtIA4MIoCjEGIZKrBWigI+u0g/MBQQABAhCC2JEYQBgpYEITohGCEQFAAAFA7ANwAqKKo4zsAXCDdnvxAhUD9MECQiABMdIAdg4a4EAgTgAE4EwAIjAG4kFoIQPaDhoAGgCZJ//9IuBO5ElAwAgBAAYAGiAG4kruTFKMAENXk/MD8IIDABAAAEIDhnUFEH/+AXPAAODgTAAiIpugIUAMAOIQg0BYYEoAB1f2EIJouXPAAQOgEGBKAAdX6gAaAJkn//xqABoQgRCAAOEn/50mDhrkQuBOUS7oSiAFAEAQGiCJAICAJuZK4kxADAD8QIwA+QCBACZIYEAMAPEAAoAkQEwA7EAMAOkAAwAmSOBAjAD0QAwA5EBMAOIAGgCZJ//7rgCeEQ4OGuxSUE0AxgA2uyLsVjkFAMYANrsy7FowhQDGADa7PuxdAMYANEDCAC7sYQDGADRAwgA+7GUAxgA0QMIATuxpAMYANEDCAF7sbQAGADRAAgBtaL//X/KDCPfwgp0WkwKUBxQ+nRAhggAFAUxUEiGWIg5dZQDKOHJdhQEKSHI5Bl9SvxZJBwhxc8QFpgKLpA0RQAWiKRUBQlCBMEoALp4gBAIABQGgZBIhmiIOMItX2l1lAMo4cl2FAQpIc1eXHA6ZIrkRAMY4cQEISHKzArQH8oN2epsWkQKSBwwumBEAQgQCIQZYJQBAGHJYRQCAKHJYJltFAIYocQAAGHEAACgTdnvwCth+EH/GBEg+ABRIPgASEABAPgA20P7AC8gFJ//+dsAJJ///Y/IL8IkZgBgpYYwYI84PygvGBgOBJ/9cBgAZJ/9ghRhAGClgQhnQ4AJ4CSf/YGfIC8QFGAAYKWAAGOEn/2BHxA0YABgpYAAZISf/YCoAGSf/YB0kACE/8AvCB8YLyg4QA8QHyAvMDSf//zvwC8IHxgvKDhAHxAfIC8wNJ///E5gToFkbwBgVY94v0OAeAAEDwPABKADwABAgMEIQA1QaEAdUEhALVAoQDPA4aVN2ePA3lBFoAAQ7ABVoIAg6ECdUJLgeUvMgDhALVBIQD1QKEBDwOGlU8DBubwAM8DhpT3Z78QITARpAGCliUh0xGcAYYWHOGIDgEmgJJAAE8OAOaCozBWmgE+fzAAAD8YEawBhhYtYs0RsAGGFjGBiDmDTwP5NjoXkbwBgVY94yUOAeAAEDwPADdDxqoHhokKCwwNDg8QA4ARqAGGFilCzSFINUqhAHVE0n//63VQ4QC1Q6EA9UMhATVCoQF1QiEBtUGhAfVBIQI1QKECTwOGlXVMTgGHgJOBQAISQABUEAAHAz/h5ewjOFaeAT1AFUAbNYKjSGNTDwMG7WEwOMg6BiA5tXoBAUAHVoIDAlGAAYKWAAGfEn/107V7YQMgMtCZIBzg4a4HEn//1a4HdWiPG4aVfzgkgD8ADwN5NjICDwMGlVaCAEFSf//XtUfPA3k2TwcG5yMAeIBPA/k2ekEhAA8D+TZPB3k2YQMRmAGGFhjCzRCYIBzoDQ8DhpToDNJ//8qoDJJ//9t/ID8AEn//9X8gPwAPCwaVTxMGlRGEAYKWBCHbEYwBgpYMYdcOBCKAjgxkgI8LBpTRgAGClgABpxJ/9b4PAwaVfyAPAwaU92ePAwaVN2e/ABJ//+vPCwaVTxMGlRGEAYKWBCHbEYwBgpYMYdcOBCKAjgxkgI8LBpTRgAGClgABsRJ/9bUPAwaVfyA/EBGcAYLWHOCdPo0gEdCIARzRmAGC1hjDNgEIQAIRhAGC1gQjPBMYIAJtKbSA4zY1fugcVof/wSEH9UbgSCgNLQgyQ76FEJ0gHOgcaA5iAFGEAYYWBCGMDhgggrVCvoUgEdCJIBzgAKMBN0hyOzV5fzA/ECE4EZgBgtYYwzYRpAGC1iUjPCFX0xkgBSgMogHXPABAOgKoHPJBaAyqfGI4NUGtAbdIcj6FKMAAYzY1e38wICgPB3la4QA+lRGMAYLWDGCdEwAgA2Ag0JACHOhItQDjAHV+PwASf//lPyAhB/dnvwAPD3la4Qg+pRGUAYLWFKCdEwRgAyARUIgkHOhkUwDQASgFdUEjCHV9YQA/ID8QTx95WvwgYTA+zRGoAYLWKUCdExjgBCAKkITJHPwAaBPSf/ktsgFgAZJ//9j1QSMwdXxhB/8wUYQBhhYEIYwOBCCAsEJoIygksIG/ACgSYoB3SL8gN2eRhAGGFgQhjA4IIICwgmgVKBNwQj8AKCRigLdIfyAgALdnoAB3Z5GIAYYWCEGMDghAgLCCqDUoRrEB/wAoRGgm4oE3SL8gN2e/CBGGCABUFCML0YABhhYAApAggVGcAYYWHOKOEZABhhYQgowUCCMK5xsqEFQEoAIqEJQEoAMqENQEoAQQDgUAahEUBKAFLagqEWZn1ASgByIZI6hqEaphxQwAAhGGCABUAAAJNriRgggBVAgAfk8LhuCUCAB/TwuG4NQQAH4UCACATwuG4Q8ThuLUCACBVBAAfw8LhuFPE4bjFAgAglQQAIAPC4bhjxOG41QIIxFUEACBFAAAgg8LhuHPA4bj1AgjE1QAIxEPC4biDwOG5BGMAYYWDGKPFAAjExGIAYYWCEKNDw+G4k8LhuKPA4bkYxhhACMQTxOG448PhuSPC4bkxQAgxASAIYiRgAGGFgACkD8oOQa6QKMBt2e5BrpAo4G3Z78AFwQgAFJAAFQ/IA8DBuV3Z5GKJq8PFwcBVAhDe/aEDwsHAY8LhuWPCwcBzwuG5WEQDwuHAU8LBwIPC4blDwsG5bCBrZAPAwblLYB3Z78IIDBgOBJAAMVPA4blkkAAws8HBuWtic8DhuUtgb8oEYQBgpYEIe8OACCAt2ePA4bld2e/ABGSJq8RjAGGFgxjNxQQg3vtoOoGahaqJtJ/9SJ/IA8DhuX3Z78AbYfPAwbl/GBtGC0P/IB3SP8gfwBth88DBuX8YGgwbQ/8gHdI/yB/AHwgTwMG5fxAaCE3SL8gfwBth88DBuX8YGgxbQ/8gHdI/yB/AHwgTwMG5fxAaCG3SL8gUYnJia0oFAhDWPaD+Ys6Q2gQaACPB4bmo4BiAE8DhuYPB4bmYQB3Z6EAN2egCA8DBuawBA8DBuZPCwbmIw/ZhCAH4pA4kHpBYggPB4bmd2ehADdnkYgX15QIQEAgCJGOCAFAEGBdMQDjkHK/EY4IAUAQYJaRiggBcQDjiHJ+hABAlSEABQBAJgEUQBcBAEAXND+RgBfXlAAAQBGGCAFACCCWsIDjgHI/EYIIAUEAACY3Z78QIFCgOGAw4EgQHOoDEn//8pGUF9eQAAcEkBjKAxQUoEA/4eAhUYIIAUAEAF0wQOOoc38RhggBQAgglpGCCAFwgOOgcz6EJACVBRgAJcEUABcBBAAXNH+RgBfXlAAAQBGGCAFACCCWsIDjgHI/PzA/CCA4YDAVBM//4QGhE+AZ0n//8BGCCAFg4C5bpWyQGCYEkBjHES+7rlu/ku58fyg/ACEQIBihAeEP0n//6tEA///hCBJ///ehECAYoQIRBA//0n//5+EBoQhhEyEYEn//5lGCCAFg4CEILnuuW7+S7nxRhEAALmIhCEQEAAo/IDmG+kr/ECA4IQGgUFQY//lSf//UYRBQGEYDFSTP/9ABIH+hEDiQFqoAQbpFoAGgCbVEegShAhJ//8+QAAkAsAIRgAGClgAB8yAJ0n/0+6ABoQgSf//l/zA3Z5GGCAFAhCBDIRAlklGQAYKWEIIDMEMlszDBzgyCgJaN/8ETAGAB4xBkiHV9YAB3Z6EAd2ePAwb5sAw/ABGaCAFAAMCEJYAWgABCUYABgpYAAhESf/TvYQAABMCEVoQAQlGAAYKWAAIaEn/07KEAAATAhJaEAEJRgAGClgACIxJ/9On1QLICUYABgpYAAiwSf/Tn0n//2L8gN2e/EFJ//yJgOBGkAYLWJSOIEn//J7wgUZgBgtYYw3gTGSAGKFz3xO0RsoKoLLxAYAH3SKgccEJgAfdIdUGgAfxAd0iyPTVA0n/4CGM0NXpSf/8hYDg1d78IEAAABSXgVpgAQ2EAcYpWmgCHkYABgpYAAksSf/TYNUdOHCIAoABQHOAFIAiSf/7FkBzwAuAIExwABOAR0YABgpYAAjkSf/TS9UIRgAGClgACVyAJkn/00OEANUCgAb8oPxCsEKwg/CBSf/XpcgHRgAGClgACYjxAdUQ9gJGEAYKWBCJsIAGhERJ/+GdwApGAAYKWAAJuLQmSf/TIUgAAOMAIwAdABMAHECRQAhAlIcEABMAHkCUhQQAEwAfQJCkBECUgBRAlMALWp//CEYABgpYAAncSAAAwgATAAkAIwAIQBDACEAQiwQAIwAKADMAIkAQiQQAIwALAHMAI/5XQBCAFEIQwAvBC0BzjQRAc4AUlrlQEwAk+viAYNVIQHONBAAzACUAAwAkQDHACEAxgwQAAwAmQHOAFEAxgQQAAwAnlzn+x0AxgBRAMcALWjf/wAADACoAcwArQHOBBEBzgBSX+YjkAEMALQATACxAQkAIAFMALgADAC9AQgcEQEIVBP8HQAIAFEAAQAtaB/+hABMAMgAjADNAIQUEQCEAFJaRiEdQEwA0RHAAOIhgiGmIZ6QIiEOAJkn//yTIBkYABgpYAAn41UrwAph3AgAAEIBJSf//F8gGRgAGClgAChjVPUn/3xX2AkYQBgpYEIo8iMeABoRESf/g58glpjWmdEAAQAhAAAcEpnYAIwAIQAAFBKZ3/g8AEwAJQAAAFEAQwAhAEIsEACMACkAAQAtAEIkEACMAC4gG/ldAEIAUQBDAC9UDgAaAKUn/3wFJ/99DyAhGAAYKWAAKREn/0kHVA0n/30r8wkYQBgpYEIqkOACCAt2eRgggAoQgUAAMAK5E1QBGCCACUAAMAKYB3Z48DBvnyCRGGCACUBCMAKZJhGGWSEAhgAz+jowBwgQ8Dhvn1QNaCAn4PBwb50YIIAVaGAEJBBAAcVobCgWEIzweG+eEIBQQAHE8DBvn3Z78AEn//9iAwIQASf/805405gLoD4QggAaAQUn//M5J/9qYRgggAoQgUAAMAK5E1QD8gEYYIAIEAIIAhEAUIIIARhTlYEBQBALZB5YBwAZaAAEFhALdnoQD3Z78AbYf8YG0H/EBSf/8vMD8/IH8Y1BxABCBYPGBsAOAJ4DCSf/8zMgJgCdGAAYKWAAKyEn/0brVThJ/gAguoG+mPHwb6MYM8APxAYBGjBBJ/+AN8AGAJkkAAfWBIPMDRAAAdK4YRAAAc64ZRAAAYa4aRAAAZq4bQAMgCa4eQAPgCRABgAhAA8AJEAGACUADoAmEIBABgApABKAJEAGADhCxgAQQoYAFr58QcYALEBGADBARgA0QkYAPsANJ//x4yApGAAYKWAAK9En/0W+wA0n//ID84/wAhCBEAAD/gEFJ//+a/ID8REYABgpYAAsURnZmF0n/0VpQc4N0hADwhFCfgBSwAYQhSf//ffABpkDwBEAAgQTwhLABSf/8W/UE3/KwAYQsSf//bvABOwBIALABOwTIIEn//E0Cb4AOxhWEABIPgA76ILAESQABfIAgTAMADIBGRgAGClgACyxJ/9ElSf//utXPAB+AFOYk6AxG8AYGWPeJlDgHhABA8DwA3Q8SOl74RgAGClgAC1xJ/9EN1bU8YDfSzghJ/92fPmBvpjxuG+jVAoTfhCBEAACAgEFJ//8xxqNIAAC7RgAGClgADEC0APCBAA+AFT4Ab6bwBjwOG+iwQUQAAIGERNVKAB+AFS4gb6ZMEUBSPCwb6PEGnBFMEEBMAm+AC1pgAghGAAYKWAALoIAm1VewAYAmSf/++fABpkAQH4AApgEQD4ABsAFJ//vWgCaAH0kAAQsCH4APgEBMEAAHRgAGClgAC7zVKQIfgABc8Ifx6QhGAAYKWAAL6EQgB/DVHTwMG+g8GDfSjAGEIDwOG+iAQUQAAIJJ//7RSP//QwAfgBUuIG+mhAASD4AATBEACUYABgpYAAuESf/QitVHPCwb6PEGnBFMEH/1Ah+ACzxQN9LRB0YABgpYAAughELV7YAlsAFJ//6hPBA30vABSQAAvAIfgA+AQEwQAAlGAAYKWAALvEn/0GTVGDwMG+iAP4wBPA4b6IRCRAAAg0n//o7wATwQN9JJAAAiwAtGAAYKWAAMGEn/0EywAUn/+13VBrABSf/7WUj//u1J//7YSP/+6Un/3TjAA0n/3UZGAAYKWAAMNEn/0DT8xPxCLmefUYEggOHGZLABSf/7NIFAyAmAJ0YABgpYAAxESf/QIdVnLhBv4MkfhAE+AG/gPB4b6jweG+tGAAYYWAAMcPowRiAGBlghDrhEMAA4Sf/gkYAgwAlGAAYKWAAMeEn/0AGAytVGPJ4b6jx+G+vwATwOG+0CD4AEPA4b7oQiRgAGGFgADHA8bBvvSf/guOYCgCDpFy4Hn1DACoQAPgefUD4Hn1GwAUn/+vHVE0YABgpYAAygPCwb8En/z9SEwdUZPHwb74QAPgefUASfgAGK5oAJgCdJ/9x9gMAuB59RzgXACDwcG+vJxMAEsAFJ//rOgAb8wvwASf/9gYRARED//44hlklMEgATQDEgCZbYQCGJBAgwAAH+nZbQQCEMn0AhCYOW0EAhDKPV7JYR3Z5SZXNldAoAAE5vIGNhbGxiYWNrIGZvciBJUlEgJWQKAEJMOiBleGNlcHRpb24gJWQgSVRZUEU6IDB4JTA4bHggUEM6IDB4JTA4bHggRVZBOiAweCUwOGx4CgAAAEVycm9yOiBVbmhhbmRsZWQgTk1JISEhCgAAAAAweAAAAQAAAAAAAAogKGNvbXByZXNzZWQpAAAAZWxmOiBIZWFkZXIgZmluaXNoZWQKAAAAZWxmOiBFcnJvcjogSW52YWxpZCBoZWFkZXIKAGVsZjogSWdub3JpbmcgbmV4dCAlZCBieXRlcwoAAAAAZWxmOiBXYWl0aW5nIGZvciAlZCBieXRlcwoAAGVsZjogRXJyb3I6IEhlYWRlcnMgdG9vIGxhcmdlCgAAZWxmOiBQcm9ncmFtIEhlYWRlciBmaW5pc2hlZAoAAABlbGY6IFNlY3Rpb24gaXMgZW1wdHkKAABlbGY6IFBIIDB4JTA4WCwgJWQgYnl0ZXMlcwoAZWxmOiBFcnJvcjogTm90ZSB0b28gbGFyZ2UgPT4gc2tpcHBpbmcKAGVsZjogRXJyb3I6IElsbGVnYWwgcmFuZ2UgWyVwLCAlcFsKAGVsZjogRXJyb3I6IENhbid0IGVuYWJsZSBjcnlwdG8KAAAAAGVsZjogTm90ZSAweCUwOHgKAAAAU1FOAGVsZjogRXJyb3I6IEluZmxhdGUgZmFpbGVkIDogKCVkKSAlcwoAAAB6bGliAAAAADEuMi44AAAAZWxmOiBFcnJvcjogSW5mbGF0ZSBpbml0IGZhaWxlZCA6ICVkICVzCgAAAABlbGY6IEVMRiBmb3JtYXQgc2VsZWN0ZWQKAAAAf0VMRgECAQBlbGY6IGtleSAlcyAAAAAAJTAyWAAAAABlbGY6IEVycm9yOiBVbnN1cHBvcnRlZCBjcnlwdG8gaGVhZGVyIHZlcnNpb24KAABlbGY6IEVycm9yOiBDYW4ndCByZXRyaWV2ZSBwcmltYXJ5IGJvb3Qga2V5CgAAAABib290AAAAAG1hc3RlcgAAZW5jcnlwdGlvbgAAZWxmOiBFcnJvcjogTm8gbWF0Y2hpbmcgYm9vdCBrZXlzCgAAZWxmOiBNYXN0ZXIga2V5IHZlcmlmaWVkCgAAAGVsZjogRGVjaXBoZXJpbmcgUEglZAoAAFVua25vd24ATWFjcm9uaXgAAAAAV2luZGJvbmQAAAAARXJyb3IgaWRlbnRpZnlpbmcgZmxhc2ggQDB4JXgKAABVbmtvd24gZmxhc2ggSUQgMHgleAoAAABbR1BJT10gRXJyb3I6IEhBTCBpbml0IGZhaWxlZAoAAABgGMAAYBtwAGAabABgFogAYBp2AGAZcFdBUk5JTkc6IEZsb3cgY29udHJvbCBwcmV2ZW50cyB0byBzZW5kIGRhdGEgb24gdWFydCVkCgAAcHNkAHBzaQAA/yMARXJyb3I6IEZsYXNoIGlzIG5vdCBpbiBxdWFkIG1vZGUsIGl0IG1heSBiZSB1bnN1cHBvcnRlZAoAAAAAc2JwOiBCb290aW5nIGF0ICVwLi4uCgAAc2RtYS5jAABfZmlmbwAAAEJMOiBXYXRjaGRvZyB0aW1lb3V0IQoAAGluY29ycmVjdCBoZWFkZXIgY2hlY2sAAHVua25vd24gY29tcHJlc3Npb24gbWV0aG9kAABpbnZhbGlkIHdpbmRvdyBzaXplAHVua25vd24gaGVhZGVyIGZsYWdzIHNldAAAAABoZWFkZXIgY3JjIG1pc21hdGNoAGludmFsaWQgYmxvY2sgdHlwZQAAaW52YWxpZCBzdG9yZWQgYmxvY2sgbGVuZ3RocwAAAAB0b28gbWFueSBsZW5ndGggb3IgZGlzdGFuY2Ugc3ltYm9scwBpbnZhbGlkIGNvZGUgbGVuZ3RocyBzZXQAAAAAaW52YWxpZCBiaXQgbGVuZ3RoIHJlcGVhdAAAAGludmFsaWQgY29kZSAtLSBtaXNzaW5nIGVuZC1vZi1ibG9jawAAAABpbnZhbGlkIGxpdGVyYWwvbGVuZ3RocyBzZXQAaW52YWxpZCBkaXN0YW5jZXMgc2V0AAAAaW52YWxpZCBsaXRlcmFsL2xlbmd0aCBjb2RlAGludmFsaWQgZGlzdGFuY2UgY29kZQAAAGludmFsaWQgZGlzdGFuY2UgdG9vIGZhciBiYWNrAAAAaW5jb3JyZWN0IGRhdGEgY2hlY2sAAAAAaW5jb3JyZWN0IGxlbmd0aCBjaGVjawAAEAUAARcFAQETBQARGwUQAREFAAUZBQQBFQUAQR0FQAEQBQADGAUCARQFACEcBSABEgUACRoFCAEWBQCBQAUAABAFAAIXBQGBEwUAGRsFGAERBQAHGQUGARUFAGEdBWABEAUABBgFAwEUBQAxHAUwARIFAA0aBQwBFgUAwUAFAABgBwAAAAgAUAAIABAUCABzEgcAHwAIAHAACAAwAAkAwBAHAAoACABgAAgAIAAJAKAACAAAAAgAgAAIAEAACQDgEAcABgAIAFgACAAYAAkAkBMHADsACAB4AAgAOAAJANARBwARAAgAaAAIACgACQCwAAgACAAIAIgACABIAAkA8BAHAAQACABUAAgAFBUIAOMTBwArAAgAdAAIADQACQDIEQcADQAIAGQACAAkAAkAqAAIAAQACACEAAgARAAJAOgQBwAIAAgAXAAIABwACQCYFAcAUwAIAHwACAA8AAkA2BIHABcACABsAAgALAAJALgACAAMAAgAjAAIAEwACQD4EAcAAwAIAFIACAASFQgAoxMHACMACAByAAgAMgAJAMQRBwALAAgAYgAIACIACQCkAAgAAgAIAIIACABCAAkA5BAHAAcACABaAAgAGgAJAJQUBwBDAAgAegAIADoACQDUEgcAEwAIAGoACAAqAAkAtAAIAAoACACKAAgASgAJAPQQBwAFAAgAVgAIABZACAAAEwcAMwAIAHYACAA2AAkAzBEHAA8ACABmAAgAJgAJAKwACAAGAAgAhgAIAEYACQDsEAcACQAIAF4ACAAeAAkAnBQHAGMACAB+AAgAPgAJANwSBwAbAAgAbgAIAC4ACQC8AAgADgAIAI4ACABOAAkA/GAHAAAACABRAAgAERUIAIMSBwAfAAgAcQAIADEACQDCEAcACgAIAGEACAAhAAkAogAIAAEACACBAAgAQQAJAOIQBwAGAAgAWQAIABkACQCSEwcAOwAIAHkACAA5AAkA0hEHABEACABpAAgAKQAJALIACAAJAAgAiQAIAEkACQDyEAcABAAIAFUACAAVEAgBAhMHACsACAB1AAgANQAJAMoRBwANAAgAZQAIACUACQCqAAgABQAIAIUACABFAAkA6hAHAAgACABdAAgAHQAJAJoUBwBTAAgAfQAIAD0ACQDaEgcAFwAIAG0ACAAtAAkAugAIAA0ACACNAAgATQAJAPoQBwADAAgAUwAIABMVCADDEwcAIwAIAHMACAAzAAkAxhEHAAsACABjAAgAIwAJAKYACAADAAgAgwAIAEMACQDmEAcABwAIAFsACAAbAAkAlhQHAEMACAB7AAgAOwAJANYSBwATAAgAawAIACsACQC2AAgACwAIAIsACABLAAkA9hAHAAUACABXAAgAF0AIAAATBwAzAAgAdwAIADcACQDOEQcADwAIAGcACAAnAAkArgAIAAcACACHAAgARwAJAO4QBwAJAAgAXwAIAB8ACQCeFAcAYwAIAH8ACAA/AAkA3hIHABsACABvAAgALwAJAL4ACAAPAAgAjwAIAE8ACQD+YAcAAAAIAFAACAAQFAgAcxIHAB8ACABwAAgAMAAJAMEQBwAKAAgAYAAIACAACQChAAgAAAAIAIAACABAAAkA4RAHAAYACABYAAgAGAAJAJETBwA7AAgAeAAIADgACQDREQcAEQAIAGgACAAoAAkAsQAIAAgACACIAAgASAAJAPEQBwAEAAgAVAAIABQVCADjEwcAKwAIAHQACAA0AAkAyREHAA0ACABkAAgAJAAJAKkACAAEAAgAhAAIAEQACQDpEAcACAAIAFwACAAcAAkAmRQHAFMACAB8AAgAPAAJANkSBwAXAAgAbAAIACwACQC5AAgADAAIAIwACABMAAkA+RAHAAMACABSAAgAEhUIAKMTBwAjAAgAcgAIADIACQDFEQcACwAIAGIACAAiAAkApQAIAAIACACCAAgAQgAJAOUQBwAHAAgAWgAIABoACQCVFAcAQwAIAHoACAA6AAkA1RIHABMACABqAAgAKgAJALUACAAKAAgAigAIAEoACQD1EAcABQAIAFYACAAWQAgAABMHADMACAB2AAgANgAJAM0RBwAPAAgAZgAIACYACQCtAAgABgAIAIYACABGAAkA7RAHAAkACABeAAgAHgAJAJ0UBwBjAAgAfgAIAD4ACQDdEgcAGwAIAG4ACAAuAAkAvQAIAA4ACACOAAgATgAJAP1gBwAAAAgAUQAIABEVCACDEgcAHwAIAHEACAAxAAkAwxAHAAoACABhAAgAIQAJAKMACAABAAgAgQAIAEEACQDjEAcABgAIAFkACAAZAAkAkxMHADsACAB5AAgAOQAJANMRBwARAAgAaQAIACkACQCzAAgACQAIAIkACABJAAkA8xAHAAQACABVAAgAFRAIAQITBwArAAgAdQAIADUACQDLEQcADQAIAGUACAAlAAkAqwAIAAUACACFAAgARQAJAOsQBwAIAAgAXQAIAB0ACQCbFAcAUwAIAH0ACAA9AAkA2xIHABcACABtAAgALQAJALsACAANAAgAjQAIAE0ACQD7EAcAAwAIAFMACAATFQgAwxMHACMACABzAAgAMwAJAMcRBwALAAgAYwAIACMACQCnAAgAAwAIAIMACABDAAkA5xAHAAcACABbAAgAGwAJAJcUBwBDAAgAewAIADsACQDXEgcAEwAIAGsACAArAAkAtwAIAAsACACLAAgASwAJAPcQBwAFAAgAVwAIABdACAAAEwcAMwAIAHcACAA3AAkAzxEHAA8ACABnAAgAJwAJAK8ACAAHAAgAhwAIAEcACQDvEAcACQAIAF8ACAAfAAkAnxQHAGMACAB/AAgAPwAJAN8SBwAbAAgAbwAIAC8ACQC/AAgADwAIAI8ACABPAAkA/wAQABEAEgAAAAgABwAJAAYACgAFAAsABAAMAAMADQACAA4AAQAPAAAAEAAQABAAEAARABEAEgASABMAEwAUABQAFQAVABYAFgAXABcAGAAYABkAGQAaABoAGwAbABwAHAAdAB0AQABAAAEAAgADAAQABQAHAAkADQARABkAIQAxAEEAYQCBAMEBAQGBAgEDAQQBBgEIAQwBEAEYASABMAFAAWABAAAAAAAQABAAEAAQABAAEAAQABAAEQARABEAEQASABIAEgASABMAEwATABMAFAAUABQAFAAVABUAFQAVABAASABOAAAAAwAEAAUABgAHAAgACQAKAAsADQAPABEAEwAXABsAHwAjACsAMwA7AEMAUwBjAHMAgwCjAMMA4wECAAAAAAAAAAAAAHcHMJbuDmEsmQlRugdtxBlwavSP6WOlNZ5klaMO24gyedy4pODV6R6X0tmICbZMK36xfL3nuC0HkL8dkR23EGRqsCDy87lxSIS+Qd4a2tR9bd3k6/TUtVGD04XHE2yYVmRrqMD9Yvl6imXJ7BQBXE9jBmzZ+g89Y40IDfU7biDITGkQXtVgQeSiZ3FyPAPk0UsE1EfSDYX9pQq1azW1qPpCsphs27vJ1qy8+UAy2GzjRd9cddzWDc+r0T1ZJtkwrFHeADrI11GAv9BhFiG09LVWs8Qjz7qVmbi9pQ8oArieXwWICMYM2bKxC+kkL298h1hoTBHBYR2rtmYtPXbcQZAB23EGmNIgvO/VECpxsYWJBra1H5+/5KXouNQzeAfJog8A+TSWCaiO4Q6YGH9qDbsIbT0tkWRsl+ZjXAFra1H0HGxhYoVlMNjyYgBObAaV7RsBpXuCCPTB9Q/EV2Ww2cYSt+lQi7646vy5iHxi3R3fFdotSYzTfPP71ExlTbJhWDq1Uc6jvAB01Lsw4krfpUE92JXXpNHEbdPW9PtDaelqNG7Z/K1niEbaYLjQRAQtczMDHeWqCkxf3Q18yVAFcTwnAkGqvgsQEMkMIIZXaLUlIG+Fs7lm1AnOYeSfXt75DinZyZiw0Jgix9eotFmzPRcutA2Bt71cO8C6bK3tuIMgmr+ztgO24gx0sdKa6tVHOZ3Sd68E2yYVc9wWg+NjCxKUZDuEDW1qPnpqWqjkDs8Lkwn/nQoArid9B56x8A+TRIcIo9IeAfJoaQbC/vdiV12AZWfLGWw2cW5rBuf+1Bt2idMr4BDaelpn3UrM+bnfb46+7/kXt75DYLCO1dbWo+ih0ZN+ONjCxE/f8lLRu2fxprxXZz+1Bt1IsjZL2A0r2q8KG0w2A0r2QQR6YN9g78OoZ99VMW6O70ZpvnnLYbOMvGaDGiVv0qBSaOI2zAx3lbsLRwMiAha5VQUmL8W6O76yvQsoK7RaklyzagTC1/+ntdDPMSzZnotb3q4dm2TCsOxj8iZ1aqOcAm2TCpwJBqnrDjY/cgdnhQUAVxOVv0qC4rh6FHuxK64Mths4ktKOm+XVvg183O+3C9vfIYbT0tTx1OJCaN2z+B/ag26BvhbN9rkmW2+wd+EYt0d3iAha5v8PanBmBjvKEQELXI9lnv/4Yq5pYWv/0xZsz0WgCuJ41w3S7k4Eg1Q5A7PCp2cmYdBgFvdJaUdNPm53267RakrZ1lrcQN8LZjfYO/CpvK5T3ruexUeyz38wtf/pvb3yHMq6wopTs5MwJLSjprrQNgXN1waTVN5XKSPZZ7+zZnouxGFKuF1oGwIqbyuUtAu+N8MMjqFaBd8bLQLvjQAAAAAZGzFBMjZigistU8NkbMUEfXf0RVZap4ZPQZbHyNmKCNHCu0n67+iK4/TZy6y1Twy1rn5NnoMtjoeYHM9KwhJRU9kjEHj0cNNh70GSLq7XVTe15hQcmLXXBYOEloIbmFmbAKkYsC3626k2y5rmd11d/2xsHNRBP9/NWg6elYQkooyfFeOnskYgvql3YfHo4abo89Dnw96DJNrFsmVdXa6qREaf629rzCh2cP1pOTFrriAqWu8LBwksEhw4bd9GNvPGXQey7XBUcfRrZTC7KvP3ojHCtokckXWQB6A0F5+8+w6Ejbolqd55PLLvOHPzef9q6Ei+QcUbfVjeKjzweU8F6WJ+RMJPLYfbVBzGlBWKAY0Ou0CmI+iDvzjZwjigxQ0hu/RMCpanjxONls5czAAJRdcxSG76Yot34VPKurtdVKOgbBWIjT/WkZYOl97XmFDHzKkR7OH60vX6y5NyYtdca3nmHUBUtd5ZT4SfFg4SWA8VIxkkOHDaPSNBm2X9a6d85lrmV8sJJU7QOGQBka6jGIqf4jOnzCEqvP1grSThr7Q/0O6fEoMthgmybMlIJKvQUxXq+35GKeJld2gvP3n2NiRItx0JG3QEEio1S1O88lJIjbN5Zd5wYH7vMefm8/7+/cK/1dCRfMzLoD2Dijb6mpEHu7G8VHiop2U5O4OYSyKYqQoJtfrJEK7LiF/vXU9G9GwObdk/zXTCDozzWhJD6kEjAsFscMHYd0GAlzbXR44t5galALXFvBuEhHFBihpoWrtbQ3fomFps2dkVLU8eDDZ+XycbLZw+ABzduZgAEqCDMVOLrmKQkrVT0d30xRbE7/RX78KnlPbZltWuB7zptxyNqJwx3muFKu8qymt57dNwSKz4XRtv4UYqLmbeNuF/xQegVOhUY03zZSICsvPlG6nCpDCEkWcpn6Am5MWuuP3en/nW88w6z+j9e4Cpa7yZslr9sp8JPquEOH8sHCSwNQcV8R4qRjIHMXdzSHDhtFFr0PV6RoM2Y12yd8v6107S4eYP+cy1zODXhI2vlhJKto0jC52gcMiEu0GJAyNdRho4bAcxFT/EKA4OhWdPmEJ+VKkDVXn6wExiy4GBOMUfmCP0XrMOp52qFZbc5VQAG/xPMVrXYmKZznlT2EnhTxdQ+n5We9ctlWLMHNQtjYoTNJa7Uh+76JEGoNnQXn7z7Edlwq1sSJFudVOgLzoSNugjCQepCCRUahE/ZSuWp3nkj7xIpaSRG2a9iion8su84OvQjaHA/d5i2ebvIxS84b0Np9D8JoqDPz+Rsn5w0CS5acsV+ELmRjtb/Xd63GVrtcV+WvTuUwk390g4drgJrrGhEp/wij/MM5Mk/XIAAAAAAcJqNwOE1G4CRr5ZBwmo3AbLwusEjXyyBU8WhQ4TUbgP0TuPDZeF1gxV7+EJGvlkCNiTUwqeLQoLXEc9HCajcB3kyUcfonceHmAdKRsvC6wa7WGbGKvfwhlptfUSNfLIE/eY/xGxJqYQc0yRFTxaFBT+MCMWuI56F3rkTThNRuA5jyzXO8mSjjoL+Lk/RO48PoaECzzAOlI9AlBlNl4XWDecfW812sM2NBipATFXv4QwldWzMtNr6jMRAd0ka+WQJamPpyfvMf4mLVvJI2JNTCKgJ3sg5pkiISTzFSp4tCgrut4fKfxgRig+CnEtcRz0LLN2wy71yJovN6KtcJqNwHFY5/dzHlmuctwzmXeTJRx2UU8rdBfxcnXVm0V+idx4f0u2T30NCBZ8z2IheYB0pHhCHpN6BKDKe8bK/Wy8LrBtfkSHbzj63m76kOlrtYZsanfsW2gxUgJp8zg1Yq9/CGNtFT9hK6tmYOnBUWWm19RkZL3jZiIDumfgaY1I18sgSRWhF0tTH05KkXV5T95j/E4cCctMWreSTZjdpUbEmphHBvCvRUBO9kSCJMFBzTJEQA9Yc0JJ5ipDi4wdVPFoUFUzAmdXdbw+VrfWCVP4wIxSOqq7UHwU4lG+ftVa4jnoWyBT31lm7YZYpIexXeuRNFwp+wNeb0VaX60vbeE1G4Dg93G34rHP7uNzpdnmPLNc5/7Za+W4ZzLkeg0F7yZKOO7kIA/sop5W7WD0Yegv4uTp7YjT66s2iuppXL39E7jw/NHSx/6XbJ7/VQap+hoQLPvYehv5nsRC+FyudfMA6UjywoN/8IQ9JvFGVxH0CUGU9csro/eNlfr2T//N2XhdYNi6N1fa/IkO2z7jOd5x9bzfs5+L3fUh0tw3S+XXawzY1qlm79Tv2LbVLbKB0GKkBNGgzjPT5nBq0iQaXcVe/hDEnJQnxtoqfscYQEnCV1bMw5U8+8HTgqLAEeiVy02vqMqPxZ/IyXvGyQsR8cxEB3TNhm1Dz8DTGs4CuS2Rr5ZAkG38d5IrQi6T6SgZlqY+nJdkVKuVIurylOCAxZ+8x/iefq3PnDgTlp36eaGYtW8kmXcFE5sxu0qa89F9jYk1MIxLXweODeFej8+LaYqAneyLQvfbiQRJgojGI7WDmmSIglgOv4AesOaB3NrRhJPMVIVRpmOHFxg6htVyDani0KCoILqXqmYEzqukbvmu63h8rykSS61vrBKsrcYlp/GBGKYz6y+kdVV2pbc/QaD4KcShOkPzo3z9qqK+l521xHPQtAYZ57ZAp763gs2Jss3bDLMPsTuxSQ9isItlVbvXImi6FUhfuFP2BrmRnDG83oq0vRzgg79aXtq+mDTtAAAAALi8Z2WqCciLErWv7o9il1c33vAyJWtf3J3XOLnFtCjvfQhPim+94GTXAYcBSta/uPJq2N3g33czWGMQVlAZV5/opTD6+hCfFEKs+HHfe8DIZ8enrXVyCEPNzm8mla1/cC0RGBU/pLf7hxjQnhrP6Ceic49CsMYgrAh6R8mgMq8+GI7IWwo7Z7WyhwDQL1A4aZfsXwyFWfDiPeWXh2WGh9HdOuC0z49PWnczKD/q5BCGUlh340Dt2A34Ub9o8Cv4oUiXn8RaIjAq4p5XT39Jb/bH9QiT1UCnfW38wBg1n9BOjSO3K5+WGMUnKn+guv1HGQJBIHwQ9I+SqEjo95sUWD0jqD9YMR2Qtomh99MUds9qrMqoD75/B+EGw2CEXqBw0uYcF7f0qbhZTBXfPNHC54VpfoDge8svDsN3SGvLDQ+ic7Fox2EExynZuKBMRG+Y9fzT/5DuZlB+Vto3Gw65J022BUAopLDvxhwMiKOB27AaOWfXfyvSeJGTbh/0Oyb3A4OakGaRLz+IKZNY7bREYFQM+AcxHk2o36bxz7r+kt/sRi64iVSbF2fsJ3ACcfBIu8lML97b+YAwY0XnVWs/oJzTg8f5wTZoF3mKD3LkXTfLXOFQrk5U/0D26JglrouIcxY37xYEgkD4vD4nnSHpHySZVXhBi+DXrzNcsMrtWbY7VeXRXkdQfrD/7BnVYjshbNqHRgnIMunncI6OgijtntSQUfmxguRWXzpYMTqnjwmDHzNu5g2GwQi1OqZtvUDhpAX8hsEXSSkvr/VOSjIidvOKnhGWmCu+eCCX2R149MlLwEiuLtL9AcBqQWal95ZeHE8qOXldn5aX5SPx8k1rGQX1135g52LRjl/etuvCCY5SerXpN2gARtnQvCG8iN8x6jBjVo8i1vlhmmqeBAe9pr2/AcHYrbRuNhUICVMdck6apc4p/7d7hhEPx+F0khDZzSqsvqg4GRFGgKV2I9jGZnVgegEQcs+u/spzyZtXpPEi7xiWR/2tOalFEV7Mdk3uBs7xiWPcRCaNZPhB6PkveVFBkx40Uyax2uua1r+z+cbpC0WhjBnwDmKhTGkHPJtRvoQnNtuWkpk1Li7+UCZUuZme6N78jF1xEjThFnepNi7OEYpJqwM/5kW7g4Eg4+CRdltc9hNJ6Vn98VU+mGyCBiHUPmFExovOqn43qc/Wf0E4bsMmXXx2ibPEyu7WWR3Wb+GhsQrzFB7kS6h5gRPLaderdw6yucKhXAF+xjmcqf6AJBWZ5TagNguOHFFuhmYWpz7accIsb94slNO5SQkEgfCxuOaVow1JexuxLh5D0j5I+25ZLenb9sNRZ5GmzLCpH3QMznpmuWGU3gUG8QAAAACWMAd3LGEO7rpRCZkZxG0Hj/RqcDWlY+mjlWSeMojbDqS43Hke6dXgiNnSlytMtgm9fLF+By2455Edv5BkELcd8iCwakhxufPeQb6EfdTaGuvk3W1RtdT0x4XTg1aYbBPAqGtkevli/ezJZYpPXAEU2WwGY2M9D/r1DQiNyCBuO14QaUzkQWDVcnFnotHkAzxH1ARL/YUN0mu1CqX6qLU1bJiyQtbJu9tA+bys42zYMnVc30XPDdbcWT3Rq6ww2SY6AN5RgFHXyBZh0L+19LQhI8SzVpmVus8Ppb24nrgCKAiIBV+y2QzGJOkLsYd8by8RTGhYqx1hwT0tZraQQdx2BnHbAbwg0pgqENXviYWxcR+1tgal5L+fM9S46KLJB3g0+QAPjqgJlhiYDuG7DWp/LT1tCJdsZJEBXGPm9FFra2JhbBzYMGWFTgBi8u2VBmx7pQEbwfQIglfED/XG2bBlUOm3Euq4vot8iLn83x3dYkkt2hXzfNOMZUzU+1hhsk3OUbU6dAC8o+Iwu9RBpd9K15XYPW3E0aT79NbTaulpQ/zZbjRGiGet0Lhg2nMtBETlHQMzX0wKqsl8Dd08cQVQqkECJxAQC76GIAzJJbVoV7OFbyAJ1Ga5n+Rhzg753l6YydkpIpjQsLSo18cXPbNZgQ20LjtcvbetbLrAIIO47bazv5oM4rYDmtKxdDlH1eqvd9KdFSbbBIMW3HMSC2PjhDtklD5qbQ2oWmp6C88O5J3/CZMnrgAKsZ4HfUSTD/DSowiHaPIBHv7CBmldV2L3y2dlgHE2bBnnBmtudhvU/uAr04laetoQzErdZ2/fufn5776OQ763F9WOsGDoo9bWfpPRocTC2DhS8t9P8We70WdXvKbdBrU/SzaySNorDdhMGwqv9koDNmB6BEHD72DfVd9nqO+ObjF5vmlGjLNhyxqDZryg0m8lNuJoUpV3DMwDRwu7uRYCIi8mBVW+O7rFKAu9spJatCsEarNcp//XwjHP0LWLntksHa7eW7DCZJsm8mPsnKNqdQqTbQKpBgmcPzYO64VnB3ITVwAFgkq/lRR6uOKuK7F7OBu2DJuO0pINvtXlt+/cfCHf2wvU0tOGQuLU8fiz3Whug9ofzRa+gVsmufbhd7Bvd0e3GOZaCIhwag//yjsGZlwLARH/nmWPaa5i+NP/a2FFz2wWeOIKoO7SDddUgwROwrMDOWEmZ6f3FmDQTUdpSdt3bj5KatGu3FrW2WYL30DwO9g3U668qcWeu95/z7JH6f+1MBzyvb2KwrrKMJOzU6ajtCQFNtC6kwbXzSlX3lS/Z9kjLnpms7hKYcQCG2hdlCtvKje+C7ShjgzDG98FWo3vAi0AAAAAQTEbGYJiNjLDUy0rBMVsZEX0d32Gp1pWx5ZBTwiK2chJu8LRiujv+svZ9OMMT7WsTX6utY4tg57PHJiHURLCShAj2VPTcPR4kkHvYVXXri4U5rU317WYHJaEgwVZmBuCGKkAm9v6LbCayzapXV135hxsbP/fP0HUng5azaIkhJXjFZ+MIEayp2F3qb6m4ejx59Dz6CSD3sNlssXaqq5dXeufRkQozGtvaf1wdq5rMTnvWiogLAkHC204HBLzNkbfsgddxnFUcO0wZWv09/Mqu7bCMaJ1kRyJNKAHkPu8nxe6jYQOed6pJTjvsjz/efNzvkjoan0bxUE8Kt5YBU958ER+YumHLU/CxhxU2wGKFZRAuw6Ng+gjpsLZOL8NxaA4TPS7IY+nlgrOlo0TCQDMXEgx10WLYvpuylPhd1Rdu7oVbKCj1j+NiJcOlpFQmNfeEanMx9L64eyTy/r1XNdich3meWvetVRAn4RPWVgSDhYZIxUP2nA4JJtBIz2na/1l5lrmfCUJy1dkONBOo66RAeKfihghzKczYP28Kq/hJK3u0D+0LYMSn2yyCYarJEjJ6hVT0ClGfvtod2Xi9nk/L7dIJDZ0GwkdNSoSBPK8U0uzjUhScN5leTHvfmD+8+bnv8L9/nyR0NU9oMvM+jaKg7sHkZp4VLyxOWWnqEuYgzsKqZgiyfq1CYjLrhBPXe9fDmz0Rs0/2W2MDsJ0QxJa8wIjQerBcGzBgEF32EfXNpcG5i2OxbUApYSEG7waikFxW7taaJjod0PZ2WxaHk8tFV9+NgycLRsn3RwAPhIAmLlTMYOgkGKui9FTtZIWxfTdV/TvxJSnwu/Vltn26bwHrqiNHLdr3jGcKu8qhe15a8qsSHDTbxtd+C4qRuHhNt5moAfFf2NU6FQiZfNN5fOyAqTCqRtnkYQwJqCfKbiuxeT5n979Oszz1nv96M+8a6mA/VqymT4Jn7J/OISrsCQcLPEVBzUyRioec3cxB7ThcEj10GtRNoNGeneyXWNO1/rLD+bh0sy1zPmNhNfgShKWrwsjjbbIcKCdiUG7hEZdIwMHbDgaxD8VMYUODihCmE9nA6lUfsD6eVWBy2JMH8U4gV70I5idpw6z3JYVqhsAVOVaMU/8mWJi19hTec4XT+FJVn76UJUt13vUHMxiE4qNLVK7ljSR6Lsf0NmgBuzzfl6twmVHbpFIbC+gU3XoNhI6qQcJI2pUJAgrZT8R5HmnlqVIvI9mG5GkJyqKveC8y/KhjdDrYt79wCPv5tm94bwU/NCnDT+DiiZ+spE/uSTQcPgVy2k7RuZCenf9W7VrZdz0Wn7FNwlT7nY4SPexrgm48J8SoTPMP4py/SSTAAAAADdqwgFu1IQDWb5GAtyoCQfrwssGsnyNBIUWTwW4URMOjzvRD9aFlw3h71UMZPkaCVOT2AgKLZ4KPUdcC3CjJhxHyeQdHneiHykdYB6sCy8bm2HtGsLfqxj1tWkZyPI1Ev+Y9xOmJrERkUxzEBRaPBUjMP4Ueo64Fk3kehfgRk041yyPOY6SyTu5+As6PO5EPwuEhj5SOsA8ZVACPVgXXjZvfZw3NsPaNQGpGDSEv1cxs9WVMOpr0zLdAREzkOVrJKePqSX+Me8nyVstJkxNYiN7J6AiIpnmIBXzJCEotHgqH966K0Zg/ClxCj4o9BxxLcN2syyayPUuraI3L8CNmnD351hxrlkec5kz3HIcJZN3K09RdnLxF3RFm9V1eNyJfk+2S38WCA19IWLPfKR0gHmTHkJ4yqAEev3KxnuwLrxsh0R+bd76OG/pkPpubIa1a1vsd2oCUjFoNTjzaQh/r2I/FW1jZqsrYVHB6WDU16Zl471kZLoDImaNaeBnIMvXSBehFUlOH1NLeXWRSvxj3k/LCRxOkrdaTKXdmE2YmsRGr/AGR/ZOQEXBJIJERDLNQXNYD0Aq5klCHYyLQ1Bo8VRnAjNVPrx1VwnWt1aMwPhTu6o6UuIUfFDVfr5R6DniWt9TIFuG7WZZsYekWDSR610D+ylcWkVvXm0vrV+AGzXht3H34O7PseLZpXPjXLM85mvZ/ucyZ7jlBQ165DhKJu8PIOTuVp6i7GH0YO3k4i/o04jt6Yo2q+u9XGnq8LgT/cfS0fyebJf+qQZV/ywQGvobetj7QsSe+XWuXPhI6QDzf4PC8iY9hPARV0bxlEEJ9KMry/X6lY33zf9P9mBdeNlXN7rYDon82jnjPtu89XHei5+z39Ih9d3lSzfc2Axr1+9mqda22O/UgbIt1QSkYtAzzqDRanDm010aJNIQ/l7FJ5ScxH4q2sZJQBjHzFZXwvs8lcOigtPBlegRwKivTcufxY/KxnvJyPERC8l0B0TMQ22GzRrTwM8tuQLOQJavkXf8bZAuQiuSGSjpk5w+pparVGSX8uoilcWA4JT4x7yfz61+npYTOJyhefqdJG+1mBMFd5lKuzGbfdHzmjA1iY0HX0uMXuENjmmLz4/snYCK2/dCi4JJBIm1I8aIiGSag78OWILmsB6A0drcgVTMk4RjplGFOhgXhw1y1Yag0OKpl7ogqM4EZqr5bqSrfHjrrksSKa8SrG+tJcatrBiB8acv6zOmdlV1pEE/t6XEKfig80M6oar9fKOdl76i0HPEtecZBrS+p0C2ic2CtwzbzbI7sQ+zYg9JsVVli7BoIte7X0gVugb2U7gxnJG5tIrevIPgHL3aXlq/7TSYvgAAAABlZ7y4i8gJqu6vtRJXl2KPMvDeN9xfayW5ONed7yi0xYpPCH1k4L1vAYcB17i/1krd2GryM3ff4FYQY1ifVxlQ+jCl6BSfEPpx+KxCyMB7362nx2dDCHJ1Jm/OzXB/rZUVGBEt+7ekP57QGIcn6M8aQo9zoqwgxrDJR3oIPq8yoFvIjhi1ZzsK0ACHsmk4UC8MX+yX4vBZhYeX5T3Rh4ZltOA63VpPj88/KDN3hhDk6uN3WFIN2O1AaL9R+KH4K/DEn5dIKjAiWk9XnuL2b0l/kwj1x32nQNUYwPxtTtCfNSu3I43FGJafoH8qJxlH/bp8IEECko/0EPfoSKg9WBSbWD+oI7aQHTHT96GJas92FA+oyqzhB3++hGDDBtJwoF63FxzmWbip9DzfFUyF58LR4IB+aQ4vy3trSHfDog8Ny8dosXMpxwRhTKC42fWYb0SQ/9P8flBm7hs32lZNJ7kOKEAFtsbvsKSjiAwcGrDbgX/XZzmReNIr9B9ukwP3JjtmkJqDiD8vke1YkylUYES0MQf4DN+oTR66z/Gm7N+S/om4LkZnF5tUAnAn7LtI8HHeL0zJMID521XnRWOcoD9r+ceD0xdoNsFyD4p5yzdd5K5Q4VxA/1ROJZjo9nOIi64W7zcW+ECCBJ0nPrwkH+khQXhVma/X4IvKsFwzO7ZZ7V7R5VWwflBH1Rns/2whO2IJRofa5+kyyIKOjnDUnu0osflRkF9W5II6MVg6gwmPp+ZuMx8IwYYNbaY6taThQL3BhvwFLylJF0pO9a/zdiIylhGeini+K5gd2ZcgS8n0eC6uSMDAAf3SpWZBahxelvd5OSpPl5afXfLxI+UFGWtNYH7X9Y7RYufrtt5fUo4JwjfptXrZRgBovCG80Oox34iPVmMwYfnWIgSeapq9pr0H2MEBvzZutK1TCQgVmk5yHf8pzqURhnu3dOHHD83ZEJKovqwqRhEZOCN2pYB1ZsbYEAF6YP6uz3KbyXPKIvGkV0eWGO+pOa39zF4RRQbuTXZjifHOjSZE3OhB+GRReS/5NB6TQdqxJlO/1prr6cb5s4yhRQtiDvAZB2lMob5RmzzbNieENZmSllD+Li6ZuVQm/N7onhJxXYx3FuE0zi42qatJihFF5j8DIIGDu3aR4OMT9lxb/VnpSZg+VfEhBoJsRGE+1KrOi8bPqTd+OEF/1l0mw26ziXZ81u7KxG/WHVkKsaHh5B4U84F5qEvXacsTsg53q1yhwrk5xn4BgP6pnOWZFSQLNqA2blEcjqcWZobCcdo+LN5vLEm505TwgQQJlea4sXtJDaMeLrEbSD7SQy1ZbvvD9tvpppFnUR+psMx6zgx0lGG5ZvEGBd5bemxpYmNdIEVycm9yOiBGYWlsZWQgdG8gYWxsb2MgJWQgKiAlZCBieXRlcyAocG9vbD0lbHUgaGVhZGVyPSVsdSkgJWx1CgBbemxpYmNdIEVycm9yOiBCYWQgZnJlZSBhZGRyZXNzCgAAAABVTktOT1dOAEZhaWxlZCB0byBib290ICVzLiBGYWxsYmFja2luZyBib290IG1vZGUKAAAAdWFydDogdXNpbmcgdWFydCVkIHdpdGggYmF1ZHJhdGUgJWQKAAAAAEVycm9yOiBjb25zb2xlIGFuZCBGRkggdXNlcyB0aGUgc2FtZSBVQVJULCBkZWFjdGl2YXRpbmcgY29uc29sZQoAAAAAYm9vdDogRm9yY2VkIHRvIEZGSAoAAAAAJXMgaW1hZ2UgZmFpbGVkIHRvIGNvbXBsZXRlIGl0cyAzIGZpcnN0IGJvb3RzIHNvIGlzIG5vdCByZWxpYWJsZS4KAABGbGFzaCBhIG5ldyAlcyBpbWFnZSB0byBzb2x2ZSB0aGUgcHJvYmxlbQoAAGJvb3Q6ICVzIG1vZGUKAABVbmtvd24gYm9vdCBtb2RlICVkLCBmYWxsYmFja2luZyB0byBGRkYKAAAAAEZhaWxlZCB0byBzZXQgZGlydHkgYm9vdAoAAABib290U3JjX2dlcmJpbC5jAAAAAF9wb29sLmZyZWUgPCAzAAAhX3Bvb2wucG9vbFtfcG9vbC5mcmVlXQBQb29sIGVtcHR5CgBfcG9vbC5mcmVlIDw9IDMAcAAAAEVycm9yOiBhbGxvY2F0aW9uIGZhaWx1cmUgKCVkIGJ5dGVzKSwgY2FuJ3QgYWxsb2NhdGUgYmxvY2tzIG9mIG1vcmUgdGhhdCAlZCBieXRlcwoAAEZGRgBGRkgAVVBEQVRFUgBSRUNPVkVSWQAAAAAAYJ94AGCffABgn4AAYJ+IY29uc29sZQBTaHV0ZG93bgoAAABNT0RVTEVfRlNUX1NIVVRET1dOAHVhcnQwX2N0c19uAHVhcnQxX2N0c19uAGJvb3Q6IENhbid0IGFsbG9jYXRlIG1lbW9yeSBmb3IgZXh0IGJvb3QgQUJJIGRlc2NyaXB0b3IKAAAAAFJ1bm5pbmcgb24gJXMgZmxhc2ggZmFpbHNhZmUgc2VjdG9yCgAAAABSdW5uaW5nIG9uICVzIGZsYXNoIHNlY3RvciAlcAoAAFdBUk5JTkc6IGNvcnJ1cHRlZCBib290IHNlY3RvcnMgcHJlc2VudAoAAAAAW2Z3IHBhbmljXQAAUkJHZXJiaWwgJWQuJWRAJWQgJzUuMS4xLjAgWzM5NTI5XScKAAAAAFJlc2V0IGNhdXNlICclcycocmVhbCAnJXMnICklcyAoYm9vdFdERyA6ICclZCcpIFtyYXdSc3QgJzB4JTA4eCddCgAATlZSQU0gQm9vdCBTdGF0dXMgJyVzJwoATG9hZGVkIHZpYSBKVEFHCgAAAAByZWdDb25maWcgJXBAJWQKAAAAAGJvb3RMb2FkZXIuYwAAAABOb3RoaW5nIHRvIGJvb3QgZnJvbQAAAAAAAQICAwMDAwQEBAQEBAQEBQUFBQUFBQUFBQUFBQUFBQYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBwcHBwcHBwcHBwcHBwcHBwcHBwcHBwcHBwcHBwcHBwcHBwcHBwcHBwcHBwcHBwcHBwcHBwcHBwcHBwcHBwcHBwgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIOmF0OiBFcnJvcjogRmFpbGVkIHRvIGFsbG9jYXRlIG91dHB1dCBwb29sCgBPSw0KAAAAADphdDogRXJyb3I6IENNRCBGQUlMRUQKAEVSUk9SDQoAOmF0OiBFcnJvcjogJXMlcwoAAAA6YXQ6IEVycm9yOiAlcyVzPwoAADANCgA6YXQ6IEVycm9yOiAlcyVzPTxiYXVkcmF0ZT4KAAAAADphdDogRXJyb3I6IEZhaWxlZCB0byBjb252ZXJ0ICVzIGludG8gYW4gaW50ZWdlcgoAAABhdDogU2V0dGluZyBiYXVkcmF0ZSB0byAlZAoAOmF0OiBFcnJvcjogVW5rb3duIGNvbW1hbmQgJXMKAABhdDogRm9yY2luZyBiYXVkcmF0ZSB0byAlZCBmb3IgQVQgbmVnb2NpYXRpb24KAAArU1lTRkZIDQoAAAA6YXQ6IEVycm9yOiBGYWlsZWQgdG8gYWxsb2NhdGUgaW5wdXQgcG9vbAoAADphdDogRXJyb3I6IENvbW1hbmQgdG9vIGxhcmdlCgAAAGCkTABgUzYAYKREAGBUagBgpDwAYFPiAGCkNABgU2BVc2FnZTogAEFUK1NNT0QAQVQrSVBSAABBVCtTVFAAAEFUAABib290ZmxhZ3MgRXJyb3I6IEZhaWxlZCB0byByZWFkIGJvb3QgZmxhZ3MKAEJPT1RGTEFHAAAAAGJvb3RmbGFncyBFcnJvcjogSW52YWxpZCBib290IGZsYWdzCgAAAABib290ZmxhZ3M6IFNldHRpbmcgZGlydHkgYm9vdCBsZXZlbCAlZAoANS4xLjEuMCBbMzk1MjldAGoJ5me7Z66FPG7zcqVP9TpRDlJ/mwVojB+D2atb4M0ZQoovmHE3RJG1wPvP6bXbpTlWwltZ8RHxkj+CpKscXtXYB6qYEoNbASQxhb5VDH3Dcr5ddIDesf6b3AanwZvxdOSbacHvvkeGD8GdxiQMocwt6SxvSnSEqlywqdx2+YjamD5RUqgxxm2wAyfIv1l/x8bgC/PVp5FHBspjURQpKWcntwqFLhshOE0sbfxTOA0TZQpzVHZqCruBwskuknIshaK/6KGoGmZLwkuLcMdsUaPRkugZ1pkGJPQONYUQaqBwGaTBFh43bAgnSHdMNLC8tTkcDLNO2KpKW5zKT2gub/N0j4LueKVjb4TIeBSMxwIIkL7/+qRQbOu++aP3xnF48i0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLQoAAEZpbGU6ICVzQCVkCgAAAAAnJXMnCgAAAEZhdGFsIGVycm9yCgAAAABBc3NlcnRpb24gZmFpbGVkCgAAAABgplAAYKZgYm9vdDogU2tpcHBpbmcgc3RyYXAgcmVjdXJzaW9uCgBib290OiBDdXJyZW50ICVzLCB0aW1lb3V0ICV1LCBwcm90byAlcwoAYm9vdDogU3dpdGNoZWQgdG8gJXMsIHRpbWVvdXQgJXUsIHByb3RvICVzCgB0aHAAc3RwAGR0cABhdAAAbm9uZQAAAABmbGFzaAAAAHVzYjAAAAAAdXNiMQAAAABldGgAdWFydDAAAAB1YXJ0MQAAAHVhcnQyAAAAdWFydDMAAABzZGlvAAAAAAAAADcAAAA4AAAAOQAAADoAYKbwAGCm9ABgpvgAYKb8AGCnAABgpwgAYKcQAGCnGABgpyAAYKckAGCnLABgpzQAYKc8AGCnRE5vcm1hbCBCb290AEZsYXNoIHJlc2V0AE5vIE5WUkFNIEJvb3QAAAAAYKeUAGCnoABgb/wAYKesUGluICVkIGlzIHVzZWQgYXMgd2FrZSBzb3VyY2UsIGNhbid0IGJlIGNvbmZpZ3VyZWQgZm9yIG91dHB1dC4KAAAAABsAAAAcAAAAHQAAAB4AAAAfAAAAIAAAACEAAAAiAAAAIwAAACQAAAAlAAAAJgAAACcAAAAoW1BPV0VSXSBFcnJvcjogREMgMVY4IGlzIG5vdCBnb29kCgAAW1BPV0VSXSBFcnJvcjogREMgM1YwIGlzIG5vdCBnb29kCgAAW1BPV0VSXSBFcnJvcjogREMgMVYxIGlzIG5vdCBnb29kCgAAW1BPV0VSXSBFcnJvcjogUG93ZXIgaXMgbm90IGdvb2QsIHNodXR0aW5nIGRvd24KAAAAAFtTRkZGXSBFcnJvcjogQ1JDIEVycm9yOiBjb21wdXRlZCBjcmMgPSAweCUwOHgsIGV4cGVjdGVkIGNyYyA9IDB4JTA4eAoAAFtTRkZGXSBFcnJvcjogRUNEU0FfMjU2IGlzIG5vdCBzdXBwb3J0ZWQgeWV0CgAAAFtTRkZGXSBFcnJvcjogVW5rbm93biBzaWduYXR1cmUgdHlwZSAlZAoAAAAAW1NGRkZdIEVycm9yOiBCb290IHJlZ2lvbiAlZCBub3QgZm91bmQKAEZGRiEAAAAAW1NGRkZdIEVycm9yOiBXcm9uZyBtYWdpYzogMHglMDh4CgAAW1NGRkZdIEVycm9yOiBXcm9uZyBoZWFkZXIKAFtTRkZGXSBFcnJvcjogQ29ycnVwdGVkIGltYWdlCgAAW1NGRkZdIEVycm9yOiBDb3JydXB0ZWQgYm9vdCBpbWFnZQoASUVMRgAAAABbU0ZGRl0gRXJyb3I6IEludmFsaWQgYm9vdCBlbnRyeQoAAAA/Pz8ARVhUAExQAABTVwAAV0RUMAAAAABXRFQxAAAAAExQV0RUAAAATFBDUFVSU1QAAAAATFBIV1JTVAAAYKpoAGCqbABgqnAAYKp0AGCqeABgqoAAYKqIAGCqkABgqpxzdHA6IGZhaWxlZCB0byBhbGxvY2F0ZSBJT0Igb2YgJWQgYnl0ZXMKAAAAAHN0cDogZmFpbGVkIHRvIHB1c2ggU1JTUCBJT0IKAAAAc3RwOiBVc2luZyBTVFAgc291cmNlCgAAc3RwOiBpbmNvcnJlY3QgTVJFUSBoZWFkZXIgQ1JDOiAweCUwOFghPTB4JTA4WAoAc3RwOiB1bmtub3duIE1SRVEgb3BlcmF0aW9uOiAweCUwMlgKAAAAAHN0cDogd3Jvbmcgc2lkOiAlZCAhPSAlZAoAAABzdHA6IHdyb25nIHBsZW46ICVkICE9ICVsZAoAc3RwOiB3cm9uZyBwYXlsb2FkIENSQzogMHglMDhYICE9IDB4JTA4WAoAAABzdHA6IHBlbmRpbmcgdHJhbnNhY3Rpb24gaXMgdG9vIGJpZzogJWQgPiAlbGQKAABzdHA6IFNCUCBwcm9jZXNzaW5nIGZhaWxlZAoAc3RwOiBGQVRBTAoAAQEIAFtaU1RQXSBFcnJvcjogRmFpbGVkIHRvIGFsbG9jYXRlIElPQiBvZiAlZCBieXRlcwoAAABbWlNUUF0gRXJyb3I6IEluZmxhdGUgaW5pdCBmYWlsZWQgOiAlZAoAW1pTVFBdIEVycm9yOiBJbmZsYXRlIGZhaWxlZCA6ICglZCkgJXMKABwAAAAAAAAABQYAAQAAAQYBAQABAQYCAQACAQYDAQADAQYEAQAEAQAAAAAAAQECAgAAAAAAYK0QAQsAJAAEAFwAAAIAAAAAAABgrRQAYK00AwYAAQAAAQYBAQAEBAsCJAAMABQACAQAAAAAAABgrTgAAAAABAYABQAABAYBAQAEBAYCAQAIBAcDAgAMAAQAAAAAAAAAYK1wAQsAJAAEACAAAAQAAAAAAABgrXQAAAAACAYAAQAABAYBAQAEBAYCBQAIBAYDBQAMBAYEBQAQBAYFBQAUBAUGAwAYBgcFABwEAAAAAAAAAAAAAAAAAAHCAAAAAAAAAAADAAAAAAAAAAAAAAAAAAAAAAAAAAAAAcIAAAAAAAAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAABwgAAAAAAAAAAAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAHCAAAAAAAAAAADAAAAAAAAAAAAAAAAAAAAAABgrlACCwAkAAQAIAAABAALASQAiAAMAIQIAQAAAAAAAGCudABgrlgAAAAAAwYABQAABAYBAQAEBAYCAQAIBAAAAAAAAAAAAAsGAAEAAAQGAgUABAQGAwEACAQGBAEADAQGBQEAEAQGBgEAFAQGBwEAGAEGCAEAGQEGCQEAGgEGCgEAGwEGCwEAHAEAAAAAAAAAAAAAAAAAAAAAAgAAAQAAAAAAAAAAAAAAUBTFZpkGBQAAAAAAAAAAAAACAAABAAAAAAAAAAAAAABQFMVmmQYFAAAAAAAAAAAAAAIAAAEAAAAAAAAAAAAAAFAUxWaZBgUAAAAAAAAAAAAAAgAAAQAAAAAAAAAAAAAAUBTFZpkGBQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAYK+4AQYABAAAAAAAAAAAAGCvvAAAAAABBwACAAAABAAAAAABAAAAAGGNAABgSxgAYEjEAGBIrgBgSKQAYEqEAGBLTABgSnoAAAAAa2FiaQAAAAMAAAAAAAAAAAAAAAAAAAAAYkFiaQAAAAcAAAAAAAAAAAAAmmkAAAAAAAAAAAAAAAH/////AGCwVAMGAAEAAAQLASQACAAMAAQIAAsCJABsAAwAaBABAAAAAGCweABgsFwAAAAAAwYAAQAAAQYBBQAEBAYCBQAIBAAAAAAAAAAAAAMGAAUAAAQGAQUABAQGAgAACAQAAAAAAAAAAAABBgAFAAAEAAAAAAAAAAABAAAAAAEGAAUAAAQAAAAAAAAAAAAEBgAFAAAEBgEFAAQEBgIBAAgIBgMBABAIAAAAAAAAAAAAAAAAAAAWCAAAAAAAAAAAAAAAAAAAABIGAAEAAAIGAQEAAgIGAgEABAIGAwUACAQGBAUADAQGBQUAEAQGBgUAFAQGBwUAGAQGCAEAHAIGCQEAHgEGCgEAHwEGCwEAIAEGDAEAIQEFDQMAJAUOAwAoBRADACwGEQUAMAQGEgUANAQAAAAAAAAUjhEBoAAAAAAAAAEAAAABAAAAAAAAAAAAAAAAASwAAQAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAgBgsdgFCwAkAAQAJAAAQAAGAQEJBAQLAiQJDAAMCQgEAQsDJAlAAAgJPAQCCwQkCWQAEAlgBAMAAAAAAABgsjQAYLIYAGCyBABgsegAAAAABAUAAwAABQEDAAQFAgMACAUDAwAMAAAAAAAAAAIGAAUAAAQGAQAABAQAAAAAAAAAAwYAAQAABAYBAQAEBAYCAQAIBAAAAAAAAAAAAAkGAAEAAAQGAQUABAQGAgUACAQGAwUADAQGBAUAEAQGBQUAFAQFBgMAGAYHBQAcBAYIAQAgBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABTUU5TAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/////wAAAAD/////AAAAAP////8AAAAA/////wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQEAAAAAAACKxR1iXnElWSUv1TcLbA3iAAAAAAAAAAAAYB6gAAAAAABgI6YAAAAAAGBdlAAAAAAAYFw+AAAAAABgF9gAAAAAAGBHsgAAAAAAYEzaAAAAAABgXo4AAAAAAGAJqAAAAAAAYCl4AAAAAABgRswAAAAAAGAUVAAAAAAAYCXiAAAAAABgKwoAAAAAAGBMugAAAAAAYBuCAAAAAABgKcQAAAADAGArMgAAAAJjcnkAAGANcmNyegQAYGHyAAAAAAAAAAAAAAApAAAAAABgcHQAAAAAAGCfuABgTBAAAAAA/////wBgTHoAAAAAAGAejgAAAAAAAAAUAGCs9ABgrMwAAAAAAAAAEgBhDBQAYKz8AAAAAAAAACsAYK2sAGCtXAAAAAAAAAAAAGCuwABgrjAAAAAAAAAAFwBhDNAAYK+oAAAAAAAAACAAYYs0AGCwMAAAAAAAAAAvAGCwpABgsJQAAAAAAAAAMQBhjGAAYLCoAAAAAAAAAAQAYLDYAGCwuAAAAAAAAAAGAGCxZABgsPAAAAAAAAAACQBgsnQAYLGcAAAAAABgEcgAYBA6AGANZAAAAAAAYCSEAGAkiABgJIwAAAAAAAAAAAAAAAAAYEj4AAAAAQBgSEgAAAAAAGBH6gAAAAcAYEhIAAAAAABgR+oAAAAGAGBISAAAAAAAYEfqAAAABYIAVAAAAAADAAAAAAAAAAAAAAAAAAAAAIIADACCAFH2AQAAAABgS4QAYBzKBjKIWAIAAAAAAAAAggAIAIIAUfUBAAAAAGBLhABgHMoGMohYAQAAAAAAAACCAAQAggBR9AEAAAAAYEuEAGAcygYyiFgAAAAAAAAAADUuMS4xLjAgWzM5NTI5XQByYm1jAAAAAYIAUkEAAABUAAAAAQIAAAAAAAAAAAAAAoIAHPAAAAAJAAAAAYIAHPEAAAAQAAAAAYIAHPIAAABpAAAAAYIAHPMAAAAQAAAAAXBzaQBzcW4x/////wAAAAABTgERAgEihIAAKoiAgAAyhqxAOgAJOQKGk73edBKYgAAAAgYKmIAAEoSAAAACCAqcgAASoIAAAAICCryAABKDgIAAAAIDCoO8gAAShMSAABGdARqBgMDiOHGceGdFRmJXbHdhVkJtMWhhbTl5QXpUSVF4c0xrNU5MSzVLQk9BR1k1QlhCaGJYQ1FWMWMybGt3UXhOVWc3c3l0ekkKM3VXREdCZ1lHQ0lNNXVES3lzbUFySUswdHpTNlNDTWJheVltYkdwcVptcEFiR3BxWm1wQWJHcHFabXBDQ05qZwoyeUVOakM2TXJjeHZPQ21CQVlKQm1WdWRHVnlrQW5FVEF3TURBZ01ERXlPQ0EyTlRVek5VZ0U0aVlHQmdZa0JnCllHQmdRR3hxYW1acU1STURBd015QXdNREF3SURZMU5UTTFHSW1CZ1pIQkFZR0JnYmtCc2FtcG1hbUlLeXZEUzYKU0FUZ0tGU0N1RGszczhnckV3dHpJb0FZQ09RVnRiMlJsd013U0FMeVV5TkRVZ01qUTFJREkwTlNBeU5EVWdNagpRMUlESTBOU0F5TkRVZ01qUTFJREVnTUVRVndZV2N3a0FUaUpnWUdCZ1FHQmljSEJBYkdwcVptcVFCT0ltQmdZCkdKQVlHQmliRUJzYW1wbWFqRVRBd01ETWdNREV5T0NBMk5UVXpOUmdNbklLNE1MT1l5QUp3SEVnQ2NSTURBd00KU0F3TURFM0lEWTFOVE0xR0E4TUJrd2dyZ3dzNWxJQW5BY1NBSnhFd01EQXhJREF3TXpRZ05qVTFNelVZQzRZQwprMGdyZ3dzNW5JQW5BV0pBRTRpWUdCZ1lrQmdZR1pxUUd4cWFtWnFNQmNNQlNjUVZ3WVdjMGtBVGdMRWdDY1JNCkRBd01TQXdNRFk0SURZMU5UTTFHQXVHQXBQSUs0TUxPYXlBSndGaVFCT0ltQmdZR0pBWUdCdVprQnNhbXBtYWoKRVRBd01ETWdNREV6T0NBMk5UVXpOUmdLVEJCWEJoWnphUUJPQXNTQUp3R1l3R2d3RkprZ3Jnd3M1dklBbkFXSgpBRTRETVlEUVlDazBRVndZV2M0a0FUaUpnWUdCZ1FHQmthbVpBYkdwcVptcVFCT0FwTmtKYzNGdVJISnBkbVdRClp5WVc1blpjWk5qVTFNelVnTmpVMU16VWdOalUxTXpVZ05qVTFNelV1UUI2Qm1SZ0tsWUN0TEFXREFXakFYREEKVW1HQXNHQXZHQXVHQXBMc0JZTUJnTUJjTUJTV1lDd1lERVlDNFlDa3F3Rmd3R1F3Rnd3RkpSZ0xCaUpnWUdCaQpRR0JnYm1KQWJHcHFabW94RXdNREF6SURBeE16Y2dOalUxTXpVWUNrbXdGZ3dIQXdISXdGSkpnTEJnT0JnT1JnCktTTEFhakFVa0dBMkxFRE16QVZLd0ZhV0FzR0F0R0F1R0FwTU1CWU1CZU1CY01CU1hZQ3dZREFZQzRZQ2tzd0YKZ3dHSXdGd3dGSlZnTEJnTWhnTGhnS1NqQVdERVRBd01ERWdNREUxTUNBMk5UVXpOUmlKZ1lHQm1RR0JpWm14QQpiR3BxWm1vd0ZKTmdMQmdPeGdQQmdLU1RBV0RBZGpBZURBVWtXQTFHQXBJTUJzV0lDQXdGU3NCV2xnTEJnTFJnCkxoZ0tUREFXREFYakFYREFVbDJBc0dBd0dBdUdBcExNQllNQmlNQmNNQlNWWUN3WURJWUM0WUNrb3dGZ3dIWXcKSGd3RkpOZ0xCZ094Z1BCZ0tTVEFXREFkakFlREFVa1dBMUdBcElNQnNXSUdhbUFxVmdLMHNSTURBd01DQXdNVApZMElEWTFOVE0xR0F0R0F1R0FwTU1COE1STURBd01TQXdNREF4SURZMU5UTTFHQXVHQXBMc0I4TVJNREF3TVNBCndNRE16SURZMU5UTTFHQW5EQVNTekFYaGdLSXdFNFlDU1ZZQzhNUk1EQXdNU0F3TURNM0lEWTFOVE0xR0FuREEKU1NqQVhoZ0xBeEV3TURBeklEQXhNemtnTmpVMU16VVlDU1RZQzhNQllHQXhEQVNTVEFYaGdMQXdHSVlDU1JZQwpxTUJKSU1CV0xFRE9EQVNsWUNXbGdMd3dFMFlDY01CSk1NQmVHQXZqQVRoZ0pKZGdMd3dHQVlDY01CSkxNQmVHCkFvakFUaGdKSlZnTHd3R0VZQ2NNQkpLTUJlR0ltQmdZR0pBWUdCcWJrQnNhbXBtYWpBWWhnSkpOZ0x3d0dRWUQKRU1CSkpNQmVHQXlEQVloZ0pKRmdLb3dFa2d3RllzUVF4TWpBU2xZQ1dsZ0x3d0UwWUNjTUJKTU1CZUdBdmpBVApoZ0pKZGdMd3dHQVlDY01CSkxNQmVHQW9qQVRoZ0pKVmdMd3dHRVlDY01CSktNQmVHQXNEQVRoZ0pKTmdMd3dGCmdZQ2NNQkpKTUJlR0FzREFUaGdKSkZnS293RWtnd0ZZc1FReE16QVNsWUNXbGdMd3dFMFlDY01CSk1NQmVHQXYKakFUaGdKSmRnTHd3R0FZQ2NNQkpMTUJlR0FvakFUaGdKSlZnTHd3R0VZQ2NNQkpLTUJlR0FzREFZaGdKSk5nTAp3d0ZnWURFTUJKSk1CZUdBc0RBWWhnSkpGZ0tvd0VrZ3dGWXNRUXhOREFTbFlDV2xnTHd3RTBZQ2NNQkpNTUJlCkdBdmpBVGhnSkpkZ0x3d0dBWUNjTUJKTE1CZUdBb2pBVGhnSkpWZ0x3d0dFWUNjTUJKS01CZUdBc0RBWWhnSkoKTmdMd3dGZ1lERU1CSkpNQmVHQXNEQVloZ0pKRmdLb3dFa2d3RllzUVF4TnpBU2xZQ1dsZ0x3d0UwWUNjTUJKTQpNQmVHQXZqQVRoZ0pKZGdMd3dHQVlDY01CSkxNQmVHQW9qQVRoZ0pKVmdMd3dHRVlDY01CSktNQmVHQXNEQVRoCmdKSk5nTHd3RmdZQ2NNQkpKTUJlR0FzREFUaGdKSkZnS293RWtnd0ZZc1FReE9EQVNsWUNXbGdMd3dFMFlDY00KQkpNTUJlR0F2akFUaGdKSmRnTHd3R0FZQ2NNQkpMTUJlR0FvakFUaGdKSlZnTHd3R0VZQ2NNQkpLTUJlR0FzRApBWWhnSkpOZ0x3d0ZnWURFTUJKSk1CZUdBc0RBWWhnSkpGZ0tvd0VrZ3dGWXNRUXhPVEFTbFlDV2xnTHd3RTBZCkNjTUJKTU1CZUdBdmpBVGhnSkpkZ0x3d0dBWUNjTUJKTE1CZUdBb2pBVGhnSkpWZ0x3d0dFWUNjTUJKS01CZUcKQXNEQVloZ0pKTmdMd3dGZ1lERU1CSkpNQmVHQXNEQVloZ0pKRmdLb3dFa2d3RllzUVF5TURBU2xZQ1dsZ0x3dwpFMFlDY01CSk1NQmVHQXZqQVRoZ0pKZGdMd3dHQVlDY01CSkxNQmVHQW9qQVRoZ0pKVmdMd3dHRVlDY01CSktNCkJlR0FzREFZaGdKSk5nTHd3RmdZREVNQkpKTUJlR0FzREFZaGdKSkZnS293RWtnd0ZZc1FReU5UQVNsWUNXbGcKSmd3RTBZQ2NNQkpNTUJNR0FuakFUaGdKSmRnSmd3RkFZQ2NNQkpMTUJNR0FvakFUaGdKSlZnSmd3RklZQ2NNQgpKS01CTUdBc0RBV1JnSkpOZ0pnd0ZnWUN5TUJKSk1CTUdBc0RBV1JnSkpGZ0tvd0VrZ3dGWXNRUXlOakFTbFlDCldsZ0x3d0UwWUNjTUJKTU1CZUdBdmpBVGhnSkpkZ0x3d0dBWUNjTUJKTE1CZUdBb2pBVGhnSkpWZ0x3d0dFWUMKY01CSktNQmVHQXNEQVloZ0pKTmdMd3dGZ1lERU1CSkpNQmVHQXNEQVloZ0pKRmdLb3dFa2d3RllzUVF5T0RBUwpsWUNXbGdMd3dFMFlDY01CSk1NQmVHQXZqQVRoZ0pKZGdMd3dHQVlDY01CSkxNQmVHQW9qQVRoZ0pKVmdMd3dHCkVZQ2NNQkpLTUJlR0FzREFZaGdKSk5nTHd3RmdZREVNQkpKTUJlR0FzREFZaGdKSkZnS293RWtnd0ZZc1FRMk4KakFTbFlDV2xnSmd3RTBZQ2NNQkpNTUJNR0FuakFUaGdKSmRnSmd3RkFZQ2NNQkpMTUJNR0FvakFUaGdKSlZnSgpnd0ZJWUNjTUJKS01CTUdBdGpBWEJnSkpOZ0pnd0ZzWUM0TUJKSk1CTUdBdGpBWEJnSkpGZ0tvd0VrZ3dGWXRzCmdyQzNPYnZJQVhBUWtnQnNCRFJBRDRDQ3lBSVlDSVFnQ21BaWxnSWhHQWlGU0FPSUNEU0FMd0VWaEEzUjRrQVQKZ0ppUUJPQWtuU0J1VHhJQW5FVEF3TURBZ01ERTBNQ0EyTlRVek5VZ0NjQkhHQW5EQVNUcEFLNWdJb1dBbURBUwpTREFjQmdJNHdFNFlDU2RJQmFNQkZDd0V3WUNTUVlEZ01CSEdBbkRBU1RwQUlCZ0lvV0FtREFTU0RBY0JnSTR3CkU0WUNTZElCZE1CRkN3RjRZQ1NRWWlZR0JnWUVCZ1ltcHNRR3hxYW1acU1CSEdBbkRBU1RwQU1aZ0lvV0F2REEKU1NEQWNSZ0k0d0U0WUNTZElCbE1CRkN3RjRZQ1NRWURpTUJIR0FuREFTVHBBTXhnSW9XQXZEQVNTREFjUmdJNAp3RTRZQ1NkSUJuTUJGQ3dGNFlDU1FZRGlNQkhHQW5EQVNUcEFOQmdJb1dBdkRBU1NEQWNSZ0k0d0U0WUNTZElCCnBNQkZDd0Y0WUNTUVlEaU1CSEdBbkRBU1RwQU5SZ0lvV0F2REFTU0RBY1JnSTR3RTRZQ1NkSUJyTUJGQ3dGNFkKQ1NRWURpTUJIR0FuREFTVHBBTmhnSW9XQW1EQVNTREFjQmdJNHdFNFlDU2RJQnRNQkZDd0Y0WUNTUVlEaU1CSApHQW5EQVNUcEFOeGdJb1dBdkRBU1NEQWNSZ0k0d0U0WUNTZElCdk1CRkN3RXdZQ1NRWURnTUJIR0FuREFTVHJVGW8RbYABAAUACVJFREJFTExZAIABABIABlBZQ09NAIABABYADUdFUkJJTC1SRURCRQCAAQAEAAhTUU4zMzMwAIABABEAK0ZJUFlfQjNCNEIxMkIxM0IyMEIyOF9CQkExLVJGQTMtU0tZNjgwMDEzMQA5PgEgAR4CwG4AAsAxAALAMgACwDMAAsBvAAAAAAAAAAAAAAAJGgEYAALAbQACAwACAgACAQAAAAAAAAAAAAAASU0BSwIlEgExDHVhcnQwX2N0c19uAAACAxIBMQx1YXJ0MF9ydHNfbgAAAgcSATEMdWFydDFfcnRzX24AAAIMEgExDHVhcnQyX3J0c19uAHETGRECuY5iMoNOAAKCrAAAAoHwAA8BEQkPAgMSgZwgAAIHCgMSh6lADxEGAogACogAD0EoAQVGaVB5AAkIU1FOMzMzMAAZDUdFUkJJTC1SRURCRQAhBlBZQ09NAA9ZKwEpCrigACoEMQNhdAAAAgEqBTEIY29uc29sZQAAAgIKuKAAKgQxBGRjcAAPYZIQAZAHZ0VNYzJWeGRXRnVjek16TXpCUVp0WVdwdmNnTXh5RHV6SzNNamU1YUFqcHBnWXFKYXBJcXNhRURHM3R6TTBzNwpxNU1MbzB0N2NRS2FpbkdabVptQkFnbUtDWmtDbWxySnNjR0JnWWxwbVlrQmlia0RFd3R6STVrQ2tZR2FRZGpiCjIxdGIyNlE5MGVGOW5ZV2x1WDNCdmNuUmZNTmZMVFk0T0RBZ0xUWTBPREFnTFRVNU1UQWdMVFV6TlRBZ0xUUTUKTmpBZ0xUUXpOekFnTFRNM05EQWdMVE13T0RBZ0xUSTBNVEFnTFRJd05UQWdMVEUzTXpBZ0xURTFNakFnTFRFegpNakFnTFRFd016QWdMVGd5TUNBdE5qQXdTSHVqd3ZzN0MwdHkrNE43azZMNWpzQmFiSEJnWUVCYWFuSmlZRUJhCmFtaG1ZRUJhYUc1bVlFQmFhR0p3WUVCYVpteG1ZRUJhWm1Ca1lFQmFaR3BvWUVCYVpHWnVZRUJhWkdKa1lFQmEKWW5Cd1lFQmFZbTVnWUVCYVltaHNZRUJhWW1SaVlFQmFZbUJrWUVCYWNHaGdpSHVqd3ZzN0MwdHkrNE43azZMNQpsZ095SHVUd3ZzN0MwdHkrNE43azZMNWhsSmtZR3BnUUdSc2FHQkFabVJtWUVCbWNHUmdRR2hvWm1CQWFtQmlZCkVCcWFtWmdRR3hnWUdDRVBjbmhmWjJGcGJsOXdiM0owWHpIS1RFM05EQWdNak15TUNBeU9UQXdJRE0xTWpBZ04KREV5TUNBME56QXdJRFV5TXpBZ05UYzJNRkllNVBDK3pzTFMzTDdnM3VUb3ZtV1VtSm9hbUJBWkdwaVlFQm1ZbQpCZ1FHWnNjbUJBYUdSbVlFQm9ibXhnUUdwb1ptQkFiR0pnWUxFRlltRnVaRkFuQUJHUWx3YjNKMFgyNTFiY0JDClFwMGVGOWtZV05mWW0vQXpCRUtkSGhmYjJabWMyVjB3VXRNekJrSWNHRmZaMkZwYnNrTFRFMU9UQWdNVEkzTUMKQXhPRGt3SURJeU1EQWdNalV6TUNBeU9UQXdJREFnTUVJYTRNSys2TkRreXViUTN0akpraGFZbkJtYWtCYVltaApxYWtCYWJtcGdRR1J1YWtCd2NHcEFhR0JnWUVCb1lHQmdwRm5SNFgzUmxiWEJsY21GMGRYSmxYMjltWm5ObGRNCkVOakZpSE9Ud3ZzVGV3dVRJdnRqZTV1ZUNtUmdZT1JaeWVGOTBaVzF3WlhKaGRIVnlaVjl2Wm1aelpYVEJESTUKUVFaMFptRmpkTUpNQ0F3SURBZ01FQ0JtUmdJSHdGellEQmNrTFRFMU9UQWdNVEkzTUNBeE9Ea3dJREl5TURBZwpNalV6TUNBeU5qa3dJREFnTUNaSVdtSndabXBBV21Kb2FtcEFXbTVxWUVCa2JtcEFjRzVnUUdoZ1lHQkFhR0JnCllEd1ExT0JZQ3dPQXRCZ0xrQ0JtWmdJRDRDYzJDbHBvWUZ5UXRNVFU1TUNBeE1qY3dJREU0T1RBZ01qSXdNQ0EKeU5UTXdJREk1TVRBZ01DQXdKa2hhWW5CbWFrQmFZbWhxYWtCYWJtcGdRR1J1YWtCeWNHQkFhR0JnWUVCb1lHQgpnUEJEY3lGZ0xBNEMwR0F1UUlHYUdBZ1BnSnpZS1dteGdYQWFrd0d3OEVOekFXQXNEZ0xRWUM1QWdacVlDYytBCm5OZ3BhWkc1Y2tMVEUzTlRBZ01UQTFNQ0F4TkRBd0lESXhOekFnTWpRNU1DQXlOek13SURBZ01DWklXbVJnYW0KQkFXbUpvWW1wQVdteHNha0JtYW1CQWJtNXFRR2hnWUdCQWFHQmdZRHdRMk1CWUN3T0NHSnVEQVRrQ0JuQmdJNQo4QkhOZ3BhYW1CY2tMVEUzTlRBZ01UQTFNQ0F4TkRBd0lESXhOekFnTWpRNU1DQXlOekF3SURBZ01DWklXbVJnCmFtQkFXbUpvWW1wQVdteHNha0JtYW1CQWJtUnFRR2hnWUdCQWFHQmdZRHdRMk14WUNZSEFZQVlDY2dRUXhNakEKUno0Q09iQVhDNUlXbUp1YW1CQVltQnFZRUJpYUdCZ1FHUmlibUJBWkdoeVlFQmtjR1pnUUdCQVlFeVF0TWpBMQpNQ0F0TVRReE5TQXROalkxSURNMU1DQTRNalVnTkRBd01DQTBNREF3SGdMNHNCTURnTUFNQk9RSUlZbVpnSTU4CkJITmdwYVltcGNCZEpnTHc4QmZGZ0pnY0JnQmdKeUJCREUwTUJIUGdJNXNCcUxnTHBNQmVIZ0w0c0JNRGdNQU0KQk9RSURBWUNPZkFSellDNFhBWnlZRFFQQVh4WUNZSEFZQVlDY2dRUXhPREFSejRDT2JBYWk0QzZUQVhoNENrTApBVEE0REFEQVRrQ0NHSnlZQ09mQVJ6WUM0WEFYU1lDOFBBWHhZQ1lIQVlBWUNjZ1FReU1EQVJ6NENPYkFWQzRDCjZUQVhoNEMrTEFUQTREQURBVGtDQ0dScVlDQWZBUnpZQ1FYQVVDWUNpUEFVaFlDWUhBVFFZQ2NnUVF5TmpBUnoKNENPYkFYQzRDNlRBWGg0Q2tMQVRBNERBREFUa0NDR1J3WUNPZkFSellDNFhBWFNZQzhQQVh4WUNZSEFZQVlDYwpnUVEyTmpBUUQ0Q09iQVhDNENxVEFWaDRDdUxBVEE0Q2FEQVRrUUE9CYIDVWxOTlVnQUJBQUFBS3dBQ01nQUFCQUFTQUE0QkJBQVZGNjhBRjdnVEFDTC9aZ0FqQ1VBQUxUUkpBRE9NQkFBMgpBQUFBT3lNQkFEd0FCQUEvQUFNQVFJVW5BRUZqbFFCQ0lFQUFUbkxqQUU4Q0RRQlNEOEFBV3dBL0FGd0FQd0JlCkJDd0FYeEtJQUdQY3lBQnRNcDhBY0lSUUFIRVJDd0NpaU9NQXVDQUFBTGtnQUFDNklBQUF1eUFBQUx3Z0FBQzkKQUFBQXZnQUFBTDhBQUFEQUVhTUF3NmdwQU1ZQ0FBRFFBRGtBNEJHakFPWUNBQUR3QURreU5qWTVNREV4T1Rjegg27Xl7+vzJcQ==""") + BOOTROM=binascii.a2b_base64(b"""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""") diff --git a/lib/sqnsupgrade/sqnsbrz.py b/lib/sqnsupgrade/sqnsbrz.py index 570709f..592465a 100644 --- a/lib/sqnsupgrade/sqnsbrz.py +++ b/lib/sqnsupgrade/sqnsbrz.py @@ -1,4 +1,4 @@ -# Copyright (c) 2016, Pycom Limited. +# Copyright (c) 2018, Pycom Limited. # # This software is licensed under the GNU GPL version 3 or any # later version, with permitted additional terms. For more information @@ -7,7 +7,10 @@ class bootrom(object): import binascii - import uzlib as zlib + try: + import uzlib as zlib + except: + import zlib def __init__(self): self.__fpointer = 0 @@ -50,4 +53,4 @@ def read(self, size=0): else: return self.BOOTROM[fpointer:self.__fpointer] - BOOTROM=zlib.decompress(binascii.a2b_base64(b"""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""")) + BOOTROM=zlib.decompress(binascii.a2b_base64(b"""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""")) diff --git a/lib/sqnsupgrade/sqnstp.py b/lib/sqnsupgrade/sqnstp.py index 148506d..31280cf 100755 --- a/lib/sqnsupgrade/sqnstp.py +++ b/lib/sqnsupgrade/sqnstp.py @@ -1,11 +1,22 @@ #!/usr/bin/env python -# Copyright (c) 2016, Pycom Limited. +################################################################# # -# This software is licensed under the GNU GPL version 3 or any -# later version, with permitted additional terms. For more information -# see the Pycom Licence v1.0 document supplied with this file, or -# available at https://www.pycom.io/opensource/licensing - +# Copyright (c) 2011 SEQUANS Communications. +# All rights reserved. +# +# This is confidential and proprietary source code of SEQUANS +# Communications. The use of the present source code and all +# its derived forms is exclusively governed by the restricted +# terms and conditions set forth in the SEQUANS +# Communications' EARLY ADOPTER AGREEMENT and/or LICENCE +# AGREEMENT. The present source code and all its derived +# forms can ONLY and EXCLUSIVELY be used with SEQUANS +# Communications' products. The distribution/sale of the +# present source code and all its derived forms is EXCLUSIVELY +# RESERVED to regular LICENCE holder and otherwise STRICTLY +# PROHIBITED. +# +################################################################# import struct import time import os @@ -380,11 +391,17 @@ def start(elf, elfsize, serial, baud=3686400, retry=None, debug=None, AT=True, p while True: try: + if debug: print('running m.wipe') m.wipe() + if debug: print('running m.reset') m.reset() + if debug: print('running m.open_session') m.open_session() + if debug: print('running push(m)') push(m) + if debug: print('running dev.set_timeout(2)') dev.set_timeout(2) + if debug: print('running m.reset(True)') m.reset(True) return True except MException as ex: diff --git a/lib/sqnsupgrade/sqnsupgrade.py b/lib/sqnsupgrade/sqnsupgrade.py index 7d64775..15b1905 100644 --- a/lib/sqnsupgrade/sqnsupgrade.py +++ b/lib/sqnsupgrade/sqnsupgrade.py @@ -1,7 +1,7 @@ #!/usr/bin/env python -VERSION = "1.2.0" +VERSION = "1.2.4" -# Copyright (c) 2016, Pycom Limited. +# Copyright (c) 2019, Pycom Limited. # # This software is licensed under the GNU GPL version 3 or any # later version, with permitted additional terms. For more information @@ -17,6 +17,7 @@ import sqnstp as stp release = None + try: sysname = os.uname().sysname if 'FiPy' in sysname or 'GPy' in sysname: @@ -50,6 +51,8 @@ def __init__(self): self.__resp_921600 = False self.__serial = None self.__kill_ppp_ok = False + self.__modem_speed = None + self.__speed_detected = False if 'GPy' in self.__sysname: self.__pins = ('P5', 'P98', 'P7', 'P99') @@ -86,7 +89,8 @@ def read_rsp(self, size=None, timeout=-1): else: return b'' - def print_pretty_response(self, rsp, flush=False): + def print_pretty_response(self, rsp, flush=False, prefix=None): + if prefix is not None: self.special_print(prefix, flush=flush, end=' ') lines = rsp.decode('ascii').split('\r\n') for line in lines: if 'OK' not in line and line!='': @@ -188,37 +192,32 @@ def __hangup_modem(self, delay, debug): self.__serial.read() if not self.__kill_ppp_ok: self.__serial.write(b"+++") - time.sleep_ms(delay) + time.sleep_ms(1150) resp = self.__serial.read() if debug: print('Response (+++ #1): {}'.format(resp)) self.__check_resp(resp, True) self.__serial.write(b"AT\r\n") - time.sleep_ms(delay) + time.sleep_ms(250) resp = self.__serial.read() if debug: print('Response (AT #1) {}'.format(resp)) self.__check_resp(resp) if resp is not None: if b'OK' not in resp and not self.__kill_ppp_ok: self.__serial.write(b"AT\r\n") - time.sleep_ms(delay) + time.sleep_ms(250) resp = self.__serial.read() if debug: print('Response (AT #2) {}'.format(resp)) self.__check_resp(resp) if resp is not None and b'OK' in resp: return True self.__serial.write(b"+++") - time.sleep_ms(delay) + time.sleep_ms(1150) resp = self.__serial.read() if debug: print('Response (+++ #2): {}'.format(resp)) self.__check_resp(resp, True) if resp is not None and b'OK' in resp: - # self.__serial.write(b"ATH\r\n") - # time.sleep_ms(delay) - # resp = self.__serial.read() - # if debug: print('Response (ATH #1) {}'.format(resp)) - # self.__check_resp(resp) self.__serial.write(b"AT\r\n") - time.sleep_ms(delay) + time.sleep_ms(250) resp = self.__serial.read() if debug: print('Response (AT #2) {}'.format(resp)) self.__check_resp(resp) @@ -227,17 +226,20 @@ def __hangup_modem(self, delay, debug): return False - def detect_modem_state(self, retry=3, initial_delay=1000, debug=False): + def detect_modem_state(self, retry=5, initial_delay=1000, hangup=True, debug=False): count = 0 self.__serial = UART(1, baudrate=921600, pins=self.__pins, timeout_chars=1) + self.__modem_speed = 921600 self.__serial.read() while count < retry: count += 1 delay = initial_delay * count if debug: print("The current delay is {}".format(delay)) self.__serial = UART(1, baudrate=921600, pins=self.__pins, timeout_chars=10) + self.__modem_speed = 921600 #if True: - if self.__hangup_modem(initial_delay, debug): + if hangup and self.__hangup_modem(initial_delay, debug): + self.__speed_detected = True self.__serial.write(b"AT+SMOD?\r\n") time.sleep_ms(delay) resp = self.__serial.read() @@ -247,6 +249,7 @@ def detect_modem_state(self, retry=3, initial_delay=1000, debug=False): except: pass else: + self.__modem_speed = 921600 self.__serial = UART(1, baudrate=921600, pins=self.__pins, timeout_chars=1) self.__serial.read() self.__serial.write(b"AT\r\n") @@ -255,6 +258,7 @@ def detect_modem_state(self, retry=3, initial_delay=1000, debug=False): self.__check_resp(resp) if debug: print('Response (AT #3) {}'.format(resp)) if resp is not None and b'OK' in resp: + self.__speed_detected = True self.__serial.write(b"AT+SMOD?\r\n") time.sleep_ms(delay) resp = self.__serial.read() @@ -269,6 +273,7 @@ def detect_modem_state(self, retry=3, initial_delay=1000, debug=False): self.__check_resp(resp) if debug: print('Response (AT #4) {}'.format(resp)) if resp is not None and b'OK' in resp: + self.__speed_detected = True self.__serial.write(b"AT+SMOD?\r\n") time.sleep_ms(delay) resp = self.__serial.read() @@ -279,12 +284,14 @@ def detect_modem_state(self, retry=3, initial_delay=1000, debug=False): pass else: if not self.__resp_921600: + self.__modem_speed = 115200 self.__serial = UART(1, baudrate=115200, pins=self.__pins, timeout_chars=10) self.__serial.write(b"AT\r\n") time.sleep_ms(delay) resp = self.__serial.read() if debug: print('Response (AT #1 @ 115200) {}'.format(resp)) if resp is not None and b'OK' in resp: + self.__speed_detected = True self.__serial.write(b"AT+SMOD?\r\n") time.sleep_ms(delay) resp = self.__serial.read() @@ -298,6 +305,7 @@ def detect_modem_state(self, retry=3, initial_delay=1000, debug=False): resp = self.__serial.read() if debug: print('Response (AT #2 @ 115200) {}'.format(resp)) if resp is not None and b'OK' in resp: + self.__speed_detected = True self.__serial.write(b"AT+SMOD?\r\n") time.sleep_ms(delay) resp = self.__serial.read() @@ -308,6 +316,14 @@ def detect_modem_state(self, retry=3, initial_delay=1000, debug=False): pass return None + def get_imei(self): + self.__serial = UART(1, baudrate=921600, pins=self.__pins, timeout_chars=10) + self.__serial.write(b"AT+CGSN\r\n") + time.sleep(.5) + imei_val = self.read_rsp(2000) + return self.return_pretty_response(imei_val) + + def __get_power_warning(self): return "<<<=== DO NOT DISCONNECT POWER ===>>>" @@ -322,21 +338,24 @@ def __get_wait_msg(self, load_fff=True): - def __run(self, file_path=None, baudrate=921600, port=None, resume=False, load_ffh=False, mirror=False, switch_ffh=False, bootrom=False, rgbled=0x050505, debug=False, pkgdebug=False, atneg=True, max_try=10, direct=True, atneg_only=False, version_only=False, expected_smod=None, verbose=False, load_fff=False): + def __run(self, file_path=None, baudrate=921600, port=None, resume=False, load_ffh=False, mirror=False, switch_ffh=False, bootrom=False, rgbled=0x050505, debug=False, pkgdebug=False, atneg=True, max_try=10, direct=True, atneg_only=False, info_only=False, expected_smod=None, verbose=False, load_fff=False): self.__wait_msg = False mirror = True if atneg_only else mirror recover = True if atneg_only else load_ffh - resume = True if mirror or recover or atneg_only or version_only else resume + resume = True if mirror or recover or atneg_only or info_only else resume verbose = True if debug else verbose load_fff = False if bootrom and switch_ffh else load_fff + target_baudrate = baudrate + baudrate = self.__modem_speed if self.__speed_detected else baudrate if debug: print('mirror? {} recover? {} resume? {} direct? {} atneg_only? {} bootrom? {} load_fff? {}'.format(mirror, recover, resume, direct, atneg_only, bootrom, load_fff)) + if debug: print('baudrate: {} target_baudrate: {}'.format(baudrate, target_baudrate)) abort = True external = False self.__serial = None if 'FiPy' in self.__sysname or 'GPy' in self.__sysname: - self.__serial = UART(1, baudrate=115200 if recover else baudrate, pins=self.__pins, timeout_chars=100) + self.__serial = UART(1, baudrate=115200 if recover and not self.__speed_detected else baudrate, pins=self.__pins, timeout_chars=100) self.__serial.read() else: if port is None: @@ -345,15 +364,18 @@ def __run(self, file_path=None, baudrate=921600, port=None, resume=False, load_f external = True br = 115200 if recover and not direct else baudrate if debug: print('Setting baudrate to {}'.format(br)) - self.__serial = serial.Serial(port, br, bytesize=serial.EIGHTBITS, timeout=1 if version_only else 0.1) + self.__serial = serial.Serial(port, br, bytesize=serial.EIGHTBITS, timeout=1 if info_only else 0.1) self.__serial.reset_input_buffer() self.__serial.reset_output_buffer() - if version_only: + if info_only: self.__serial.read() self.__serial.write(b'AT\r\n') self.__serial.write(b'AT\r\n') self.__serial.read() + self.__serial.write(b"AT+CGSN\r\n") + time.sleep(.5) + shimei = self.read_rsp(2000) if verbose: self.__serial.write(b"AT!=\"showver\"\r\n") else: @@ -362,6 +384,8 @@ def __run(self, file_path=None, baudrate=921600, port=None, resume=False, load_f shver = self.read_rsp(2000) if shver is not None: self.print_pretty_response(shver) + if shimei is not None: + self.print_pretty_response(shimei, prefix='\nIMEI:') return True if debug: print('Initial prepartion complete...') @@ -380,7 +404,7 @@ def __run(self, file_path=None, baudrate=921600, port=None, resume=False, load_f else: if debug: print('Loading {}'.format(file_path)) blobsize = os.stat(file_path)[6] - if blobsize < 10240: + if blobsize < 128: print('Firmware file is too small!') reconnect_uart() sys.exit(1) @@ -396,9 +420,17 @@ def __run(self, file_path=None, baudrate=921600, port=None, resume=False, load_f if not resume: + # bind to AT channel + self.__serial.write(b"AT+BIND=AT\r\n") + time.sleep(.5) + response = self.read_rsp(size=100) + if debug: print("AT+BIND=AT returned {}".format(response)) + # disable echo self.__serial.write(b"ATE0\r\n") - response = self.read_rsp(size=6) + time.sleep(.5) + response = self.read_rsp(size=100) + if debug: print("ATE0 returned {}".format(response)) self.__serial.read(100) if debug: print('Entering upgrade mode...') @@ -415,9 +447,18 @@ def __run(self, file_path=None, baudrate=921600, port=None, resume=False, load_f resp = self.read_rsp(100) if debug: print('AT+SMSWBOOT=3,1 returned: {}'.format(resp)) if b'ERROR' in resp: - print('Received ERROR from AT+SMSWBOOT=3,1! Aborting!') - reconnect_uart() - sys.exit(1) + time.sleep(5) + self.__serial.write(b"AT+SMSWBOOT=3,0\r\n") + resp = self.read_rsp(100) + if debug: print('AT+SMSWBOOT=3,0 returned: {}'.format(resp)) + if b'OK' in resp: + self.__serial.write(b"AT^RESET\r\n") + resp = self.read_rsp(100) + if debug: print('AT^RESET returned: {}'.format(resp)) + else: + print('Received ERROR from AT+SMSWBOOT=3,1! Aborting!') + reconnect_uart() + sys.exit(1) time.sleep(3) resp = self.__serial.read() if debug: print("Response after reset: {}".format(resp)) @@ -444,14 +485,18 @@ def __run(self, file_path=None, baudrate=921600, port=None, resume=False, load_f self.uart_mirror(rgbled) elif bootrom: - if verbose: print('Starting STP\n{}'.format(self.__get_power_warning())) - + if verbose: print('Starting STP') else: if verbose: if load_fff: print('Starting STP [FFF]') else: print('Starting STP ON_THE_FLY') + + self.__serial.read(100) + if verbose: print("Sending AT+CFUN=4") + resonse = self.__serial.write(b'AT+CFUN=4\r\n') + if verbose: print("AT+CFUN=4 returned {}".format(response)) self.__serial.read(100) if load_fff: @@ -469,8 +514,11 @@ def __run(self, file_path=None, baudrate=921600, port=None, resume=False, load_f self.__serial.read() elif recover and (not direct): if atneg: - result = self.at_negotiation(baudrate, port, max_try, mirror, atneg_only, debug) + result = self.at_negotiation(baudrate, port, max_try, mirror, atneg_only, debug, target_baudrate) if result: + baudrate = target_baudrate + self.__modem_speed = target_baudrate + self.__speed_detected = True if atneg_only: return True if mirror: @@ -532,8 +580,18 @@ def __run(self, file_path=None, baudrate=921600, port=None, resume=False, load_f resp = self.read_rsp(100) if debug: print("AT+SMSWBOOT=0,1 returned {}".format(resp)) if b"ERROR" in resp: - print('Received ERROR from AT+SMSWBOOT=0,1! Aborting!') - return False + time.sleep(5) + self.__serial.write(b"AT+SMSWBOOT=0,0\r\n") + resp = self.read_rsp(100) + if debug: print('AT+SMSWBOOT=0,0 returned: {}'.format(resp)) + if b'OK' in resp: + self.__serial.write(b"AT^RESET\r\n") + resp = self.read_rsp(100) + if debug: print('AT^RESET returned: {}'.format(resp)) + return True + else: + print('Received ERROR from AT+SMSWBOOT=0,0! Aborting!') + return False return True else: if load_fff: @@ -587,9 +645,22 @@ def __run(self, file_path=None, baudrate=921600, port=None, resume=False, load_f if debug: print('This is my result: {}'.format(sqnup_result)) if 'success' in sqnup_result: if not load_fff: - self.special_print(self.__get_power_warning(), end='\n', flush=True) self.special_print('Resetting.', end='', flush=True) self.__serial.write(b"AT+SMSWBOOT=1,1\r\n") + if debug: print("AT+SMSWBOOT=1,1 returned {}".format(resp)) + if b"ERROR" in resp: + time.sleep(5) + self.__serial.write(b"AT+SMSWBOOT=1,0\r\n") + resp = self.read_rsp(100) + if debug: print('AT+SMSWBOOT=1,0 returned: {}'.format(resp)) + if b'OK' in resp: + self.__serial.write(b"AT^RESET\r\n") + resp = self.read_rsp(100) + if debug: print('AT^RESET returned: {}'.format(resp)) + return True + else: + print('Received ERROR from AT+SMSWBOOT=1,0! Aborting!') + return False self.wait_for_modem(send=False, echo_char='.', expected=b'+SYSSTART') elif sqnup_result is not None: @@ -642,14 +713,18 @@ def __check_br(self, br_only=False, verbose=False, debug=False): def wakeup_modem(self, baudrate, port, max_try, delay, debug, msg='Attempting AT wakeup...'): if 'FiPy' in self.__sysname or 'GPy' in self.__sysname: - self.__serial = UART(1, baudrate=baudrate, pins=self.__pins, timeout_chars=1) + self.__serial = UART(1, baudrate=baudrate, pins=self.__pins, timeout_chars=10) MAX_TRY = max_try count = 0 if msg is not None: - print(msg) + if debug: + print(msg + 'with baudrate {}'.format(baudrate)) + else: + print(msg) + self.__serial.read() self.__serial.write(b"AT\r\n") - response = self.read_rsp(size=6) + response = self.read_rsp(size=25) if debug: print('{}'.format(response)) while (not b'OK' in response) and (count < MAX_TRY): count = count + 1 @@ -657,18 +732,21 @@ def wakeup_modem(self, baudrate, port, max_try, delay, debug, msg='Attempting AT time.sleep(delay) self.__serial.read() self.__serial.write(b"AT\r\n") - response = self.read_rsp(size=6) + response = self.read_rsp(size=25) if debug: print('{}'.format(response)) if 'FiPy' in sysname or 'GPy' in sysname: self.__serial = UART(1, baudrate=baudrate, pins=self.__pins, timeout_chars=100) return count < MAX_TRY - def at_negotiation(self, baudrate, port, max_try, mirror, atneg_only, debug): + def at_negotiation(self, baudrate, port, max_try, mirror, atneg_only, debug, target_baudrate): MAX_TRY = max_try count = 0 - print('Attempting AT auto-negotiation...') + if debug: + print('Attempting AT auto-negotiation... with baudrate {} and target_baudrate {}'.format(baudrate, target_baudrate)) + else: + print('Attempting AT auto-negotiation...') self.__serial.write(b"AT\r\n") - response = self.read_rsp(size=6) + response = self.read_rsp(size=20) if debug: print('{}'.format(response)) while (not b'OK' in response) and (count < MAX_TRY): count = count + 1 @@ -676,23 +754,25 @@ def at_negotiation(self, baudrate, port, max_try, mirror, atneg_only, debug): time.sleep(1) self.__serial.read() self.__serial.write(b"AT\r\n") - response = self.read_rsp(size=6) + response = self.read_rsp(size=20) if debug: print('{}'.format(response)) if b'OK' in response: self.__serial.read() - cmd = "AT+IPR=%d\n"%baudrate - if debug: print('Setting baudrate to {}'.format(baudrate)) + cmd = "AT+IPR=%d\n"%target_baudrate + if debug: print('Setting baudrate to {}'.format(target_baudrate)) self.__serial.write(cmd.encode()) response = self.read_rsp(size=6) if debug: print('{}'.format(response)) if b'OK' in response: + self.__modem_speed = target_baudrate + self.__speed_detected = True if atneg_only: return True if 'FiPy' in self.__sysname or 'GPy' in self.__sysname: - self.__serial = UART(1, baudrate=baudrate, pins=self.__pins, timeout_chars=100) + self.__serial = UART(1, baudrate=target_baudrate, pins=self.__pins, timeout_chars=100) else: self.__serial = None - self.__serial = serial.Serial(port, baudrate, bytesize=serial.EIGHTBITS, timeout=0.1) + self.__serial = serial.Serial(port, target_baudrate, bytesize=serial.EIGHTBITS, timeout=0.1) self.__serial.reset_input_buffer() self.__serial.reset_output_buffer() self.__serial.flush() @@ -708,7 +788,7 @@ def at_negotiation(self, baudrate, port, max_try, mirror, atneg_only, debug): print('ERROR in AT+SMOD returned {}'.format(response)) return False else: - print('ERROR in AT+IPR={} returned {}'.format(baudrate, response)) + print('ERROR in AT+IPR={} returned {}'.format(target_baudrate, response)) return False else: print('ERROR sending AT command... no response? {}'.format(response)) @@ -726,9 +806,9 @@ def uart_mirror(self, color): def success_message(self, port=None, verbose=False, debug=False): print("Your modem has been successfully updated.") print("Here is the current firmware version:\n") - self.show_version(port=port, verbose=verbose, debug=debug) + self.show_info(port=port, verbose=verbose, debug=debug) - def upgrade(self, ffile, mfile=None, baudrate=921600, retry=False, resume=False, debug=False, pkgdebug=False, verbose=False, load_fff=True): + def upgrade(self, ffile, mfile=None, baudrate=921600, retry=False, resume=False, debug=False, pkgdebug=False, verbose=False, load_fff=True, load_only=False): success = True if not retry and mfile is not None: if resume or self.__check_br(br_only=True, verbose=verbose, debug=debug): @@ -745,6 +825,8 @@ def upgrade(self, ffile, mfile=None, baudrate=921600, retry=False, resume=False, success = False success = self.__run(file_path=mfile, load_ffh=True, direct=False, baudrate=baudrate, debug=debug, pkgdebug=pkgdebug, verbose=verbose) time.sleep(1) + if load_only: + return True else: success = True else: @@ -771,8 +853,15 @@ def upgrade_uart(self, ffh_mode=False, mfile=None, retry=False, resume=False, co print('Preparing modem for upgrade...') if not retry and ffh_mode: success = False - success = self.__run(bootrom=True, resume=resume, switch_ffh=True, direct=False, debug=debug, pkgdebug=pkgdebug, verbose=verbose) - time.sleep(1) + if self.__check_br(verbose=verbose, debug=debug): + success = self.__run(bootrom=True, resume=resume, switch_ffh=True, direct=False, debug=debug, pkgdebug=pkgdebug, verbose=verbose) + time.sleep(1) + else: + print('FFH mode is not necessary... ignoring!') + print('Do not specify updater.elf when updating!') + mfile = None + ffh_mode = False + success = True if success: if mfile is not None: success = False @@ -787,8 +876,8 @@ def upgrade_uart(self, ffh_mode=False, mfile=None, retry=False, resume=False, co else: print('Unable to upgrade bootrom.') - def show_version(self, port=None, debug=False, verbose=False): - self.__run(port=port, debug=debug, version_only=True, verbose=verbose) + def show_info(self, port=None, debug=False, verbose=False): + self.__run(port=port, debug=debug, info_only=True, verbose=verbose) def upgrade_ext(self, port, ffile, mfile, resume=False, debug=False, pkgdebug=False, verbose=False, load_fff=True): success = True @@ -816,13 +905,29 @@ def print_welcome(): if 'FiPy' in sysname or 'GPy' in sysname: - def run(ffile, mfile=None, baudrate=921600, verbose=False, debug=False, load_fff=True): + def load(mfile, baudrate=921600, verbose=False, debug=False, hangup=False): + print_welcome() + sqnup = sqnsupgrade() + if sqnup.check_files(mfile, None, debug): + state = sqnup.detect_modem_state(debug=debug, hangup=hangup) + if debug: print('Modem state: {}'.format(state)) + if state is None: + detect_error() + elif state == 0: + sqnup.upgrade(ffile=None, mfile=mfile, baudrate=baudrate, retry=True, resume=False, debug=debug, pkgdebug=False, verbose=verbose, load_fff=False, load_only=True) + elif state == -1: + detect_error() + else: + print('Modem must be in recovery mode!') + reconnect_uart() + + def run(ffile, mfile=None, baudrate=921600, verbose=False, debug=False, load_fff=True, hangup=True): print_welcome() retry = False resume = False sqnup = sqnsupgrade() if sqnup.check_files(ffile, mfile, debug): - state = sqnup.detect_modem_state() + state = sqnup.detect_modem_state(debug=debug, hangup=hangup) if debug: print('Modem state: {}'.format(state)) if state is None: detect_error() @@ -832,19 +937,24 @@ def run(ffile, mfile=None, baudrate=921600, verbose=False, debug=False, load_fff print('Your modem is in recovery mode. Please specify updater.elf file') reconnect_uart() sys.exit(1) - elif state == 4: + elif state == 4 or state == 1: resume = True elif state == -1: detect_error() sqnup.upgrade(ffile=ffile, mfile=mfile, baudrate=baudrate, retry=retry, resume=resume, debug=debug, pkgdebug=False, verbose=verbose, load_fff=load_fff) reconnect_uart() - def uart(ffh_mode=False, mfile=None, color=0x050505, verbose=False, debug=False): + def uart(ffh_mode=False, mfile=None, color=0x050505, verbose=False, debug=False, hangup=True): print_welcome() retry = False resume = False + import pycom + state = None sqnup = sqnsupgrade() - state = sqnup.detect_modem_state() + if verbose: print('Trying to detect modem state...') + state = sqnup.detect_modem_state(debug=debug, hangup=hangup) + if debug: print('Modem state: {}'.format(state)) + if state is None: detect_error() elif state == 0: @@ -857,22 +967,19 @@ def uart(ffh_mode=False, mfile=None, color=0x050505, verbose=False, debug=False) detect_error() sqnup.upgrade_uart(ffh_mode, mfile, retry, resume, color, debug, False, verbose) - def info(verbose=False, debug=False, retry=5): + def info(verbose=False, debug=False, hangup=True): print_welcome() import pycom - count = 0 + state = None sqnup = sqnsupgrade() - while count < retry: - count += 1 - if verbose: print('Trying to detect modem state [{}/{}]'.format(count, retry)) - state = sqnup.detect_modem_state(debug=debug) - if debug: print('State: {} at count: {}'.format(state, count)) - if state is not None: break + if verbose: print('Trying to detect modem state...') + state = sqnup.detect_modem_state(debug=debug, hangup=hangup) + if debug: print('Modem state: {}'.format(state)) if state is not None: if state == 2: print('Your modem is in application mode. Here is the current version:') - sqnup.show_version(verbose=verbose, debug=debug) + sqnup.show_info(verbose=verbose, debug=debug) elif state == 1: print('Your modem is in mTools mode.') elif state == 0: @@ -887,6 +994,15 @@ def info(verbose=False, debug=False, retry=5): print('Cannot determine modem state!') reconnect_uart() + def imei(verbose=False, debug=False, retry=5, hangup=False): + sqnup = sqnsupgrade() + state = sqnup.detect_modem_state(debug=debug, hangup=hangup, retry=retry) + return sqnup.get_imei() if state == 2 else None + + def state(verbose=False, debug=False, retry=5, hangup=False): + sqnup = sqnsupgrade() + return sqnup.detect_modem_state(debug=debug, hangup=hangup, retry=retry) + else: def run(port, ffile, mfile=None, resume=False, debug=False, verbose=False, load_fff=True): print_welcome() @@ -896,4 +1012,4 @@ def run(port, ffile, mfile=None, resume=False, debug=False, verbose=False, load_ def version(port, verbose=False, debug=False): sqnup = sqnsupgrade() - sqnup.show_version(port=port, debug=debug, verbose=verbose) + sqnup.show_info(port=port, debug=debug, verbose=verbose) diff --git a/lib/sqnsupgrade/test_sd.py b/lib/sqnsupgrade/test_sd.py deleted file mode 100644 index 0a5f993..0000000 --- a/lib/sqnsupgrade/test_sd.py +++ /dev/null @@ -1,10 +0,0 @@ -import sqnsupgrade, time -sqnsupgrade.version() -time.sleep(10) -sqnsupgrade.run('/sd/CATM1-38638.dup','/sd/updater.elf') -time.sleep(10) -sqnsupgrade.run('/sd/NB1-37781.dup','/sd/updater.elf') -time.sleep(10) -sqnsupgrade.run('/sd/CATM1-38638.dup') -time.sleep(10) -sqnsupgrade.run('/sd/NB1-37781.dup') From d8c3af32d5305957ef936ebaddc1772d2baa95cd Mon Sep 17 00:00:00 2001 From: iwahdan88 Date: Wed, 20 Mar 2019 19:03:32 +0100 Subject: [PATCH 12/92] Updated Readme.md --- lib/sqnsupgrade/README.md | 49 +++++++++++++++++++++++++++------------ 1 file changed, 34 insertions(+), 15 deletions(-) diff --git a/lib/sqnsupgrade/README.md b/lib/sqnsupgrade/README.md index 80b6548..7646d50 100644 --- a/lib/sqnsupgrade/README.md +++ b/lib/sqnsupgrade/README.md @@ -2,14 +2,6 @@ _Note: This article is only related to GPy, FiPy, and G01 boards_ -**Important**: When upgrading your modem for the first time, even if you have updated it in the past with the old firmware update method, you **MUST** use the "recovery" upgrade method described below. Otherwise you will risk breaking your module. - -Please also use the file CATM1-39529.dup from the archive. - -```python -import sqnsupgrade -sqnsupgrade.run('CATM1-39529.dup', 'updater.elf') -``` Please read the following instructions carefully as there are some significant changes compared to the previous updater version. @@ -18,27 +10,54 @@ Most importantly, the updater is now integrated in the latest stable firmware re Please start with the following steps: 1. Upgrade the Pycom Firmware Updater tool to latest version -2. Select Firmware Type `stable` in the communication window to upgrade to version `v1.18.2.r1` +2. Select Firmware Type `stable` in the communication window to upgrade to latest stable version You can find the different versions of firmwares available here: http://software.pycom.io/downloads/sequans2.html​ These files are password protected, to download them you should be a forum.pycom.io member and access to: Announcements & News --> Announcements only for members --> Firmware Files for Sequans LTE modem now are secured, or clicking Here -We are using `CATM1-39529.zip` and `NB1-37781.zip` as examples in this tutorial. +We are using `CATM1-39529.zip` and `NB1-40343.zip` as examples in this tutorial. + +After unpacking the zip archive, you will find each firmware packages contains two files, one being the firmware file \(e.g. `upgdiff_33080-to-39529.dup` or `upgdiff_33080-to-40343.dup`\) and the `updater.elf` file, which is required when using the **"recovery"** firmware update method or if a previous upgrade failed and the modem is in **recovery** mode. + +to Know if your modem is in recovery mode or not, please execute the following code via the REPEL + +``` +import sqnsupgrade +sqnsupgrade.info() +``` + +For modems in recovery mode this will be displayed: +`Your modem is in recovery mode! Use firmware.dup and updater.elf to flash new firmware.` + +`firmware.dup` => here refers to the full firmware image eg. `CATM1-39529.dup` **NOT** the differential upgrade file eg. `upgdiff_33080-to-39529.dup` + +Please note that you have to choose the right .dup file when updating the modem Firmware , example if you are going to update modem with current FW version 33080 to FW version 39529, you should use `upgdiff_33080-to-39529.dup` and similarly for other Firmware versions. + +`sqnsupgrade.info()` will show the current firmware version: + +``` +Your modem is in application mode. Here is the current version: +UE5.0.0.0d +LR5.1.1.0-39529 + +IMEI: 354346099225475 +``` +Here it is **39529** -After unpacking the zip archive, you will find each firmware packages contains two files, one being the firmware file \(e.g. `CATM1-39529.dup` or `NB1-37781.dup`\) and the `updater.elf` file, which is required when using the "recovery" firmware update method or if a previous upgrade failed and the modem is in recovery mode. Please note that the `updater.elf` file is only around 300K so you can also store it inside the flash file system of the module. The firmware dup files will NOT fit into the available `/flash` file system on the module, so you either need to use an SD card or upload it directly from your computer. +If you modem is **not** in recovery mode , you **don't** need the "updater.elf" file + -To upgrade from the previous CAT-M1 firmware 38638 you can simply upload the upgdiff_38638-to-39529.dup file (452K) from the CATM1-39529.zip archive into the /flash directory on your module and run: +To upgrade from the previous CAT-M1 firmware 38638 you can simply upload the `upgdiff_38638-to-39529.dup` file (452K) from the CATM1-39529.zip archive into the /flash directory on your module and run: ```python import sqnsupgrade sqnsupgrade.run('upgdiff_38638-to-39529.dup') ``` -If you are updating the Sequans firmware on your module for the first time, please use the file CATM1-39529.dup along with the 'updater.elf' from the same archive. Similar upgrade packages are available for the NB-IoT firmwares. >When using differential upgrade packages (ex: upgdiff_XXXX-to-XXXX.dup) you **CANNOT** use updater.elf file. @@ -72,7 +91,7 @@ To flash the NB-IoT firmware onto your device using the recovery method: ```python import sqnsupgrade -sqnsupgrade.run('/sd/NB1-37781.dup', '/sd/updater.elf') +sqnsupgrade.run('/sd/NB1-40343.dup', '/sd/updater.elf') ``` Please note you can directly flash the desired firmware onto your module, it is not necessary to upgrade to the latest CAT-M1 firmware before switching to NB-IoT. @@ -120,7 +139,7 @@ SYSTEM VERSION Please note that the firmware update may seem to "stall" around 7-10% and again at 99%. This is not an indication of a failure but the fact that the modem has to do some tasks during and the updater will wait for these tasks to be completed. Unless the upgrade process is hanging for more than 5 minutes, **do not interrupt the process** as you will have to start again if you don't finish it. It may also take several minutes for the updater to load before responding to the AT wakeup command. -After you have updated your modem once using the recovery method, you can now flash your modem again using just the `CATM1-38638.dup` or `NB1-37781.dup` file without specifying the `updater.elf` file. However, should the upgrade fail, your modem may end up in recovery mode and you will need the `updater.elf` file again. The updater will check for this and prompt you if using the `updater.elf` file is necessary. +After you have updated your modem once using the recovery method, you can now flash your modem again using just the `firmware.dup` or `updiff_XXXX_to_XXXX.dup` file without specifying the `updater.elf` file. However, should the upgrade fail, your modem may end up in recovery mode and you will need the `updater.elf` file again. The updater will check for this and prompt you if using the `updater.elf` file is necessary. Example output using just the firmware file: From 681302a4bffb531b91cc2c6f8583fd463313518e Mon Sep 17 00:00:00 2001 From: Christian Ehlers Date: Tue, 26 Mar 2019 15:58:38 +0100 Subject: [PATCH 13/92] Update pycoproc.py Lower baudrate to 100000 to avoid I2C errors Removed old version from pyscan directory. --- lib/pycoproc/pycoproc.py | 4 +- pyscan/lib/pycoproc.py | 284 --------------------------------------- 2 files changed, 2 insertions(+), 286 deletions(-) delete mode 100644 pyscan/lib/pycoproc.py diff --git a/lib/pycoproc/pycoproc.py b/lib/pycoproc/pycoproc.py index 12db08b..f8babb6 100644 --- a/lib/pycoproc/pycoproc.py +++ b/lib/pycoproc/pycoproc.py @@ -75,7 +75,7 @@ def __init__(self, i2c=None, sda='P22', scl='P21'): if i2c is not None: self.i2c = i2c else: - self.i2c = I2C(0, mode=I2C.MASTER, pins=(sda, scl)) + self.i2c = I2C(0, mode=I2C.MASTER, pins=(sda, scl), baudrate=100000) self.sda = sda self.scl = scl @@ -235,7 +235,7 @@ def calibrate_rtc(self): self.i2c.deinit() Pin('P21', mode=Pin.IN) pulses = pycom.pulses_get('P21', 100) - self.i2c.init(mode=I2C.MASTER, pins=(self.sda, self.scl)) + self.i2c.init(mode=I2C.MASTER, pins=(self.sda, self.scl), baudrate=100000) idx = 0 for i in range(len(pulses)): if pulses[i][1] > EXP_RTC_PERIOD: diff --git a/pyscan/lib/pycoproc.py b/pyscan/lib/pycoproc.py deleted file mode 100644 index 12db08b..0000000 --- a/pyscan/lib/pycoproc.py +++ /dev/null @@ -1,284 +0,0 @@ -from machine import Pin -from machine import I2C -import time -import pycom - -__version__ = '0.0.2' - -""" PIC MCU wakeup reason types """ -WAKE_REASON_ACCELEROMETER = 1 -WAKE_REASON_PUSH_BUTTON = 2 -WAKE_REASON_TIMER = 4 -WAKE_REASON_INT_PIN = 8 - -class Pycoproc: - """ class for handling the interaction with PIC MCU """ - - I2C_SLAVE_ADDR = const(8) - - CMD_PEEK = const(0x0) - CMD_POKE = const(0x01) - CMD_MAGIC = const(0x02) - CMD_HW_VER = const(0x10) - CMD_FW_VER = const(0x11) - CMD_PROD_ID = const(0x12) - CMD_SETUP_SLEEP = const(0x20) - CMD_GO_SLEEP = const(0x21) - CMD_CALIBRATE = const(0x22) - CMD_BAUD_CHANGE = const(0x30) - CMD_DFU = const(0x31) - - REG_CMD = const(0) - REG_ADDRL = const(1) - REG_ADDRH = const(2) - REG_AND = const(3) - REG_OR = const(4) - REG_XOR = const(5) - - ANSELA_ADDR = const(0x18C) - ANSELB_ADDR = const(0x18D) - ANSELC_ADDR = const(0x18E) - - ADCON0_ADDR = const(0x9D) - ADCON1_ADDR = const(0x9E) - - IOCAP_ADDR = const(0x391) - IOCAN_ADDR = const(0x392) - - INTCON_ADDR = const(0x0B) - OPTION_REG_ADDR = const(0x95) - - _ADCON0_CHS_POSN = const(0x02) - _ADCON0_ADON_MASK = const(0x01) - _ADCON1_ADCS_POSN = const(0x04) - _ADCON0_GO_nDONE_MASK = const(0x02) - - ADRESL_ADDR = const(0x09B) - ADRESH_ADDR = const(0x09C) - - TRISC_ADDR = const(0x08E) - - PORTA_ADDR = const(0x00C) - PORTC_ADDR = const(0x00E) - - WPUA_ADDR = const(0x20C) - - WAKE_REASON_ADDR = const(0x064C) - MEMORY_BANK_ADDR = const(0x0620) - - PCON_ADDR = const(0x096) - STATUS_ADDR = const(0x083) - - EXP_RTC_PERIOD = const(7000) - - def __init__(self, i2c=None, sda='P22', scl='P21'): - if i2c is not None: - self.i2c = i2c - else: - self.i2c = I2C(0, mode=I2C.MASTER, pins=(sda, scl)) - - self.sda = sda - self.scl = scl - self.clk_cal_factor = 1 - self.reg = bytearray(6) - self.wake_int = False - self.wake_int_pin = False - self.wake_int_pin_rising_edge = True - - # Make sure we are inserted into the - # correct board and can talk to the PIC - try: - self.read_fw_version() - except Exception as e: - raise Exception('Board not detected: {}'.format(e)) - - # init the ADC for the battery measurements - self.poke_memory(ANSELC_ADDR, 1 << 2) - self.poke_memory(ADCON0_ADDR, (0x06 << _ADCON0_CHS_POSN) | _ADCON0_ADON_MASK) - self.poke_memory(ADCON1_ADDR, (0x06 << _ADCON1_ADCS_POSN)) - # enable the pull-up on RA3 - self.poke_memory(WPUA_ADDR, (1 << 3)) - # make RC5 an input - self.set_bits_in_memory(TRISC_ADDR, 1 << 5) - # set RC6 and RC7 as outputs and enable power to the sensors and the GPS - self.mask_bits_in_memory(TRISC_ADDR, ~(1 << 6)) - self.mask_bits_in_memory(TRISC_ADDR, ~(1 << 7)) - - if self.read_fw_version() < 6: - raise ValueError('Firmware out of date') - - - def _write(self, data, wait=True): - self.i2c.writeto(I2C_SLAVE_ADDR, data) - if wait: - self._wait() - - def _read(self, size): - return self.i2c.readfrom(I2C_SLAVE_ADDR, size + 1)[1:(size + 1)] - - def _wait(self): - count = 0 - time.sleep_us(10) - while self.i2c.readfrom(I2C_SLAVE_ADDR, 1)[0] != 0xFF: - time.sleep_us(100) - count += 1 - if (count > 500): # timeout after 50ms - raise Exception('Board timeout') - - def _send_cmd(self, cmd): - self._write(bytes([cmd])) - - def read_hw_version(self): - self._send_cmd(CMD_HW_VER) - d = self._read(2) - return (d[1] << 8) + d[0] - - def read_fw_version(self): - self._send_cmd(CMD_FW_VER) - d = self._read(2) - return (d[1] << 8) + d[0] - - def read_product_id(self): - self._send_cmd(CMD_PROD_ID) - d = self._read(2) - return (d[1] << 8) + d[0] - - def peek_memory(self, addr): - self._write(bytes([CMD_PEEK, addr & 0xFF, (addr >> 8) & 0xFF])) - return self._read(1)[0] - - def poke_memory(self, addr, value): - self._write(bytes([CMD_POKE, addr & 0xFF, (addr >> 8) & 0xFF, value & 0xFF])) - - def magic_write_read(self, addr, _and=0xFF, _or=0, _xor=0): - self._write(bytes([CMD_MAGIC, addr & 0xFF, (addr >> 8) & 0xFF, _and & 0xFF, _or & 0xFF, _xor & 0xFF])) - return self._read(1)[0] - - def toggle_bits_in_memory(self, addr, bits): - self.magic_write_read(addr, _xor=bits) - - def mask_bits_in_memory(self, addr, mask): - self.magic_write_read(addr, _and=mask) - - def set_bits_in_memory(self, addr, bits): - self.magic_write_read(addr, _or=bits) - - def get_wake_reason(self): - """ returns the wakeup reason, a value out of constants WAKE_REASON_* """ - return self.peek_memory(WAKE_REASON_ADDR) - - def get_sleep_remaining(self): - """ returns the remaining time from sleep, as an interrupt (wakeup source) might have triggered """ - c3 = self.peek_memory(WAKE_REASON_ADDR + 3) - c2 = self.peek_memory(WAKE_REASON_ADDR + 2) - c1 = self.peek_memory(WAKE_REASON_ADDR + 1) - time_device_s = (c3 << 16) + (c2 << 8) + c1 - # this time is from PIC internal oscilator, so it needs to be adjusted with the calibration value - try: - self.calibrate_rtc() - except Exception: - pass - time_s = int((time_device_s / self.clk_cal_factor) + 0.5) # 0.5 used for round - return time_s - - def setup_sleep(self, time_s): - try: - self.calibrate_rtc() - except Exception: - pass - time_s = int((time_s * self.clk_cal_factor) + 0.5) # round to the nearest integer - if time_s >= 2**(8*3): - time_s = 2**(8*3)-1 - self._write(bytes([CMD_SETUP_SLEEP, time_s & 0xFF, (time_s >> 8) & 0xFF, (time_s >> 16) & 0xFF])) - - def go_to_sleep(self, gps=True): - # enable or disable back-up power to the GPS receiver - if gps: - self.set_bits_in_memory(PORTC_ADDR, 1 << 7) - else: - self.mask_bits_in_memory(PORTC_ADDR, ~(1 << 7)) - # disable the ADC - self.poke_memory(ADCON0_ADDR, 0) - - if self.wake_int: - # Don't touch RA3, RA5 or RC1 so that interrupt wake-up works - self.poke_memory(ANSELA_ADDR, ~((1 << 3) | (1 << 5))) - self.poke_memory(ANSELC_ADDR, ~((1 << 6) | (1 << 7) | (1 << 1))) - else: - # disable power to the accelerometer, and don't touch RA3 so that button wake-up works - self.poke_memory(ANSELA_ADDR, ~(1 << 3)) - self.poke_memory(ANSELC_ADDR, ~(1 << 7)) - - self.poke_memory(ANSELB_ADDR, 0xFF) - - # check if INT pin (PIC RC1), should be used for wakeup - if self.wake_int_pin: - if self.wake_int_pin_rising_edge: - self.set_bits_in_memory(OPTION_REG_ADDR, 1 << 6) # rising edge of INT pin - else: - self.mask_bits_in_memory(OPTION_REG_ADDR, ~(1 << 6)) # falling edge of INT pin - self.mask_bits_in_memory(ANSELC_ADDR, ~(1 << 1)) # disable analog function for RC1 pin - self.set_bits_in_memory(TRISC_ADDR, 1 << 1) # make RC1 input pin - self.mask_bits_in_memory(INTCON_ADDR, ~(1 << 1)) # clear INTF - self.set_bits_in_memory(INTCON_ADDR, 1 << 4) # enable interrupt; set INTE) - - self._write(bytes([CMD_GO_SLEEP]), wait=False) - # kill the run pin - Pin('P3', mode=Pin.OUT, value=0) - - def calibrate_rtc(self): - # the 1.024 factor is because the PIC LF operates at 31 KHz - # WDT has a frequency divider to generate 1 ms - # and then there is a binary prescaler, e.g., 1, 2, 4 ... 512, 1024 ms - # hence the need for the constant - self._write(bytes([CMD_CALIBRATE]), wait=False) - self.i2c.deinit() - Pin('P21', mode=Pin.IN) - pulses = pycom.pulses_get('P21', 100) - self.i2c.init(mode=I2C.MASTER, pins=(self.sda, self.scl)) - idx = 0 - for i in range(len(pulses)): - if pulses[i][1] > EXP_RTC_PERIOD: - idx = i - break - try: - period = pulses[idx][1] - pulses[(idx - 1)][1] - except: - period = 0 - if period > 0: - self.clk_cal_factor = (EXP_RTC_PERIOD / period) * (1000 / 1024) - if self.clk_cal_factor > 1.25 or self.clk_cal_factor < 0.75: - self.clk_cal_factor = 1 - - def button_pressed(self): - button = self.peek_memory(PORTA_ADDR) & (1 << 3) - return not button - - def read_battery_voltage(self): - self.set_bits_in_memory(ADCON0_ADDR, _ADCON0_GO_nDONE_MASK) - time.sleep_us(50) - while self.peek_memory(ADCON0_ADDR) & _ADCON0_GO_nDONE_MASK: - time.sleep_us(100) - adc_val = (self.peek_memory(ADRESH_ADDR) << 2) + (self.peek_memory(ADRESL_ADDR) >> 6) - return (((adc_val * 3.3 * 280) / 1023) / 180) + 0.01 # add 10mV to compensate for the drop in the FET - - def setup_int_wake_up(self, rising, falling): - """ rising is for activity detection, falling for inactivity """ - wake_int = False - if rising: - self.set_bits_in_memory(IOCAP_ADDR, 1 << 5) - wake_int = True - else: - self.mask_bits_in_memory(IOCAP_ADDR, ~(1 << 5)) - - if falling: - self.set_bits_in_memory(IOCAN_ADDR, 1 << 5) - wake_int = True - else: - self.mask_bits_in_memory(IOCAN_ADDR, ~(1 << 5)) - self.wake_int = wake_int - - def setup_int_pin_wake_up(self, rising_edge = True): - """ allows wakeup to be made by the INT pin (PIC -RC1) """ - self.wake_int_pin = True - self.wake_int_pin_rising_edge = rising_edge From 8358c56cb7358c54695e135a8b452a9a79b9c6c7 Mon Sep 17 00:00:00 2001 From: Oliver Gauci Date: Fri, 19 Apr 2019 15:06:20 +0200 Subject: [PATCH 14/92] Lorawan OTA: First commit --- examples/OTA-lorawan/LoraServer.py | 259 +++ examples/OTA-lorawan/config.py | 18 + examples/OTA-lorawan/diff_match_patch.py | 1907 +++++++++++++++++ .../firmware/1.17.0/flash/OTA_INFO.py | 1 + .../firmware/1.17.0/flash/diff_match_patch.py | 1605 ++++++++++++++ .../firmware/1.17.0/flash/loranet.py | 131 ++ .../OTA-lorawan/firmware/1.17.0/flash/main.py | 33 + .../OTA-lorawan/firmware/1.17.0/flash/ota.py | 467 ++++ .../firmware/1.17.0/flash/watchdog.py | 33 + .../firmware/1.17.1/flash/OTA_INFO.py | 1 + .../firmware/1.17.1/flash/diff_match_patch.py | 1605 ++++++++++++++ .../firmware/1.17.1/flash/loranet.py | 131 ++ .../OTA-lorawan/firmware/1.17.1/flash/main.py | 35 + .../OTA-lorawan/firmware/1.17.1/flash/ota.py | 467 ++++ .../firmware/1.17.1/flash/watchdog.py | 33 + examples/OTA-lorawan/groupUpdater.py | 264 +++ examples/OTA-lorawan/ota.py | 255 +++ examples/OTA-lorawan/updaterService.py | 42 + 18 files changed, 7287 insertions(+) create mode 100644 examples/OTA-lorawan/LoraServer.py create mode 100644 examples/OTA-lorawan/config.py create mode 100644 examples/OTA-lorawan/diff_match_patch.py create mode 100644 examples/OTA-lorawan/firmware/1.17.0/flash/OTA_INFO.py create mode 100644 examples/OTA-lorawan/firmware/1.17.0/flash/diff_match_patch.py create mode 100644 examples/OTA-lorawan/firmware/1.17.0/flash/loranet.py create mode 100644 examples/OTA-lorawan/firmware/1.17.0/flash/main.py create mode 100644 examples/OTA-lorawan/firmware/1.17.0/flash/ota.py create mode 100644 examples/OTA-lorawan/firmware/1.17.0/flash/watchdog.py create mode 100644 examples/OTA-lorawan/firmware/1.17.1/flash/OTA_INFO.py create mode 100644 examples/OTA-lorawan/firmware/1.17.1/flash/diff_match_patch.py create mode 100644 examples/OTA-lorawan/firmware/1.17.1/flash/loranet.py create mode 100644 examples/OTA-lorawan/firmware/1.17.1/flash/main.py create mode 100644 examples/OTA-lorawan/firmware/1.17.1/flash/ota.py create mode 100644 examples/OTA-lorawan/firmware/1.17.1/flash/watchdog.py create mode 100644 examples/OTA-lorawan/groupUpdater.py create mode 100644 examples/OTA-lorawan/ota.py create mode 100644 examples/OTA-lorawan/updaterService.py diff --git a/examples/OTA-lorawan/LoraServer.py b/examples/OTA-lorawan/LoraServer.py new file mode 100644 index 0000000..8086c34 --- /dev/null +++ b/examples/OTA-lorawan/LoraServer.py @@ -0,0 +1,259 @@ +#!/usr/bin/env python3 + + +import urllib.request +import binascii +import base64 +import os +import json +import config + +login_payload = { + "password": "string", + "username": "string" +} + +mcGroup_payload = { + "multicastGroup": { + "dr": 0, + "fCnt": 0, + "frequency": 0, + "groupType": "CLASS_C", + "id": "string", + "mcAddr": "string", + "mcAppSKey": "string", + "mcNwkSKey": "string", + "name": "string", + "pingSlotPeriod": 0, + "serviceProfileID": "string" + } +} + +mcQueue_payload = { + "multicastQueueItem": { + "data": "string", + "fCnt": 0, + "fPort": 1, + "multicastGroupID": "string" + } +} + +mcAddDevice_payload = { + "devEUI": "string", + "multicastGroupID": "string" +} + +class LoraServerClient: + + def __init__(self): + self.server = config.LORASERVER_URL + self.port = config.LORASERVER_API_PORT + self.username = config.LORASERVER_USER + self.passwd = config.LORASERVER_PASS + + def login(self): + url = self.server + ':' + str(self.port) + '/api/internal/login' + + login_payload["password"] = self.passwd + login_payload["username"] = self.username + + payload = bytes(json.dumps(login_payload),'utf-8') + + try: + r = urllib.request.Request(url, data= payload, method= 'POST') + r.add_header("Content-Type", "application/json") + r.add_header("Accept", "application/json") + + with urllib.request.urlopen(r) as f: + return json.loads(f.read().decode('utf-8'))['jwt'] + + except Exception as ex: + print("Error getting the jwt: {}".format(ex)) + + return None + + def parse_service_profile_list(self, response, profile_name): + + try: + json_obj = json.loads(response) + for sp_obj in json_obj["result"]: + if sp_obj["name"] == profile_name: + return sp_obj["id"] + except Exception as ex: + print("Error parsing service profile list: {}".format(ex)) + + return None + + def request_service_profile_id(self, profile_name, jwt): + url = self.server + ':' + str(self.port) + '/api/service-profiles?limit=100' + + try: + r = urllib.request.Request(url, method= 'GET') + r.add_header("Accept", "application/json") + r.add_header("Grpc-Metadata-Authorization", "Bearer " + jwt) + + with urllib.request.urlopen(r) as f: + return self.parse_service_profile_list(f.read().decode('utf-8'), profile_name) + + except Exception as ex: + print("Error getting service profile id: {}".format(ex)) + + return None + + def create_multicast_group(self, dr, freq, group_name, serviceProfileID, jwt): + + group_id = self.generate_random_id() + mcAddr = self.generate_randon_addr() + mcAppSKey = self.generate_random_key() + mcNwkSKey = self.generate_random_key() + + url = self.server + ':' + str(self.port) + '/api/multicast-groups' + + mcGroup_payload["multicastGroup"]["dr"] = dr + mcGroup_payload["multicastGroup"]["frequency"] = freq + mcGroup_payload["multicastGroup"]["id"] = group_id.decode("utf-8") + mcGroup_payload["multicastGroup"]["mcAddr"] = mcAddr.decode("utf-8") + mcGroup_payload["multicastGroup"]["mcAppSKey"] = mcAppSKey.decode("utf-8") + mcGroup_payload["multicastGroup"]["mcNwkSKey"] = mcNwkSKey.decode("utf-8") + mcGroup_payload["multicastGroup"]["name"] = group_name + mcGroup_payload["multicastGroup"]["serviceProfileID"] = serviceProfileID + + payload = bytes(json.dumps(mcGroup_payload),'utf-8') + + + try: + r = urllib.request.Request(url, data= payload, method= 'POST') + r.add_header("Content-Type", "application/json") + r.add_header("Accept", "application/json") + r.add_header("Grpc-Metadata-Authorization", "Bearer " + jwt) + + with urllib.request.urlopen(r) as f: + resp = f.read().decode('utf-8') + if '"id":' in resp: + multicast_id = json.loads(resp)["id"] + return (multicast_id, mcAddr, mcNwkSKey, mcAppSKey) + else: + return None + except Exception as ex: + print("Error creating multicast data: {}".format(ex)) + + return None + + def delete_multicast_group(self, group_id): + + url = self.server + ':' + str(self.port) + '/api/multicast-groups/' + group_id + + try: + r = urllib.request.Request(url, method = 'DELETE') + + with urllib.request.urlopen(r) as f: + return f.getcode() == 200 + + except Exception as ex: + print("Error deleting multicast group: {}".format(ex)) + + return False + + def add_device_multicast_group(self, devEUI, group_id, jwt): + + url = self.server + ':' + str(self.port) + '/api/multicast-groups/' + group_id + '/devices' + + mcAddDevice_payload["devEUI"] = devEUI + mcAddDevice_payload["multicastGroupID"] = group_id + + payload = json.dumps(mcAddDevice_payload).encode('utf-8') + + try: + r = urllib.request.Request(url, data= payload, method= 'POST') + r.add_header("Content-Type", "application/json") + r.add_header("Accept", "application/json") + r.add_header("Grpc-Metadata-Authorization", "Bearer " + jwt) + + with urllib.request.urlopen(r) as f: + return f.getcode() == 200 + + except Exception as ex: + print("Error adding device to multicast group: {}".format(ex)) + + return False + + def request_multicast_keys(self, group_id, jwt): + + url = self.server + ':' + str(self.port) + '/api/multicast-groups/' + group_id + + try: + r = urllib.request.Request(url, method= 'GET') + r.add_header("Accept", "application/json") + r.add_header("Grpc-Metadata-Authorization", "Bearer " + jwt) + + with urllib.request.urlopen(r) as f: + resp = f.read().decode('utf-8') + if "mcNwkSKey" in resp: + json_resp = json.loads(resp)["multicastGroup"] + return (json_resp["mcAddr"], json_resp["mcNwkSKey"], json_resp["mcAppSKey"]) + else: + return None + except Exception as ex: + print("Error getting multicast keys: {}".format(ex)) + + return None + + def generate_randon_addr(self): + return binascii.hexlify(os.urandom(4)) + + def generate_random_key(self): + return binascii.hexlify(os.urandom(16)) + + def generate_random_id(self): + return binascii.hexlify(os.urandom(4)) + b'-' + binascii.hexlify(os.urandom(2)) + b'-' + binascii.hexlify(os.urandom(2)) \ + + b'-' + binascii.hexlify(os.urandom(2)) + b'-' + binascii.hexlify(os.urandom(6)) + + def multicast_queue_length(self, jwt, multicast_group): + url = self.server + ':' + str(self.port) + '/api/multicast-groups/' + multicast_group + '/queue' + + try: + r = urllib.request.Request(url, method= 'GET') + r.add_header("Content-Type", "application/json") + r.add_header("Grpc-Metadata-Authorization", "Bearer " + jwt) + + with urllib.request.urlopen(r) as f: + resp = f.read().decode('utf-8') + if "multicastQueueItems" in resp: + print(resp) + json_resp = json.loads(resp)["multicastQueueItems"] + print("Len: {}".format(len(json_resp))) + return len(json_resp) + else: + return -1 + + except Exception as ex: + print("Error getting multicast queue length: {}".format(ex)) + + return -1 + + + def send(self, jwt, multicast_group, data): + url = self.server + ':' + str(self.port) + '/api/multicast-groups/' + multicast_group + '/queue' + + mcQueue_payload["multicastQueueItem"]["data"] = base64.b64encode(data).decode("utf-8") + mcQueue_payload["multicastQueueItem"]["multicastGroupID"] = multicast_group + + payload = bytes(json.dumps(mcQueue_payload),'utf-8') + + try: + r = urllib.request.Request(url, data= payload, method= 'POST') + r.add_header("Content-Type", "application/json") + r.add_header("Accept", "application/json") + r.add_header("Grpc-Metadata-Authorization", "Bearer " + jwt) + + with urllib.request.urlopen(r) as f: + return f.getcode() == 200 + + except Exception as ex: + print("Error sending multicast data: {}".format(ex)) + + return False + + + + diff --git a/examples/OTA-lorawan/config.py b/examples/OTA-lorawan/config.py new file mode 100644 index 0000000..f8ccf20 --- /dev/null +++ b/examples/OTA-lorawan/config.py @@ -0,0 +1,18 @@ +#!/usr/bin/env python3 + + +#LORASERVER configuration +LORASERVER_IP = "127.0.0.1" +LORASERVER_URL = 'http://localhost/' +LORASERVER_MQTT_PORT = 1883 +LORASERVER_API_PORT = 8080 +LORASERVER_USER = 'admin' +LORASERVER_PASS = 'admin' + +LORASERVER_SERVICE_PROFILE = 'multicast_sp' +LORASERVER_DOWNLINK_DR = 5 +LORASERVER_DOWNLINK_FREQ = 869525000 + +#update configuration +UPDATE_DELAY = 300 + diff --git a/examples/OTA-lorawan/diff_match_patch.py b/examples/OTA-lorawan/diff_match_patch.py new file mode 100644 index 0000000..906d16d --- /dev/null +++ b/examples/OTA-lorawan/diff_match_patch.py @@ -0,0 +1,1907 @@ +#!/usr/bin/python3 + +"""Diff Match and Patch +Copyright 2018 The diff-match-patch Authors. +https://github.com/google/diff-match-patch + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +""" + +"""Functions for diff, match and patch. + +Computes the difference between two texts to create a patch. +Applies the patch onto another text, allowing for errors. +""" + +__author__ = 'fraser@google.com (Neil Fraser)' + +import re +import sys +import time +import urllib.parse + + +class diff_match_patch: + """Class containing the diff, match and patch methods. + + Also contains the behaviour settings. + """ + + def __init__(self): + """Inits a diff_match_patch object with default settings. + Redefine these in your program to override the defaults. + """ + + # Number of seconds to map a diff before giving up (0 for infinity). + self.Diff_Timeout = 1.0 + # Cost of an empty edit operation in terms of edit characters. + self.Diff_EditCost = 4 + # At what point is no match declared (0.0 = perfection, 1.0 = very loose). + self.Match_Threshold = 0.5 + # How far to search for a match (0 = exact location, 1000+ = broad match). + # A match this many characters away from the expected location will add + # 1.0 to the score (0.0 is a perfect match). + self.Match_Distance = 1000 + # When deleting a large block of text (over ~64 characters), how close do + # the contents have to be to match the expected contents. (0.0 = perfection, + # 1.0 = very loose). Note that Match_Threshold controls how closely the + # end points of a delete need to match. + self.Patch_DeleteThreshold = 0.5 + # Chunk size for context length. + self.Patch_Margin = 4 + + # The number of bits in an int. + # Python has no maximum, thus to disable patch splitting set to 0. + # However to avoid long patches in certain pathological cases, use 32. + # Multiple short patches (using native ints) are much faster than long ones. + self.Match_MaxBits = 32 + + # DIFF FUNCTIONS + + # The data structure representing a diff is an array of tuples: + # [(DIFF_DELETE, "Hello"), (DIFF_INSERT, "Goodbye"), (DIFF_EQUAL, " world.")] + # which means: delete "Hello", add "Goodbye" and keep " world." + DIFF_DELETE = -1 + DIFF_INSERT = 1 + DIFF_EQUAL = 0 + + def diff_main(self, text1, text2, checklines=True, deadline=None): + """Find the differences between two texts. Simplifies the problem by + stripping any common prefix or suffix off the texts before diffing. + + Args: + text1: Old string to be diffed. + text2: New string to be diffed. + checklines: Optional speedup flag. If present and false, then don't run + a line-level diff first to identify the changed areas. + Defaults to true, which does a faster, slightly less optimal diff. + deadline: Optional time when the diff should be complete by. Used + internally for recursive calls. Users should set DiffTimeout instead. + + Returns: + Array of changes. + """ + # Set a deadline by which time the diff must be complete. + if deadline == None: + # Unlike in most languages, Python counts time in seconds. + if self.Diff_Timeout <= 0: + deadline = sys.maxsize + else: + deadline = time.time() + self.Diff_Timeout + + # Check for null inputs. + if text1 == None or text2 == None: + raise ValueError("Null inputs. (diff_main)") + + # Check for equality (speedup). + if text1 == text2: + if text1: + return [(self.DIFF_EQUAL, text1)] + return [] + + # Trim off common prefix (speedup). + commonlength = self.diff_commonPrefix(text1, text2) + commonprefix = text1[:commonlength] + text1 = text1[commonlength:] + text2 = text2[commonlength:] + + # Trim off common suffix (speedup). + commonlength = self.diff_commonSuffix(text1, text2) + if commonlength == 0: + commonsuffix = '' + else: + commonsuffix = text1[-commonlength:] + text1 = text1[:-commonlength] + text2 = text2[:-commonlength] + + # Compute the diff on the middle block. + diffs = self.diff_compute(text1, text2, checklines, deadline) + + # Restore the prefix and suffix. + if commonprefix: + diffs[:0] = [(self.DIFF_EQUAL, commonprefix)] + if commonsuffix: + diffs.append((self.DIFF_EQUAL, commonsuffix)) + self.diff_cleanupMerge(diffs) + return diffs + + def diff_compute(self, text1, text2, checklines, deadline): + """Find the differences between two texts. Assumes that the texts do not + have any common prefix or suffix. + + Args: + text1: Old string to be diffed. + text2: New string to be diffed. + checklines: Speedup flag. If false, then don't run a line-level diff + first to identify the changed areas. + If true, then run a faster, slightly less optimal diff. + deadline: Time when the diff should be complete by. + + Returns: + Array of changes. + """ + if not text1: + # Just add some text (speedup). + return [(self.DIFF_INSERT, text2)] + + if not text2: + # Just delete some text (speedup). + return [(self.DIFF_DELETE, text1)] + + if len(text1) > len(text2): + (longtext, shorttext) = (text1, text2) + else: + (shorttext, longtext) = (text1, text2) + i = longtext.find(shorttext) + if i != -1: + # Shorter text is inside the longer text (speedup). + diffs = [(self.DIFF_INSERT, longtext[:i]), (self.DIFF_EQUAL, shorttext), + (self.DIFF_INSERT, longtext[i + len(shorttext):])] + # Swap insertions for deletions if diff is reversed. + if len(text1) > len(text2): + diffs[0] = (self.DIFF_DELETE, diffs[0][1]) + diffs[2] = (self.DIFF_DELETE, diffs[2][1]) + return diffs + + if len(shorttext) == 1: + # Single character string. + # After the previous speedup, the character can't be an equality. + return [(self.DIFF_DELETE, text1), (self.DIFF_INSERT, text2)] + + # Check to see if the problem can be split in two. + hm = self.diff_halfMatch(text1, text2) + if hm: + # A half-match was found, sort out the return data. + (text1_a, text1_b, text2_a, text2_b, mid_common) = hm + # Send both pairs off for separate processing. + diffs_a = self.diff_main(text1_a, text2_a, checklines, deadline) + diffs_b = self.diff_main(text1_b, text2_b, checklines, deadline) + # Merge the results. + return diffs_a + [(self.DIFF_EQUAL, mid_common)] + diffs_b + + if checklines and len(text1) > 100 and len(text2) > 100: + return self.diff_lineMode(text1, text2, deadline) + + return self.diff_bisect(text1, text2, deadline) + + def diff_lineMode(self, text1, text2, deadline): + """Do a quick line-level diff on both strings, then rediff the parts for + greater accuracy. + This speedup can produce non-minimal diffs. + + Args: + text1: Old string to be diffed. + text2: New string to be diffed. + deadline: Time when the diff should be complete by. + + Returns: + Array of changes. + """ + + # Scan the text on a line-by-line basis first. + (text1, text2, linearray) = self.diff_linesToChars(text1, text2) + + diffs = self.diff_main(text1, text2, False, deadline) + + # Convert the diff back to original text. + self.diff_charsToLines(diffs, linearray) + # Eliminate freak matches (e.g. blank lines) + self.diff_cleanupSemantic(diffs) + + # Rediff any replacement blocks, this time character-by-character. + # Add a dummy entry at the end. + diffs.append((self.DIFF_EQUAL, '')) + pointer = 0 + count_delete = 0 + count_insert = 0 + text_delete = '' + text_insert = '' + while pointer < len(diffs): + if diffs[pointer][0] == self.DIFF_INSERT: + count_insert += 1 + text_insert += diffs[pointer][1] + elif diffs[pointer][0] == self.DIFF_DELETE: + count_delete += 1 + text_delete += diffs[pointer][1] + elif diffs[pointer][0] == self.DIFF_EQUAL: + # Upon reaching an equality, check for prior redundancies. + if count_delete >= 1 and count_insert >= 1: + # Delete the offending records and add the merged ones. + subDiff = self.diff_main(text_delete, text_insert, False, deadline) + diffs[pointer - count_delete - count_insert : pointer] = subDiff + pointer = pointer - count_delete - count_insert + len(subDiff) + count_insert = 0 + count_delete = 0 + text_delete = '' + text_insert = '' + + pointer += 1 + + diffs.pop() # Remove the dummy entry at the end. + + return diffs + + def diff_bisect(self, text1, text2, deadline): + """Find the 'middle snake' of a diff, split the problem in two + and return the recursively constructed diff. + See Myers 1986 paper: An O(ND) Difference Algorithm and Its Variations. + + Args: + text1: Old string to be diffed. + text2: New string to be diffed. + deadline: Time at which to bail if not yet complete. + + Returns: + Array of diff tuples. + """ + + # Cache the text lengths to prevent multiple calls. + text1_length = len(text1) + text2_length = len(text2) + max_d = (text1_length + text2_length + 1) // 2 + v_offset = max_d + v_length = 2 * max_d + v1 = [-1] * v_length + v1[v_offset + 1] = 0 + v2 = v1[:] + delta = text1_length - text2_length + # If the total number of characters is odd, then the front path will + # collide with the reverse path. + front = (delta % 2 != 0) + # Offsets for start and end of k loop. + # Prevents mapping of space beyond the grid. + k1start = 0 + k1end = 0 + k2start = 0 + k2end = 0 + for d in range(max_d): + # Bail out if deadline is reached. + if time.time() > deadline: + break + + # Walk the front path one step. + for k1 in range(-d + k1start, d + 1 - k1end, 2): + k1_offset = v_offset + k1 + if k1 == -d or (k1 != d and + v1[k1_offset - 1] < v1[k1_offset + 1]): + x1 = v1[k1_offset + 1] + else: + x1 = v1[k1_offset - 1] + 1 + y1 = x1 - k1 + while (x1 < text1_length and y1 < text2_length and + text1[x1] == text2[y1]): + x1 += 1 + y1 += 1 + v1[k1_offset] = x1 + if x1 > text1_length: + # Ran off the right of the graph. + k1end += 2 + elif y1 > text2_length: + # Ran off the bottom of the graph. + k1start += 2 + elif front: + k2_offset = v_offset + delta - k1 + if k2_offset >= 0 and k2_offset < v_length and v2[k2_offset] != -1: + # Mirror x2 onto top-left coordinate system. + x2 = text1_length - v2[k2_offset] + if x1 >= x2: + # Overlap detected. + return self.diff_bisectSplit(text1, text2, x1, y1, deadline) + + # Walk the reverse path one step. + for k2 in range(-d + k2start, d + 1 - k2end, 2): + k2_offset = v_offset + k2 + if k2 == -d or (k2 != d and + v2[k2_offset - 1] < v2[k2_offset + 1]): + x2 = v2[k2_offset + 1] + else: + x2 = v2[k2_offset - 1] + 1 + y2 = x2 - k2 + while (x2 < text1_length and y2 < text2_length and + text1[-x2 - 1] == text2[-y2 - 1]): + x2 += 1 + y2 += 1 + v2[k2_offset] = x2 + if x2 > text1_length: + # Ran off the left of the graph. + k2end += 2 + elif y2 > text2_length: + # Ran off the top of the graph. + k2start += 2 + elif not front: + k1_offset = v_offset + delta - k2 + if k1_offset >= 0 and k1_offset < v_length and v1[k1_offset] != -1: + x1 = v1[k1_offset] + y1 = v_offset + x1 - k1_offset + # Mirror x2 onto top-left coordinate system. + x2 = text1_length - x2 + if x1 >= x2: + # Overlap detected. + return self.diff_bisectSplit(text1, text2, x1, y1, deadline) + + # Diff took too long and hit the deadline or + # number of diffs equals number of characters, no commonality at all. + return [(self.DIFF_DELETE, text1), (self.DIFF_INSERT, text2)] + + def diff_bisectSplit(self, text1, text2, x, y, deadline): + """Given the location of the 'middle snake', split the diff in two parts + and recurse. + + Args: + text1: Old string to be diffed. + text2: New string to be diffed. + x: Index of split point in text1. + y: Index of split point in text2. + deadline: Time at which to bail if not yet complete. + + Returns: + Array of diff tuples. + """ + text1a = text1[:x] + text2a = text2[:y] + text1b = text1[x:] + text2b = text2[y:] + + # Compute both diffs serially. + diffs = self.diff_main(text1a, text2a, False, deadline) + diffsb = self.diff_main(text1b, text2b, False, deadline) + + return diffs + diffsb + + def diff_linesToChars(self, text1, text2): + """Split two texts into an array of strings. Reduce the texts to a string + of hashes where each Unicode character represents one line. + + Args: + text1: First string. + text2: Second string. + + Returns: + Three element tuple, containing the encoded text1, the encoded text2 and + the array of unique strings. The zeroth element of the array of unique + strings is intentionally blank. + """ + lineArray = [] # e.g. lineArray[4] == "Hello\n" + lineHash = {} # e.g. lineHash["Hello\n"] == 4 + + # "\x00" is a valid character, but various debuggers don't like it. + # So we'll insert a junk entry to avoid generating a null character. + lineArray.append('') + + def diff_linesToCharsMunge(text): + """Split a text into an array of strings. Reduce the texts to a string + of hashes where each Unicode character represents one line. + Modifies linearray and linehash through being a closure. + + Args: + text: String to encode. + + Returns: + Encoded string. + """ + chars = [] + # Walk the text, pulling out a substring for each line. + # text.split('\n') would would temporarily double our memory footprint. + # Modifying text would create many large strings to garbage collect. + lineStart = 0 + lineEnd = -1 + while lineEnd < len(text) - 1: + lineEnd = text.find('\n', lineStart) + if lineEnd == -1: + lineEnd = len(text) - 1 + line = text[lineStart:lineEnd + 1] + + if line in lineHash: + chars.append(chr(lineHash[line])) + else: + if len(lineArray) == maxLines: + # Bail out at 1114111 because chr(1114112) throws. + line = text[lineStart:] + lineEnd = len(text) + lineArray.append(line) + lineHash[line] = len(lineArray) - 1 + chars.append(chr(len(lineArray) - 1)) + lineStart = lineEnd + 1 + return "".join(chars) + + # Allocate 2/3rds of the space for text1, the rest for text2. + maxLines = 666666 + chars1 = diff_linesToCharsMunge(text1) + maxLines = 1114111 + chars2 = diff_linesToCharsMunge(text2) + return (chars1, chars2, lineArray) + + def diff_charsToLines(self, diffs, lineArray): + """Rehydrate the text in a diff from a string of line hashes to real lines + of text. + + Args: + diffs: Array of diff tuples. + lineArray: Array of unique strings. + """ + for i in range(len(diffs)): + text = [] + for char in diffs[i][1]: + text.append(lineArray[ord(char)]) + diffs[i] = (diffs[i][0], "".join(text)) + + def diff_commonPrefix(self, text1, text2): + """Determine the common prefix of two strings. + + Args: + text1: First string. + text2: Second string. + + Returns: + The number of characters common to the start of each string. + """ + # Quick check for common null cases. + if not text1 or not text2 or text1[0] != text2[0]: + return 0 + # Binary search. + # Performance analysis: https://neil.fraser.name/news/2007/10/09/ + pointermin = 0 + pointermax = min(len(text1), len(text2)) + pointermid = pointermax + pointerstart = 0 + while pointermin < pointermid: + if text1[pointerstart:pointermid] == text2[pointerstart:pointermid]: + pointermin = pointermid + pointerstart = pointermin + else: + pointermax = pointermid + pointermid = (pointermax - pointermin) // 2 + pointermin + return pointermid + + def diff_commonSuffix(self, text1, text2): + """Determine the common suffix of two strings. + + Args: + text1: First string. + text2: Second string. + + Returns: + The number of characters common to the end of each string. + """ + # Quick check for common null cases. + if not text1 or not text2 or text1[-1] != text2[-1]: + return 0 + # Binary search. + # Performance analysis: https://neil.fraser.name/news/2007/10/09/ + pointermin = 0 + pointermax = min(len(text1), len(text2)) + pointermid = pointermax + pointerend = 0 + while pointermin < pointermid: + if (text1[-pointermid:len(text1) - pointerend] == + text2[-pointermid:len(text2) - pointerend]): + pointermin = pointermid + pointerend = pointermin + else: + pointermax = pointermid + pointermid = (pointermax - pointermin) // 2 + pointermin + return pointermid + + def diff_commonOverlap(self, text1, text2): + """Determine if the suffix of one string is the prefix of another. + + Args: + text1 First string. + text2 Second string. + + Returns: + The number of characters common to the end of the first + string and the start of the second string. + """ + # Cache the text lengths to prevent multiple calls. + text1_length = len(text1) + text2_length = len(text2) + # Eliminate the null case. + if text1_length == 0 or text2_length == 0: + return 0 + # Truncate the longer string. + if text1_length > text2_length: + text1 = text1[-text2_length:] + elif text1_length < text2_length: + text2 = text2[:text1_length] + text_length = min(text1_length, text2_length) + # Quick check for the worst case. + if text1 == text2: + return text_length + + # Start by looking for a single character match + # and increase length until no match is found. + # Performance analysis: https://neil.fraser.name/news/2010/11/04/ + best = 0 + length = 1 + while True: + pattern = text1[-length:] + found = text2.find(pattern) + if found == -1: + return best + length += found + if found == 0 or text1[-length:] == text2[:length]: + best = length + length += 1 + + def diff_halfMatch(self, text1, text2): + """Do the two texts share a substring which is at least half the length of + the longer text? + This speedup can produce non-minimal diffs. + + Args: + text1: First string. + text2: Second string. + + Returns: + Five element Array, containing the prefix of text1, the suffix of text1, + the prefix of text2, the suffix of text2 and the common middle. Or None + if there was no match. + """ + if self.Diff_Timeout <= 0: + # Don't risk returning a non-optimal diff if we have unlimited time. + return None + if len(text1) > len(text2): + (longtext, shorttext) = (text1, text2) + else: + (shorttext, longtext) = (text1, text2) + if len(longtext) < 4 or len(shorttext) * 2 < len(longtext): + return None # Pointless. + + def diff_halfMatchI(longtext, shorttext, i): + """Does a substring of shorttext exist within longtext such that the + substring is at least half the length of longtext? + Closure, but does not reference any external variables. + + Args: + longtext: Longer string. + shorttext: Shorter string. + i: Start index of quarter length substring within longtext. + + Returns: + Five element Array, containing the prefix of longtext, the suffix of + longtext, the prefix of shorttext, the suffix of shorttext and the + common middle. Or None if there was no match. + """ + seed = longtext[i:i + len(longtext) // 4] + best_common = '' + j = shorttext.find(seed) + while j != -1: + prefixLength = self.diff_commonPrefix(longtext[i:], shorttext[j:]) + suffixLength = self.diff_commonSuffix(longtext[:i], shorttext[:j]) + if len(best_common) < suffixLength + prefixLength: + best_common = (shorttext[j - suffixLength:j] + + shorttext[j:j + prefixLength]) + best_longtext_a = longtext[:i - suffixLength] + best_longtext_b = longtext[i + prefixLength:] + best_shorttext_a = shorttext[:j - suffixLength] + best_shorttext_b = shorttext[j + prefixLength:] + j = shorttext.find(seed, j + 1) + + if len(best_common) * 2 >= len(longtext): + return (best_longtext_a, best_longtext_b, + best_shorttext_a, best_shorttext_b, best_common) + else: + return None + + # First check if the second quarter is the seed for a half-match. + hm1 = diff_halfMatchI(longtext, shorttext, (len(longtext) + 3) // 4) + # Check again based on the third quarter. + hm2 = diff_halfMatchI(longtext, shorttext, (len(longtext) + 1) // 2) + if not hm1 and not hm2: + return None + elif not hm2: + hm = hm1 + elif not hm1: + hm = hm2 + else: + # Both matched. Select the longest. + if len(hm1[4]) > len(hm2[4]): + hm = hm1 + else: + hm = hm2 + + # A half-match was found, sort out the return data. + if len(text1) > len(text2): + (text1_a, text1_b, text2_a, text2_b, mid_common) = hm + else: + (text2_a, text2_b, text1_a, text1_b, mid_common) = hm + return (text1_a, text1_b, text2_a, text2_b, mid_common) + + def diff_cleanupSemantic(self, diffs): + """Reduce the number of edits by eliminating semantically trivial + equalities. + + Args: + diffs: Array of diff tuples. + """ + changes = False + equalities = [] # Stack of indices where equalities are found. + lastEquality = None # Always equal to diffs[equalities[-1]][1] + pointer = 0 # Index of current position. + # Number of chars that changed prior to the equality. + length_insertions1, length_deletions1 = 0, 0 + # Number of chars that changed after the equality. + length_insertions2, length_deletions2 = 0, 0 + while pointer < len(diffs): + if diffs[pointer][0] == self.DIFF_EQUAL: # Equality found. + equalities.append(pointer) + length_insertions1, length_insertions2 = length_insertions2, 0 + length_deletions1, length_deletions2 = length_deletions2, 0 + lastEquality = diffs[pointer][1] + else: # An insertion or deletion. + if diffs[pointer][0] == self.DIFF_INSERT: + length_insertions2 += len(diffs[pointer][1]) + else: + length_deletions2 += len(diffs[pointer][1]) + # Eliminate an equality that is smaller or equal to the edits on both + # sides of it. + if (lastEquality and (len(lastEquality) <= + max(length_insertions1, length_deletions1)) and + (len(lastEquality) <= max(length_insertions2, length_deletions2))): + # Duplicate record. + diffs.insert(equalities[-1], (self.DIFF_DELETE, lastEquality)) + # Change second copy to insert. + diffs[equalities[-1] + 1] = (self.DIFF_INSERT, + diffs[equalities[-1] + 1][1]) + # Throw away the equality we just deleted. + equalities.pop() + # Throw away the previous equality (it needs to be reevaluated). + if len(equalities): + equalities.pop() + if len(equalities): + pointer = equalities[-1] + else: + pointer = -1 + # Reset the counters. + length_insertions1, length_deletions1 = 0, 0 + length_insertions2, length_deletions2 = 0, 0 + lastEquality = None + changes = True + pointer += 1 + + # Normalize the diff. + if changes: + self.diff_cleanupMerge(diffs) + self.diff_cleanupSemanticLossless(diffs) + + # Find any overlaps between deletions and insertions. + # e.g: abcxxxxxxdef + # -> abcxxxdef + # e.g: xxxabcdefxxx + # -> defxxxabc + # Only extract an overlap if it is as big as the edit ahead or behind it. + pointer = 1 + while pointer < len(diffs): + if (diffs[pointer - 1][0] == self.DIFF_DELETE and + diffs[pointer][0] == self.DIFF_INSERT): + deletion = diffs[pointer - 1][1] + insertion = diffs[pointer][1] + overlap_length1 = self.diff_commonOverlap(deletion, insertion) + overlap_length2 = self.diff_commonOverlap(insertion, deletion) + if overlap_length1 >= overlap_length2: + if (overlap_length1 >= len(deletion) / 2.0 or + overlap_length1 >= len(insertion) / 2.0): + # Overlap found. Insert an equality and trim the surrounding edits. + diffs.insert(pointer, (self.DIFF_EQUAL, + insertion[:overlap_length1])) + diffs[pointer - 1] = (self.DIFF_DELETE, + deletion[:len(deletion) - overlap_length1]) + diffs[pointer + 1] = (self.DIFF_INSERT, + insertion[overlap_length1:]) + pointer += 1 + else: + if (overlap_length2 >= len(deletion) / 2.0 or + overlap_length2 >= len(insertion) / 2.0): + # Reverse overlap found. + # Insert an equality and swap and trim the surrounding edits. + diffs.insert(pointer, (self.DIFF_EQUAL, deletion[:overlap_length2])) + diffs[pointer - 1] = (self.DIFF_INSERT, + insertion[:len(insertion) - overlap_length2]) + diffs[pointer + 1] = (self.DIFF_DELETE, deletion[overlap_length2:]) + pointer += 1 + pointer += 1 + pointer += 1 + + def diff_cleanupSemanticLossless(self, diffs): + """Look for single edits surrounded on both sides by equalities + which can be shifted sideways to align the edit to a word boundary. + e.g: The cat came. -> The cat came. + + Args: + diffs: Array of diff tuples. + """ + + def diff_cleanupSemanticScore(one, two): + """Given two strings, compute a score representing whether the + internal boundary falls on logical boundaries. + Scores range from 6 (best) to 0 (worst). + Closure, but does not reference any external variables. + + Args: + one: First string. + two: Second string. + + Returns: + The score. + """ + if not one or not two: + # Edges are the best. + return 6 + + # Each port of this function behaves slightly differently due to + # subtle differences in each language's definition of things like + # 'whitespace'. Since this function's purpose is largely cosmetic, + # the choice has been made to use each language's native features + # rather than force total conformity. + char1 = one[-1] + char2 = two[0] + nonAlphaNumeric1 = not char1.isalnum() + nonAlphaNumeric2 = not char2.isalnum() + whitespace1 = nonAlphaNumeric1 and char1.isspace() + whitespace2 = nonAlphaNumeric2 and char2.isspace() + lineBreak1 = whitespace1 and (char1 == "\r" or char1 == "\n") + lineBreak2 = whitespace2 and (char2 == "\r" or char2 == "\n") + blankLine1 = lineBreak1 and self.BLANKLINEEND.search(one) + blankLine2 = lineBreak2 and self.BLANKLINESTART.match(two) + + if blankLine1 or blankLine2: + # Five points for blank lines. + return 5 + elif lineBreak1 or lineBreak2: + # Four points for line breaks. + return 4 + elif nonAlphaNumeric1 and not whitespace1 and whitespace2: + # Three points for end of sentences. + return 3 + elif whitespace1 or whitespace2: + # Two points for whitespace. + return 2 + elif nonAlphaNumeric1 or nonAlphaNumeric2: + # One point for non-alphanumeric. + return 1 + return 0 + + pointer = 1 + # Intentionally ignore the first and last element (don't need checking). + while pointer < len(diffs) - 1: + if (diffs[pointer - 1][0] == self.DIFF_EQUAL and + diffs[pointer + 1][0] == self.DIFF_EQUAL): + # This is a single edit surrounded by equalities. + equality1 = diffs[pointer - 1][1] + edit = diffs[pointer][1] + equality2 = diffs[pointer + 1][1] + + # First, shift the edit as far left as possible. + commonOffset = self.diff_commonSuffix(equality1, edit) + if commonOffset: + commonString = edit[-commonOffset:] + equality1 = equality1[:-commonOffset] + edit = commonString + edit[:-commonOffset] + equality2 = commonString + equality2 + + # Second, step character by character right, looking for the best fit. + bestEquality1 = equality1 + bestEdit = edit + bestEquality2 = equality2 + bestScore = (diff_cleanupSemanticScore(equality1, edit) + + diff_cleanupSemanticScore(edit, equality2)) + while edit and equality2 and edit[0] == equality2[0]: + equality1 += edit[0] + edit = edit[1:] + equality2[0] + equality2 = equality2[1:] + score = (diff_cleanupSemanticScore(equality1, edit) + + diff_cleanupSemanticScore(edit, equality2)) + # The >= encourages trailing rather than leading whitespace on edits. + if score >= bestScore: + bestScore = score + bestEquality1 = equality1 + bestEdit = edit + bestEquality2 = equality2 + + if diffs[pointer - 1][1] != bestEquality1: + # We have an improvement, save it back to the diff. + if bestEquality1: + diffs[pointer - 1] = (diffs[pointer - 1][0], bestEquality1) + else: + del diffs[pointer - 1] + pointer -= 1 + diffs[pointer] = (diffs[pointer][0], bestEdit) + if bestEquality2: + diffs[pointer + 1] = (diffs[pointer + 1][0], bestEquality2) + else: + del diffs[pointer + 1] + pointer -= 1 + pointer += 1 + + # Define some regex patterns for matching boundaries. + BLANKLINEEND = re.compile(r"\n\r?\n$") + BLANKLINESTART = re.compile(r"^\r?\n\r?\n") + + def diff_cleanupEfficiency(self, diffs): + """Reduce the number of edits by eliminating operationally trivial + equalities. + + Args: + diffs: Array of diff tuples. + """ + changes = False + equalities = [] # Stack of indices where equalities are found. + lastEquality = None # Always equal to diffs[equalities[-1]][1] + pointer = 0 # Index of current position. + pre_ins = False # Is there an insertion operation before the last equality. + pre_del = False # Is there a deletion operation before the last equality. + post_ins = False # Is there an insertion operation after the last equality. + post_del = False # Is there a deletion operation after the last equality. + while pointer < len(diffs): + if diffs[pointer][0] == self.DIFF_EQUAL: # Equality found. + if (len(diffs[pointer][1]) < self.Diff_EditCost and + (post_ins or post_del)): + # Candidate found. + equalities.append(pointer) + pre_ins = post_ins + pre_del = post_del + lastEquality = diffs[pointer][1] + else: + # Not a candidate, and can never become one. + equalities = [] + lastEquality = None + + post_ins = post_del = False + else: # An insertion or deletion. + if diffs[pointer][0] == self.DIFF_DELETE: + post_del = True + else: + post_ins = True + + # Five types to be split: + # ABXYCD + # AXCD + # ABXC + # AXCD + # ABXC + + if lastEquality and ((pre_ins and pre_del and post_ins and post_del) or + ((len(lastEquality) < self.Diff_EditCost / 2) and + (pre_ins + pre_del + post_ins + post_del) == 3)): + # Duplicate record. + diffs.insert(equalities[-1], (self.DIFF_DELETE, lastEquality)) + # Change second copy to insert. + diffs[equalities[-1] + 1] = (self.DIFF_INSERT, + diffs[equalities[-1] + 1][1]) + equalities.pop() # Throw away the equality we just deleted. + lastEquality = None + if pre_ins and pre_del: + # No changes made which could affect previous entry, keep going. + post_ins = post_del = True + equalities = [] + else: + if len(equalities): + equalities.pop() # Throw away the previous equality. + if len(equalities): + pointer = equalities[-1] + else: + pointer = -1 + post_ins = post_del = False + changes = True + pointer += 1 + + if changes: + self.diff_cleanupMerge(diffs) + + def diff_cleanupMerge(self, diffs): + """Reorder and merge like edit sections. Merge equalities. + Any edit section can move as long as it doesn't cross an equality. + + Args: + diffs: Array of diff tuples. + """ + diffs.append((self.DIFF_EQUAL, '')) # Add a dummy entry at the end. + pointer = 0 + count_delete = 0 + count_insert = 0 + text_delete = '' + text_insert = '' + while pointer < len(diffs): + if diffs[pointer][0] == self.DIFF_INSERT: + count_insert += 1 + text_insert += diffs[pointer][1] + pointer += 1 + elif diffs[pointer][0] == self.DIFF_DELETE: + count_delete += 1 + text_delete += diffs[pointer][1] + pointer += 1 + elif diffs[pointer][0] == self.DIFF_EQUAL: + # Upon reaching an equality, check for prior redundancies. + if count_delete + count_insert > 1: + if count_delete != 0 and count_insert != 0: + # Factor out any common prefixies. + commonlength = self.diff_commonPrefix(text_insert, text_delete) + if commonlength != 0: + x = pointer - count_delete - count_insert - 1 + if x >= 0 and diffs[x][0] == self.DIFF_EQUAL: + diffs[x] = (diffs[x][0], diffs[x][1] + + text_insert[:commonlength]) + else: + diffs.insert(0, (self.DIFF_EQUAL, text_insert[:commonlength])) + pointer += 1 + text_insert = text_insert[commonlength:] + text_delete = text_delete[commonlength:] + # Factor out any common suffixies. + commonlength = self.diff_commonSuffix(text_insert, text_delete) + if commonlength != 0: + diffs[pointer] = (diffs[pointer][0], text_insert[-commonlength:] + + diffs[pointer][1]) + text_insert = text_insert[:-commonlength] + text_delete = text_delete[:-commonlength] + # Delete the offending records and add the merged ones. + new_ops = [] + if len(text_delete) != 0: + new_ops.append((self.DIFF_DELETE, text_delete)) + if len(text_insert) != 0: + new_ops.append((self.DIFF_INSERT, text_insert)) + pointer -= count_delete + count_insert + diffs[pointer : pointer + count_delete + count_insert] = new_ops + pointer += len(new_ops) + 1 + elif pointer != 0 and diffs[pointer - 1][0] == self.DIFF_EQUAL: + # Merge this equality with the previous one. + diffs[pointer - 1] = (diffs[pointer - 1][0], + diffs[pointer - 1][1] + diffs[pointer][1]) + del diffs[pointer] + else: + pointer += 1 + + count_insert = 0 + count_delete = 0 + text_delete = '' + text_insert = '' + + if diffs[-1][1] == '': + diffs.pop() # Remove the dummy entry at the end. + + # Second pass: look for single edits surrounded on both sides by equalities + # which can be shifted sideways to eliminate an equality. + # e.g: ABAC -> ABAC + changes = False + pointer = 1 + # Intentionally ignore the first and last element (don't need checking). + while pointer < len(diffs) - 1: + if (diffs[pointer - 1][0] == self.DIFF_EQUAL and + diffs[pointer + 1][0] == self.DIFF_EQUAL): + # This is a single edit surrounded by equalities. + if diffs[pointer][1].endswith(diffs[pointer - 1][1]): + # Shift the edit over the previous equality. + if diffs[pointer - 1][1] != "": + diffs[pointer] = (diffs[pointer][0], + diffs[pointer - 1][1] + + diffs[pointer][1][:-len(diffs[pointer - 1][1])]) + diffs[pointer + 1] = (diffs[pointer + 1][0], + diffs[pointer - 1][1] + diffs[pointer + 1][1]) + del diffs[pointer - 1] + changes = True + elif diffs[pointer][1].startswith(diffs[pointer + 1][1]): + # Shift the edit over the next equality. + diffs[pointer - 1] = (diffs[pointer - 1][0], + diffs[pointer - 1][1] + diffs[pointer + 1][1]) + diffs[pointer] = (diffs[pointer][0], + diffs[pointer][1][len(diffs[pointer + 1][1]):] + + diffs[pointer + 1][1]) + del diffs[pointer + 1] + changes = True + pointer += 1 + + # If shifts were made, the diff needs reordering and another shift sweep. + if changes: + self.diff_cleanupMerge(diffs) + + def diff_xIndex(self, diffs, loc): + """loc is a location in text1, compute and return the equivalent location + in text2. e.g. "The cat" vs "The big cat", 1->1, 5->8 + + Args: + diffs: Array of diff tuples. + loc: Location within text1. + + Returns: + Location within text2. + """ + chars1 = 0 + chars2 = 0 + last_chars1 = 0 + last_chars2 = 0 + for x in range(len(diffs)): + (op, text) = diffs[x] + if op != self.DIFF_INSERT: # Equality or deletion. + chars1 += len(text) + if op != self.DIFF_DELETE: # Equality or insertion. + chars2 += len(text) + if chars1 > loc: # Overshot the location. + break + last_chars1 = chars1 + last_chars2 = chars2 + + if len(diffs) != x and diffs[x][0] == self.DIFF_DELETE: + # The location was deleted. + return last_chars2 + # Add the remaining len(character). + return last_chars2 + (loc - last_chars1) + + def diff_prettyHtml(self, diffs): + """Convert a diff array into a pretty HTML report. + + Args: + diffs: Array of diff tuples. + + Returns: + HTML representation. + """ + html = [] + for (op, data) in diffs: + text = (data.replace("&", "&").replace("<", "<") + .replace(">", ">").replace("\n", "¶
")) + if op == self.DIFF_INSERT: + html.append("%s" % text) + elif op == self.DIFF_DELETE: + html.append("%s" % text) + elif op == self.DIFF_EQUAL: + html.append("%s" % text) + return "".join(html) + + def diff_text1(self, diffs): + """Compute and return the source text (all equalities and deletions). + + Args: + diffs: Array of diff tuples. + + Returns: + Source text. + """ + text = [] + for (op, data) in diffs: + if op != self.DIFF_INSERT: + text.append(data) + return "".join(text) + + def diff_text2(self, diffs): + """Compute and return the destination text (all equalities and insertions). + + Args: + diffs: Array of diff tuples. + + Returns: + Destination text. + """ + text = [] + for (op, data) in diffs: + if op != self.DIFF_DELETE: + text.append(data) + return "".join(text) + + def diff_levenshtein(self, diffs): + """Compute the Levenshtein distance; the number of inserted, deleted or + substituted characters. + + Args: + diffs: Array of diff tuples. + + Returns: + Number of changes. + """ + levenshtein = 0 + insertions = 0 + deletions = 0 + for (op, data) in diffs: + if op == self.DIFF_INSERT: + insertions += len(data) + elif op == self.DIFF_DELETE: + deletions += len(data) + elif op == self.DIFF_EQUAL: + # A deletion and an insertion is one substitution. + levenshtein += max(insertions, deletions) + insertions = 0 + deletions = 0 + levenshtein += max(insertions, deletions) + return levenshtein + + def diff_toDelta(self, diffs): + """Crush the diff into an encoded string which describes the operations + required to transform text1 into text2. + E.g. =3\t-2\t+ing -> Keep 3 chars, delete 2 chars, insert 'ing'. + Operations are tab-separated. Inserted text is escaped using %xx notation. + + Args: + diffs: Array of diff tuples. + + Returns: + Delta text. + """ + text = [] + for (op, data) in diffs: + if op == self.DIFF_INSERT: + # High ascii will raise UnicodeDecodeError. Use Unicode instead. + data = data.encode("utf-8") + text.append("+" + urllib.parse.quote(data, "!~*'();/?:@&=+$,# ")) + elif op == self.DIFF_DELETE: + text.append("-%d" % len(data)) + elif op == self.DIFF_EQUAL: + text.append("=%d" % len(data)) + return "\t".join(text) + + def diff_fromDelta(self, text1, delta): + """Given the original text1, and an encoded string which describes the + operations required to transform text1 into text2, compute the full diff. + + Args: + text1: Source string for the diff. + delta: Delta text. + + Returns: + Array of diff tuples. + + Raises: + ValueError: If invalid input. + """ + diffs = [] + pointer = 0 # Cursor in text1 + tokens = delta.split("\t") + for token in tokens: + if token == "": + # Blank tokens are ok (from a trailing \t). + continue + # Each token begins with a one character parameter which specifies the + # operation of this token (delete, insert, equality). + param = token[1:] + if token[0] == "+": + param = urllib.parse.unquote(param) + diffs.append((self.DIFF_INSERT, param)) + elif token[0] == "-" or token[0] == "=": + try: + n = int(param) + except ValueError: + raise ValueError("Invalid number in diff_fromDelta: " + param) + if n < 0: + raise ValueError("Negative number in diff_fromDelta: " + param) + text = text1[pointer : pointer + n] + pointer += n + if token[0] == "=": + diffs.append((self.DIFF_EQUAL, text)) + else: + diffs.append((self.DIFF_DELETE, text)) + else: + # Anything else is an error. + raise ValueError("Invalid diff operation in diff_fromDelta: " + + token[0]) + if pointer != len(text1): + raise ValueError( + "Delta length (%d) does not equal source text length (%d)." % + (pointer, len(text1))) + return diffs + + # MATCH FUNCTIONS + + def match_main(self, text, pattern, loc): + """Locate the best instance of 'pattern' in 'text' near 'loc'. + + Args: + text: The text to search. + pattern: The pattern to search for. + loc: The location to search around. + + Returns: + Best match index or -1. + """ + # Check for null inputs. + if text == None or pattern == None: + raise ValueError("Null inputs. (match_main)") + + loc = max(0, min(loc, len(text))) + if text == pattern: + # Shortcut (potentially not guaranteed by the algorithm) + return 0 + elif not text: + # Nothing to match. + return -1 + elif text[loc:loc + len(pattern)] == pattern: + # Perfect match at the perfect spot! (Includes case of null pattern) + return loc + else: + # Do a fuzzy compare. + match = self.match_bitap(text, pattern, loc) + return match + + def match_bitap(self, text, pattern, loc): + """Locate the best instance of 'pattern' in 'text' near 'loc' using the + Bitap algorithm. + + Args: + text: The text to search. + pattern: The pattern to search for. + loc: The location to search around. + + Returns: + Best match index or -1. + """ + # Python doesn't have a maxint limit, so ignore this check. + #if self.Match_MaxBits != 0 and len(pattern) > self.Match_MaxBits: + # raise ValueError("Pattern too long for this application.") + + # Initialise the alphabet. + s = self.match_alphabet(pattern) + + def match_bitapScore(e, x): + """Compute and return the score for a match with e errors and x location. + Accesses loc and pattern through being a closure. + + Args: + e: Number of errors in match. + x: Location of match. + + Returns: + Overall score for match (0.0 = good, 1.0 = bad). + """ + accuracy = float(e) / len(pattern) + proximity = abs(loc - x) + if not self.Match_Distance: + # Dodge divide by zero error. + return proximity and 1.0 or accuracy + return accuracy + (proximity / float(self.Match_Distance)) + + # Highest score beyond which we give up. + score_threshold = self.Match_Threshold + # Is there a nearby exact match? (speedup) + best_loc = text.find(pattern, loc) + if best_loc != -1: + score_threshold = min(match_bitapScore(0, best_loc), score_threshold) + # What about in the other direction? (speedup) + best_loc = text.rfind(pattern, loc + len(pattern)) + if best_loc != -1: + score_threshold = min(match_bitapScore(0, best_loc), score_threshold) + + # Initialise the bit arrays. + matchmask = 1 << (len(pattern) - 1) + best_loc = -1 + + bin_max = len(pattern) + len(text) + # Empty initialization added to appease pychecker. + last_rd = None + for d in range(len(pattern)): + # Scan for the best match each iteration allows for one more error. + # Run a binary search to determine how far from 'loc' we can stray at + # this error level. + bin_min = 0 + bin_mid = bin_max + while bin_min < bin_mid: + if match_bitapScore(d, loc + bin_mid) <= score_threshold: + bin_min = bin_mid + else: + bin_max = bin_mid + bin_mid = (bin_max - bin_min) // 2 + bin_min + + # Use the result from this iteration as the maximum for the next. + bin_max = bin_mid + start = max(1, loc - bin_mid + 1) + finish = min(loc + bin_mid, len(text)) + len(pattern) + + rd = [0] * (finish + 2) + rd[finish + 1] = (1 << d) - 1 + for j in range(finish, start - 1, -1): + if len(text) <= j - 1: + # Out of range. + charMatch = 0 + else: + charMatch = s.get(text[j - 1], 0) + if d == 0: # First pass: exact match. + rd[j] = ((rd[j + 1] << 1) | 1) & charMatch + else: # Subsequent passes: fuzzy match. + rd[j] = (((rd[j + 1] << 1) | 1) & charMatch) | ( + ((last_rd[j + 1] | last_rd[j]) << 1) | 1) | last_rd[j + 1] + if rd[j] & matchmask: + score = match_bitapScore(d, j - 1) + # This match will almost certainly be better than any existing match. + # But check anyway. + if score <= score_threshold: + # Told you so. + score_threshold = score + best_loc = j - 1 + if best_loc > loc: + # When passing loc, don't exceed our current distance from loc. + start = max(1, 2 * loc - best_loc) + else: + # Already passed loc, downhill from here on in. + break + # No hope for a (better) match at greater error levels. + if match_bitapScore(d + 1, loc) > score_threshold: + break + last_rd = rd + return best_loc + + def match_alphabet(self, pattern): + """Initialise the alphabet for the Bitap algorithm. + + Args: + pattern: The text to encode. + + Returns: + Hash of character locations. + """ + s = {} + for char in pattern: + s[char] = 0 + for i in range(len(pattern)): + s[pattern[i]] |= 1 << (len(pattern) - i - 1) + return s + + # PATCH FUNCTIONS + + def patch_addContext(self, patch, text): + """Increase the context until it is unique, + but don't let the pattern expand beyond Match_MaxBits. + + Args: + patch: The patch to grow. + text: Source text. + """ + if len(text) == 0: + return + pattern = text[patch.start2 : patch.start2 + patch.length1] + padding = 0 + + # Look for the first and last matches of pattern in text. If two different + # matches are found, increase the pattern length. + while (text.find(pattern) != text.rfind(pattern) and (self.Match_MaxBits == + 0 or len(pattern) < self.Match_MaxBits - self.Patch_Margin - + self.Patch_Margin)): + padding += self.Patch_Margin + pattern = text[max(0, patch.start2 - padding) : + patch.start2 + patch.length1 + padding] + # Add one chunk for good luck. + padding += self.Patch_Margin + + # Add the prefix. + prefix = text[max(0, patch.start2 - padding) : patch.start2] + if prefix: + patch.diffs[:0] = [(self.DIFF_EQUAL, prefix)] + # Add the suffix. + suffix = text[patch.start2 + patch.length1 : + patch.start2 + patch.length1 + padding] + if suffix: + patch.diffs.append((self.DIFF_EQUAL, suffix)) + + # Roll back the start points. + patch.start1 -= len(prefix) + patch.start2 -= len(prefix) + # Extend lengths. + patch.length1 += len(prefix) + len(suffix) + patch.length2 += len(prefix) + len(suffix) + + def patch_make(self, a, b=None, c=None): + """Compute a list of patches to turn text1 into text2. + Use diffs if provided, otherwise compute it ourselves. + There are four ways to call this function, depending on what data is + available to the caller: + Method 1: + a = text1, b = text2 + Method 2: + a = diffs + Method 3 (optimal): + a = text1, b = diffs + Method 4 (deprecated, use method 3): + a = text1, b = text2, c = diffs + + Args: + a: text1 (methods 1,3,4) or Array of diff tuples for text1 to + text2 (method 2). + b: text2 (methods 1,4) or Array of diff tuples for text1 to + text2 (method 3) or undefined (method 2). + c: Array of diff tuples for text1 to text2 (method 4) or + undefined (methods 1,2,3). + + Returns: + Array of Patch objects. + """ + text1 = None + diffs = None + if isinstance(a, str) and isinstance(b, str) and c is None: + # Method 1: text1, text2 + # Compute diffs from text1 and text2. + text1 = a + diffs = self.diff_main(text1, b, True) + if len(diffs) > 2: + self.diff_cleanupSemantic(diffs) + self.diff_cleanupEfficiency(diffs) + elif isinstance(a, list) and b is None and c is None: + # Method 2: diffs + # Compute text1 from diffs. + diffs = a + text1 = self.diff_text1(diffs) + elif isinstance(a, str) and isinstance(b, list) and c is None: + # Method 3: text1, diffs + text1 = a + diffs = b + elif (isinstance(a, str) and isinstance(b, str) and + isinstance(c, list)): + # Method 4: text1, text2, diffs + # text2 is not used. + text1 = a + diffs = c + else: + raise ValueError("Unknown call format to patch_make.") + + if not diffs: + return [] # Get rid of the None case. + patches = [] + patch = patch_obj() + char_count1 = 0 # Number of characters into the text1 string. + char_count2 = 0 # Number of characters into the text2 string. + prepatch_text = text1 # Recreate the patches to determine context info. + postpatch_text = text1 + for x in range(len(diffs)): + (diff_type, diff_text) = diffs[x] + if len(patch.diffs) == 0 and diff_type != self.DIFF_EQUAL: + # A new patch starts here. + patch.start1 = char_count1 + patch.start2 = char_count2 + if diff_type == self.DIFF_INSERT: + # Insertion + patch.diffs.append(diffs[x]) + patch.length2 += len(diff_text) + postpatch_text = (postpatch_text[:char_count2] + diff_text + + postpatch_text[char_count2:]) + elif diff_type == self.DIFF_DELETE: + # Deletion. + patch.length1 += len(diff_text) + patch.diffs.append(diffs[x]) + postpatch_text = (postpatch_text[:char_count2] + + postpatch_text[char_count2 + len(diff_text):]) + elif (diff_type == self.DIFF_EQUAL and + len(diff_text) <= 2 * self.Patch_Margin and + len(patch.diffs) != 0 and len(diffs) != x + 1): + # Small equality inside a patch. + patch.diffs.append(diffs[x]) + patch.length1 += len(diff_text) + patch.length2 += len(diff_text) + + if (diff_type == self.DIFF_EQUAL and + len(diff_text) >= 2 * self.Patch_Margin): + # Time for a new patch. + if len(patch.diffs) != 0: + self.patch_addContext(patch, prepatch_text) + patches.append(patch) + patch = patch_obj() + # Unlike Unidiff, our patch lists have a rolling context. + # https://github.com/google/diff-match-patch/wiki/Unidiff + # Update prepatch text & pos to reflect the application of the + # just completed patch. + prepatch_text = postpatch_text + char_count1 = char_count2 + + # Update the current character count. + if diff_type != self.DIFF_INSERT: + char_count1 += len(diff_text) + if diff_type != self.DIFF_DELETE: + char_count2 += len(diff_text) + + # Pick up the leftover patch if not empty. + if len(patch.diffs) != 0: + self.patch_addContext(patch, prepatch_text) + patches.append(patch) + return patches + + def patch_deepCopy(self, patches): + """Given an array of patches, return another array that is identical. + + Args: + patches: Array of Patch objects. + + Returns: + Array of Patch objects. + """ + patchesCopy = [] + for patch in patches: + patchCopy = patch_obj() + # No need to deep copy the tuples since they are immutable. + patchCopy.diffs = patch.diffs[:] + patchCopy.start1 = patch.start1 + patchCopy.start2 = patch.start2 + patchCopy.length1 = patch.length1 + patchCopy.length2 = patch.length2 + patchesCopy.append(patchCopy) + return patchesCopy + + def patch_apply(self, patches, text): + """Merge a set of patches onto the text. Return a patched text, as well + as a list of true/false values indicating which patches were applied. + + Args: + patches: Array of Patch objects. + text: Old text. + + Returns: + Two element Array, containing the new text and an array of boolean values. + """ + if not patches: + return (text, []) + + # Deep copy the patches so that no changes are made to originals. + patches = self.patch_deepCopy(patches) + + nullPadding = self.patch_addPadding(patches) + text = nullPadding + text + nullPadding + self.patch_splitMax(patches) + + # delta keeps track of the offset between the expected and actual location + # of the previous patch. If there are patches expected at positions 10 and + # 20, but the first patch was found at 12, delta is 2 and the second patch + # has an effective expected position of 22. + delta = 0 + results = [] + for patch in patches: + expected_loc = patch.start2 + delta + text1 = self.diff_text1(patch.diffs) + end_loc = -1 + if len(text1) > self.Match_MaxBits: + # patch_splitMax will only provide an oversized pattern in the case of + # a monster delete. + start_loc = self.match_main(text, text1[:self.Match_MaxBits], + expected_loc) + if start_loc != -1: + end_loc = self.match_main(text, text1[-self.Match_MaxBits:], + expected_loc + len(text1) - self.Match_MaxBits) + if end_loc == -1 or start_loc >= end_loc: + # Can't find valid trailing context. Drop this patch. + start_loc = -1 + else: + start_loc = self.match_main(text, text1, expected_loc) + if start_loc == -1: + # No match found. :( + results.append(False) + # Subtract the delta for this failed patch from subsequent patches. + delta -= patch.length2 - patch.length1 + else: + # Found a match. :) + results.append(True) + delta = start_loc - expected_loc + if end_loc == -1: + text2 = text[start_loc : start_loc + len(text1)] + else: + text2 = text[start_loc : end_loc + self.Match_MaxBits] + if text1 == text2: + # Perfect match, just shove the replacement text in. + text = (text[:start_loc] + self.diff_text2(patch.diffs) + + text[start_loc + len(text1):]) + else: + # Imperfect match. + # Run a diff to get a framework of equivalent indices. + diffs = self.diff_main(text1, text2, False) + if (len(text1) > self.Match_MaxBits and + self.diff_levenshtein(diffs) / float(len(text1)) > + self.Patch_DeleteThreshold): + # The end points match, but the content is unacceptably bad. + results[-1] = False + else: + self.diff_cleanupSemanticLossless(diffs) + index1 = 0 + for (op, data) in patch.diffs: + if op != self.DIFF_EQUAL: + index2 = self.diff_xIndex(diffs, index1) + if op == self.DIFF_INSERT: # Insertion + text = text[:start_loc + index2] + data + text[start_loc + + index2:] + elif op == self.DIFF_DELETE: # Deletion + text = text[:start_loc + index2] + text[start_loc + + self.diff_xIndex(diffs, index1 + len(data)):] + if op != self.DIFF_DELETE: + index1 += len(data) + # Strip the padding off. + text = text[len(nullPadding):-len(nullPadding)] + return (text, results) + + def patch_addPadding(self, patches): + """Add some padding on text start and end so that edges can match + something. Intended to be called only from within patch_apply. + + Args: + patches: Array of Patch objects. + + Returns: + The padding string added to each side. + """ + paddingLength = self.Patch_Margin + nullPadding = "" + for x in range(1, paddingLength + 1): + nullPadding += chr(x) + + # Bump all the patches forward. + for patch in patches: + patch.start1 += paddingLength + patch.start2 += paddingLength + + # Add some padding on start of first diff. + patch = patches[0] + diffs = patch.diffs + if not diffs or diffs[0][0] != self.DIFF_EQUAL: + # Add nullPadding equality. + diffs.insert(0, (self.DIFF_EQUAL, nullPadding)) + patch.start1 -= paddingLength # Should be 0. + patch.start2 -= paddingLength # Should be 0. + patch.length1 += paddingLength + patch.length2 += paddingLength + elif paddingLength > len(diffs[0][1]): + # Grow first equality. + extraLength = paddingLength - len(diffs[0][1]) + newText = nullPadding[len(diffs[0][1]):] + diffs[0][1] + diffs[0] = (diffs[0][0], newText) + patch.start1 -= extraLength + patch.start2 -= extraLength + patch.length1 += extraLength + patch.length2 += extraLength + + # Add some padding on end of last diff. + patch = patches[-1] + diffs = patch.diffs + if not diffs or diffs[-1][0] != self.DIFF_EQUAL: + # Add nullPadding equality. + diffs.append((self.DIFF_EQUAL, nullPadding)) + patch.length1 += paddingLength + patch.length2 += paddingLength + elif paddingLength > len(diffs[-1][1]): + # Grow last equality. + extraLength = paddingLength - len(diffs[-1][1]) + newText = diffs[-1][1] + nullPadding[:extraLength] + diffs[-1] = (diffs[-1][0], newText) + patch.length1 += extraLength + patch.length2 += extraLength + + return nullPadding + + def patch_splitMax(self, patches): + """Look through the patches and break up any which are longer than the + maximum limit of the match algorithm. + Intended to be called only from within patch_apply. + + Args: + patches: Array of Patch objects. + """ + patch_size = self.Match_MaxBits + if patch_size == 0: + # Python has the option of not splitting strings due to its ability + # to handle integers of arbitrary precision. + return + for x in range(len(patches)): + if patches[x].length1 <= patch_size: + continue + bigpatch = patches[x] + # Remove the big old patch. + del patches[x] + x -= 1 + start1 = bigpatch.start1 + start2 = bigpatch.start2 + precontext = '' + while len(bigpatch.diffs) != 0: + # Create one of several smaller patches. + patch = patch_obj() + empty = True + patch.start1 = start1 - len(precontext) + patch.start2 = start2 - len(precontext) + if precontext: + patch.length1 = patch.length2 = len(precontext) + patch.diffs.append((self.DIFF_EQUAL, precontext)) + + while (len(bigpatch.diffs) != 0 and + patch.length1 < patch_size - self.Patch_Margin): + (diff_type, diff_text) = bigpatch.diffs[0] + if diff_type == self.DIFF_INSERT: + # Insertions are harmless. + patch.length2 += len(diff_text) + start2 += len(diff_text) + patch.diffs.append(bigpatch.diffs.pop(0)) + empty = False + elif (diff_type == self.DIFF_DELETE and len(patch.diffs) == 1 and + patch.diffs[0][0] == self.DIFF_EQUAL and + len(diff_text) > 2 * patch_size): + # This is a large deletion. Let it pass in one chunk. + patch.length1 += len(diff_text) + start1 += len(diff_text) + empty = False + patch.diffs.append((diff_type, diff_text)) + del bigpatch.diffs[0] + else: + # Deletion or equality. Only take as much as we can stomach. + diff_text = diff_text[:patch_size - patch.length1 - + self.Patch_Margin] + patch.length1 += len(diff_text) + start1 += len(diff_text) + if diff_type == self.DIFF_EQUAL: + patch.length2 += len(diff_text) + start2 += len(diff_text) + else: + empty = False + + patch.diffs.append((diff_type, diff_text)) + if diff_text == bigpatch.diffs[0][1]: + del bigpatch.diffs[0] + else: + bigpatch.diffs[0] = (bigpatch.diffs[0][0], + bigpatch.diffs[0][1][len(diff_text):]) + + # Compute the head context for the next patch. + precontext = self.diff_text2(patch.diffs) + precontext = precontext[-self.Patch_Margin:] + # Append the end context for this patch. + postcontext = self.diff_text1(bigpatch.diffs)[:self.Patch_Margin] + if postcontext: + patch.length1 += len(postcontext) + patch.length2 += len(postcontext) + if len(patch.diffs) != 0 and patch.diffs[-1][0] == self.DIFF_EQUAL: + patch.diffs[-1] = (self.DIFF_EQUAL, patch.diffs[-1][1] + + postcontext) + else: + patch.diffs.append((self.DIFF_EQUAL, postcontext)) + + if not empty: + x += 1 + patches.insert(x, patch) + + def patch_toText(self, patches): + """Take a list of patches and return a textual representation. + + Args: + patches: Array of Patch objects. + + Returns: + Text representation of patches. + """ + text = [] + for patch in patches: + text.append(str(patch)) + return "".join(text) + + def patch_fromText(self, textline): + """Parse a textual representation of patches and return a list of patch + objects. + + Args: + textline: Text representation of patches. + + Returns: + Array of Patch objects. + + Raises: + ValueError: If invalid input. + """ + patches = [] + if not textline: + return patches + text = textline.split('\n') + while len(text) != 0: + m = re.match("^@@ -(\d+),?(\d*) \+(\d+),?(\d*) @@$", text[0]) + if not m: + raise ValueError("Invalid patch string: " + text[0]) + patch = patch_obj() + patches.append(patch) + patch.start1 = int(m.group(1)) + if m.group(2) == '': + patch.start1 -= 1 + patch.length1 = 1 + elif m.group(2) == '0': + patch.length1 = 0 + else: + patch.start1 -= 1 + patch.length1 = int(m.group(2)) + + patch.start2 = int(m.group(3)) + if m.group(4) == '': + patch.start2 -= 1 + patch.length2 = 1 + elif m.group(4) == '0': + patch.length2 = 0 + else: + patch.start2 -= 1 + patch.length2 = int(m.group(4)) + + del text[0] + + while len(text) != 0: + if text[0]: + sign = text[0][0] + else: + sign = '' + line = urllib.parse.unquote(text[0][1:]) + if sign == '+': + # Insertion. + patch.diffs.append((self.DIFF_INSERT, line)) + elif sign == '-': + # Deletion. + patch.diffs.append((self.DIFF_DELETE, line)) + elif sign == ' ': + # Minor equality. + patch.diffs.append((self.DIFF_EQUAL, line)) + elif sign == '@': + # Start of next patch. + break + elif sign == '': + # Blank line? Whatever. + pass + else: + # WTF? + raise ValueError("Invalid patch mode: '%s'\n%s" % (sign, line)) + del text[0] + return patches + + +class patch_obj: + """Class representing one patch operation. + """ + + def __init__(self): + """Initializes with an empty list of diffs. + """ + self.diffs = [] + self.start1 = None + self.start2 = None + self.length1 = 0 + self.length2 = 0 + + def __str__(self): + """Emulate GNU diff's format. + Header: @@ -382,8 +481,9 @@ + Indices are printed as 1-based, not 0-based. + + Returns: + The GNU diff string. + """ + if self.length1 == 0: + coords1 = str(self.start1) + ",0" + elif self.length1 == 1: + coords1 = str(self.start1 + 1) + else: + coords1 = str(self.start1 + 1) + "," + str(self.length1) + if self.length2 == 0: + coords2 = str(self.start2) + ",0" + elif self.length2 == 1: + coords2 = str(self.start2 + 1) + else: + coords2 = str(self.start2 + 1) + "," + str(self.length2) + text = ["@@ -", coords1, " +", coords2, " @@\n"] + # Escape the body of the patch with %xx notation. + for (op, data) in self.diffs: + if op == diff_match_patch.DIFF_INSERT: + text.append("+") + elif op == diff_match_patch.DIFF_DELETE: + text.append("-") + elif op == diff_match_patch.DIFF_EQUAL: + text.append(" ") + # High ascii will raise UnicodeDecodeError. Use Unicode instead. + data = data.encode("utf-8") + text.append(urllib.parse.quote(data, "!~*'();/?:@&=+$,# ") + "\n") + return "".join(text) diff --git a/examples/OTA-lorawan/firmware/1.17.0/flash/OTA_INFO.py b/examples/OTA-lorawan/firmware/1.17.0/flash/OTA_INFO.py new file mode 100644 index 0000000..092afa1 --- /dev/null +++ b/examples/OTA-lorawan/firmware/1.17.0/flash/OTA_INFO.py @@ -0,0 +1 @@ +1.17.0 diff --git a/examples/OTA-lorawan/firmware/1.17.0/flash/diff_match_patch.py b/examples/OTA-lorawan/firmware/1.17.0/flash/diff_match_patch.py new file mode 100644 index 0000000..494f051 --- /dev/null +++ b/examples/OTA-lorawan/firmware/1.17.0/flash/diff_match_patch.py @@ -0,0 +1,1605 @@ +#!/usr/bin/python2.7 + +#from __future__ import division + +"""Diff Match and Patch +Copyright 2018 The diff-match-patch Authors. +https://github.com/google/diff-match-patch + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +""" + +"""Functions for diff, match and patch. + +Computes the difference between two texts to create a patch. +Applies the patch onto another text, allowing for errors. +""" + +__author__ = 'fraser@google.com (Neil Fraser)' + +import math +import ure +import sys +import time +#import urllib + +class diff_match_patch: + """Class containing the diff, match and patch methods. + + Also contains the behaviour settings. + """ + + def __init__(self): + """Inits a diff_match_patch object with default settings. + Redefine these in your program to override the defaults. + """ + + # Number of seconds to map a diff before giving up (0 for infinity). + self.Diff_Timeout = 1.0 + # Cost of an empty edit operation in terms of edit characters. + self.Diff_EditCost = 4 + # At what point is no match declared (0.0 = perfection, 1.0 = very loose). + self.Match_Threshold = 0.5 + # How far to search for a match (0 = exact location, 1000+ = broad match). + # A match this many characters away from the expected location will add + # 1.0 to the score (0.0 is a perfect match). + self.Match_Distance = 1000 + # When deleting a large block of text (over ~64 characters), how close do + # the contents have to be to match the expected contents. (0.0 = perfection, + # 1.0 = very loose). Note that Match_Threshold controls how closely the + # end points of a delete need to match. + self.Patch_DeleteThreshold = 0.5 + # Chunk size for context length. + self.Patch_Margin = 4 + + # The number of bits in an int. + # Python has no maximum, thus to disable patch splitting set to 0. + # However to avoid long patches in certain pathological cases, use 32. + # Multiple short patches (using native ints) are much faster than long ones. + self.Match_MaxBits = 32 + + self._hexdig = '0123456789ABCDEFabcdef' + self._hextochr = dict((a+b, chr(int(a+b,16))) + for a in self._hexdig for b in self._hexdig) + + # DIFF FUNCTIONS + + # The data structure representing a diff is an array of tuples: + # [(DIFF_DELETE, "Hello"), (DIFF_INSERT, "Goodbye"), (DIFF_EQUAL, " world.")] + # which means: delete "Hello", add "Goodbye" and keep " world." + DIFF_DELETE = -1 + DIFF_INSERT = 1 + DIFF_EQUAL = 0 + + def diff_main(self, text1, text2, checklines=True, deadline=None): + """Find the differences between two texts. Simplifies the problem by + stripping any common prefix or suffix off the texts before diffing. + + Args: + text1: Old string to be diffed. + text2: New string to be diffed. + checklines: Optional speedup flag. If present and false, then don't run + a line-level diff first to identify the changed areas. + Defaults to true, which does a faster, slightly less optimal diff. + deadline: Optional time when the diff should be complete by. Used + internally for recursive calls. Users should set DiffTimeout instead. + + Returns: + Array of changes. + """ + # Set a deadline by which time the diff must be complete. + if deadline == None: + # Unlike in most languages, Python counts time in seconds. + if self.Diff_Timeout <= 0: + deadline = sys.maxsize + else: + deadline = time.time() + self.Diff_Timeout + + # Check for null inputs. + if text1 == None or text2 == None: + raise ValueError("Null inputs. (diff_main)") + + # Check for equality (speedup). + if text1 == text2: + if text1: + return [(self.DIFF_EQUAL, text1)] + return [] + + # Trim off common prefix (speedup). + commonlength = self.diff_commonPrefix(text1, text2) + commonprefix = text1[:commonlength] + text1 = text1[commonlength:] + text2 = text2[commonlength:] + + # Trim off common suffix (speedup). + commonlength = self.diff_commonSuffix(text1, text2) + if commonlength == 0: + commonsuffix = '' + else: + commonsuffix = text1[-commonlength:] + text1 = text1[:-commonlength] + text2 = text2[:-commonlength] + + # Compute the diff on the middle block. + diffs = self.diff_compute(text1, text2, checklines, deadline) + + # Restore the prefix and suffix. + if commonprefix: + diffs[:0] = [(self.DIFF_EQUAL, commonprefix)] + if commonsuffix: + diffs.append((self.DIFF_EQUAL, commonsuffix)) + self.diff_cleanupMerge(diffs) + return diffs + + def diff_compute(self, text1, text2, checklines, deadline): + """Find the differences between two texts. Assumes that the texts do not + have any common prefix or suffix. + + Args: + text1: Old string to be diffed. + text2: New string to be diffed. + checklines: Speedup flag. If false, then don't run a line-level diff + first to identify the changed areas. + If true, then run a faster, slightly less optimal diff. + deadline: Time when the diff should be complete by. + + Returns: + Array of changes. + """ + if not text1: + # Just add some text (speedup). + return [(self.DIFF_INSERT, text2)] + + if not text2: + # Just delete some text (speedup). + return [(self.DIFF_DELETE, text1)] + + if len(text1) > len(text2): + (longtext, shorttext) = (text1, text2) + else: + (shorttext, longtext) = (text1, text2) + i = longtext.find(shorttext) + if i != -1: + # Shorter text is inside the longer text (speedup). + diffs = [(self.DIFF_INSERT, longtext[:i]), (self.DIFF_EQUAL, shorttext), + (self.DIFF_INSERT, longtext[i + len(shorttext):])] + # Swap insertions for deletions if diff is reversed. + if len(text1) > len(text2): + diffs[0] = (self.DIFF_DELETE, diffs[0][1]) + diffs[2] = (self.DIFF_DELETE, diffs[2][1]) + return diffs + + if len(shorttext) == 1: + # Single character string. + # After the previous speedup, the character can't be an equality. + return [(self.DIFF_DELETE, text1), (self.DIFF_INSERT, text2)] + + # Check to see if the problem can be split in two. + hm = self.diff_halfMatch(text1, text2) + if hm: + # A half-match was found, sort out the return data. + (text1_a, text1_b, text2_a, text2_b, mid_common) = hm + # Send both pairs off for separate processing. + diffs_a = self.diff_main(text1_a, text2_a, checklines, deadline) + diffs_b = self.diff_main(text1_b, text2_b, checklines, deadline) + # Merge the results. + return diffs_a + [(self.DIFF_EQUAL, mid_common)] + diffs_b + + if checklines and len(text1) > 100 and len(text2) > 100: + return self.diff_lineMode(text1, text2, deadline) + + return self.diff_bisect(text1, text2, deadline) + + def diff_lineMode(self, text1, text2, deadline): + """Do a quick line-level diff on both strings, then rediff the parts for + greater accuracy. + This speedup can produce non-minimal diffs. + + Args: + text1: Old string to be diffed. + text2: New string to be diffed. + deadline: Time when the diff should be complete by. + + Returns: + Array of changes. + """ + + # Scan the text on a line-by-line basis first. + (text1, text2, linearray) = self.diff_linesToChars(text1, text2) + + diffs = self.diff_main(text1, text2, False, deadline) + + # Convert the diff back to original text. + self.diff_charsToLines(diffs, linearray) + # Eliminate freak matches (e.g. blank lines) + self.diff_cleanupSemantic(diffs) + + # Rediff any replacement blocks, this time character-by-character. + # Add a dummy entry at the end. + diffs.append((self.DIFF_EQUAL, '')) + pointer = 0 + count_delete = 0 + count_insert = 0 + text_delete = '' + text_insert = '' + while pointer < len(diffs): + if diffs[pointer][0] == self.DIFF_INSERT: + count_insert += 1 + text_insert += diffs[pointer][1] + elif diffs[pointer][0] == self.DIFF_DELETE: + count_delete += 1 + text_delete += diffs[pointer][1] + elif diffs[pointer][0] == self.DIFF_EQUAL: + # Upon reaching an equality, check for prior redundancies. + if count_delete >= 1 and count_insert >= 1: + # Delete the offending records and add the merged ones. + a = self.diff_main(text_delete, text_insert, False, deadline) + diffs[pointer - count_delete - count_insert : pointer] = a + pointer = pointer - count_delete - count_insert + len(a) + count_insert = 0 + count_delete = 0 + text_delete = '' + text_insert = '' + + pointer += 1 + + diffs.pop() # Remove the dummy entry at the end. + + return diffs + + def diff_bisect(self, text1, text2, deadline): + """Find the 'middle snake' of a diff, split the problem in two + and return the recursively constructed diff. + See Myers 1986 paper: An O(ND) Difference Algorithm and Its Variations. + + Args: + text1: Old string to be diffed. + text2: New string to be diffed. + deadline: Time at which to bail if not yet complete. + + Returns: + Array of diff tuples. + """ + + # Cache the text lengths to prevent multiple calls. + text1_length = len(text1) + text2_length = len(text2) + max_d = (text1_length + text2_length + 1) // 2 + v_offset = max_d + v_length = 2 * max_d + v1 = [-1] * v_length + v1[v_offset + 1] = 0 + v2 = v1[:] + delta = text1_length - text2_length + # If the total number of characters is odd, then the front path will + # collide with the reverse path. + front = (delta % 2 != 0) + # Offsets for start and end of k loop. + # Prevents mapping of space beyond the grid. + k1start = 0 + k1end = 0 + k2start = 0 + k2end = 0 + for d in range(max_d): + # Bail out if deadline is reached. + if time.time() > deadline: + break + + # Walk the front path one step. + for k1 in range(-d + k1start, d + 1 - k1end, 2): + k1_offset = v_offset + k1 + if k1 == -d or (k1 != d and + v1[k1_offset - 1] < v1[k1_offset + 1]): + x1 = v1[k1_offset + 1] + else: + x1 = v1[k1_offset - 1] + 1 + y1 = x1 - k1 + while (x1 < text1_length and y1 < text2_length and + text1[x1] == text2[y1]): + x1 += 1 + y1 += 1 + v1[k1_offset] = x1 + if x1 > text1_length: + # Ran off the right of the graph. + k1end += 2 + elif y1 > text2_length: + # Ran off the bottom of the graph. + k1start += 2 + elif front: + k2_offset = v_offset + delta - k1 + if k2_offset >= 0 and k2_offset < v_length and v2[k2_offset] != -1: + # Mirror x2 onto top-left coordinate system. + x2 = text1_length - v2[k2_offset] + if x1 >= x2: + # Overlap detected. + return self.diff_bisectSplit(text1, text2, x1, y1, deadline) + + # Walk the reverse path one step. + for k2 in range(-d + k2start, d + 1 - k2end, 2): + k2_offset = v_offset + k2 + if k2 == -d or (k2 != d and + v2[k2_offset - 1] < v2[k2_offset + 1]): + x2 = v2[k2_offset + 1] + else: + x2 = v2[k2_offset - 1] + 1 + y2 = x2 - k2 + while (x2 < text1_length and y2 < text2_length and + text1[-x2 - 1] == text2[-y2 - 1]): + x2 += 1 + y2 += 1 + v2[k2_offset] = x2 + if x2 > text1_length: + # Ran off the left of the graph. + k2end += 2 + elif y2 > text2_length: + # Ran off the top of the graph. + k2start += 2 + elif not front: + k1_offset = v_offset + delta - k2 + if k1_offset >= 0 and k1_offset < v_length and v1[k1_offset] != -1: + x1 = v1[k1_offset] + y1 = v_offset + x1 - k1_offset + # Mirror x2 onto top-left coordinate system. + x2 = text1_length - x2 + if x1 >= x2: + # Overlap detected. + return self.diff_bisectSplit(text1, text2, x1, y1, deadline) + + # Diff took too long and hit the deadline or + # number of diffs equals number of characters, no commonality at all. + return [(self.DIFF_DELETE, text1), (self.DIFF_INSERT, text2)] + + def diff_bisectSplit(self, text1, text2, x, y, deadline): + """Given the location of the 'middle snake', split the diff in two parts + and recurse. + + Args: + text1: Old string to be diffed. + text2: New string to be diffed. + x: Index of split point in text1. + y: Index of split point in text2. + deadline: Time at which to bail if not yet complete. + + Returns: + Array of diff tuples. + """ + text1a = text1[:x] + text2a = text2[:y] + text1b = text1[x:] + text2b = text2[y:] + + # Compute both diffs serially. + diffs = self.diff_main(text1a, text2a, False, deadline) + diffsb = self.diff_main(text1b, text2b, False, deadline) + + return diffs + diffsb + + def diff_linesToChars(self, text1, text2): + """Split two texts into an array of strings. Reduce the texts to a string + of hashes where each Unicode character represents one line. + + Args: + text1: First string. + text2: Second string. + + Returns: + Three element tuple, containing the encoded text1, the encoded text2 and + the array of unique strings. The zeroth element of the array of unique + strings is intentionally blank. + """ + lineArray = [] # e.g. lineArray[4] == "Hello\n" + lineHash = {} # e.g. lineHash["Hello\n"] == 4 + + # "\x00" is a valid character, but various debuggers don't like it. + # So we'll insert a junk entry to avoid generating a null character. + lineArray.append('') + + def diff_linesToCharsMunge(text): + """Split a text into an array of strings. Reduce the texts to a string + of hashes where each Unicode character represents one line. + Modifies linearray and linehash through being a closure. + + Args: + text: String to encode. + + Returns: + Encoded string. + """ + chars = [] + # Walk the text, pulling out a substring for each line. + # text.split('\n') would would temporarily double our memory footprint. + # Modifying text would create many large strings to garbage collect. + lineStart = 0 + lineEnd = -1 + while lineEnd < len(text) - 1: + lineEnd = text.find('\n', lineStart) + if lineEnd == -1: + lineEnd = len(text) - 1 + line = text[lineStart:lineEnd + 1] + + if line in lineHash: + chars.append(chr(lineHash[line])) + else: + if len(lineArray) == maxLines: + # Bail out at 65535 because unichr(65536) throws. - not in micropython + line = text[lineStart:] + lineEnd = len(text) + lineArray.append(line) + lineHash[line] = len(lineArray) - 1 + chars.append(chr(len(lineArray) - 1)) + lineStart = lineEnd + 1 + return "".join(chars) + + # Allocate 2/3rds of the space for text1, the rest for text2. + maxLines = 40000 + chars1 = diff_linesToCharsMunge(text1) + maxLines = 65535 + chars2 = diff_linesToCharsMunge(text2) + return (chars1, chars2, lineArray) + + def diff_charsToLines(self, diffs, lineArray): + """Rehydrate the text in a diff from a string of line hashes to real lines + of text. + + Args: + diffs: Array of diff tuples. + lineArray: Array of unique strings. + """ + for x in range(len(diffs)): + text = [] + for char in diffs[x][1]: + text.append(lineArray[ord(char)]) + diffs[x] = (diffs[x][0], "".join(text)) + + def diff_commonPrefix(self, text1, text2): + """Determine the common prefix of two strings. + + Args: + text1: First string. + text2: Second string. + + Returns: + The number of characters common to the start of each string. + """ + # Quick check for common null cases. + if not text1 or not text2 or text1[0] != text2[0]: + return 0 + # Binary search. + # Performance analysis: http://neil.fraser.name/news/2007/10/09/ + pointermin = 0 + pointermax = min(len(text1), len(text2)) + pointermid = pointermax + pointerstart = 0 + while pointermin < pointermid: + if text1[pointerstart:pointermid] == text2[pointerstart:pointermid]: + pointermin = pointermid + pointerstart = pointermin + else: + pointermax = pointermid + pointermid = (pointermax - pointermin) // 2 + pointermin + return pointermid + + def diff_commonSuffix(self, text1, text2): + """Determine the common suffix of two strings. + + Args: + text1: First string. + text2: Second string. + + Returns: + The number of characters common to the end of each string. + """ + # Quick check for common null cases. + if not text1 or not text2 or text1[-1] != text2[-1]: + return 0 + # Binary search. + # Performance analysis: http://neil.fraser.name/news/2007/10/09/ + pointermin = 0 + pointermax = min(len(text1), len(text2)) + pointermid = pointermax + pointerend = 0 + while pointermin < pointermid: + if (text1[-pointermid:len(text1) - pointerend] == + text2[-pointermid:len(text2) - pointerend]): + pointermin = pointermid + pointerend = pointermin + else: + pointermax = pointermid + pointermid = (pointermax - pointermin) // 2 + pointermin + return pointermid + + def diff_commonOverlap(self, text1, text2): + """Determine if the suffix of one string is the prefix of another. + + Args: + text1 First string. + text2 Second string. + + Returns: + The number of characters common to the end of the first + string and the start of the second string. + """ + # Cache the text lengths to prevent multiple calls. + text1_length = len(text1) + text2_length = len(text2) + # Eliminate the null case. + if text1_length == 0 or text2_length == 0: + return 0 + # Truncate the longer string. + if text1_length > text2_length: + text1 = text1[-text2_length:] + elif text1_length < text2_length: + text2 = text2[:text1_length] + text_length = min(text1_length, text2_length) + # Quick check for the worst case. + if text1 == text2: + return text_length + + # Start by looking for a single character match + # and increase length until no match is found. + # Performance analysis: http://neil.fraser.name/news/2010/11/04/ + best = 0 + length = 1 + while True: + pattern = text1[-length:] + found = text2.find(pattern) + if found == -1: + return best + length += found + if found == 0 or text1[-length:] == text2[:length]: + best = length + length += 1 + + def diff_halfMatch(self, text1, text2): + """Do the two texts share a substring which is at least half the length of + the longer text? + This speedup can produce non-minimal diffs. + + Args: + text1: First string. + text2: Second string. + + Returns: + Five element Array, containing the prefix of text1, the suffix of text1, + the prefix of text2, the suffix of text2 and the common middle. Or None + if there was no match. + """ + if self.Diff_Timeout <= 0: + # Don't risk returning a non-optimal diff if we have unlimited time. + return None + if len(text1) > len(text2): + (longtext, shorttext) = (text1, text2) + else: + (shorttext, longtext) = (text1, text2) + if len(longtext) < 4 or len(shorttext) * 2 < len(longtext): + return None # Pointless. + + def diff_halfMatchI(longtext, shorttext, i): + """Does a substring of shorttext exist within longtext such that the + substring is at least half the length of longtext? + Closure, but does not reference any external variables. + + Args: + longtext: Longer string. + shorttext: Shorter string. + i: Start index of quarter length substring within longtext. + + Returns: + Five element Array, containing the prefix of longtext, the suffix of + longtext, the prefix of shorttext, the suffix of shorttext and the + common middle. Or None if there was no match. + """ + seed = longtext[i:i + len(longtext) // 4] + best_common = '' + j = shorttext.find(seed) + while j != -1: + prefixLength = self.diff_commonPrefix(longtext[i:], shorttext[j:]) + suffixLength = self.diff_commonSuffix(longtext[:i], shorttext[:j]) + if len(best_common) < suffixLength + prefixLength: + best_common = (shorttext[j - suffixLength:j] + + shorttext[j:j + prefixLength]) + best_longtext_a = longtext[:i - suffixLength] + best_longtext_b = longtext[i + prefixLength:] + best_shorttext_a = shorttext[:j - suffixLength] + best_shorttext_b = shorttext[j + prefixLength:] + j = shorttext.find(seed, j + 1) + + if len(best_common) * 2 >= len(longtext): + return (best_longtext_a, best_longtext_b, + best_shorttext_a, best_shorttext_b, best_common) + else: + return None + + # First check if the second quarter is the seed for a half-match. + hm1 = diff_halfMatchI(longtext, shorttext, (len(longtext) + 3) // 4) + # Check again based on the third quarter. + hm2 = diff_halfMatchI(longtext, shorttext, (len(longtext) + 1) // 2) + if not hm1 and not hm2: + return None + elif not hm2: + hm = hm1 + elif not hm1: + hm = hm2 + else: + # Both matched. Select the longest. + if len(hm1[4]) > len(hm2[4]): + hm = hm1 + else: + hm = hm2 + + # A half-match was found, sort out the return data. + if len(text1) > len(text2): + (text1_a, text1_b, text2_a, text2_b, mid_common) = hm + else: + (text2_a, text2_b, text1_a, text1_b, mid_common) = hm + return (text1_a, text1_b, text2_a, text2_b, mid_common) + + def diff_cleanupSemantic(self, diffs): + """Reduce the number of edits by eliminating semantically trivial + equalities. + + Args: + diffs: Array of diff tuples. + """ + changes = False + equalities = [] # Stack of indices where equalities are found. + lastequality = None # Always equal to diffs[equalities[-1]][1] + pointer = 0 # Index of current position. + # Number of chars that changed prior to the equality. + length_insertions1, length_deletions1 = 0, 0 + # Number of chars that changed after the equality. + length_insertions2, length_deletions2 = 0, 0 + while pointer < len(diffs): + if diffs[pointer][0] == self.DIFF_EQUAL: # Equality found. + equalities.append(pointer) + length_insertions1, length_insertions2 = length_insertions2, 0 + length_deletions1, length_deletions2 = length_deletions2, 0 + lastequality = diffs[pointer][1] + else: # An insertion or deletion. + if diffs[pointer][0] == self.DIFF_INSERT: + length_insertions2 += len(diffs[pointer][1]) + else: + length_deletions2 += len(diffs[pointer][1]) + # Eliminate an equality that is smaller or equal to the edits on both + # sides of it. + if (lastequality and (len(lastequality) <= + max(length_insertions1, length_deletions1)) and + (len(lastequality) <= max(length_insertions2, length_deletions2))): + # Duplicate record. + diffs.insert(equalities[-1], (self.DIFF_DELETE, lastequality)) + # Change second copy to insert. + diffs[equalities[-1] + 1] = (self.DIFF_INSERT, + diffs[equalities[-1] + 1][1]) + # Throw away the equality we just deleted. + equalities.pop() + # Throw away the previous equality (it needs to be reevaluated). + if len(equalities): + equalities.pop() + if len(equalities): + pointer = equalities[-1] + else: + pointer = -1 + # Reset the counters. + length_insertions1, length_deletions1 = 0, 0 + length_insertions2, length_deletions2 = 0, 0 + lastequality = None + changes = True + pointer += 1 + + # Normalize the diff. + if changes: + self.diff_cleanupMerge(diffs) + self.diff_cleanupSemanticLossless(diffs) + + # Find any overlaps between deletions and insertions. + # e.g: abcxxxxxxdef + # -> abcxxxdef + # e.g: xxxabcdefxxx + # -> defxxxabc + # Only extract an overlap if it is as big as the edit ahead or behind it. + pointer = 1 + while pointer < len(diffs): + if (diffs[pointer - 1][0] == self.DIFF_DELETE and + diffs[pointer][0] == self.DIFF_INSERT): + deletion = diffs[pointer - 1][1] + insertion = diffs[pointer][1] + overlap_length1 = self.diff_commonOverlap(deletion, insertion) + overlap_length2 = self.diff_commonOverlap(insertion, deletion) + if overlap_length1 >= overlap_length2: + if (overlap_length1 >= len(deletion) / 2.0 or + overlap_length1 >= len(insertion) / 2.0): + # Overlap found. Insert an equality and trim the surrounding edits. + diffs.insert(pointer, (self.DIFF_EQUAL, + insertion[:overlap_length1])) + diffs[pointer - 1] = (self.DIFF_DELETE, + deletion[:len(deletion) - overlap_length1]) + diffs[pointer + 1] = (self.DIFF_INSERT, + insertion[overlap_length1:]) + pointer += 1 + else: + if (overlap_length2 >= len(deletion) / 2.0 or + overlap_length2 >= len(insertion) / 2.0): + # Reverse overlap found. + # Insert an equality and swap and trim the surrounding edits. + diffs.insert(pointer, (self.DIFF_EQUAL, deletion[:overlap_length2])) + diffs[pointer - 1] = (self.DIFF_INSERT, + insertion[:len(insertion) - overlap_length2]) + diffs[pointer + 1] = (self.DIFF_DELETE, deletion[overlap_length2:]) + pointer += 1 + pointer += 1 + pointer += 1 + + def diff_cleanupSemanticLossless(self, diffs): + """Look for single edits surrounded on both sides by equalities + which can be shifted sideways to align the edit to a word boundary. + e.g: The cat came. -> The cat came. + + Args: + diffs: Array of diff tuples. + """ + + def diff_cleanupSemanticScore(one, two): + """Given two strings, compute a score representing whether the + internal boundary falls on logical boundaries. + Scores range from 6 (best) to 0 (worst). + Closure, but does not reference any external variables. + + Args: + one: First string. + two: Second string. + + Returns: + The score. + """ + if not one or not two: + # Edges are the best. + return 6 + + # Each port of this function behaves slightly differently due to + # subtle differences in each language's definition of things like + # 'whitespace'. Since this function's purpose is largely cosmetic, + # the choice has been made to use each language's native features + # rather than force total conformity. + char1 = one[-1] + char2 = two[0] + nonAlphaNumeric1 = not char1.isalpha() + nonAlphaNumeric2 = not char2.isalpha() + whitespace1 = nonAlphaNumeric1 and char1.isspace() + whitespace2 = nonAlphaNumeric2 and char2.isspace() + lineBreak1 = whitespace1 and (char1 == "\r" or char1 == "\n") + lineBreak2 = whitespace2 and (char2 == "\r" or char2 == "\n") + blankLine1 = lineBreak1 and self.BLANKLINEEND.search(one) + blankLine2 = lineBreak2 and self.BLANKLINESTART.match(two) + + if blankLine1 or blankLine2: + # Five points for blank lines. + return 5 + elif lineBreak1 or lineBreak2: + # Four points for line breaks. + return 4 + elif nonAlphaNumeric1 and not whitespace1 and whitespace2: + # Three points for end of sentences. + return 3 + elif whitespace1 or whitespace2: + # Two points for whitespace. + return 2 + elif nonAlphaNumeric1 or nonAlphaNumeric2: + # One point for non-alphanumeric. + return 1 + return 0 + + pointer = 1 + # Intentionally ignore the first and last element (don't need checking). + while pointer < len(diffs) - 1: + if (diffs[pointer - 1][0] == self.DIFF_EQUAL and + diffs[pointer + 1][0] == self.DIFF_EQUAL): + # This is a single edit surrounded by equalities. + equality1 = diffs[pointer - 1][1] + edit = diffs[pointer][1] + equality2 = diffs[pointer + 1][1] + + # First, shift the edit as far left as possible. + commonOffset = self.diff_commonSuffix(equality1, edit) + if commonOffset: + commonString = edit[-commonOffset:] + equality1 = equality1[:-commonOffset] + edit = commonString + edit[:-commonOffset] + equality2 = commonString + equality2 + + # Second, step character by character right, looking for the best fit. + bestEquality1 = equality1 + bestEdit = edit + bestEquality2 = equality2 + bestScore = (diff_cleanupSemanticScore(equality1, edit) + + diff_cleanupSemanticScore(edit, equality2)) + while edit and equality2 and edit[0] == equality2[0]: + equality1 += edit[0] + edit = edit[1:] + equality2[0] + equality2 = equality2[1:] + score = (diff_cleanupSemanticScore(equality1, edit) + + diff_cleanupSemanticScore(edit, equality2)) + # The >= encourages trailing rather than leading whitespace on edits. + if score >= bestScore: + bestScore = score + bestEquality1 = equality1 + bestEdit = edit + bestEquality2 = equality2 + + if diffs[pointer - 1][1] != bestEquality1: + # We have an improvement, save it back to the diff. + if bestEquality1: + diffs[pointer - 1] = (diffs[pointer - 1][0], bestEquality1) + else: + del diffs[pointer - 1] + pointer -= 1 + diffs[pointer] = (diffs[pointer][0], bestEdit) + if bestEquality2: + diffs[pointer + 1] = (diffs[pointer + 1][0], bestEquality2) + else: + del diffs[pointer + 1] + pointer -= 1 + pointer += 1 + + # Define some regex patterns for matching boundaries. + BLANKLINEEND = ure.compile(r"\n\r?\n$"); + BLANKLINESTART = ure.compile(r"^\r?\n\r?\n"); + + def diff_cleanupMerge(self, diffs): + """Reorder and merge like edit sections. Merge equalities. + Any edit section can move as long as it doesn't cross an equality. + + Args: + diffs: Array of diff tuples. + """ + diffs.append((self.DIFF_EQUAL, '')) # Add a dummy entry at the end. + pointer = 0 + count_delete = 0 + count_insert = 0 + text_delete = '' + text_insert = '' + while pointer < len(diffs): + if diffs[pointer][0] == self.DIFF_INSERT: + count_insert += 1 + text_insert += diffs[pointer][1] + pointer += 1 + elif diffs[pointer][0] == self.DIFF_DELETE: + count_delete += 1 + text_delete += diffs[pointer][1] + pointer += 1 + elif diffs[pointer][0] == self.DIFF_EQUAL: + # Upon reaching an equality, check for prior redundancies. + if count_delete + count_insert > 1: + if count_delete != 0 and count_insert != 0: + # Factor out any common prefixies. + commonlength = self.diff_commonPrefix(text_insert, text_delete) + if commonlength != 0: + x = pointer - count_delete - count_insert - 1 + if x >= 0 and diffs[x][0] == self.DIFF_EQUAL: + diffs[x] = (diffs[x][0], diffs[x][1] + + text_insert[:commonlength]) + else: + diffs.insert(0, (self.DIFF_EQUAL, text_insert[:commonlength])) + pointer += 1 + text_insert = text_insert[commonlength:] + text_delete = text_delete[commonlength:] + # Factor out any common suffixies. + commonlength = self.diff_commonSuffix(text_insert, text_delete) + if commonlength != 0: + diffs[pointer] = (diffs[pointer][0], text_insert[-commonlength:] + + diffs[pointer][1]) + text_insert = text_insert[:-commonlength] + text_delete = text_delete[:-commonlength] + # Delete the offending records and add the merged ones. + if count_delete == 0: + diffs[pointer - count_insert : pointer] = [ + (self.DIFF_INSERT, text_insert)] + elif count_insert == 0: + diffs[pointer - count_delete : pointer] = [ + (self.DIFF_DELETE, text_delete)] + else: + diffs[pointer - count_delete - count_insert : pointer] = [ + (self.DIFF_DELETE, text_delete), + (self.DIFF_INSERT, text_insert)] + pointer = pointer - count_delete - count_insert + 1 + if count_delete != 0: + pointer += 1 + if count_insert != 0: + pointer += 1 + elif pointer != 0 and diffs[pointer - 1][0] == self.DIFF_EQUAL: + # Merge this equality with the previous one. + diffs[pointer - 1] = (diffs[pointer - 1][0], + diffs[pointer - 1][1] + diffs[pointer][1]) + del diffs[pointer] + else: + pointer += 1 + + count_insert = 0 + count_delete = 0 + text_delete = '' + text_insert = '' + + if diffs[-1][1] == '': + diffs.pop() # Remove the dummy entry at the end. + + # Second pass: look for single edits surrounded on both sides by equalities + # which can be shifted sideways to eliminate an equality. + # e.g: ABAC -> ABAC + changes = False + pointer = 1 + # Intentionally ignore the first and last element (don't need checking). + while pointer < len(diffs) - 1: + if (diffs[pointer - 1][0] == self.DIFF_EQUAL and + diffs[pointer + 1][0] == self.DIFF_EQUAL): + # This is a single edit surrounded by equalities. + if diffs[pointer][1].endswith(diffs[pointer - 1][1]): + # Shift the edit over the previous equality. + diffs[pointer] = (diffs[pointer][0], + diffs[pointer - 1][1] + + diffs[pointer][1][:-len(diffs[pointer - 1][1])]) + diffs[pointer + 1] = (diffs[pointer + 1][0], + diffs[pointer - 1][1] + diffs[pointer + 1][1]) + del diffs[pointer - 1] + changes = True + elif diffs[pointer][1].startswith(diffs[pointer + 1][1]): + # Shift the edit over the next equality. + diffs[pointer - 1] = (diffs[pointer - 1][0], + diffs[pointer - 1][1] + diffs[pointer + 1][1]) + diffs[pointer] = (diffs[pointer][0], + diffs[pointer][1][len(diffs[pointer + 1][1]):] + + diffs[pointer + 1][1]) + del diffs[pointer + 1] + changes = True + pointer += 1 + + # If shifts were made, the diff needs reordering and another shift sweep. + if changes: + self.diff_cleanupMerge(diffs) + + def diff_xIndex(self, diffs, loc): + """loc is a location in text1, compute and return the equivalent location + in text2. e.g. "The cat" vs "The big cat", 1->1, 5->8 + + Args: + diffs: Array of diff tuples. + loc: Location within text1. + + Returns: + Location within text2. + """ + chars1 = 0 + chars2 = 0 + last_chars1 = 0 + last_chars2 = 0 + for x in range(len(diffs)): + (op, text) = diffs[x] + if op != self.DIFF_INSERT: # Equality or deletion. + chars1 += len(text) + if op != self.DIFF_DELETE: # Equality or insertion. + chars2 += len(text) + if chars1 > loc: # Overshot the location. + break + last_chars1 = chars1 + last_chars2 = chars2 + + if len(diffs) != x and diffs[x][0] == self.DIFF_DELETE: + # The location was deleted. + return last_chars2 + # Add the remaining len(character). + return last_chars2 + (loc - last_chars1) + + def diff_text1(self, diffs): + """Compute and return the source text (all equalities and deletions). + + Args: + diffs: Array of diff tuples. + + Returns: + Source text. + """ + text = [] + for (op, data) in diffs: + if op != self.DIFF_INSERT: + text.append(data) + return "".join(text) + + def diff_text2(self, diffs): + """Compute and return the destination text (all equalities and insertions). + + Args: + diffs: Array of diff tuples. + + Returns: + Destination text. + """ + text = [] + for (op, data) in diffs: + if op != self.DIFF_DELETE: + text.append(data) + return "".join(text) + + def diff_levenshtein(self, diffs): + """Compute the Levenshtein distance; the number of inserted, deleted or + substituted characters. + + Args: + diffs: Array of diff tuples. + + Returns: + Number of changes. + """ + levenshtein = 0 + insertions = 0 + deletions = 0 + for (op, data) in diffs: + if op == self.DIFF_INSERT: + insertions += len(data) + elif op == self.DIFF_DELETE: + deletions += len(data) + elif op == self.DIFF_EQUAL: + # A deletion and an insertion is one substitution. + levenshtein += max(insertions, deletions) + insertions = 0 + deletions = 0 + levenshtein += max(insertions, deletions) + return levenshtein + + # MATCH FUNCTIONS + + def match_main(self, text, pattern, loc): + """Locate the best instance of 'pattern' in 'text' near 'loc'. + + Args: + text: The text to search. + pattern: The pattern to search for. + loc: The location to search around. + + Returns: + Best match index or -1. + """ + # Check for null inputs. + if text == None or pattern == None: + raise ValueError("Null inputs. (match_main)") + + loc = max(0, min(loc, len(text))) + if text == pattern: + # Shortcut (potentially not guaranteed by the algorithm) + return 0 + elif not text: + # Nothing to match. + return -1 + elif text[loc:loc + len(pattern)] == pattern: + # Perfect match at the perfect spot! (Includes case of null pattern) + return loc + else: + # Do a fuzzy compare. + match = self.match_bitap(text, pattern, loc) + return match + + def match_bitap(self, text, pattern, loc): + """Locate the best instance of 'pattern' in 'text' near 'loc' using the + Bitap algorithm. + + Args: + text: The text to search. + pattern: The pattern to search for. + loc: The location to search around. + + Returns: + Best match index or -1. + """ + # Python doesn't have a maxint limit, so ignore this check. + #if self.Match_MaxBits != 0 and len(pattern) > self.Match_MaxBits: + # raise ValueError("Pattern too long for this application.") + + # Initialise the alphabet. + s = self.match_alphabet(pattern) + + def match_bitapScore(e, x): + """Compute and return the score for a match with e errors and x location. + Accesses loc and pattern through being a closure. + + Args: + e: Number of errors in match. + x: Location of match. + + Returns: + Overall score for match (0.0 = good, 1.0 = bad). + """ + accuracy = float(e) / len(pattern) + proximity = abs(loc - x) + if not self.Match_Distance: + # Dodge divide by zero error. + return proximity and 1.0 or accuracy + return accuracy + (proximity / float(self.Match_Distance)) + + # Highest score beyond which we give up. + score_threshold = self.Match_Threshold + # Is there a nearby exact match? (speedup) + best_loc = text.find(pattern, loc) + if best_loc != -1: + score_threshold = min(match_bitapScore(0, best_loc), score_threshold) + # What about in the other direction? (speedup) + best_loc = text.rfind(pattern, loc + len(pattern)) + if best_loc != -1: + score_threshold = min(match_bitapScore(0, best_loc), score_threshold) + + # Initialise the bit arrays. + matchmask = 1 << (len(pattern) - 1) + best_loc = -1 + + bin_max = len(pattern) + len(text) + # Empty initialization added to appease pychecker. + last_rd = None + for d in range(len(pattern)): + # Scan for the best match each iteration allows for one more error. + # Run a binary search to determine how far from 'loc' we can stray at + # this error level. + bin_min = 0 + bin_mid = bin_max + while bin_min < bin_mid: + if match_bitapScore(d, loc + bin_mid) <= score_threshold: + bin_min = bin_mid + else: + bin_max = bin_mid + bin_mid = (bin_max - bin_min) // 2 + bin_min + + # Use the result from this iteration as the maximum for the next. + bin_max = bin_mid + start = max(1, loc - bin_mid + 1) + finish = min(loc + bin_mid, len(text)) + len(pattern) + + rd = [0] * (finish + 2) + rd[finish + 1] = (1 << d) - 1 + for j in range(finish, start - 1, -1): + if len(text) <= j - 1: + # Out of range. + charMatch = 0 + else: + charMatch = s.get(text[j - 1], 0) + if d == 0: # First pass: exact match. + rd[j] = ((rd[j + 1] << 1) | 1) & charMatch + else: # Subsequent passes: fuzzy match. + rd[j] = (((rd[j + 1] << 1) | 1) & charMatch) | ( + ((last_rd[j + 1] | last_rd[j]) << 1) | 1) | last_rd[j + 1] + if rd[j] & matchmask: + score = match_bitapScore(d, j - 1) + # This match will almost certainly be better than any existing match. + # But check anyway. + if score <= score_threshold: + # Told you so. + score_threshold = score + best_loc = j - 1 + if best_loc > loc: + # When passing loc, don't exceed our current distance from loc. + start = max(1, 2 * loc - best_loc) + else: + # Already passed loc, downhill from here on in. + break + # No hope for a (better) match at greater error levels. + if match_bitapScore(d + 1, loc) > score_threshold: + break + last_rd = rd + return best_loc + + def match_alphabet(self, pattern): + """Initialise the alphabet for the Bitap algorithm. + + Args: + pattern: The text to encode. + + Returns: + Hash of character locations. + """ + s = {} + for char in pattern: + s[char] = 0 + for i in range(len(pattern)): + s[pattern[i]] |= 1 << (len(pattern) - i - 1) + return s + + # PATCH FUNCTIONS + def patch_deepCopy(self, patches): + """Given an array of patches, return another array that is identical. + + Args: + patches: Array of Patch objects. + + Returns: + Array of Patch objects. + """ + patchesCopy = [] + for patch in patches: + patchCopy = patch_obj() + # No need to deep copy the tuples since they are immutable. + patchCopy.diffs = patch.diffs[:] + patchCopy.start1 = patch.start1 + patchCopy.start2 = patch.start2 + patchCopy.length1 = patch.length1 + patchCopy.length2 = patch.length2 + patchesCopy.append(patchCopy) + return patchesCopy + + def patch_apply(self, patches, text): + """Merge a set of patches onto the text. Return a patched text, as well + as a list of true/false values indicating which patches were applied. + + Args: + patches: Array of Patch objects. + text: Old text. + + Returns: + Two element Array, containing the new text and an array of boolean values. + """ + if not patches: + return (text, []) + + # Deep copy the patches so that no changes are made to originals. + patches = self.patch_deepCopy(patches) + + nullPadding = self.patch_addPadding(patches) + text = nullPadding + text + nullPadding + self.patch_splitMax(patches) + + # delta keeps track of the offset between the expected and actual location + # of the previous patch. If there are patches expected at positions 10 and + # 20, but the first patch was found at 12, delta is 2 and the second patch + # has an effective expected position of 22. + delta = 0 + results = [] + for patch in patches: + expected_loc = patch.start2 + delta + text1 = self.diff_text1(patch.diffs) + end_loc = -1 + if len(text1) > self.Match_MaxBits: + # patch_splitMax will only provide an oversized pattern in the case of + # a monster delete. + start_loc = self.match_main(text, text1[:self.Match_MaxBits], + expected_loc) + if start_loc != -1: + end_loc = self.match_main(text, text1[-self.Match_MaxBits:], + expected_loc + len(text1) - self.Match_MaxBits) + if end_loc == -1 or start_loc >= end_loc: + # Can't find valid trailing context. Drop this patch. + start_loc = -1 + else: + start_loc = self.match_main(text, text1, expected_loc) + if start_loc == -1: + # No match found. :( + results.append(False) + # Subtract the delta for this failed patch from subsequent patches. + delta -= patch.length2 - patch.length1 + else: + # Found a match. :) + results.append(True) + delta = start_loc - expected_loc + if end_loc == -1: + text2 = text[start_loc : start_loc + len(text1)] + else: + text2 = text[start_loc : end_loc + self.Match_MaxBits] + if text1 == text2: + # Perfect match, just shove the replacement text in. + text = (text[:start_loc] + self.diff_text2(patch.diffs) + + text[start_loc + len(text1):]) + else: + # Imperfect match. + # Run a diff to get a framework of equivalent indices. + diffs = self.diff_main(text1, text2, False) + if (len(text1) > self.Match_MaxBits and + self.diff_levenshtein(diffs) / float(len(text1)) > + self.Patch_DeleteThreshold): + # The end points match, but the content is unacceptably bad. + results[-1] = False + else: + self.diff_cleanupSemanticLossless(diffs) + index1 = 0 + for (op, data) in patch.diffs: + if op != self.DIFF_EQUAL: + index2 = self.diff_xIndex(diffs, index1) + if op == self.DIFF_INSERT: # Insertion + text = text[:start_loc + index2] + data + text[start_loc + + index2:] + elif op == self.DIFF_DELETE: # Deletion + text = text[:start_loc + index2] + text[start_loc + + self.diff_xIndex(diffs, index1 + len(data)):] + if op != self.DIFF_DELETE: + index1 += len(data) + # Strip the padding off. + text = text[len(nullPadding):-len(nullPadding)] + return (text, results) + + def patch_addPadding(self, patches): + """Add some padding on text start and end so that edges can match + something. Intended to be called only from within patch_apply. + + Args: + patches: Array of Patch objects. + + Returns: + The padding string added to each side. + """ + paddingLength = self.Patch_Margin + nullPadding = "" + for x in range(1, paddingLength + 1): + nullPadding += chr(x) + + # Bump all the patches forward. + for patch in patches: + patch.start1 += paddingLength + patch.start2 += paddingLength + + # Add some padding on start of first diff. + patch = patches[0] + diffs = patch.diffs + if not diffs or diffs[0][0] != self.DIFF_EQUAL: + # Add nullPadding equality. + diffs.insert(0, (self.DIFF_EQUAL, nullPadding)) + patch.start1 -= paddingLength # Should be 0. + patch.start2 -= paddingLength # Should be 0. + patch.length1 += paddingLength + patch.length2 += paddingLength + elif paddingLength > len(diffs[0][1]): + # Grow first equality. + extraLength = paddingLength - len(diffs[0][1]) + newText = nullPadding[len(diffs[0][1]):] + diffs[0][1] + diffs[0] = (diffs[0][0], newText) + patch.start1 -= extraLength + patch.start2 -= extraLength + patch.length1 += extraLength + patch.length2 += extraLength + + # Add some padding on end of last diff. + patch = patches[-1] + diffs = patch.diffs + if not diffs or diffs[-1][0] != self.DIFF_EQUAL: + # Add nullPadding equality. + diffs.append((self.DIFF_EQUAL, nullPadding)) + patch.length1 += paddingLength + patch.length2 += paddingLength + elif paddingLength > len(diffs[-1][1]): + # Grow last equality. + extraLength = paddingLength - len(diffs[-1][1]) + newText = diffs[-1][1] + nullPadding[:extraLength] + diffs[-1] = (diffs[-1][0], newText) + patch.length1 += extraLength + patch.length2 += extraLength + + return nullPadding + + def patch_splitMax(self, patches): + """Look through the patches and break up any which are longer than the + maximum limit of the match algorithm. + Intended to be called only from within patch_apply. + + Args: + patches: Array of Patch objects. + """ + patch_size = self.Match_MaxBits + if patch_size == 0: + # Python has the option of not splitting strings due to its ability + # to handle integers of arbitrary precision. + return + for x in range(len(patches)): + if patches[x].length1 <= patch_size: + continue + bigpatch = patches[x] + # Remove the big old patch. + del patches[x] + x -= 1 + start1 = bigpatch.start1 + start2 = bigpatch.start2 + precontext = '' + while len(bigpatch.diffs) != 0: + # Create one of several smaller patches. + patch = patch_obj() + empty = True + patch.start1 = start1 - len(precontext) + patch.start2 = start2 - len(precontext) + if precontext: + patch.length1 = patch.length2 = len(precontext) + patch.diffs.append((self.DIFF_EQUAL, precontext)) + + while (len(bigpatch.diffs) != 0 and + patch.length1 < patch_size - self.Patch_Margin): + (diff_type, diff_text) = bigpatch.diffs[0] + if diff_type == self.DIFF_INSERT: + # Insertions are harmless. + patch.length2 += len(diff_text) + start2 += len(diff_text) + patch.diffs.append(bigpatch.diffs.pop(0)) + empty = False + elif (diff_type == self.DIFF_DELETE and len(patch.diffs) == 1 and + patch.diffs[0][0] == self.DIFF_EQUAL and + len(diff_text) > 2 * patch_size): + # This is a large deletion. Let it pass in one chunk. + patch.length1 += len(diff_text) + start1 += len(diff_text) + empty = False + patch.diffs.append((diff_type, diff_text)) + del bigpatch.diffs[0] + else: + # Deletion or equality. Only take as much as we can stomach. + diff_text = diff_text[:patch_size - patch.length1 - + self.Patch_Margin] + patch.length1 += len(diff_text) + start1 += len(diff_text) + if diff_type == self.DIFF_EQUAL: + patch.length2 += len(diff_text) + start2 += len(diff_text) + else: + empty = False + + patch.diffs.append((diff_type, diff_text)) + if diff_text == bigpatch.diffs[0][1]: + del bigpatch.diffs[0] + else: + bigpatch.diffs[0] = (bigpatch.diffs[0][0], + bigpatch.diffs[0][1][len(diff_text):]) + + # Compute the head context for the next patch. + precontext = self.diff_text2(patch.diffs) + precontext = precontext[-self.Patch_Margin:] + # Append the end context for this patch. + postcontext = self.diff_text1(bigpatch.diffs)[:self.Patch_Margin] + if postcontext: + patch.length1 += len(postcontext) + patch.length2 += len(postcontext) + if len(patch.diffs) != 0 and patch.diffs[-1][0] == self.DIFF_EQUAL: + patch.diffs[-1] = (self.DIFF_EQUAL, patch.diffs[-1][1] + + postcontext) + else: + patch.diffs.append((self.DIFF_EQUAL, postcontext)) + + if not empty: + x += 1 + patches.insert(x, patch) + + def unquote(self, s): + """unquote('abc%20def') -> 'abc def'.""" + res = s.split('%') + # fastpath + if len(res) == 1: + return s + s = res[0] + for item in res[1:]: + try: + s += self._hextochr[item[:2]] + item[2:] + except KeyError: + s += '%' + item +# except UnicodeDecodeError: +# s += unichr(int(item[:2], 16)) + item[2:] + return s + + def patch_fromText(self, textline): + """Parse a textual representation of patches and return a list of patch + objects. + + Args: + textline: Text representation of patches. + + Returns: + Array of Patch objects. + + Raises: + ValueError: If invalid input. + """ + if type(textline) == bytes: + # Patches should be composed of a subset of ascii chars, Unicode not + # required. If this encode raises UnicodeEncodeError, patch is invalid. + textline = textline.encode("ascii") + patches = [] + if not textline: + return patches + text = textline.split('\n') + while len(text) != 0: + m = ure.match("^@@ -(\d+),?(\d*) \+(\d+),?(\d*) @@$", text[0]) + if not m: + raise ValueError("Invalid patch string: " + text[0]) + patch = patch_obj() + patches.append(patch) + patch.start1 = int(m.group(1)) + if m.group(2) == '': + patch.start1 -= 1 + patch.length1 = 1 + elif m.group(2) == '0': + patch.length1 = 0 + else: + patch.start1 -= 1 + patch.length1 = int(m.group(2)) + + patch.start2 = int(m.group(3)) + if m.group(4) == '': + patch.start2 -= 1 + patch.length2 = 1 + elif m.group(4) == '0': + patch.length2 = 0 + else: + patch.start2 -= 1 + patch.length2 = int(m.group(4)) + + del text[0] + + while len(text) != 0: + if text[0]: + sign = text[0][0] + else: + sign = '' + line = self.unquote(text[0][1:]) + #line = line.decode("utf-8") + if sign == '+': + # Insertion. + patch.diffs.append((self.DIFF_INSERT, line)) + elif sign == '-': + # Deletion. + patch.diffs.append((self.DIFF_DELETE, line)) + elif sign == ' ': + # Minor equality. + patch.diffs.append((self.DIFF_EQUAL, line)) + elif sign == '@': + # Start of next patch. + break + elif sign == '': + # Blank line? Whatever. + pass + else: + # WTF? + raise ValueError("Invalid patch mode: '%s'\n%s" % (sign, line)) + del text[0] + return patches + + +class patch_obj: + """Class representing one patch operation. + """ + + def __init__(self): + """Initializes with an empty list of diffs. + """ + self.diffs = [] + self.start1 = None + self.start2 = None + self.length1 = 0 + self.length2 = 0 + + def __str__(self): + """Emmulate GNU diff's format. + Header: @@ -382,8 +481,9 @@ + Indicies are printed as 1-based, not 0-based. + + Returns: + The GNU diff string. + """ + if self.length1 == 0: + coords1 = str(self.start1) + ",0" + elif self.length1 == 1: + coords1 = str(self.start1 + 1) + else: + coords1 = str(self.start1 + 1) + "," + str(self.length1) + if self.length2 == 0: + coords2 = str(self.start2) + ",0" + elif self.length2 == 1: + coords2 = str(self.start2 + 1) + else: + coords2 = str(self.start2 + 1) + "," + str(self.length2) + text = ["@@ -", coords1, " +", coords2, " @@\n"] + # Escape the body of the patch with %xx notation. + for (op, data) in self.diffs: + if op == diff_match_patch.DIFF_INSERT: + text.append("+") + elif op == diff_match_patch.DIFF_DELETE: + text.append("-") + elif op == diff_match_patch.DIFF_EQUAL: + text.append(" ") + # High ascii will raise UnicodeDecodeError. Use Unicode instead. + data = data.encode("utf-8") + text.append(urllib.quote(data, "!~*'();/?:@&=+$,# ") + "\n") + return "".join(text) diff --git a/examples/OTA-lorawan/firmware/1.17.0/flash/loranet.py b/examples/OTA-lorawan/firmware/1.17.0/flash/loranet.py new file mode 100644 index 0000000..573d178 --- /dev/null +++ b/examples/OTA-lorawan/firmware/1.17.0/flash/loranet.py @@ -0,0 +1,131 @@ +from network import LoRa +import socket +import binascii +import struct +import time +import _thread + +class LoraNet: + def __init__(self, frequency, dr, region, device_class=LoRa.CLASS_C, activation = LoRa.OTAA, auth = None): + self.frequency = frequency + self.dr = dr + self.region = region + self.device_class = device_class + self.activation = activation + self.auth = auth + self.sock = None + self._exit = False + self.s_lock = _thread.allocate_lock() + self.lora = LoRa(mode=LoRa.LORAWAN, region = self.region, device_class = self.device_class) + + self._msg_queue = [] + self.q_lock = _thread.allocate_lock() + self._process_ota_msg = None + + def stop(self): + self._exit = True + + def init(self, process_msg_callback): + self._process_ota_msg = process_msg_callback + + def receive_callback(self, lora): + events = lora.events() + if events & LoRa.RX_PACKET_EVENT: + rx, port = self.sock.recvfrom(256) + if rx: + if '$OTA' in rx: + print("OTA msg received: {}".format(rx)) + self._process_ota_msg(rx.decode()) + else: + self.q_lock.acquire() + self._msg_queue.append(rx) + self.q_lock.release() + + def connect(self): + if self.activation != LoRa.OTAA and self.activation != LoRa.ABP: + raise ValueError("Invalid Lora activation method") + if len(self.auth) < 3: + raise ValueError("Invalid authentication parameters") + + self.lora.callback(trigger=LoRa.RX_PACKET_EVENT, handler=self.receive_callback) + + # set the 3 default channels to the same frequency + self.lora.add_channel(0, frequency=self.frequency, dr_min=0, dr_max=5) + self.lora.add_channel(1, frequency=self.frequency, dr_min=0, dr_max=5) + self.lora.add_channel(2, frequency=self.frequency, dr_min=0, dr_max=5) + + # remove all the non-default channels + for i in range(3, 16): + self.lora.remove_channel(i) + + # authenticate with abp or ota + if self.activation == LoRa.OTAA: + self._authenticate_otaa(self.auth) + else: + self._authenticate_abp(self.auth) + + # create socket to server + self._create_socket() + + def _authenticate_otaa(self, auth_params): + + # create an OTAA authentication params + self.dev_eui = binascii.unhexlify(auth_params[0]) + self.app_eui = binascii.unhexlify(auth_params[1]) + self.app_key = binascii.unhexlify(auth_params[2]) + + self.lora.join(activation=LoRa.OTAA, auth=(self.dev_eui, self.app_eui, self.app_key), timeout=0, dr=self.dr) + + while not self.lora.has_joined(): + time.sleep(2.5) + print('Not joined yet...') + + def has_joined(self): + return self.lora.has_joined() + + def _authenticate_abp(self, auth_params): + # create an ABP authentication params + self.dev_addr = struct.unpack(">l", binascii.unhexlify(auth_params[0]))[0] + self.nwk_swkey = binascii.unhexlify(auth_params[1]) + self.app_swkey = binascii.unhexlify(auth_params[2]) + + self.lora.join(activation=LoRa.ABP, auth=(self.dev_addr, self.nwk_swkey, self.app_swkey)) + + def _create_socket(self): + + # create a LoRa socket + self.sock = socket.socket(socket.AF_LORA, socket.SOCK_RAW) + + # set the LoRaWAN data rate + self.sock.setsockopt(socket.SOL_LORA, socket.SO_DR, self.dr) + + # make the socket non blocking + self.sock.setblocking(False) + + time.sleep(2) + + def send(self, packet): + with self.s_lock: + self.sock.send(packet) + + def receive(self, bufsize): + with self.q_lock: + if len(self._msg_queue) > 0: + return self._msg_queue.pop(0) + return '' + + def get_dev_eui(self): + return binascii.hexlify(self.lora.mac()).decode('ascii') + + def change_to_multicast_mode(self, mcAuth): + print('Start listening for firmware updates ...........') + + if self.device_class != LoRa.CLASS_C: + self.lora = LoRa(mode=LoRa.LORAWAN, region = self.region, device_class=LoRa.CLASS_C) + self.connect() + + mcAddr = struct.unpack(">l", binascii.unhexlify(mcAuth[0]))[0] + mcNwkKey = binascii.unhexlify(mcAuth[1]) + mcAppKey = binascii.unhexlify(mcAuth[2]) + + self.lora.join_multicast_group(mcAddr, mcNwkKey, mcAppKey) diff --git a/examples/OTA-lorawan/firmware/1.17.0/flash/main.py b/examples/OTA-lorawan/firmware/1.17.0/flash/main.py new file mode 100644 index 0000000..0dbf7c6 --- /dev/null +++ b/examples/OTA-lorawan/firmware/1.17.0/flash/main.py @@ -0,0 +1,33 @@ +from loranet import LoraNet +from ota import LoraOTA +from network import LoRa +import machine +import utime + +def main(): + LORA_FREQUENCY = 868100000 + LORA_NODE_DR = 0 + LORA_REGION = LoRa.EU868 + LORA_DEVICE_CLASS = LoRa.CLASS_C + LORA_ACTIVATION = LoRa.OTAA + LORA_CRED = ('240ac4fffe0bf998', '948c87eff87f04508f64661220f71e3f', '5e6795a5c9abba017d05a2ffef6ba858') + + lora = LoraNet(LORA_FREQUENCY, LORA_NODE_DR, LORA_REGION, LORA_DEVICE_CLASS, LORA_ACTIVATION, LORA_CRED) + lora.connect() + + ota = LoraOTA(lora) + + while True: + rx = lora.receive(256) + if rx: + print('Received user message: {}'.format(rx)) + + utime.sleep(2) + +main() + +#try: +# main() +#except Exception as e: +# print('Firmware exception: Reverting to old firmware') +# LoraOTA.revert() diff --git a/examples/OTA-lorawan/firmware/1.17.0/flash/ota.py b/examples/OTA-lorawan/firmware/1.17.0/flash/ota.py new file mode 100644 index 0000000..0fca7db --- /dev/null +++ b/examples/OTA-lorawan/firmware/1.17.0/flash/ota.py @@ -0,0 +1,467 @@ +import diff_match_patch as dmp_module +from watchdog import Watchdog +from machine import RTC +import ubinascii +import uhashlib +import _thread +import utime +import uos +import machine +import json + +class LoraOTA: + + MSG_HEADER = b'$OTA' + MSG_TAIL = b'*' + + UPDATE_INFO_MSG = 1 + UPDATE_INFO_REPLY = 2 + + MULTICAST_KEY_REQ = 3 + MULTICAST_KEY_REPLY = 4 + + LISTENING_MSG = 5 + LISTENING_REPLY = 6 + + UPDATE_TYPE_FNAME = 7 + UPDATE_TYPE_PATCH = 8 + UPDATE_TYPE_CHECKSUM = 9 + + DELETE_FILE_MSG = 10 + MANIFEST_MSG = 11 + + def __init__(self, lora): + self.lora = lora + self.is_updating = False + self.version_file = '/flash/OTA_INFO.py' + self.update_version = '0.0.0' + self.update_time = -1 + self.resp_received = False + self.update_in_progress = False + self.operation_timeout = 10 + self.max_send = 5 + self.listen_before_sec = uos.urandom(1)[0] % 180 + self.updates_check_period = 6 * 3600 + + self.mcAddr = None + self.mcNwkSKey = None + self.mcAppSKey = None + + self.patch = '' + self.file_to_patch = None + self.patch_list = dict() + self.checksum_failure = False + self.device_mainfest = None + + self._exit = False + _thread.start_new_thread(self._thread_proc, ()) + + self.inactivity_timeout = 120 + self.wdt = Watchdog() + + self.lora.init(self.process_message) + + def stop(self): + self.lora.stop() + self._exit = True + + def _thread_proc(self): + updates_check_time = utime.time() + self.device_mainfest = self.create_device_manifest() + + while not self._exit: + if utime.time() > updates_check_time and self.update_time < 0: + self.synch_request(self.check_firmware_updates) + updates_check_time = utime.time() + self.updates_check_period + + if self.update_time > 0 and not self.update_in_progress: + if self.update_time - utime.time() < self.listen_before_sec: + self.update_in_progress = True + self.updating_proc() + + if self.update_failed(): + print('Update failed: No data received') + machine.reset() + + utime.sleep(2) + + def updating_proc(self): + self.synch_request(self.get_mulitcast_keys) + + if self.mcAddr is not None: + mulitcast_auth = (self.mcAddr, self.mcNwkSKey, self.mcAppSKey) + self.lora.change_to_multicast_mode(mulitcast_auth) + + wdt_timeout = self.listen_before_sec + self.inactivity_timeout + self.wdt.enable(wdt_timeout) + + self.synch_request(self.send_listening_msg) + else: + self.reset_update_params() + + def create_device_manifest(self): + + manifest = dict() + manifest["delete"] = 0 + manifest["update"] = 0 + manifest["new"] = 0 + + return manifest + + def reset_update_params(self): + self.mcAddr = None + self.mcNwkSKey = None + self.mcAppSKey = None + + self.update_in_progress = False + self.update_time = -1 + self.update_version = '0.0.0' + + def get_mulitcast_keys(self): + msg = bytearray() + msg.extend(self.MSG_HEADER) + msg.extend(b',' + str(self.MULTICAST_KEY_REQ).encode()) + msg.extend(b',' + self.MSG_TAIL) + + self.lora.send(msg) + + def synch_request(self, func): + attempt_num = 0 + self.resp_received = False + + while attempt_num < self.max_send and not self.resp_received: + func() + + count_10ms = 0 + while(count_10ms <= self.operation_timeout * 100 and not self.resp_received): + count_10ms += 1 + utime.sleep(0.01) + + attempt_num += 1 + + def check_firmware_updates(self): + msg = bytearray() + msg.extend(self.MSG_HEADER) + msg.extend(b',' + str(self.UPDATE_INFO_MSG).encode()) + + version = self.get_current_version().encode() + msg.extend(b',' + version) + msg.extend(b',' + self.MSG_TAIL) + + self.lora.send(msg) + print("Lora OTA: Request for info sent") + + def get_current_version(self): + version = '0.0.0' + if self.file_exists(self.version_file): + with open(self.version_file, 'r') as fh: + version = fh.read().rstrip("\r\n\s") + else: + self._write_version_info(version) + + print("Version: {}", version) + + return version + + def send_listening_msg(self): + msg = bytearray() + msg.extend(self.MSG_HEADER) + msg.extend(b',' + str(self.LISTENING_MSG).encode()) + msg.extend(b',' + self.MSG_TAIL) + + self.lora.send(msg) + + def _write_version_info(self, version): + try: + with open(self.version_file, 'w+') as fh: + fh.write(version) + except Exception as e: + print("Exception creating OTA version file") + + def file_exists(self, file_path): + exists = False + try: + if uos.stat(file_path)[6] > 0: + exists = True + except Exception as e: + exists = False + return exists + + def get_msg_type(self, msg): + msg_type = -1 + try: + msg_type = int(msg.split(",")[1]) + except Exception as ex: + print("Exception getting message type") + + return msg_type + + def sync_clock(self, epoc): + try: + rtc = RTC() + rtc.init(utime.gmtime(epoc)) + except Exception as ex: + print("Exception setting system data/time: {}".format(ex)) + return False + + return True + + def parse_update_info_reply(self, msg): + self.resp_received = True + + try: + token_msg = msg.split(",") + need_updating = int(token_msg[2]) + if need_updating: + self.update_version = token_msg[3] + self.update_time = int(token_msg[5]) + + if utime.time() < 1550000000: + self.sync_clock(int(token_msg[4])) + + except Exception as ex: + print("Exception getting update information: {}".format(ex)) + return False + + return True + + def parse_multicast_keys(self, msg): + + try: + token_msg = msg.split(",") + print(token_msg) + + if len(token_msg[2]) > 0: + self.mcAddr = token_msg[2] + self.mcNwkSKey = token_msg[3] + self.mcAppSKey = token_msg[4] + + print("mcAddr: {}, mcNwkSKey: {}, mcAppSKey: {}".format(self.mcAddr, self.mcNwkSKey, self.mcAppSKey)) + + self.resp_received = True + except Exception as ex: + print("Exception getting multicast keys: {}".format(ex)) + return False + + return True + + def parse_listening_reply(self, msg): + self.resp_received = True + + def _data_start_idx(self, msg): + # Find first index + i = msg.find(",") + + #Find second index + return msg.find(",", i + 1) + + def _data_stop_idx(self, msg): + return msg.rfind(",") + + def get_msg_data(self, msg): + data = None + try: + start_idx = self._data_start_idx(msg) + 1 + stop_idx = self._data_stop_idx(msg) + data = msg[start_idx:stop_idx] + except Exception as ex: + print("Exception getting msg data: {}".format(ex)) + return data + + def process_patch_msg(self, msg): + partial_patch = self.get_msg_data(msg) + + if partial_patch: + self.patch += partial_patch + + def verify_patch(self, patch, received_checksum): + h = uhashlib.sha1() + h.update(patch) + checksum = ubinascii.hexlify(h.digest()).decode() + print("Computed checksum: {}".format(checksum)) + print("Received checksum: {}".format(received_checksum)) + + if checksum != received_checksum: + self.checksum_failure = True + return False + + return True + + def process_checksum_msg(self, msg): + checksum = self.get_msg_data(msg) + verified = self.verify_patch(self.patch, checksum) + if verified: + self.patch_list[self.file_to_patch] = self.patch + + self.file_to_patch = None + self.patch = '' + + def backup_file(self, filename): + bak_path = "{}.bak".format(filename) + + # Delete previous backup if it exists + try: + uos.remove(bak_path) + except OSError: + pass # There isnt a previous backup + + # Backup current file + uos.rename(filename, bak_path) + + def process_delete_msg(self, msg): + filename = self.get_msg_data(msg) + + if self.file_exists('/flash/' + filename): + self.backup_file('/flash/' + filename) + self.device_mainfest["delete"] += 1 + + def get_tmp_filename(self, filename): + idx = filename.rfind(".") + return filename[:idx + 1] + "tmp" + + def _read_file(self, filename): + + try: + with open('/flash/' + filename, 'r') as fh: + return fh.read() + except Exception as ex: + print("Error reading file: {}".format(ex)) + + return None + + def backup_file(self, filename): + bak_path = "{}.bak".format(filename) + + # Delete previous backup if it exists + try: + uos.remove(bak_path) + except OSError: + pass # There isnt a previous backup + + # Backup current file + uos.rename(filename, bak_path) + + def _write_to_file(self, filename, text): + tmp_file = self.get_tmp_filename('/flash/' + filename) + + try: + with open(tmp_file, 'w+') as fh: + fh.write(text) + except Exception as ex: + print("Error writing to file: {}".format(ex)) + return False + + if self.file_exists('/flash/' + filename): + self.backup_file('/flash/' + filename) + uos.rename(tmp_file, '/flash/' + filename) + + return True + + def apply_patches(self): + for key, value in self.patch_list.items(): + self.dmp = dmp_module.diff_match_patch() + self.patch_list = self.dmp.patch_fromText(value) + + to_patch = '' + print('Updating file: {}'.format(key)) + if self.file_exists('/flash/' + key): + to_patch = self._read_file(key) + + patched_text, success = self.dmp.patch_apply(self.patch_list, to_patch) + if False in success: + return False + + if not self._write_to_file(key, patched_text): + return False + + return True + + @staticmethod + def find_backups(): + backups = [] + for file in uos.listdir("/flash"): + if file.endswith(".bak"): + backups.append(file) + return backups + + @staticmethod + def revert(): + backup_list = LoraOTA.find_backups() + for backup in backup_list: + idx = backup.find('.bak') + new_filename = backup[:idx] + uos.rename(backup, new_filename) + print('Error: Reverting to old firmware') + machine.reset() + + def manifest_failure(self, msg): + + try: + start_idx = msg.find("{") + stop_idx = msg.find("}") + + recv_manifest = json.loads(msg[start_idx:stop_idx]) + + print("Received manifest: {}".format(recv_manifest)) + print("Actual manifest: {}".format(self.device_mainfest)) + + if (recv_manifest["update"] != self.device_mainfest["update"]) or \ + (recv_manifest["new"] != self.device_mainfest["new"]) or \ + (recv_manifest["delete"] != self.device_mainfest["delete"]): + return True + except Exception as ex: + print("Error in manifest: {}".format(ex)) + return True + + return False + + def process_manifest_msg(self, msg): + + if self.manifest_failure(msg): + print('Manifest failure: Discarding update ...') + self.reset_update_params() + if self.checksum_failure: + print('Failed checksum: Discarding update ...') + self.reset_update_params() + elif not self.apply_patches(): + LoraOTA.revert() + else: + print('Update Success: Restarting .... ') + self._write_version_info(self.update_version) + machine.reset() + + def process_filename_msg(self, msg): + self.file_to_patch = self.get_msg_data(msg) + + if self.file_exists('/flash/' + self.file_to_patch): + self.device_mainfest["update"] += 1 + print("Update file: {}".format(self.file_to_patch)) + else: + self.device_mainfest["new"] += 1 + print("Create new file: {}".format(self.file_to_patch)) + + self.wdt.enable(self.inactivity_timeout) + + def update_failed(self): + return self.wdt.update_failed() + + def process_message(self, msg): + self.wdt.ack() + + msg_type = self.get_msg_type(msg) + if msg_type == self.UPDATE_INFO_REPLY: + self.parse_update_info_reply(msg) + elif msg_type == self.MULTICAST_KEY_REPLY: + self.parse_multicast_keys(msg) + elif msg_type == self.LISTENING_REPLY: + self.parse_listening_reply(msg) + elif msg_type == self.UPDATE_TYPE_FNAME: + self.process_filename_msg(msg) + elif msg_type == self.UPDATE_TYPE_PATCH: + self.process_patch_msg(msg) + elif msg_type == self.UPDATE_TYPE_CHECKSUM: + self.process_checksum_msg(msg) + elif msg_type == self.DELETE_FILE_MSG: + self.process_delete_msg(msg) + elif msg_type == self.MANIFEST_MSG: + self.process_manifest_msg(msg) diff --git a/examples/OTA-lorawan/firmware/1.17.0/flash/watchdog.py b/examples/OTA-lorawan/firmware/1.17.0/flash/watchdog.py new file mode 100644 index 0000000..31d1e24 --- /dev/null +++ b/examples/OTA-lorawan/firmware/1.17.0/flash/watchdog.py @@ -0,0 +1,33 @@ +from machine import Timer +import _thread + +class Watchdog: + + def __init__(self): + self.failed = False + self.acknowledged = 0 + self._alarm = None + self._lock = _thread.allocate_lock() + + def enable(self, timeout = 120): + if self._alarm: + self._alarm.cancel() + self._alarm = None + + self._alarm = Timer.Alarm(self._check, s = timeout, periodic = True) + + def _check(self, alarm): + with self._lock: + if self.acknowledged > 0: + self.failed = False + self.acknowledged = 0 + else: + self.failed = True + + def ack(self): + with self._lock: + self.acknowledged += 1 + + def update_failed(self): + with self._lock: + return self.failed diff --git a/examples/OTA-lorawan/firmware/1.17.1/flash/OTA_INFO.py b/examples/OTA-lorawan/firmware/1.17.1/flash/OTA_INFO.py new file mode 100644 index 0000000..511a76e --- /dev/null +++ b/examples/OTA-lorawan/firmware/1.17.1/flash/OTA_INFO.py @@ -0,0 +1 @@ +1.17.1 diff --git a/examples/OTA-lorawan/firmware/1.17.1/flash/diff_match_patch.py b/examples/OTA-lorawan/firmware/1.17.1/flash/diff_match_patch.py new file mode 100644 index 0000000..494f051 --- /dev/null +++ b/examples/OTA-lorawan/firmware/1.17.1/flash/diff_match_patch.py @@ -0,0 +1,1605 @@ +#!/usr/bin/python2.7 + +#from __future__ import division + +"""Diff Match and Patch +Copyright 2018 The diff-match-patch Authors. +https://github.com/google/diff-match-patch + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +""" + +"""Functions for diff, match and patch. + +Computes the difference between two texts to create a patch. +Applies the patch onto another text, allowing for errors. +""" + +__author__ = 'fraser@google.com (Neil Fraser)' + +import math +import ure +import sys +import time +#import urllib + +class diff_match_patch: + """Class containing the diff, match and patch methods. + + Also contains the behaviour settings. + """ + + def __init__(self): + """Inits a diff_match_patch object with default settings. + Redefine these in your program to override the defaults. + """ + + # Number of seconds to map a diff before giving up (0 for infinity). + self.Diff_Timeout = 1.0 + # Cost of an empty edit operation in terms of edit characters. + self.Diff_EditCost = 4 + # At what point is no match declared (0.0 = perfection, 1.0 = very loose). + self.Match_Threshold = 0.5 + # How far to search for a match (0 = exact location, 1000+ = broad match). + # A match this many characters away from the expected location will add + # 1.0 to the score (0.0 is a perfect match). + self.Match_Distance = 1000 + # When deleting a large block of text (over ~64 characters), how close do + # the contents have to be to match the expected contents. (0.0 = perfection, + # 1.0 = very loose). Note that Match_Threshold controls how closely the + # end points of a delete need to match. + self.Patch_DeleteThreshold = 0.5 + # Chunk size for context length. + self.Patch_Margin = 4 + + # The number of bits in an int. + # Python has no maximum, thus to disable patch splitting set to 0. + # However to avoid long patches in certain pathological cases, use 32. + # Multiple short patches (using native ints) are much faster than long ones. + self.Match_MaxBits = 32 + + self._hexdig = '0123456789ABCDEFabcdef' + self._hextochr = dict((a+b, chr(int(a+b,16))) + for a in self._hexdig for b in self._hexdig) + + # DIFF FUNCTIONS + + # The data structure representing a diff is an array of tuples: + # [(DIFF_DELETE, "Hello"), (DIFF_INSERT, "Goodbye"), (DIFF_EQUAL, " world.")] + # which means: delete "Hello", add "Goodbye" and keep " world." + DIFF_DELETE = -1 + DIFF_INSERT = 1 + DIFF_EQUAL = 0 + + def diff_main(self, text1, text2, checklines=True, deadline=None): + """Find the differences between two texts. Simplifies the problem by + stripping any common prefix or suffix off the texts before diffing. + + Args: + text1: Old string to be diffed. + text2: New string to be diffed. + checklines: Optional speedup flag. If present and false, then don't run + a line-level diff first to identify the changed areas. + Defaults to true, which does a faster, slightly less optimal diff. + deadline: Optional time when the diff should be complete by. Used + internally for recursive calls. Users should set DiffTimeout instead. + + Returns: + Array of changes. + """ + # Set a deadline by which time the diff must be complete. + if deadline == None: + # Unlike in most languages, Python counts time in seconds. + if self.Diff_Timeout <= 0: + deadline = sys.maxsize + else: + deadline = time.time() + self.Diff_Timeout + + # Check for null inputs. + if text1 == None or text2 == None: + raise ValueError("Null inputs. (diff_main)") + + # Check for equality (speedup). + if text1 == text2: + if text1: + return [(self.DIFF_EQUAL, text1)] + return [] + + # Trim off common prefix (speedup). + commonlength = self.diff_commonPrefix(text1, text2) + commonprefix = text1[:commonlength] + text1 = text1[commonlength:] + text2 = text2[commonlength:] + + # Trim off common suffix (speedup). + commonlength = self.diff_commonSuffix(text1, text2) + if commonlength == 0: + commonsuffix = '' + else: + commonsuffix = text1[-commonlength:] + text1 = text1[:-commonlength] + text2 = text2[:-commonlength] + + # Compute the diff on the middle block. + diffs = self.diff_compute(text1, text2, checklines, deadline) + + # Restore the prefix and suffix. + if commonprefix: + diffs[:0] = [(self.DIFF_EQUAL, commonprefix)] + if commonsuffix: + diffs.append((self.DIFF_EQUAL, commonsuffix)) + self.diff_cleanupMerge(diffs) + return diffs + + def diff_compute(self, text1, text2, checklines, deadline): + """Find the differences between two texts. Assumes that the texts do not + have any common prefix or suffix. + + Args: + text1: Old string to be diffed. + text2: New string to be diffed. + checklines: Speedup flag. If false, then don't run a line-level diff + first to identify the changed areas. + If true, then run a faster, slightly less optimal diff. + deadline: Time when the diff should be complete by. + + Returns: + Array of changes. + """ + if not text1: + # Just add some text (speedup). + return [(self.DIFF_INSERT, text2)] + + if not text2: + # Just delete some text (speedup). + return [(self.DIFF_DELETE, text1)] + + if len(text1) > len(text2): + (longtext, shorttext) = (text1, text2) + else: + (shorttext, longtext) = (text1, text2) + i = longtext.find(shorttext) + if i != -1: + # Shorter text is inside the longer text (speedup). + diffs = [(self.DIFF_INSERT, longtext[:i]), (self.DIFF_EQUAL, shorttext), + (self.DIFF_INSERT, longtext[i + len(shorttext):])] + # Swap insertions for deletions if diff is reversed. + if len(text1) > len(text2): + diffs[0] = (self.DIFF_DELETE, diffs[0][1]) + diffs[2] = (self.DIFF_DELETE, diffs[2][1]) + return diffs + + if len(shorttext) == 1: + # Single character string. + # After the previous speedup, the character can't be an equality. + return [(self.DIFF_DELETE, text1), (self.DIFF_INSERT, text2)] + + # Check to see if the problem can be split in two. + hm = self.diff_halfMatch(text1, text2) + if hm: + # A half-match was found, sort out the return data. + (text1_a, text1_b, text2_a, text2_b, mid_common) = hm + # Send both pairs off for separate processing. + diffs_a = self.diff_main(text1_a, text2_a, checklines, deadline) + diffs_b = self.diff_main(text1_b, text2_b, checklines, deadline) + # Merge the results. + return diffs_a + [(self.DIFF_EQUAL, mid_common)] + diffs_b + + if checklines and len(text1) > 100 and len(text2) > 100: + return self.diff_lineMode(text1, text2, deadline) + + return self.diff_bisect(text1, text2, deadline) + + def diff_lineMode(self, text1, text2, deadline): + """Do a quick line-level diff on both strings, then rediff the parts for + greater accuracy. + This speedup can produce non-minimal diffs. + + Args: + text1: Old string to be diffed. + text2: New string to be diffed. + deadline: Time when the diff should be complete by. + + Returns: + Array of changes. + """ + + # Scan the text on a line-by-line basis first. + (text1, text2, linearray) = self.diff_linesToChars(text1, text2) + + diffs = self.diff_main(text1, text2, False, deadline) + + # Convert the diff back to original text. + self.diff_charsToLines(diffs, linearray) + # Eliminate freak matches (e.g. blank lines) + self.diff_cleanupSemantic(diffs) + + # Rediff any replacement blocks, this time character-by-character. + # Add a dummy entry at the end. + diffs.append((self.DIFF_EQUAL, '')) + pointer = 0 + count_delete = 0 + count_insert = 0 + text_delete = '' + text_insert = '' + while pointer < len(diffs): + if diffs[pointer][0] == self.DIFF_INSERT: + count_insert += 1 + text_insert += diffs[pointer][1] + elif diffs[pointer][0] == self.DIFF_DELETE: + count_delete += 1 + text_delete += diffs[pointer][1] + elif diffs[pointer][0] == self.DIFF_EQUAL: + # Upon reaching an equality, check for prior redundancies. + if count_delete >= 1 and count_insert >= 1: + # Delete the offending records and add the merged ones. + a = self.diff_main(text_delete, text_insert, False, deadline) + diffs[pointer - count_delete - count_insert : pointer] = a + pointer = pointer - count_delete - count_insert + len(a) + count_insert = 0 + count_delete = 0 + text_delete = '' + text_insert = '' + + pointer += 1 + + diffs.pop() # Remove the dummy entry at the end. + + return diffs + + def diff_bisect(self, text1, text2, deadline): + """Find the 'middle snake' of a diff, split the problem in two + and return the recursively constructed diff. + See Myers 1986 paper: An O(ND) Difference Algorithm and Its Variations. + + Args: + text1: Old string to be diffed. + text2: New string to be diffed. + deadline: Time at which to bail if not yet complete. + + Returns: + Array of diff tuples. + """ + + # Cache the text lengths to prevent multiple calls. + text1_length = len(text1) + text2_length = len(text2) + max_d = (text1_length + text2_length + 1) // 2 + v_offset = max_d + v_length = 2 * max_d + v1 = [-1] * v_length + v1[v_offset + 1] = 0 + v2 = v1[:] + delta = text1_length - text2_length + # If the total number of characters is odd, then the front path will + # collide with the reverse path. + front = (delta % 2 != 0) + # Offsets for start and end of k loop. + # Prevents mapping of space beyond the grid. + k1start = 0 + k1end = 0 + k2start = 0 + k2end = 0 + for d in range(max_d): + # Bail out if deadline is reached. + if time.time() > deadline: + break + + # Walk the front path one step. + for k1 in range(-d + k1start, d + 1 - k1end, 2): + k1_offset = v_offset + k1 + if k1 == -d or (k1 != d and + v1[k1_offset - 1] < v1[k1_offset + 1]): + x1 = v1[k1_offset + 1] + else: + x1 = v1[k1_offset - 1] + 1 + y1 = x1 - k1 + while (x1 < text1_length and y1 < text2_length and + text1[x1] == text2[y1]): + x1 += 1 + y1 += 1 + v1[k1_offset] = x1 + if x1 > text1_length: + # Ran off the right of the graph. + k1end += 2 + elif y1 > text2_length: + # Ran off the bottom of the graph. + k1start += 2 + elif front: + k2_offset = v_offset + delta - k1 + if k2_offset >= 0 and k2_offset < v_length and v2[k2_offset] != -1: + # Mirror x2 onto top-left coordinate system. + x2 = text1_length - v2[k2_offset] + if x1 >= x2: + # Overlap detected. + return self.diff_bisectSplit(text1, text2, x1, y1, deadline) + + # Walk the reverse path one step. + for k2 in range(-d + k2start, d + 1 - k2end, 2): + k2_offset = v_offset + k2 + if k2 == -d or (k2 != d and + v2[k2_offset - 1] < v2[k2_offset + 1]): + x2 = v2[k2_offset + 1] + else: + x2 = v2[k2_offset - 1] + 1 + y2 = x2 - k2 + while (x2 < text1_length and y2 < text2_length and + text1[-x2 - 1] == text2[-y2 - 1]): + x2 += 1 + y2 += 1 + v2[k2_offset] = x2 + if x2 > text1_length: + # Ran off the left of the graph. + k2end += 2 + elif y2 > text2_length: + # Ran off the top of the graph. + k2start += 2 + elif not front: + k1_offset = v_offset + delta - k2 + if k1_offset >= 0 and k1_offset < v_length and v1[k1_offset] != -1: + x1 = v1[k1_offset] + y1 = v_offset + x1 - k1_offset + # Mirror x2 onto top-left coordinate system. + x2 = text1_length - x2 + if x1 >= x2: + # Overlap detected. + return self.diff_bisectSplit(text1, text2, x1, y1, deadline) + + # Diff took too long and hit the deadline or + # number of diffs equals number of characters, no commonality at all. + return [(self.DIFF_DELETE, text1), (self.DIFF_INSERT, text2)] + + def diff_bisectSplit(self, text1, text2, x, y, deadline): + """Given the location of the 'middle snake', split the diff in two parts + and recurse. + + Args: + text1: Old string to be diffed. + text2: New string to be diffed. + x: Index of split point in text1. + y: Index of split point in text2. + deadline: Time at which to bail if not yet complete. + + Returns: + Array of diff tuples. + """ + text1a = text1[:x] + text2a = text2[:y] + text1b = text1[x:] + text2b = text2[y:] + + # Compute both diffs serially. + diffs = self.diff_main(text1a, text2a, False, deadline) + diffsb = self.diff_main(text1b, text2b, False, deadline) + + return diffs + diffsb + + def diff_linesToChars(self, text1, text2): + """Split two texts into an array of strings. Reduce the texts to a string + of hashes where each Unicode character represents one line. + + Args: + text1: First string. + text2: Second string. + + Returns: + Three element tuple, containing the encoded text1, the encoded text2 and + the array of unique strings. The zeroth element of the array of unique + strings is intentionally blank. + """ + lineArray = [] # e.g. lineArray[4] == "Hello\n" + lineHash = {} # e.g. lineHash["Hello\n"] == 4 + + # "\x00" is a valid character, but various debuggers don't like it. + # So we'll insert a junk entry to avoid generating a null character. + lineArray.append('') + + def diff_linesToCharsMunge(text): + """Split a text into an array of strings. Reduce the texts to a string + of hashes where each Unicode character represents one line. + Modifies linearray and linehash through being a closure. + + Args: + text: String to encode. + + Returns: + Encoded string. + """ + chars = [] + # Walk the text, pulling out a substring for each line. + # text.split('\n') would would temporarily double our memory footprint. + # Modifying text would create many large strings to garbage collect. + lineStart = 0 + lineEnd = -1 + while lineEnd < len(text) - 1: + lineEnd = text.find('\n', lineStart) + if lineEnd == -1: + lineEnd = len(text) - 1 + line = text[lineStart:lineEnd + 1] + + if line in lineHash: + chars.append(chr(lineHash[line])) + else: + if len(lineArray) == maxLines: + # Bail out at 65535 because unichr(65536) throws. - not in micropython + line = text[lineStart:] + lineEnd = len(text) + lineArray.append(line) + lineHash[line] = len(lineArray) - 1 + chars.append(chr(len(lineArray) - 1)) + lineStart = lineEnd + 1 + return "".join(chars) + + # Allocate 2/3rds of the space for text1, the rest for text2. + maxLines = 40000 + chars1 = diff_linesToCharsMunge(text1) + maxLines = 65535 + chars2 = diff_linesToCharsMunge(text2) + return (chars1, chars2, lineArray) + + def diff_charsToLines(self, diffs, lineArray): + """Rehydrate the text in a diff from a string of line hashes to real lines + of text. + + Args: + diffs: Array of diff tuples. + lineArray: Array of unique strings. + """ + for x in range(len(diffs)): + text = [] + for char in diffs[x][1]: + text.append(lineArray[ord(char)]) + diffs[x] = (diffs[x][0], "".join(text)) + + def diff_commonPrefix(self, text1, text2): + """Determine the common prefix of two strings. + + Args: + text1: First string. + text2: Second string. + + Returns: + The number of characters common to the start of each string. + """ + # Quick check for common null cases. + if not text1 or not text2 or text1[0] != text2[0]: + return 0 + # Binary search. + # Performance analysis: http://neil.fraser.name/news/2007/10/09/ + pointermin = 0 + pointermax = min(len(text1), len(text2)) + pointermid = pointermax + pointerstart = 0 + while pointermin < pointermid: + if text1[pointerstart:pointermid] == text2[pointerstart:pointermid]: + pointermin = pointermid + pointerstart = pointermin + else: + pointermax = pointermid + pointermid = (pointermax - pointermin) // 2 + pointermin + return pointermid + + def diff_commonSuffix(self, text1, text2): + """Determine the common suffix of two strings. + + Args: + text1: First string. + text2: Second string. + + Returns: + The number of characters common to the end of each string. + """ + # Quick check for common null cases. + if not text1 or not text2 or text1[-1] != text2[-1]: + return 0 + # Binary search. + # Performance analysis: http://neil.fraser.name/news/2007/10/09/ + pointermin = 0 + pointermax = min(len(text1), len(text2)) + pointermid = pointermax + pointerend = 0 + while pointermin < pointermid: + if (text1[-pointermid:len(text1) - pointerend] == + text2[-pointermid:len(text2) - pointerend]): + pointermin = pointermid + pointerend = pointermin + else: + pointermax = pointermid + pointermid = (pointermax - pointermin) // 2 + pointermin + return pointermid + + def diff_commonOverlap(self, text1, text2): + """Determine if the suffix of one string is the prefix of another. + + Args: + text1 First string. + text2 Second string. + + Returns: + The number of characters common to the end of the first + string and the start of the second string. + """ + # Cache the text lengths to prevent multiple calls. + text1_length = len(text1) + text2_length = len(text2) + # Eliminate the null case. + if text1_length == 0 or text2_length == 0: + return 0 + # Truncate the longer string. + if text1_length > text2_length: + text1 = text1[-text2_length:] + elif text1_length < text2_length: + text2 = text2[:text1_length] + text_length = min(text1_length, text2_length) + # Quick check for the worst case. + if text1 == text2: + return text_length + + # Start by looking for a single character match + # and increase length until no match is found. + # Performance analysis: http://neil.fraser.name/news/2010/11/04/ + best = 0 + length = 1 + while True: + pattern = text1[-length:] + found = text2.find(pattern) + if found == -1: + return best + length += found + if found == 0 or text1[-length:] == text2[:length]: + best = length + length += 1 + + def diff_halfMatch(self, text1, text2): + """Do the two texts share a substring which is at least half the length of + the longer text? + This speedup can produce non-minimal diffs. + + Args: + text1: First string. + text2: Second string. + + Returns: + Five element Array, containing the prefix of text1, the suffix of text1, + the prefix of text2, the suffix of text2 and the common middle. Or None + if there was no match. + """ + if self.Diff_Timeout <= 0: + # Don't risk returning a non-optimal diff if we have unlimited time. + return None + if len(text1) > len(text2): + (longtext, shorttext) = (text1, text2) + else: + (shorttext, longtext) = (text1, text2) + if len(longtext) < 4 or len(shorttext) * 2 < len(longtext): + return None # Pointless. + + def diff_halfMatchI(longtext, shorttext, i): + """Does a substring of shorttext exist within longtext such that the + substring is at least half the length of longtext? + Closure, but does not reference any external variables. + + Args: + longtext: Longer string. + shorttext: Shorter string. + i: Start index of quarter length substring within longtext. + + Returns: + Five element Array, containing the prefix of longtext, the suffix of + longtext, the prefix of shorttext, the suffix of shorttext and the + common middle. Or None if there was no match. + """ + seed = longtext[i:i + len(longtext) // 4] + best_common = '' + j = shorttext.find(seed) + while j != -1: + prefixLength = self.diff_commonPrefix(longtext[i:], shorttext[j:]) + suffixLength = self.diff_commonSuffix(longtext[:i], shorttext[:j]) + if len(best_common) < suffixLength + prefixLength: + best_common = (shorttext[j - suffixLength:j] + + shorttext[j:j + prefixLength]) + best_longtext_a = longtext[:i - suffixLength] + best_longtext_b = longtext[i + prefixLength:] + best_shorttext_a = shorttext[:j - suffixLength] + best_shorttext_b = shorttext[j + prefixLength:] + j = shorttext.find(seed, j + 1) + + if len(best_common) * 2 >= len(longtext): + return (best_longtext_a, best_longtext_b, + best_shorttext_a, best_shorttext_b, best_common) + else: + return None + + # First check if the second quarter is the seed for a half-match. + hm1 = diff_halfMatchI(longtext, shorttext, (len(longtext) + 3) // 4) + # Check again based on the third quarter. + hm2 = diff_halfMatchI(longtext, shorttext, (len(longtext) + 1) // 2) + if not hm1 and not hm2: + return None + elif not hm2: + hm = hm1 + elif not hm1: + hm = hm2 + else: + # Both matched. Select the longest. + if len(hm1[4]) > len(hm2[4]): + hm = hm1 + else: + hm = hm2 + + # A half-match was found, sort out the return data. + if len(text1) > len(text2): + (text1_a, text1_b, text2_a, text2_b, mid_common) = hm + else: + (text2_a, text2_b, text1_a, text1_b, mid_common) = hm + return (text1_a, text1_b, text2_a, text2_b, mid_common) + + def diff_cleanupSemantic(self, diffs): + """Reduce the number of edits by eliminating semantically trivial + equalities. + + Args: + diffs: Array of diff tuples. + """ + changes = False + equalities = [] # Stack of indices where equalities are found. + lastequality = None # Always equal to diffs[equalities[-1]][1] + pointer = 0 # Index of current position. + # Number of chars that changed prior to the equality. + length_insertions1, length_deletions1 = 0, 0 + # Number of chars that changed after the equality. + length_insertions2, length_deletions2 = 0, 0 + while pointer < len(diffs): + if diffs[pointer][0] == self.DIFF_EQUAL: # Equality found. + equalities.append(pointer) + length_insertions1, length_insertions2 = length_insertions2, 0 + length_deletions1, length_deletions2 = length_deletions2, 0 + lastequality = diffs[pointer][1] + else: # An insertion or deletion. + if diffs[pointer][0] == self.DIFF_INSERT: + length_insertions2 += len(diffs[pointer][1]) + else: + length_deletions2 += len(diffs[pointer][1]) + # Eliminate an equality that is smaller or equal to the edits on both + # sides of it. + if (lastequality and (len(lastequality) <= + max(length_insertions1, length_deletions1)) and + (len(lastequality) <= max(length_insertions2, length_deletions2))): + # Duplicate record. + diffs.insert(equalities[-1], (self.DIFF_DELETE, lastequality)) + # Change second copy to insert. + diffs[equalities[-1] + 1] = (self.DIFF_INSERT, + diffs[equalities[-1] + 1][1]) + # Throw away the equality we just deleted. + equalities.pop() + # Throw away the previous equality (it needs to be reevaluated). + if len(equalities): + equalities.pop() + if len(equalities): + pointer = equalities[-1] + else: + pointer = -1 + # Reset the counters. + length_insertions1, length_deletions1 = 0, 0 + length_insertions2, length_deletions2 = 0, 0 + lastequality = None + changes = True + pointer += 1 + + # Normalize the diff. + if changes: + self.diff_cleanupMerge(diffs) + self.diff_cleanupSemanticLossless(diffs) + + # Find any overlaps between deletions and insertions. + # e.g: abcxxxxxxdef + # -> abcxxxdef + # e.g: xxxabcdefxxx + # -> defxxxabc + # Only extract an overlap if it is as big as the edit ahead or behind it. + pointer = 1 + while pointer < len(diffs): + if (diffs[pointer - 1][0] == self.DIFF_DELETE and + diffs[pointer][0] == self.DIFF_INSERT): + deletion = diffs[pointer - 1][1] + insertion = diffs[pointer][1] + overlap_length1 = self.diff_commonOverlap(deletion, insertion) + overlap_length2 = self.diff_commonOverlap(insertion, deletion) + if overlap_length1 >= overlap_length2: + if (overlap_length1 >= len(deletion) / 2.0 or + overlap_length1 >= len(insertion) / 2.0): + # Overlap found. Insert an equality and trim the surrounding edits. + diffs.insert(pointer, (self.DIFF_EQUAL, + insertion[:overlap_length1])) + diffs[pointer - 1] = (self.DIFF_DELETE, + deletion[:len(deletion) - overlap_length1]) + diffs[pointer + 1] = (self.DIFF_INSERT, + insertion[overlap_length1:]) + pointer += 1 + else: + if (overlap_length2 >= len(deletion) / 2.0 or + overlap_length2 >= len(insertion) / 2.0): + # Reverse overlap found. + # Insert an equality and swap and trim the surrounding edits. + diffs.insert(pointer, (self.DIFF_EQUAL, deletion[:overlap_length2])) + diffs[pointer - 1] = (self.DIFF_INSERT, + insertion[:len(insertion) - overlap_length2]) + diffs[pointer + 1] = (self.DIFF_DELETE, deletion[overlap_length2:]) + pointer += 1 + pointer += 1 + pointer += 1 + + def diff_cleanupSemanticLossless(self, diffs): + """Look for single edits surrounded on both sides by equalities + which can be shifted sideways to align the edit to a word boundary. + e.g: The cat came. -> The cat came. + + Args: + diffs: Array of diff tuples. + """ + + def diff_cleanupSemanticScore(one, two): + """Given two strings, compute a score representing whether the + internal boundary falls on logical boundaries. + Scores range from 6 (best) to 0 (worst). + Closure, but does not reference any external variables. + + Args: + one: First string. + two: Second string. + + Returns: + The score. + """ + if not one or not two: + # Edges are the best. + return 6 + + # Each port of this function behaves slightly differently due to + # subtle differences in each language's definition of things like + # 'whitespace'. Since this function's purpose is largely cosmetic, + # the choice has been made to use each language's native features + # rather than force total conformity. + char1 = one[-1] + char2 = two[0] + nonAlphaNumeric1 = not char1.isalpha() + nonAlphaNumeric2 = not char2.isalpha() + whitespace1 = nonAlphaNumeric1 and char1.isspace() + whitespace2 = nonAlphaNumeric2 and char2.isspace() + lineBreak1 = whitespace1 and (char1 == "\r" or char1 == "\n") + lineBreak2 = whitespace2 and (char2 == "\r" or char2 == "\n") + blankLine1 = lineBreak1 and self.BLANKLINEEND.search(one) + blankLine2 = lineBreak2 and self.BLANKLINESTART.match(two) + + if blankLine1 or blankLine2: + # Five points for blank lines. + return 5 + elif lineBreak1 or lineBreak2: + # Four points for line breaks. + return 4 + elif nonAlphaNumeric1 and not whitespace1 and whitespace2: + # Three points for end of sentences. + return 3 + elif whitespace1 or whitespace2: + # Two points for whitespace. + return 2 + elif nonAlphaNumeric1 or nonAlphaNumeric2: + # One point for non-alphanumeric. + return 1 + return 0 + + pointer = 1 + # Intentionally ignore the first and last element (don't need checking). + while pointer < len(diffs) - 1: + if (diffs[pointer - 1][0] == self.DIFF_EQUAL and + diffs[pointer + 1][0] == self.DIFF_EQUAL): + # This is a single edit surrounded by equalities. + equality1 = diffs[pointer - 1][1] + edit = diffs[pointer][1] + equality2 = diffs[pointer + 1][1] + + # First, shift the edit as far left as possible. + commonOffset = self.diff_commonSuffix(equality1, edit) + if commonOffset: + commonString = edit[-commonOffset:] + equality1 = equality1[:-commonOffset] + edit = commonString + edit[:-commonOffset] + equality2 = commonString + equality2 + + # Second, step character by character right, looking for the best fit. + bestEquality1 = equality1 + bestEdit = edit + bestEquality2 = equality2 + bestScore = (diff_cleanupSemanticScore(equality1, edit) + + diff_cleanupSemanticScore(edit, equality2)) + while edit and equality2 and edit[0] == equality2[0]: + equality1 += edit[0] + edit = edit[1:] + equality2[0] + equality2 = equality2[1:] + score = (diff_cleanupSemanticScore(equality1, edit) + + diff_cleanupSemanticScore(edit, equality2)) + # The >= encourages trailing rather than leading whitespace on edits. + if score >= bestScore: + bestScore = score + bestEquality1 = equality1 + bestEdit = edit + bestEquality2 = equality2 + + if diffs[pointer - 1][1] != bestEquality1: + # We have an improvement, save it back to the diff. + if bestEquality1: + diffs[pointer - 1] = (diffs[pointer - 1][0], bestEquality1) + else: + del diffs[pointer - 1] + pointer -= 1 + diffs[pointer] = (diffs[pointer][0], bestEdit) + if bestEquality2: + diffs[pointer + 1] = (diffs[pointer + 1][0], bestEquality2) + else: + del diffs[pointer + 1] + pointer -= 1 + pointer += 1 + + # Define some regex patterns for matching boundaries. + BLANKLINEEND = ure.compile(r"\n\r?\n$"); + BLANKLINESTART = ure.compile(r"^\r?\n\r?\n"); + + def diff_cleanupMerge(self, diffs): + """Reorder and merge like edit sections. Merge equalities. + Any edit section can move as long as it doesn't cross an equality. + + Args: + diffs: Array of diff tuples. + """ + diffs.append((self.DIFF_EQUAL, '')) # Add a dummy entry at the end. + pointer = 0 + count_delete = 0 + count_insert = 0 + text_delete = '' + text_insert = '' + while pointer < len(diffs): + if diffs[pointer][0] == self.DIFF_INSERT: + count_insert += 1 + text_insert += diffs[pointer][1] + pointer += 1 + elif diffs[pointer][0] == self.DIFF_DELETE: + count_delete += 1 + text_delete += diffs[pointer][1] + pointer += 1 + elif diffs[pointer][0] == self.DIFF_EQUAL: + # Upon reaching an equality, check for prior redundancies. + if count_delete + count_insert > 1: + if count_delete != 0 and count_insert != 0: + # Factor out any common prefixies. + commonlength = self.diff_commonPrefix(text_insert, text_delete) + if commonlength != 0: + x = pointer - count_delete - count_insert - 1 + if x >= 0 and diffs[x][0] == self.DIFF_EQUAL: + diffs[x] = (diffs[x][0], diffs[x][1] + + text_insert[:commonlength]) + else: + diffs.insert(0, (self.DIFF_EQUAL, text_insert[:commonlength])) + pointer += 1 + text_insert = text_insert[commonlength:] + text_delete = text_delete[commonlength:] + # Factor out any common suffixies. + commonlength = self.diff_commonSuffix(text_insert, text_delete) + if commonlength != 0: + diffs[pointer] = (diffs[pointer][0], text_insert[-commonlength:] + + diffs[pointer][1]) + text_insert = text_insert[:-commonlength] + text_delete = text_delete[:-commonlength] + # Delete the offending records and add the merged ones. + if count_delete == 0: + diffs[pointer - count_insert : pointer] = [ + (self.DIFF_INSERT, text_insert)] + elif count_insert == 0: + diffs[pointer - count_delete : pointer] = [ + (self.DIFF_DELETE, text_delete)] + else: + diffs[pointer - count_delete - count_insert : pointer] = [ + (self.DIFF_DELETE, text_delete), + (self.DIFF_INSERT, text_insert)] + pointer = pointer - count_delete - count_insert + 1 + if count_delete != 0: + pointer += 1 + if count_insert != 0: + pointer += 1 + elif pointer != 0 and diffs[pointer - 1][0] == self.DIFF_EQUAL: + # Merge this equality with the previous one. + diffs[pointer - 1] = (diffs[pointer - 1][0], + diffs[pointer - 1][1] + diffs[pointer][1]) + del diffs[pointer] + else: + pointer += 1 + + count_insert = 0 + count_delete = 0 + text_delete = '' + text_insert = '' + + if diffs[-1][1] == '': + diffs.pop() # Remove the dummy entry at the end. + + # Second pass: look for single edits surrounded on both sides by equalities + # which can be shifted sideways to eliminate an equality. + # e.g: ABAC -> ABAC + changes = False + pointer = 1 + # Intentionally ignore the first and last element (don't need checking). + while pointer < len(diffs) - 1: + if (diffs[pointer - 1][0] == self.DIFF_EQUAL and + diffs[pointer + 1][0] == self.DIFF_EQUAL): + # This is a single edit surrounded by equalities. + if diffs[pointer][1].endswith(diffs[pointer - 1][1]): + # Shift the edit over the previous equality. + diffs[pointer] = (diffs[pointer][0], + diffs[pointer - 1][1] + + diffs[pointer][1][:-len(diffs[pointer - 1][1])]) + diffs[pointer + 1] = (diffs[pointer + 1][0], + diffs[pointer - 1][1] + diffs[pointer + 1][1]) + del diffs[pointer - 1] + changes = True + elif diffs[pointer][1].startswith(diffs[pointer + 1][1]): + # Shift the edit over the next equality. + diffs[pointer - 1] = (diffs[pointer - 1][0], + diffs[pointer - 1][1] + diffs[pointer + 1][1]) + diffs[pointer] = (diffs[pointer][0], + diffs[pointer][1][len(diffs[pointer + 1][1]):] + + diffs[pointer + 1][1]) + del diffs[pointer + 1] + changes = True + pointer += 1 + + # If shifts were made, the diff needs reordering and another shift sweep. + if changes: + self.diff_cleanupMerge(diffs) + + def diff_xIndex(self, diffs, loc): + """loc is a location in text1, compute and return the equivalent location + in text2. e.g. "The cat" vs "The big cat", 1->1, 5->8 + + Args: + diffs: Array of diff tuples. + loc: Location within text1. + + Returns: + Location within text2. + """ + chars1 = 0 + chars2 = 0 + last_chars1 = 0 + last_chars2 = 0 + for x in range(len(diffs)): + (op, text) = diffs[x] + if op != self.DIFF_INSERT: # Equality or deletion. + chars1 += len(text) + if op != self.DIFF_DELETE: # Equality or insertion. + chars2 += len(text) + if chars1 > loc: # Overshot the location. + break + last_chars1 = chars1 + last_chars2 = chars2 + + if len(diffs) != x and diffs[x][0] == self.DIFF_DELETE: + # The location was deleted. + return last_chars2 + # Add the remaining len(character). + return last_chars2 + (loc - last_chars1) + + def diff_text1(self, diffs): + """Compute and return the source text (all equalities and deletions). + + Args: + diffs: Array of diff tuples. + + Returns: + Source text. + """ + text = [] + for (op, data) in diffs: + if op != self.DIFF_INSERT: + text.append(data) + return "".join(text) + + def diff_text2(self, diffs): + """Compute and return the destination text (all equalities and insertions). + + Args: + diffs: Array of diff tuples. + + Returns: + Destination text. + """ + text = [] + for (op, data) in diffs: + if op != self.DIFF_DELETE: + text.append(data) + return "".join(text) + + def diff_levenshtein(self, diffs): + """Compute the Levenshtein distance; the number of inserted, deleted or + substituted characters. + + Args: + diffs: Array of diff tuples. + + Returns: + Number of changes. + """ + levenshtein = 0 + insertions = 0 + deletions = 0 + for (op, data) in diffs: + if op == self.DIFF_INSERT: + insertions += len(data) + elif op == self.DIFF_DELETE: + deletions += len(data) + elif op == self.DIFF_EQUAL: + # A deletion and an insertion is one substitution. + levenshtein += max(insertions, deletions) + insertions = 0 + deletions = 0 + levenshtein += max(insertions, deletions) + return levenshtein + + # MATCH FUNCTIONS + + def match_main(self, text, pattern, loc): + """Locate the best instance of 'pattern' in 'text' near 'loc'. + + Args: + text: The text to search. + pattern: The pattern to search for. + loc: The location to search around. + + Returns: + Best match index or -1. + """ + # Check for null inputs. + if text == None or pattern == None: + raise ValueError("Null inputs. (match_main)") + + loc = max(0, min(loc, len(text))) + if text == pattern: + # Shortcut (potentially not guaranteed by the algorithm) + return 0 + elif not text: + # Nothing to match. + return -1 + elif text[loc:loc + len(pattern)] == pattern: + # Perfect match at the perfect spot! (Includes case of null pattern) + return loc + else: + # Do a fuzzy compare. + match = self.match_bitap(text, pattern, loc) + return match + + def match_bitap(self, text, pattern, loc): + """Locate the best instance of 'pattern' in 'text' near 'loc' using the + Bitap algorithm. + + Args: + text: The text to search. + pattern: The pattern to search for. + loc: The location to search around. + + Returns: + Best match index or -1. + """ + # Python doesn't have a maxint limit, so ignore this check. + #if self.Match_MaxBits != 0 and len(pattern) > self.Match_MaxBits: + # raise ValueError("Pattern too long for this application.") + + # Initialise the alphabet. + s = self.match_alphabet(pattern) + + def match_bitapScore(e, x): + """Compute and return the score for a match with e errors and x location. + Accesses loc and pattern through being a closure. + + Args: + e: Number of errors in match. + x: Location of match. + + Returns: + Overall score for match (0.0 = good, 1.0 = bad). + """ + accuracy = float(e) / len(pattern) + proximity = abs(loc - x) + if not self.Match_Distance: + # Dodge divide by zero error. + return proximity and 1.0 or accuracy + return accuracy + (proximity / float(self.Match_Distance)) + + # Highest score beyond which we give up. + score_threshold = self.Match_Threshold + # Is there a nearby exact match? (speedup) + best_loc = text.find(pattern, loc) + if best_loc != -1: + score_threshold = min(match_bitapScore(0, best_loc), score_threshold) + # What about in the other direction? (speedup) + best_loc = text.rfind(pattern, loc + len(pattern)) + if best_loc != -1: + score_threshold = min(match_bitapScore(0, best_loc), score_threshold) + + # Initialise the bit arrays. + matchmask = 1 << (len(pattern) - 1) + best_loc = -1 + + bin_max = len(pattern) + len(text) + # Empty initialization added to appease pychecker. + last_rd = None + for d in range(len(pattern)): + # Scan for the best match each iteration allows for one more error. + # Run a binary search to determine how far from 'loc' we can stray at + # this error level. + bin_min = 0 + bin_mid = bin_max + while bin_min < bin_mid: + if match_bitapScore(d, loc + bin_mid) <= score_threshold: + bin_min = bin_mid + else: + bin_max = bin_mid + bin_mid = (bin_max - bin_min) // 2 + bin_min + + # Use the result from this iteration as the maximum for the next. + bin_max = bin_mid + start = max(1, loc - bin_mid + 1) + finish = min(loc + bin_mid, len(text)) + len(pattern) + + rd = [0] * (finish + 2) + rd[finish + 1] = (1 << d) - 1 + for j in range(finish, start - 1, -1): + if len(text) <= j - 1: + # Out of range. + charMatch = 0 + else: + charMatch = s.get(text[j - 1], 0) + if d == 0: # First pass: exact match. + rd[j] = ((rd[j + 1] << 1) | 1) & charMatch + else: # Subsequent passes: fuzzy match. + rd[j] = (((rd[j + 1] << 1) | 1) & charMatch) | ( + ((last_rd[j + 1] | last_rd[j]) << 1) | 1) | last_rd[j + 1] + if rd[j] & matchmask: + score = match_bitapScore(d, j - 1) + # This match will almost certainly be better than any existing match. + # But check anyway. + if score <= score_threshold: + # Told you so. + score_threshold = score + best_loc = j - 1 + if best_loc > loc: + # When passing loc, don't exceed our current distance from loc. + start = max(1, 2 * loc - best_loc) + else: + # Already passed loc, downhill from here on in. + break + # No hope for a (better) match at greater error levels. + if match_bitapScore(d + 1, loc) > score_threshold: + break + last_rd = rd + return best_loc + + def match_alphabet(self, pattern): + """Initialise the alphabet for the Bitap algorithm. + + Args: + pattern: The text to encode. + + Returns: + Hash of character locations. + """ + s = {} + for char in pattern: + s[char] = 0 + for i in range(len(pattern)): + s[pattern[i]] |= 1 << (len(pattern) - i - 1) + return s + + # PATCH FUNCTIONS + def patch_deepCopy(self, patches): + """Given an array of patches, return another array that is identical. + + Args: + patches: Array of Patch objects. + + Returns: + Array of Patch objects. + """ + patchesCopy = [] + for patch in patches: + patchCopy = patch_obj() + # No need to deep copy the tuples since they are immutable. + patchCopy.diffs = patch.diffs[:] + patchCopy.start1 = patch.start1 + patchCopy.start2 = patch.start2 + patchCopy.length1 = patch.length1 + patchCopy.length2 = patch.length2 + patchesCopy.append(patchCopy) + return patchesCopy + + def patch_apply(self, patches, text): + """Merge a set of patches onto the text. Return a patched text, as well + as a list of true/false values indicating which patches were applied. + + Args: + patches: Array of Patch objects. + text: Old text. + + Returns: + Two element Array, containing the new text and an array of boolean values. + """ + if not patches: + return (text, []) + + # Deep copy the patches so that no changes are made to originals. + patches = self.patch_deepCopy(patches) + + nullPadding = self.patch_addPadding(patches) + text = nullPadding + text + nullPadding + self.patch_splitMax(patches) + + # delta keeps track of the offset between the expected and actual location + # of the previous patch. If there are patches expected at positions 10 and + # 20, but the first patch was found at 12, delta is 2 and the second patch + # has an effective expected position of 22. + delta = 0 + results = [] + for patch in patches: + expected_loc = patch.start2 + delta + text1 = self.diff_text1(patch.diffs) + end_loc = -1 + if len(text1) > self.Match_MaxBits: + # patch_splitMax will only provide an oversized pattern in the case of + # a monster delete. + start_loc = self.match_main(text, text1[:self.Match_MaxBits], + expected_loc) + if start_loc != -1: + end_loc = self.match_main(text, text1[-self.Match_MaxBits:], + expected_loc + len(text1) - self.Match_MaxBits) + if end_loc == -1 or start_loc >= end_loc: + # Can't find valid trailing context. Drop this patch. + start_loc = -1 + else: + start_loc = self.match_main(text, text1, expected_loc) + if start_loc == -1: + # No match found. :( + results.append(False) + # Subtract the delta for this failed patch from subsequent patches. + delta -= patch.length2 - patch.length1 + else: + # Found a match. :) + results.append(True) + delta = start_loc - expected_loc + if end_loc == -1: + text2 = text[start_loc : start_loc + len(text1)] + else: + text2 = text[start_loc : end_loc + self.Match_MaxBits] + if text1 == text2: + # Perfect match, just shove the replacement text in. + text = (text[:start_loc] + self.diff_text2(patch.diffs) + + text[start_loc + len(text1):]) + else: + # Imperfect match. + # Run a diff to get a framework of equivalent indices. + diffs = self.diff_main(text1, text2, False) + if (len(text1) > self.Match_MaxBits and + self.diff_levenshtein(diffs) / float(len(text1)) > + self.Patch_DeleteThreshold): + # The end points match, but the content is unacceptably bad. + results[-1] = False + else: + self.diff_cleanupSemanticLossless(diffs) + index1 = 0 + for (op, data) in patch.diffs: + if op != self.DIFF_EQUAL: + index2 = self.diff_xIndex(diffs, index1) + if op == self.DIFF_INSERT: # Insertion + text = text[:start_loc + index2] + data + text[start_loc + + index2:] + elif op == self.DIFF_DELETE: # Deletion + text = text[:start_loc + index2] + text[start_loc + + self.diff_xIndex(diffs, index1 + len(data)):] + if op != self.DIFF_DELETE: + index1 += len(data) + # Strip the padding off. + text = text[len(nullPadding):-len(nullPadding)] + return (text, results) + + def patch_addPadding(self, patches): + """Add some padding on text start and end so that edges can match + something. Intended to be called only from within patch_apply. + + Args: + patches: Array of Patch objects. + + Returns: + The padding string added to each side. + """ + paddingLength = self.Patch_Margin + nullPadding = "" + for x in range(1, paddingLength + 1): + nullPadding += chr(x) + + # Bump all the patches forward. + for patch in patches: + patch.start1 += paddingLength + patch.start2 += paddingLength + + # Add some padding on start of first diff. + patch = patches[0] + diffs = patch.diffs + if not diffs or diffs[0][0] != self.DIFF_EQUAL: + # Add nullPadding equality. + diffs.insert(0, (self.DIFF_EQUAL, nullPadding)) + patch.start1 -= paddingLength # Should be 0. + patch.start2 -= paddingLength # Should be 0. + patch.length1 += paddingLength + patch.length2 += paddingLength + elif paddingLength > len(diffs[0][1]): + # Grow first equality. + extraLength = paddingLength - len(diffs[0][1]) + newText = nullPadding[len(diffs[0][1]):] + diffs[0][1] + diffs[0] = (diffs[0][0], newText) + patch.start1 -= extraLength + patch.start2 -= extraLength + patch.length1 += extraLength + patch.length2 += extraLength + + # Add some padding on end of last diff. + patch = patches[-1] + diffs = patch.diffs + if not diffs or diffs[-1][0] != self.DIFF_EQUAL: + # Add nullPadding equality. + diffs.append((self.DIFF_EQUAL, nullPadding)) + patch.length1 += paddingLength + patch.length2 += paddingLength + elif paddingLength > len(diffs[-1][1]): + # Grow last equality. + extraLength = paddingLength - len(diffs[-1][1]) + newText = diffs[-1][1] + nullPadding[:extraLength] + diffs[-1] = (diffs[-1][0], newText) + patch.length1 += extraLength + patch.length2 += extraLength + + return nullPadding + + def patch_splitMax(self, patches): + """Look through the patches and break up any which are longer than the + maximum limit of the match algorithm. + Intended to be called only from within patch_apply. + + Args: + patches: Array of Patch objects. + """ + patch_size = self.Match_MaxBits + if patch_size == 0: + # Python has the option of not splitting strings due to its ability + # to handle integers of arbitrary precision. + return + for x in range(len(patches)): + if patches[x].length1 <= patch_size: + continue + bigpatch = patches[x] + # Remove the big old patch. + del patches[x] + x -= 1 + start1 = bigpatch.start1 + start2 = bigpatch.start2 + precontext = '' + while len(bigpatch.diffs) != 0: + # Create one of several smaller patches. + patch = patch_obj() + empty = True + patch.start1 = start1 - len(precontext) + patch.start2 = start2 - len(precontext) + if precontext: + patch.length1 = patch.length2 = len(precontext) + patch.diffs.append((self.DIFF_EQUAL, precontext)) + + while (len(bigpatch.diffs) != 0 and + patch.length1 < patch_size - self.Patch_Margin): + (diff_type, diff_text) = bigpatch.diffs[0] + if diff_type == self.DIFF_INSERT: + # Insertions are harmless. + patch.length2 += len(diff_text) + start2 += len(diff_text) + patch.diffs.append(bigpatch.diffs.pop(0)) + empty = False + elif (diff_type == self.DIFF_DELETE and len(patch.diffs) == 1 and + patch.diffs[0][0] == self.DIFF_EQUAL and + len(diff_text) > 2 * patch_size): + # This is a large deletion. Let it pass in one chunk. + patch.length1 += len(diff_text) + start1 += len(diff_text) + empty = False + patch.diffs.append((diff_type, diff_text)) + del bigpatch.diffs[0] + else: + # Deletion or equality. Only take as much as we can stomach. + diff_text = diff_text[:patch_size - patch.length1 - + self.Patch_Margin] + patch.length1 += len(diff_text) + start1 += len(diff_text) + if diff_type == self.DIFF_EQUAL: + patch.length2 += len(diff_text) + start2 += len(diff_text) + else: + empty = False + + patch.diffs.append((diff_type, diff_text)) + if diff_text == bigpatch.diffs[0][1]: + del bigpatch.diffs[0] + else: + bigpatch.diffs[0] = (bigpatch.diffs[0][0], + bigpatch.diffs[0][1][len(diff_text):]) + + # Compute the head context for the next patch. + precontext = self.diff_text2(patch.diffs) + precontext = precontext[-self.Patch_Margin:] + # Append the end context for this patch. + postcontext = self.diff_text1(bigpatch.diffs)[:self.Patch_Margin] + if postcontext: + patch.length1 += len(postcontext) + patch.length2 += len(postcontext) + if len(patch.diffs) != 0 and patch.diffs[-1][0] == self.DIFF_EQUAL: + patch.diffs[-1] = (self.DIFF_EQUAL, patch.diffs[-1][1] + + postcontext) + else: + patch.diffs.append((self.DIFF_EQUAL, postcontext)) + + if not empty: + x += 1 + patches.insert(x, patch) + + def unquote(self, s): + """unquote('abc%20def') -> 'abc def'.""" + res = s.split('%') + # fastpath + if len(res) == 1: + return s + s = res[0] + for item in res[1:]: + try: + s += self._hextochr[item[:2]] + item[2:] + except KeyError: + s += '%' + item +# except UnicodeDecodeError: +# s += unichr(int(item[:2], 16)) + item[2:] + return s + + def patch_fromText(self, textline): + """Parse a textual representation of patches and return a list of patch + objects. + + Args: + textline: Text representation of patches. + + Returns: + Array of Patch objects. + + Raises: + ValueError: If invalid input. + """ + if type(textline) == bytes: + # Patches should be composed of a subset of ascii chars, Unicode not + # required. If this encode raises UnicodeEncodeError, patch is invalid. + textline = textline.encode("ascii") + patches = [] + if not textline: + return patches + text = textline.split('\n') + while len(text) != 0: + m = ure.match("^@@ -(\d+),?(\d*) \+(\d+),?(\d*) @@$", text[0]) + if not m: + raise ValueError("Invalid patch string: " + text[0]) + patch = patch_obj() + patches.append(patch) + patch.start1 = int(m.group(1)) + if m.group(2) == '': + patch.start1 -= 1 + patch.length1 = 1 + elif m.group(2) == '0': + patch.length1 = 0 + else: + patch.start1 -= 1 + patch.length1 = int(m.group(2)) + + patch.start2 = int(m.group(3)) + if m.group(4) == '': + patch.start2 -= 1 + patch.length2 = 1 + elif m.group(4) == '0': + patch.length2 = 0 + else: + patch.start2 -= 1 + patch.length2 = int(m.group(4)) + + del text[0] + + while len(text) != 0: + if text[0]: + sign = text[0][0] + else: + sign = '' + line = self.unquote(text[0][1:]) + #line = line.decode("utf-8") + if sign == '+': + # Insertion. + patch.diffs.append((self.DIFF_INSERT, line)) + elif sign == '-': + # Deletion. + patch.diffs.append((self.DIFF_DELETE, line)) + elif sign == ' ': + # Minor equality. + patch.diffs.append((self.DIFF_EQUAL, line)) + elif sign == '@': + # Start of next patch. + break + elif sign == '': + # Blank line? Whatever. + pass + else: + # WTF? + raise ValueError("Invalid patch mode: '%s'\n%s" % (sign, line)) + del text[0] + return patches + + +class patch_obj: + """Class representing one patch operation. + """ + + def __init__(self): + """Initializes with an empty list of diffs. + """ + self.diffs = [] + self.start1 = None + self.start2 = None + self.length1 = 0 + self.length2 = 0 + + def __str__(self): + """Emmulate GNU diff's format. + Header: @@ -382,8 +481,9 @@ + Indicies are printed as 1-based, not 0-based. + + Returns: + The GNU diff string. + """ + if self.length1 == 0: + coords1 = str(self.start1) + ",0" + elif self.length1 == 1: + coords1 = str(self.start1 + 1) + else: + coords1 = str(self.start1 + 1) + "," + str(self.length1) + if self.length2 == 0: + coords2 = str(self.start2) + ",0" + elif self.length2 == 1: + coords2 = str(self.start2 + 1) + else: + coords2 = str(self.start2 + 1) + "," + str(self.length2) + text = ["@@ -", coords1, " +", coords2, " @@\n"] + # Escape the body of the patch with %xx notation. + for (op, data) in self.diffs: + if op == diff_match_patch.DIFF_INSERT: + text.append("+") + elif op == diff_match_patch.DIFF_DELETE: + text.append("-") + elif op == diff_match_patch.DIFF_EQUAL: + text.append(" ") + # High ascii will raise UnicodeDecodeError. Use Unicode instead. + data = data.encode("utf-8") + text.append(urllib.quote(data, "!~*'();/?:@&=+$,# ") + "\n") + return "".join(text) diff --git a/examples/OTA-lorawan/firmware/1.17.1/flash/loranet.py b/examples/OTA-lorawan/firmware/1.17.1/flash/loranet.py new file mode 100644 index 0000000..573d178 --- /dev/null +++ b/examples/OTA-lorawan/firmware/1.17.1/flash/loranet.py @@ -0,0 +1,131 @@ +from network import LoRa +import socket +import binascii +import struct +import time +import _thread + +class LoraNet: + def __init__(self, frequency, dr, region, device_class=LoRa.CLASS_C, activation = LoRa.OTAA, auth = None): + self.frequency = frequency + self.dr = dr + self.region = region + self.device_class = device_class + self.activation = activation + self.auth = auth + self.sock = None + self._exit = False + self.s_lock = _thread.allocate_lock() + self.lora = LoRa(mode=LoRa.LORAWAN, region = self.region, device_class = self.device_class) + + self._msg_queue = [] + self.q_lock = _thread.allocate_lock() + self._process_ota_msg = None + + def stop(self): + self._exit = True + + def init(self, process_msg_callback): + self._process_ota_msg = process_msg_callback + + def receive_callback(self, lora): + events = lora.events() + if events & LoRa.RX_PACKET_EVENT: + rx, port = self.sock.recvfrom(256) + if rx: + if '$OTA' in rx: + print("OTA msg received: {}".format(rx)) + self._process_ota_msg(rx.decode()) + else: + self.q_lock.acquire() + self._msg_queue.append(rx) + self.q_lock.release() + + def connect(self): + if self.activation != LoRa.OTAA and self.activation != LoRa.ABP: + raise ValueError("Invalid Lora activation method") + if len(self.auth) < 3: + raise ValueError("Invalid authentication parameters") + + self.lora.callback(trigger=LoRa.RX_PACKET_EVENT, handler=self.receive_callback) + + # set the 3 default channels to the same frequency + self.lora.add_channel(0, frequency=self.frequency, dr_min=0, dr_max=5) + self.lora.add_channel(1, frequency=self.frequency, dr_min=0, dr_max=5) + self.lora.add_channel(2, frequency=self.frequency, dr_min=0, dr_max=5) + + # remove all the non-default channels + for i in range(3, 16): + self.lora.remove_channel(i) + + # authenticate with abp or ota + if self.activation == LoRa.OTAA: + self._authenticate_otaa(self.auth) + else: + self._authenticate_abp(self.auth) + + # create socket to server + self._create_socket() + + def _authenticate_otaa(self, auth_params): + + # create an OTAA authentication params + self.dev_eui = binascii.unhexlify(auth_params[0]) + self.app_eui = binascii.unhexlify(auth_params[1]) + self.app_key = binascii.unhexlify(auth_params[2]) + + self.lora.join(activation=LoRa.OTAA, auth=(self.dev_eui, self.app_eui, self.app_key), timeout=0, dr=self.dr) + + while not self.lora.has_joined(): + time.sleep(2.5) + print('Not joined yet...') + + def has_joined(self): + return self.lora.has_joined() + + def _authenticate_abp(self, auth_params): + # create an ABP authentication params + self.dev_addr = struct.unpack(">l", binascii.unhexlify(auth_params[0]))[0] + self.nwk_swkey = binascii.unhexlify(auth_params[1]) + self.app_swkey = binascii.unhexlify(auth_params[2]) + + self.lora.join(activation=LoRa.ABP, auth=(self.dev_addr, self.nwk_swkey, self.app_swkey)) + + def _create_socket(self): + + # create a LoRa socket + self.sock = socket.socket(socket.AF_LORA, socket.SOCK_RAW) + + # set the LoRaWAN data rate + self.sock.setsockopt(socket.SOL_LORA, socket.SO_DR, self.dr) + + # make the socket non blocking + self.sock.setblocking(False) + + time.sleep(2) + + def send(self, packet): + with self.s_lock: + self.sock.send(packet) + + def receive(self, bufsize): + with self.q_lock: + if len(self._msg_queue) > 0: + return self._msg_queue.pop(0) + return '' + + def get_dev_eui(self): + return binascii.hexlify(self.lora.mac()).decode('ascii') + + def change_to_multicast_mode(self, mcAuth): + print('Start listening for firmware updates ...........') + + if self.device_class != LoRa.CLASS_C: + self.lora = LoRa(mode=LoRa.LORAWAN, region = self.region, device_class=LoRa.CLASS_C) + self.connect() + + mcAddr = struct.unpack(">l", binascii.unhexlify(mcAuth[0]))[0] + mcNwkKey = binascii.unhexlify(mcAuth[1]) + mcAppKey = binascii.unhexlify(mcAuth[2]) + + self.lora.join_multicast_group(mcAddr, mcNwkKey, mcAppKey) diff --git a/examples/OTA-lorawan/firmware/1.17.1/flash/main.py b/examples/OTA-lorawan/firmware/1.17.1/flash/main.py new file mode 100644 index 0000000..47c97ca --- /dev/null +++ b/examples/OTA-lorawan/firmware/1.17.1/flash/main.py @@ -0,0 +1,35 @@ +from loranet import LoraNet +from ota import LoraOTA +from network import LoRa +import machine +import utime + +def main(): + print('Rebooting with new firmware version 1.17.1') + + LORA_FREQUENCY = 868100000 + LORA_NODE_DR = 0 + LORA_REGION = LoRa.EU868 + LORA_DEVICE_CLASS = LoRa.CLASS_C + LORA_ACTIVATION = LoRa.OTAA + LORA_CRED = ('240ac4fffe0bf998', '948c87eff87f04508f64661220f71e3f', '5e6795a5c9abba017d05a2ffef6ba858') + + lora = LoraNet(LORA_FREQUENCY, LORA_NODE_DR, LORA_REGION, LORA_DEVICE_CLASS, LORA_ACTIVATION, LORA_CRED) + lora.connect() + + ota = LoraOTA(lora) + + while True: + rx = lora.receive(256) + if rx: + print('Received user message: {}'.format(rx)) + + utime.sleep(2) + +main() + +#try: +# main() +#except Exception as e: +# print('Firmware exception: Reverting to old firmware') +# LoraOTA.revert() diff --git a/examples/OTA-lorawan/firmware/1.17.1/flash/ota.py b/examples/OTA-lorawan/firmware/1.17.1/flash/ota.py new file mode 100644 index 0000000..0fca7db --- /dev/null +++ b/examples/OTA-lorawan/firmware/1.17.1/flash/ota.py @@ -0,0 +1,467 @@ +import diff_match_patch as dmp_module +from watchdog import Watchdog +from machine import RTC +import ubinascii +import uhashlib +import _thread +import utime +import uos +import machine +import json + +class LoraOTA: + + MSG_HEADER = b'$OTA' + MSG_TAIL = b'*' + + UPDATE_INFO_MSG = 1 + UPDATE_INFO_REPLY = 2 + + MULTICAST_KEY_REQ = 3 + MULTICAST_KEY_REPLY = 4 + + LISTENING_MSG = 5 + LISTENING_REPLY = 6 + + UPDATE_TYPE_FNAME = 7 + UPDATE_TYPE_PATCH = 8 + UPDATE_TYPE_CHECKSUM = 9 + + DELETE_FILE_MSG = 10 + MANIFEST_MSG = 11 + + def __init__(self, lora): + self.lora = lora + self.is_updating = False + self.version_file = '/flash/OTA_INFO.py' + self.update_version = '0.0.0' + self.update_time = -1 + self.resp_received = False + self.update_in_progress = False + self.operation_timeout = 10 + self.max_send = 5 + self.listen_before_sec = uos.urandom(1)[0] % 180 + self.updates_check_period = 6 * 3600 + + self.mcAddr = None + self.mcNwkSKey = None + self.mcAppSKey = None + + self.patch = '' + self.file_to_patch = None + self.patch_list = dict() + self.checksum_failure = False + self.device_mainfest = None + + self._exit = False + _thread.start_new_thread(self._thread_proc, ()) + + self.inactivity_timeout = 120 + self.wdt = Watchdog() + + self.lora.init(self.process_message) + + def stop(self): + self.lora.stop() + self._exit = True + + def _thread_proc(self): + updates_check_time = utime.time() + self.device_mainfest = self.create_device_manifest() + + while not self._exit: + if utime.time() > updates_check_time and self.update_time < 0: + self.synch_request(self.check_firmware_updates) + updates_check_time = utime.time() + self.updates_check_period + + if self.update_time > 0 and not self.update_in_progress: + if self.update_time - utime.time() < self.listen_before_sec: + self.update_in_progress = True + self.updating_proc() + + if self.update_failed(): + print('Update failed: No data received') + machine.reset() + + utime.sleep(2) + + def updating_proc(self): + self.synch_request(self.get_mulitcast_keys) + + if self.mcAddr is not None: + mulitcast_auth = (self.mcAddr, self.mcNwkSKey, self.mcAppSKey) + self.lora.change_to_multicast_mode(mulitcast_auth) + + wdt_timeout = self.listen_before_sec + self.inactivity_timeout + self.wdt.enable(wdt_timeout) + + self.synch_request(self.send_listening_msg) + else: + self.reset_update_params() + + def create_device_manifest(self): + + manifest = dict() + manifest["delete"] = 0 + manifest["update"] = 0 + manifest["new"] = 0 + + return manifest + + def reset_update_params(self): + self.mcAddr = None + self.mcNwkSKey = None + self.mcAppSKey = None + + self.update_in_progress = False + self.update_time = -1 + self.update_version = '0.0.0' + + def get_mulitcast_keys(self): + msg = bytearray() + msg.extend(self.MSG_HEADER) + msg.extend(b',' + str(self.MULTICAST_KEY_REQ).encode()) + msg.extend(b',' + self.MSG_TAIL) + + self.lora.send(msg) + + def synch_request(self, func): + attempt_num = 0 + self.resp_received = False + + while attempt_num < self.max_send and not self.resp_received: + func() + + count_10ms = 0 + while(count_10ms <= self.operation_timeout * 100 and not self.resp_received): + count_10ms += 1 + utime.sleep(0.01) + + attempt_num += 1 + + def check_firmware_updates(self): + msg = bytearray() + msg.extend(self.MSG_HEADER) + msg.extend(b',' + str(self.UPDATE_INFO_MSG).encode()) + + version = self.get_current_version().encode() + msg.extend(b',' + version) + msg.extend(b',' + self.MSG_TAIL) + + self.lora.send(msg) + print("Lora OTA: Request for info sent") + + def get_current_version(self): + version = '0.0.0' + if self.file_exists(self.version_file): + with open(self.version_file, 'r') as fh: + version = fh.read().rstrip("\r\n\s") + else: + self._write_version_info(version) + + print("Version: {}", version) + + return version + + def send_listening_msg(self): + msg = bytearray() + msg.extend(self.MSG_HEADER) + msg.extend(b',' + str(self.LISTENING_MSG).encode()) + msg.extend(b',' + self.MSG_TAIL) + + self.lora.send(msg) + + def _write_version_info(self, version): + try: + with open(self.version_file, 'w+') as fh: + fh.write(version) + except Exception as e: + print("Exception creating OTA version file") + + def file_exists(self, file_path): + exists = False + try: + if uos.stat(file_path)[6] > 0: + exists = True + except Exception as e: + exists = False + return exists + + def get_msg_type(self, msg): + msg_type = -1 + try: + msg_type = int(msg.split(",")[1]) + except Exception as ex: + print("Exception getting message type") + + return msg_type + + def sync_clock(self, epoc): + try: + rtc = RTC() + rtc.init(utime.gmtime(epoc)) + except Exception as ex: + print("Exception setting system data/time: {}".format(ex)) + return False + + return True + + def parse_update_info_reply(self, msg): + self.resp_received = True + + try: + token_msg = msg.split(",") + need_updating = int(token_msg[2]) + if need_updating: + self.update_version = token_msg[3] + self.update_time = int(token_msg[5]) + + if utime.time() < 1550000000: + self.sync_clock(int(token_msg[4])) + + except Exception as ex: + print("Exception getting update information: {}".format(ex)) + return False + + return True + + def parse_multicast_keys(self, msg): + + try: + token_msg = msg.split(",") + print(token_msg) + + if len(token_msg[2]) > 0: + self.mcAddr = token_msg[2] + self.mcNwkSKey = token_msg[3] + self.mcAppSKey = token_msg[4] + + print("mcAddr: {}, mcNwkSKey: {}, mcAppSKey: {}".format(self.mcAddr, self.mcNwkSKey, self.mcAppSKey)) + + self.resp_received = True + except Exception as ex: + print("Exception getting multicast keys: {}".format(ex)) + return False + + return True + + def parse_listening_reply(self, msg): + self.resp_received = True + + def _data_start_idx(self, msg): + # Find first index + i = msg.find(",") + + #Find second index + return msg.find(",", i + 1) + + def _data_stop_idx(self, msg): + return msg.rfind(",") + + def get_msg_data(self, msg): + data = None + try: + start_idx = self._data_start_idx(msg) + 1 + stop_idx = self._data_stop_idx(msg) + data = msg[start_idx:stop_idx] + except Exception as ex: + print("Exception getting msg data: {}".format(ex)) + return data + + def process_patch_msg(self, msg): + partial_patch = self.get_msg_data(msg) + + if partial_patch: + self.patch += partial_patch + + def verify_patch(self, patch, received_checksum): + h = uhashlib.sha1() + h.update(patch) + checksum = ubinascii.hexlify(h.digest()).decode() + print("Computed checksum: {}".format(checksum)) + print("Received checksum: {}".format(received_checksum)) + + if checksum != received_checksum: + self.checksum_failure = True + return False + + return True + + def process_checksum_msg(self, msg): + checksum = self.get_msg_data(msg) + verified = self.verify_patch(self.patch, checksum) + if verified: + self.patch_list[self.file_to_patch] = self.patch + + self.file_to_patch = None + self.patch = '' + + def backup_file(self, filename): + bak_path = "{}.bak".format(filename) + + # Delete previous backup if it exists + try: + uos.remove(bak_path) + except OSError: + pass # There isnt a previous backup + + # Backup current file + uos.rename(filename, bak_path) + + def process_delete_msg(self, msg): + filename = self.get_msg_data(msg) + + if self.file_exists('/flash/' + filename): + self.backup_file('/flash/' + filename) + self.device_mainfest["delete"] += 1 + + def get_tmp_filename(self, filename): + idx = filename.rfind(".") + return filename[:idx + 1] + "tmp" + + def _read_file(self, filename): + + try: + with open('/flash/' + filename, 'r') as fh: + return fh.read() + except Exception as ex: + print("Error reading file: {}".format(ex)) + + return None + + def backup_file(self, filename): + bak_path = "{}.bak".format(filename) + + # Delete previous backup if it exists + try: + uos.remove(bak_path) + except OSError: + pass # There isnt a previous backup + + # Backup current file + uos.rename(filename, bak_path) + + def _write_to_file(self, filename, text): + tmp_file = self.get_tmp_filename('/flash/' + filename) + + try: + with open(tmp_file, 'w+') as fh: + fh.write(text) + except Exception as ex: + print("Error writing to file: {}".format(ex)) + return False + + if self.file_exists('/flash/' + filename): + self.backup_file('/flash/' + filename) + uos.rename(tmp_file, '/flash/' + filename) + + return True + + def apply_patches(self): + for key, value in self.patch_list.items(): + self.dmp = dmp_module.diff_match_patch() + self.patch_list = self.dmp.patch_fromText(value) + + to_patch = '' + print('Updating file: {}'.format(key)) + if self.file_exists('/flash/' + key): + to_patch = self._read_file(key) + + patched_text, success = self.dmp.patch_apply(self.patch_list, to_patch) + if False in success: + return False + + if not self._write_to_file(key, patched_text): + return False + + return True + + @staticmethod + def find_backups(): + backups = [] + for file in uos.listdir("/flash"): + if file.endswith(".bak"): + backups.append(file) + return backups + + @staticmethod + def revert(): + backup_list = LoraOTA.find_backups() + for backup in backup_list: + idx = backup.find('.bak') + new_filename = backup[:idx] + uos.rename(backup, new_filename) + print('Error: Reverting to old firmware') + machine.reset() + + def manifest_failure(self, msg): + + try: + start_idx = msg.find("{") + stop_idx = msg.find("}") + + recv_manifest = json.loads(msg[start_idx:stop_idx]) + + print("Received manifest: {}".format(recv_manifest)) + print("Actual manifest: {}".format(self.device_mainfest)) + + if (recv_manifest["update"] != self.device_mainfest["update"]) or \ + (recv_manifest["new"] != self.device_mainfest["new"]) or \ + (recv_manifest["delete"] != self.device_mainfest["delete"]): + return True + except Exception as ex: + print("Error in manifest: {}".format(ex)) + return True + + return False + + def process_manifest_msg(self, msg): + + if self.manifest_failure(msg): + print('Manifest failure: Discarding update ...') + self.reset_update_params() + if self.checksum_failure: + print('Failed checksum: Discarding update ...') + self.reset_update_params() + elif not self.apply_patches(): + LoraOTA.revert() + else: + print('Update Success: Restarting .... ') + self._write_version_info(self.update_version) + machine.reset() + + def process_filename_msg(self, msg): + self.file_to_patch = self.get_msg_data(msg) + + if self.file_exists('/flash/' + self.file_to_patch): + self.device_mainfest["update"] += 1 + print("Update file: {}".format(self.file_to_patch)) + else: + self.device_mainfest["new"] += 1 + print("Create new file: {}".format(self.file_to_patch)) + + self.wdt.enable(self.inactivity_timeout) + + def update_failed(self): + return self.wdt.update_failed() + + def process_message(self, msg): + self.wdt.ack() + + msg_type = self.get_msg_type(msg) + if msg_type == self.UPDATE_INFO_REPLY: + self.parse_update_info_reply(msg) + elif msg_type == self.MULTICAST_KEY_REPLY: + self.parse_multicast_keys(msg) + elif msg_type == self.LISTENING_REPLY: + self.parse_listening_reply(msg) + elif msg_type == self.UPDATE_TYPE_FNAME: + self.process_filename_msg(msg) + elif msg_type == self.UPDATE_TYPE_PATCH: + self.process_patch_msg(msg) + elif msg_type == self.UPDATE_TYPE_CHECKSUM: + self.process_checksum_msg(msg) + elif msg_type == self.DELETE_FILE_MSG: + self.process_delete_msg(msg) + elif msg_type == self.MANIFEST_MSG: + self.process_manifest_msg(msg) diff --git a/examples/OTA-lorawan/firmware/1.17.1/flash/watchdog.py b/examples/OTA-lorawan/firmware/1.17.1/flash/watchdog.py new file mode 100644 index 0000000..31d1e24 --- /dev/null +++ b/examples/OTA-lorawan/firmware/1.17.1/flash/watchdog.py @@ -0,0 +1,33 @@ +from machine import Timer +import _thread + +class Watchdog: + + def __init__(self): + self.failed = False + self.acknowledged = 0 + self._alarm = None + self._lock = _thread.allocate_lock() + + def enable(self, timeout = 120): + if self._alarm: + self._alarm.cancel() + self._alarm = None + + self._alarm = Timer.Alarm(self._check, s = timeout, periodic = True) + + def _check(self, alarm): + with self._lock: + if self.acknowledged > 0: + self.failed = False + self.acknowledged = 0 + else: + self.failed = True + + def ack(self): + with self._lock: + self.acknowledged += 1 + + def update_failed(self): + with self._lock: + return self.failed diff --git a/examples/OTA-lorawan/groupUpdater.py b/examples/OTA-lorawan/groupUpdater.py new file mode 100644 index 0000000..02408d2 --- /dev/null +++ b/examples/OTA-lorawan/groupUpdater.py @@ -0,0 +1,264 @@ +#!/usr/bin/env python3 + +import diff_match_patch as dmp_module +import threading +import hashlib +import binascii +import filecmp +import json +import time +import os + +class updateHandler: + + def __init__(self, dev_version, latest_version, clientApp, jwt, multicast_id, ota_obj): + self.tag = dev_version + ',' + latest_version + self.oper_dict = None + self.patch_dict = None + self.dev_version = dev_version + self.latest_version = latest_version + self._clientApp = clientApp + self.ota =ota_obj + self.max_send = 5 + + self._loraserver_jwt = jwt + self._multicast_group_id = multicast_id + + self._binary_ext = [] + + self._m_th = threading.Thread(target=self._multicast_proc) + self._m_th.start() + + def print_file_operations(self, oper_dict): + if 'delete_txt' in oper_dict: + print('Delete text: {}'.format(oper_dict['delete_txt'])) + if 'delete_bin' in oper_dict: + print('Delete bin: {}'.format(oper_dict['delete_bin'])) + if 'new_txt' in oper_dict: + print('New text: {}'.format(oper_dict['new_txt'])) + if 'new_bin' in oper_dict: + print('New binary: {}'.format(oper_dict['new_bin'])) + if 'update_txt' in oper_dict: + print('Update {}'.format(oper_dict['update_txt'])) + + def _create_manifest(self, oper_dict): + manifest = {"delete":0, "update":0, "new":0} + for key, value in oper_dict.items(): + if 'delete_txt' in key: + manifest['delete'] = len(value) + elif 'new_txt' in key: + manifest['new'] = len(value) + elif 'update_txt' in key: + manifest['update'] = len(value) + + return json.dumps(manifest) + + def get_all_paths(self, path, ignore=[]): + ignore = set(ignore) + paths = [] + for entry in os.walk(path): + d, _, files = entry + files = set(files).difference(ignore) + paths += [os.path.join(d, f) for f in files] + out = [d.replace('{}{}'.format(path, os.path.sep), '') for d in paths] + return set(out) + + def text_binary_lists(self, all_delete, all_new): + path_dict = dict() + + delete_dict = self.text_binary_separation(all_delete, 'delete') + path_dict.update(delete_dict) + + new_dict = self.text_binary_separation(all_new, 'new') + path_dict.update(new_dict) + + return path_dict + + def text_binary_separation(self, paths, key): + path_dict = dict() + + for path in paths: + filename, extension = os.path.splitext(path) + if extension in self._binary_ext: + if key + '_bin' not in path_dict: + path_dict[key + '_bin'] = [] + path_dict[key + '_bin'].append(path) + else: + if key + '_txt' not in path_dict: + path_dict[key + '_txt'] = [] + path_dict[key + '_txt'].append(path) + + return path_dict + + def get_diff_list(self, left, right, ignore=['.DS_Store', 'pymakr.conf']): + left_paths = self.get_all_paths(left, ignore=ignore) + right_paths = self.get_all_paths(right, ignore=ignore) + new_files = right_paths.difference(left_paths) + to_delete = left_paths.difference(right_paths) + common = left_paths.intersection(right_paths) + + paths_dict = self.text_binary_lists(to_delete, new_files) + + for f in common: + if not filecmp.cmp(os.path.join(left, f), + os.path.join(right, f), shallow=False): + filename, extension = os.path.splitext(f) + if extension in self._binary_ext: + # No diff update for binary files + if 'new_bin' not in paths_dict: + paths_dict['update_txt'] = [] + paths_dict['new_bin'].append(f) + else: + if 'update_txt' not in paths_dict: + paths_dict['update_txt'] = [] + paths_dict['update_txt'].append(f) + + return paths_dict + + def _read_firware_file(self, filename): + text = '' + try: + text = open(filename).read() + except Exception as e: + pass + return text + + def _create_hash(self, data): + h = hashlib.sha1() + h.update(data.encode()) + + return binascii.hexlify(h.digest()).decode() + + def chunkstring(self, string, length): + return list(string[0+i:length+i] for i in range(0, len(string), length)) + + def _send_delete_msg(self, filename): + msg = bytearray() + msg.extend(self.ota.MSG_HEADER) + msg.extend(b',' + str(self.ota.DELETE_FILE_MSG).encode()) + msg.extend(b',' + filename.encode()) + msg.extend(b',' + self.ota.MSG_TAIL) + + self._clientApp.send(self._loraserver_jwt, self._multicast_group_id, msg) + + def _send_delete_operations(self, oper_dict): + for key, value in oper_dict.items(): + if key in ['delete_txt', 'delete_bin']: + for filename in value: + self._send_delete_msg(filename[6:]) + + def _send_patches(self, patch_dict): + for fname in patch_dict: + #send file name to patch + self._send_multicast_msg(self.ota.UPDATE_TYPE_FNAME, fname) + time.sleep(3) + patch_list = self.chunkstring(patch_dict[fname][0], 200) + patch_idx = 0 + for p in patch_list: + patch_idx += len(p) + # send segmented patch + self._send_multicast_msg(self.ota.UPDATE_TYPE_PATCH, p) + time.sleep(3) + checksum = patch_dict[fname][1] + # Send checksum + self._send_multicast_msg(self.ota.UPDATE_TYPE_CHECKSUM, checksum) + time.sleep(3) + + def _send_multicast_msg(self, msg_type, data): + + msg = bytearray() + msg.extend(self.ota.MSG_HEADER) + msg.extend(b',' + str(msg_type).encode()) + msg.extend(b',' + data.encode()) + msg.extend(b',' + self.ota.MSG_TAIL) + + self._clientApp.send(self._loraserver_jwt, self._multicast_group_id, msg) + + def _send_manifest_msg(self): + msg = bytearray() + msg.extend(self.ota.MSG_HEADER) + msg.extend(b',' + str(self.ota.UPDATE_TYPE_RESTART).encode()) + msg.extend(b',' + self.ota.MSG_TAIL) + + self._clientApp.send(self._loraserver_jwt, self._multicast_group_id, msg) + + def _create_file_patch(self, left, right, fileList): + patch_dict = dict() + + for f in fileList: + left_text = self._read_firware_file(left + '/' + f) + right_text = self._read_firware_file(right + '/' + f) + + dmp = dmp_module.diff_match_patch() + + # Execute one reverse diff as a warmup. + patch_lst = dmp.patch_make(left_text, right_text) + patch_str = dmp.patch_toText(patch_lst) + + print("File name: {}".format(f)) + print("Patch : {}".format(patch_str)) + + idx = f.find('/flash') + 7 + hash = self._create_hash(patch_str) + patch_dict[f[idx:]] = (patch_str, hash) + + return patch_dict + + def file_operations(self, device_version, update_version): + oper_dict = dict() + + left = self.ota.firmware_dir + '/' + device_version + right = self.ota.firmware_dir + '/' + update_version + if os.path.isdir(left): + oper_dict = self.get_diff_list(left, right) + else: + oper_dict = self.get_diff_list('', right) + + self.print_file_operations(oper_dict) + + return oper_dict + + def _create_patches(self, device_version, update_version, oper_dict): + patch_dict = dict() + + left = self.ota.firmware_dir + '/' + device_version + right = self.ota.firmware_dir + '/' + update_version + + if 'update_txt' in oper_dict: + update_dict = self._create_file_patch(left, right, oper_dict['update_txt']) + patch_dict.update(update_dict) + + if 'new_txt' in oper_dict: + new_dict = self._create_file_patch(left, right, oper_dict['new_txt']) + patch_dict.update(new_dict) + + return patch_dict + + def _send_manifest_msg(self): + manifest = self._create_manifest(self.oper_dict) + print('Manifest: {}'.format(manifest)) + + for i in (0, self.max_send): + self._send_multicast_msg(self.ota.MANIFEST_MSG, manifest) + time.sleep(4) + + def _multicast_proc(self): + + self.oper_dict = self.file_operations(self.dev_version, self.latest_version) + self.patch_dict = self._create_patches(self.dev_version, self.latest_version, self.oper_dict) + + self._send_patches(self.patch_dict) + self._send_delete_operations(self.oper_dict) + self._send_manifest_msg() + + while not self.ota.is_empty_multicast_queue(self._loraserver_jwt, self._multicast_group_id): + time.sleep(1) + + self.ota.clear_multicast_group(self.tag) + + + + + + + diff --git a/examples/OTA-lorawan/ota.py b/examples/OTA-lorawan/ota.py new file mode 100644 index 0000000..60477a2 --- /dev/null +++ b/examples/OTA-lorawan/ota.py @@ -0,0 +1,255 @@ +#!/usr/bin/env python3 + +from distutils.version import LooseVersion +from LoraServer import LoraServerClient +from groupUpdater import updateHandler +import threading +import json +import base64 +import os +import time +import config + + +class OTAHandler: + + MSG_HEADER = b'$OTA' + MSG_TAIL = b'*' + MSG_END = b'' + + UPDATE_INFO_MSG = 1 + UPDATE_INFO_REPLY = 2 + + MULTICAST_KEY_REQ = 3 + MULTICAST_KEY_REPLY = 4 + + LISTENING_MSG = 5 + LISTENING_REPLY = 6 + + UPDATE_TYPE_FNAME = 7 + UPDATE_TYPE_PATCH = 8 + UPDATE_TYPE_CHECKSUM = 9 + + DELETE_FILE_MSG = 10 + MANIFEST_MSG = 11 + + def __init__(self): + self._exit = False + self.p_client = None + self._latest_version = '0.0.0' + self._v_lock = threading.Lock() + self.firmware_dir = './firmware' + + self._next_update = -1 + self._update_timer = None + self._update_delay = config.UPDATE_DELAY + self._device_dict = dict() + self._keys_dict = dict() + + self._clientApp = LoraServerClient() + self._loraserver_jwt = None + + self._service_profile = config.LORASERVER_SERVICE_PROFILE + self._downlink_datarate = config.LORASERVER_DOWNLINK_DR + self._downlink_freq = config.LORASERVER_DOWNLINK_FREQ + + self._m_th = threading.Thread(target=self._firmware_monitor) + self._m_th.start() + + self.multicast_updaters = [] + self._updater_lock = threading.Lock() + + def stop(self): + self._exit = True + + def set_mqtt_client(self, client): + self.p_client = client + + def _firmware_monitor(self): + self._loraserver_jwt = self._clientApp.login() + + while not self._exit: + with self._v_lock: + self._latest_version = self._check_version() + + time.sleep(5) + + def process_rx_msg(self, payload): + + dev_eui = self.get_device_eui(payload) + dev_msg = self.decode_device_msg(payload) + if self.MSG_HEADER in dev_msg: + msg_type = self.get_msg_type(dev_msg.decode()) + if msg_type == self.UPDATE_INFO_MSG: + self._send_update_info(dev_eui, dev_msg.decode()) + elif msg_type == self.MULTICAST_KEY_REQ: + self._send_multicast_keys(dev_eui) + elif msg_type == self.LISTENING_MSG: + self._send_listening_reply(dev_eui) + + def _send_listening_reply(self, dev_eui): + + msg = bytearray() + msg.extend(self.MSG_HEADER) + msg.extend(b',' + str(self.LISTENING_REPLY).encode()) + msg.extend(b',' + self.MSG_TAIL) + + self.send_payload(dev_eui, msg) + + def _send_multicast_keys(self, dev_eui): + + msg = bytearray() + msg.extend(self.MSG_HEADER) + msg.extend(b',' + str(self.MULTICAST_KEY_REPLY).encode()) + + if dev_eui in self._device_dict: + multicast_param_key = self._device_dict[dev_eui] + multicast_param = self._keys_dict[multicast_param_key] + + msg.extend(b',' + multicast_param[1]) + msg.extend(b',' + multicast_param[2]) + msg.extend(b',' + multicast_param[3]) + else: + msg.extend(b',,,') + + msg.extend(b',' + self.MSG_TAIL) + + self.send_payload(dev_eui, msg) + + def get_device_eui(self, payload): + dev_eui = None + try: + dev_eui = json.loads(payload)["devEUI"] + except Exception as ex: + print("Exception extracting device eui") + + return dev_eui + + def get_msg_type(self, msg): + msg_type = -1 + + try: + msg_type = int(msg.split(",")[1]) + except Exception as ex: + print("Exception getting message type") + + return msg_type + + def decode_device_msg(self, payload): + dev_msg = None + try: + rx_pkt = json.loads(payload) + dev_msg = base64.b64decode(rx_pkt["data"]) + except Exception as ex: + print("Exception decoding device message") + return dev_msg + + def _create_multicast_group(self, update_info): + service_id = self._clientApp.request_service_profile_id(self._service_profile, self._loraserver_jwt) + + group_name = update_info.replace(',','-') + multicast_param = self._clientApp.create_multicast_group(self._downlink_datarate, self._downlink_freq, group_name, service_id, self._loraserver_jwt) + + return multicast_param + + def _init_update_params(self, dev_eui, dev_version, latest_version): + if self._next_update <= 0: + self._next_update = int(time.time()) + self._update_delay + self._update_timer = threading.Timer(self._update_delay, self.update_proc) + self._update_timer.start() + + update_info = dev_version.strip() + ',' + latest_version.strip() + self._device_dict[dev_eui] = update_info + if update_info not in self._keys_dict: + multicast_param = self._create_multicast_group(update_info) + self._keys_dict[update_info] = multicast_param + self._clientApp.add_device_multicast_group(dev_eui, multicast_param[0], self._loraserver_jwt) + + def _send_update_info(self, dev_eui, msg): + print(msg) + dev_version = self.get_device_version(msg) + print("Device eui: {}, Device Version: {}".format(dev_eui, dev_version)) + + if len(dev_version) > 0: + version = self.get_latest_version() + if LooseVersion(version) > LooseVersion(dev_version): + self._init_update_params(dev_eui, dev_version, version) + msg = self._create_update_info_msg(version) + self.send_payload(dev_eui, msg) + + def get_device_version(self, msg): + dev_version = None + try: + dev_version = msg.split(",")[2] + except Exception as ex: + print("Exception extracting device version") + + return dev_version + + def _check_version(self): + latest = '0.0.0' + for d in os.listdir(self.firmware_dir): + if os.path.isfile(d): + continue + if latest is None or LooseVersion(latest) < LooseVersion(d): + latest = d + + return latest + + def get_latest_version(self): + with self._v_lock: + return self._latest_version + + def is_empty_multicast_queue(self, jwt, multicast_group_id): + queue_length =self._clientApp.multicast_queue_length(jwt, multicast_group_id) + if queue_length > 0: + return False + else: + return True + + def clear_multicast_group(self, dict_key): + with self._updater_lock: + if dict_key in self._keys_dict: + group_id = self._keys_dict[dict_key][0] + self._clientApp.delete_multicast_group(group_id) + del self._keys_dict[dict_key] + + self._device_dict = {key:val for key, val in self._device_dict.items() if val != dict_key} + + for updater in self.multicast_updaters: + if updater.tag == dict_key: + self.multicast_updaters.remove(updater) + + if len(self.multicast_updaters) == 0: + self._next_update = -1 + self._update_timer = None + + def update_proc(self): + + for dict_key in self._keys_dict: + dev_version = dict_key.split(',')[0] + latest_version = dict_key.split(',')[1] + multicast_group_id = self._keys_dict[dict_key][0] + upater = updateHandler(dev_version, latest_version, self._clientApp, self._loraserver_jwt, multicast_group_id, self) + + self.multicast_updaters.append(upater) + + def _create_update_info_msg(self, version): + msg = bytearray() + msg.extend(self.MSG_HEADER) + msg.extend(b',' + str(self.UPDATE_INFO_REPLY).encode()) + msg.extend(b',' + str(int(self._next_update > 0)).encode()) + msg.extend(b',' + version.encode()) + msg.extend(b',' + str(int(time.time())).encode()) + if self._next_update > 0: + msg.extend(b',' + str(int(self._next_update)).encode()) + else: + msg.extend(b',-1') + msg.extend(b',' + self.MSG_TAIL) + + return msg + + def send_payload(self, dev_eui, data): + b64Data = base64.b64encode(data) + payload = '{"reference": "abcd1234" ,"fPort":1,"data": "' + b64Data.decode() + '"}' + self.p_client.publish(topic="application/1/device/" + dev_eui + "/tx",payload=payload) diff --git a/examples/OTA-lorawan/updaterService.py b/examples/OTA-lorawan/updaterService.py new file mode 100644 index 0000000..e51e3d8 --- /dev/null +++ b/examples/OTA-lorawan/updaterService.py @@ -0,0 +1,42 @@ +#!/usr/bin/env python3 + +import paho.mqtt.client as paho +from ota import OTAHandler +import signal +import time +import config + +exit = False +client = None + +def sigint_handler(signum, frame): + global exit + exit = True + print("Terminating Lora OTA updater") + +def on_message(mosq, ota, msg): + print("{} {} {}".format(msg.topic, msg.qos, msg.payload)) + ota.process_rx_msg(msg.payload.decode()) + +def on_publish(mosq, obj, mid): + pass + +if __name__ == '__main__': + signal.signal(signal.SIGINT, sigint_handler) + + ota = OTAHandler() + + client = paho.Client(userdata=ota) + client.connect(config.LORASERVER_IP, config.LORASERVER_MQTT_PORT, 60) + + client.on_message = on_message + client.on_publish = on_publish + + client.subscribe("application/+/device/+/rx", 0) + + ota.set_mqtt_client(client) + + while client.loop() == 0 and not exit: + pass + + ota.stop() From 5e4702c47087e9482690576cd251796b4546f655 Mon Sep 17 00:00:00 2001 From: iwahdan88 Date: Fri, 26 Apr 2019 12:35:34 +0200 Subject: [PATCH 15/92] Updated to version 1.2.5 --- lib/sqnsupgrade/sqnsupgrade.py | 80 +++++++++++++++++++++++++++------- 1 file changed, 65 insertions(+), 15 deletions(-) diff --git a/lib/sqnsupgrade/sqnsupgrade.py b/lib/sqnsupgrade/sqnsupgrade.py index 15b1905..b488787 100644 --- a/lib/sqnsupgrade/sqnsupgrade.py +++ b/lib/sqnsupgrade/sqnsupgrade.py @@ -1,5 +1,5 @@ #!/usr/bin/env python -VERSION = "1.2.4" +VERSION = "1.2.5" # Copyright (c) 2019, Pycom Limited. # @@ -67,6 +67,7 @@ def special_print(self, msg, flush=None, end='\n'): print(msg, flush=flush, end=end) def read_rsp(self, size=None, timeout=-1): + time.sleep(.25) if timeout < 0: timeout = 20000 elif timeout is None: @@ -338,7 +339,7 @@ def __get_wait_msg(self, load_fff=True): - def __run(self, file_path=None, baudrate=921600, port=None, resume=False, load_ffh=False, mirror=False, switch_ffh=False, bootrom=False, rgbled=0x050505, debug=False, pkgdebug=False, atneg=True, max_try=10, direct=True, atneg_only=False, info_only=False, expected_smod=None, verbose=False, load_fff=False): + def __run(self, file_path=None, baudrate=921600, port=None, resume=False, load_ffh=False, mirror=False, switch_ffh=False, bootrom=False, rgbled=0x050505, debug=False, pkgdebug=False, atneg=True, max_try=10, direct=True, atneg_only=False, info_only=False, expected_smod=None, verbose=False, load_fff=False, mtools=False): self.__wait_msg = False mirror = True if atneg_only else mirror recover = True if atneg_only else load_ffh @@ -418,7 +419,7 @@ def __run(self, file_path=None, baudrate=921600, port=None, resume=False, load_f if not self.wakeup_modem(baudrate, port, 10, 1, debug): return False - if not resume: + if (not resume) or mtools: # bind to AT channel self.__serial.write(b"AT+BIND=AT\r\n") @@ -432,17 +433,42 @@ def __run(self, file_path=None, baudrate=921600, port=None, resume=False, load_f response = self.read_rsp(size=100) if debug: print("ATE0 returned {}".format(response)) - self.__serial.read(100) + self.__serial.read() if debug: print('Entering upgrade mode...') + if verbose: print("Sending AT+SMLOG?") + self.__serial.write(b'AT+SMLOG?\r\n') + response = self.read_rsp(size=100) + if verbose: print("AT+SMLOG? returned {}".format(response)) + self.__serial.write(b"AT+SMOD?\r\n") response = self.return_pretty_response(self.read_rsp(size=7)) - self.__serial.read(100) if debug: print("AT+SMOD? returned {}".format(response)) + if verbose: print('Sending AT+FSRDFILE="/fs/crashdump"') + self.__serial.write(b'AT+FSRDFILE="/fs/crashdump"\r\n') + response = self.read_rsp(size=100) + if verbose: print('AT+FSRDFILE="/fs/crashdump" returned {}'.format(response)) + self.__serial.read() + self.__serial.write(b"AT+SQNSUPGRADENTF=\"started\"\r\n") + response = self.read_rsp(size=100) + if verbose: print('AT+SQNSUPGRADENTF="started" returned {}'.format(response)) self.wait_for_modem() - if not load_fff: + + if verbose: print('Sending AT+SQNWL="sqndcc",2') + self.__serial.write(b'AT+SQNWL="sqndcc",2\r\n') + response = self.read_rsp(size=100) + if verbose: print('AT+SQNWL="sqndcc",2 returned {}'.format(response)) + self.__serial.read(100) + + if verbose: print("Sending AT+CFUN=4") + self.__serial.write(b'AT+CFUN=4\r\n') + response = self.read_rsp(size=100) + if verbose: print("AT+CFUN=4 returned {}".format(response)) + self.__serial.read(100) + + if not (load_fff or mtools): self.__serial.write(b"AT+SMSWBOOT=3,1\r\n") resp = self.read_rsp(100) if debug: print('AT+SMSWBOOT=3,1 returned: {}'.format(resp)) @@ -465,6 +491,23 @@ def __run(self, file_path=None, baudrate=921600, port=None, resume=False, load_f self.wait_for_modem() self.__serial.write(b"AT\r\n") + if verbose: print("Sending AT+CFUN=4") + self.__serial.write(b'AT+CFUN=4\r\n') + response = self.read_rsp(size=100) + if verbose: print("AT+CFUN=4 returned {}".format(response)) + + if verbose: print("Sending AT+SMLOG?") + self.__serial.write(b'AT+SMLOG?\r\n') + response = self.read_rsp(size=100) + if verbose: print("AT+SMLOG? returned {}".format(response)) + + if verbose: print('Sending AT+FSRDFILE="/fs/crashdump"') + self.__serial.write(b'AT+FSRDFILE="/fs/crashdump"\r\n') + response = self.read_rsp(size=100) + if verbose: print('AT+FSRDFILE="/fs/crashdump" returned {}'.format(response)) + self.__serial.read() + + else: self.__serial.read(100) if debug: print('Entering recovery mode') @@ -494,10 +537,6 @@ def __run(self, file_path=None, baudrate=921600, port=None, resume=False, load_f print('Starting STP ON_THE_FLY') self.__serial.read(100) - if verbose: print("Sending AT+CFUN=4") - resonse = self.__serial.write(b'AT+CFUN=4\r\n') - if verbose: print("AT+CFUN=4 returned {}".format(response)) - self.__serial.read(100) if load_fff: if debug: print("Sending AT+SMSTPU") @@ -676,7 +715,15 @@ def __run(self, file_path=None, baudrate=921600, port=None, resume=False, load_f time.sleep(0.5) if 'success' in sqnup_result: + if verbose: print('Sending AT+SQNSUPGRADENTF="success"') self.__serial.write(b"AT+SQNSUPGRADENTF=\"success\"\r\n") + resonse = self.read_rsp(100) + if verbose: print('AT+SQNSUPGRADENTF="success" returned {}'.format(response)) + time.sleep(.25) + if verbose: print('Sending AT+FSRDFILE="/fs/crashdump"') + self.__serial.write(b'AT+FSRDFILE="/fs/crashdump"\r\n') + resonse = self.read_rsp(100) + if verbose: print('AT+FSRDFILE="/fs/crashdump" returned {}'.format(response)) self.__serial.read() return True elif sqnup_result is None: @@ -718,7 +765,7 @@ def wakeup_modem(self, baudrate, port, max_try, delay, debug, msg='Attempting AT count = 0 if msg is not None: if debug: - print(msg + 'with baudrate {}'.format(baudrate)) + print(msg + ' [{}]'.format(baudrate)) else: print(msg) @@ -808,7 +855,7 @@ def success_message(self, port=None, verbose=False, debug=False): print("Here is the current firmware version:\n") self.show_info(port=port, verbose=verbose, debug=debug) - def upgrade(self, ffile, mfile=None, baudrate=921600, retry=False, resume=False, debug=False, pkgdebug=False, verbose=False, load_fff=True, load_only=False): + def upgrade(self, ffile, mfile=None, baudrate=921600, retry=False, resume=False, debug=False, pkgdebug=False, verbose=False, load_fff=True, load_only=False, mtools=False): success = True if not retry and mfile is not None: if resume or self.__check_br(br_only=True, verbose=verbose, debug=debug): @@ -833,7 +880,7 @@ def upgrade(self, ffile, mfile=None, baudrate=921600, retry=False, resume=False, print('Unable to upgrade bootrom.') if debug: print('Success2? {}'.format(success)) if success: - if self.__run(file_path=ffile, resume=True if mfile is not None else resume, baudrate=baudrate, direct=False, debug=debug, pkgdebug=pkgdebug, verbose=verbose, load_fff=False if mfile else load_fff): + if self.__run(file_path=ffile, resume=True if mfile is not None else resume, baudrate=baudrate, direct=False, debug=debug, pkgdebug=pkgdebug, verbose=verbose, load_fff=False if mfile else load_fff, mtools=mtools): if self.__check_br(verbose=verbose, debug=debug): self.__run(bootrom=True, debug=debug, direct=False, pkgdebug=pkgdebug, verbose=verbose, load_fff=True) self.success_message(verbose=verbose, debug=debug) @@ -925,6 +972,7 @@ def run(ffile, mfile=None, baudrate=921600, verbose=False, debug=False, load_fff print_welcome() retry = False resume = False + mtools = False sqnup = sqnsupgrade() if sqnup.check_files(ffile, mfile, debug): state = sqnup.detect_modem_state(debug=debug, hangup=hangup) @@ -937,11 +985,13 @@ def run(ffile, mfile=None, baudrate=921600, verbose=False, debug=False, load_fff print('Your modem is in recovery mode. Please specify updater.elf file') reconnect_uart() sys.exit(1) - elif state == 4 or state == 1: + elif state == 4: resume = True + elif state == 1: + mtools = True elif state == -1: detect_error() - sqnup.upgrade(ffile=ffile, mfile=mfile, baudrate=baudrate, retry=retry, resume=resume, debug=debug, pkgdebug=False, verbose=verbose, load_fff=load_fff) + sqnup.upgrade(ffile=ffile, mfile=mfile, baudrate=baudrate, retry=retry, resume=resume, debug=debug, pkgdebug=False, verbose=verbose, load_fff=load_fff, mtools=mtools) reconnect_uart() def uart(ffh_mode=False, mfile=None, color=0x050505, verbose=False, debug=False, hangup=True): From 2646ca1955eb4cb2bb5a16960de26c8ac6fab012 Mon Sep 17 00:00:00 2001 From: Oliver Gauci Date: Sun, 28 Apr 2019 08:50:53 +0200 Subject: [PATCH 16/92] Added README file --- examples/OTA-lorawan/README.md | 2 ++ 1 file changed, 2 insertions(+) create mode 100644 examples/OTA-lorawan/README.md diff --git a/examples/OTA-lorawan/README.md b/examples/OTA-lorawan/README.md new file mode 100644 index 0000000..218d4e5 --- /dev/null +++ b/examples/OTA-lorawan/README.md @@ -0,0 +1,2 @@ +Coming soon + From eb87042cfcce10c8b4f40d6ede4ca8c8ff5d9d7e Mon Sep 17 00:00:00 2001 From: Catalin Ioana Date: Mon, 29 Apr 2019 09:02:29 +0300 Subject: [PATCH 17/92] updated pymesh scripts, added statistics, cli --- lib/pymesh/{ => lib}/ble.py | 30 +++- lib/pymesh/lib/cli.py | 147 +++++++++++++++++++ lib/pymesh/lib/loramesh.py | 2 +- lib/pymesh/lib/mesh_interface.py | 79 +++++++--- lib/pymesh/lib/mesh_internal.py | 215 ++++++++------------------- lib/pymesh/lib/meshaging.py | 144 +++++++++++++++--- lib/pymesh/lib/statistics.py | 241 +++++++++++++++++++++++++++++++ lib/pymesh/main.py | 222 ++++++++++++---------------- 8 files changed, 749 insertions(+), 331 deletions(-) rename lib/pymesh/{ => lib}/ble.py (71%) create mode 100644 lib/pymesh/lib/cli.py create mode 100644 lib/pymesh/lib/statistics.py diff --git a/lib/pymesh/ble.py b/lib/pymesh/lib/ble.py similarity index 71% rename from lib/pymesh/ble.py rename to lib/pymesh/lib/ble.py index 1712176..831ef60 100644 --- a/lib/pymesh/ble.py +++ b/lib/pymesh/lib/ble.py @@ -1,5 +1,3 @@ -VERSION = "1.0.0" - # Copyright (c) 2019, Pycom Limited. # # This software is licensed under the GNU GPL version 3 or any @@ -8,18 +6,25 @@ # available at https://www.pycom.io/opensource/licensing from network import Bluetooth - +import time import msgpack +VERSION = "1.0.0" + class BleCommunication: def __init__(self, mesh_mac): + self.mesh_mac = mesh_mac + self._init() + + def _init(self): self.status = { 'connected' : False } - bluetooth = Bluetooth(modem_sleep=False) - bluetooth.set_advertisement(name='PyGo (mac:' + str(mesh_mac) + ')', service_uuid=0xec00) + #bluetooth = Bluetooth(modem_sleep=False) + bluetooth = Bluetooth() + bluetooth.set_advertisement(name='PyGo (mac:' + str(self.mesh_mac) + ')', service_uuid=0xec00) bluetooth.callback(trigger=Bluetooth.CLIENT_CONNECTED | Bluetooth.CLIENT_DISCONNECTED, handler=self.conn_cb) bluetooth.advertise(True) @@ -55,3 +60,18 @@ def close(self): bluetooth.disconnect_client() bluetooth.deinit() pass + + def restart(self): + print("BLE disconnnect client") + bluetooth = Bluetooth() + bluetooth.disconnect_client() + time.sleep(2) + self.status['connected'] = False + if self.on_disconnect: + self.on_disconnect() + + # bluetooth.deinit() + # time.sleep(1) + # self._init() + pass + diff --git a/lib/pymesh/lib/cli.py b/lib/pymesh/lib/cli.py new file mode 100644 index 0000000..1e7a3ea --- /dev/null +++ b/lib/pymesh/lib/cli.py @@ -0,0 +1,147 @@ + +# Copyright (c) 2019, Pycom Limited. +# +# This software is licensed under the GNU GPL version 3 or any +# later version, with permitted additional terms. For more information +# see the Pycom Licence v1.0 document supplied with this file, or +# available at https://www.pycom.io/opensource/licensing + +import time +import json + +__version__ = '1' +""" +* initial draft +""" + +class Cli: + """ class for CLI commands """ + + def __init__(self, mesh, rpc_handler, ble_comm): + self.mesh = mesh + self.rpc_handler = rpc_handler + self.ble_comm = ble_comm + + # lamda functions + self.sleep = None + return + + def process(self, arg1, arg2): + last_mesh_pairs = [] + last_mesh_mac_list = [] + last_mesh_node_info = {} + + while True: + time.sleep(.1) + cmd = input('>') + # print(cmd) + + # if cmd == 'rb': + # print('resetting unpacker buffer') + # self.rpc_handler = RPCHandler(rx_worker, tx_worker, mesh, ble_comm) + + if cmd == 'mac': + print(self.mesh.mesh.mesh.MAC) + + elif cmd == 'mml': + mesh_mac_list = self.rpc_handler.get_mesh_mac_list() + if len(mesh_mac_list) > 0: + last_mesh_mac_list = mesh_mac_list + print('mesh_mac_list ', json.dumps(last_mesh_mac_list)) + + elif cmd == 'self': + node_info = self.rpc_handler.get_node_info() + print("self info:", node_info) + + elif cmd == 'mni': + for mac in last_mesh_mac_list: + node_info = self.rpc_handler.get_node_info(mac) + time.sleep(.5) + if len(node_info) > 0: + last_mesh_node_info[mac] = node_info + print('last_mesh_node_info', json.dumps(last_mesh_node_info)) + + elif cmd == 'mp': + mesh_pairs = self.rpc_handler.get_mesh_pairs() + if len(mesh_pairs) > 0: + last_mesh_pairs = mesh_pairs + print('last_mesh_pairs', json.dumps(last_mesh_pairs)) + + elif cmd == 's': + try: + to = int(input('(to)<')) + typ = input('(type, 0=text, 1=file, Enter for text)<') + if not typ: + typ = 0 + else: + typ = int(typ) + txt = input('(text/filename)<') + except: + print("Command parsing failed") + continue + data = { + 'to': to, + 'ty': typ, + 'b': txt, + 'id': 12345, + 'ts': int(time.time()), + } + print(self.rpc_handler.send_message(data)) + + elif cmd == 'ws': + to = int(input('(to)<')) + print(self.rpc_handler.send_message_was_sent(to, 12345)) + + elif cmd == 'rm': + print(self.rpc_handler.receive_message()) + + # elif cmd == 'gg': + # print("Gps:", (Gps.lat, Gps.lon)) + + # elif cmd == 'gs': + # lat = float(input('(lat)<')) + # lon = float(input('(lon)<')) + # Gps.set_location(lat, lon) + # print("Gps:", (Gps.lat, Gps.lon)) + + elif cmd == 'sleep': + try: + timeout = int(input('(time[sec])<')) + except: + continue + if self.sleep: + self.sleep(timeout) + + elif cmd == "ble": + # reset BLE connection + self.ble_comm.restart() + + elif cmd == "stat": + # do some statistics + # data = [] + # data[0] = {'mac':6, 'n':3, 't':30, 's1':0, 's2':0} + # data[0] = {'mac':6, 'n':3, 't':30, 's1':5, 's2':10} + # data[2] = {'mac':6, 'n':30, 't':60, 's1':10, 's2':45} + # for line in data: + # print() + # print("1 = {'mac':6, 'n':30, 't':60, 's1':10, 's2':45}<'") + # print("2 = {'mac':6, 'n':30, 't':60, 's1':10, 's2':45}<'") + # print("3 = {'mac':6, 'n':30, 't':60, 's1':10, 's2':45}<'") + # id = int(input('(choice 1-..)<')) + data = {'mac':6, 'n':3, 't':60, 's1':3, 's2':8} + res = self.mesh.statistics_start(data) + print("ok? ", res) + + elif cmd == "stat?": + try: + id = int(input('(id [Enter for all])<')) + except: + id = 0 + res = self.mesh.statistics_get(id) + print("ok? ", res) + + elif cmd == "rst": + print("Mesh Reset NVM settings ... ") + self.mesh.mesh.mesh.mesh.deinit() + if self.sleep: + self.sleep(1) \ No newline at end of file diff --git a/lib/pymesh/lib/loramesh.py b/lib/pymesh/lib/loramesh.py index cc139f9..b499daf 100644 --- a/lib/pymesh/lib/loramesh.py +++ b/lib/pymesh/lib/loramesh.py @@ -714,7 +714,7 @@ def node_info_mac_pack(self, mac): if node is None: print("Node is None %d"%mac) return bytes() - # pack type: RouterData or Child (basicaly NeighborData) + # pack type: RouterData or Child (basically NeighborData) data = pack('!B', role) data = data + node.pack() return data diff --git a/lib/pymesh/lib/mesh_interface.py b/lib/pymesh/lib/mesh_interface.py index ba2451a..d3a579f 100644 --- a/lib/pymesh/lib/mesh_interface.py +++ b/lib/pymesh/lib/mesh_interface.py @@ -11,7 +11,7 @@ #import _thread from mesh_internal import MeshInternal -#from meshaging import Meshaging +from statistics import Statistics __version__ = '3' """ @@ -34,7 +34,10 @@ def __init__(self, meshaging, lock): self.lock = lock #_thread.allocate_lock() self.meshaging = meshaging self.mesh = MeshInternal(self.meshaging) + self.sleep_function = None + self.single_leader_ts = 0 + self.statistics = Statistics(self.meshaging) self._timer = Timer.Alarm(self.periodic_cb, self.INTERVAL, periodic=True) # just run this ASAP @@ -49,7 +52,26 @@ def periodic_cb(self, alarm): t0 = time.ticks_ms() self.mesh.process() - self.mesh.process_messages() + if self.mesh.is_connected(): + self.statistics.process() + self.mesh.process_messages() + + # if Single Leader for 3 mins should reset + if self.mesh.mesh.state == self.mesh.mesh.STATE_LEADER and self.mesh.mesh.mesh.single(): + if self.single_leader_ts == 0: + # first time Single Leader, record time + self.single_leader_ts = time.time() + print("Single Leader", self.mesh.mesh.state, self.mesh.mesh.mesh.single(), + time.time() - self.single_leader_ts) + + if time.time() - self.single_leader_ts > 180: + print("Single Leader, just reset") + if self.sleep_function: + self.sleep_function(1) + else: + # print("Not Single Leader", self.mesh.mesh.state, self.mesh.mesh.mesh.single()) + self.single_leader_ts = 0 + self.lock.release() print(">>>>>>>>>>> DONE MESH THREAD ============ %d\n"%(time.ticks_ms() - t0)) @@ -57,15 +79,17 @@ def periodic_cb(self, alarm): pass def timer_kill(self): - with self.lock: - self._timer.cancel() + # with self.lock: + self._timer.cancel() def get_mesh_mac_list(self): mac_list = list() if self.lock.acquire(): - mac_list = list(self.mesh.get_all_macs_set()) + # mac_list = list(self.mesh.get_all_macs_set()) + # mac_list.sort() + mac_list = {0:list(self.mesh.get_all_macs_set())} self.lock.release() - #print("get_mesh_mac_list: %s"%str(mac_list)) + print("get_mesh_mac_list:", str(mac_list)) return mac_list def get_mesh_pairs(self): @@ -90,12 +114,17 @@ def is_connected(self): def ip(self): ip = None if self.lock.acquire(): - ip = self.mesh.ip() + ip = self.mesh.mesh.mesh.ipaddr() self.lock.release() return ip - def get_node_info(self, mac): + def get_node_info(self, mac_id): data = {} + try: + mac = int(mac_id) + except: + mac = self.mesh.MAC + print("get_node_info own mac") if self.lock.acquire(): data = self.mesh.node_info(mac) self.lock.release() @@ -108,17 +137,17 @@ def send_message(self, data): # check input parameters try: mac = int(data['to']) + msg_type = data.get('ty', 0) # text type, by default payload = data['b'] id = int(data['id']) ts = int(data['ts']) except: - ret = True - if ret: - # wrong input params + print('send_message: wrong input params') return False if self.lock.acquire(): - ret = self.meshaging.send_message(mac, payload, id, ts) + print("Send message to %d, typ %d, load %s"%(mac, msg_type, payload)) + ret = self.meshaging.send_message(mac, msg_type, payload, id, ts) # send messages ASAP self.mesh.process_messages() self.lock.release() @@ -147,8 +176,24 @@ def get_rcv_message(self): 'ts':ts} return {} - def send_file(self, ip, packsize, filename): - t = 0 - with self.lock: - self.mesh.send_file(ip, packsize, "/flash/" + filename) - return (t > 0) + def statistics_start(self, data): + """ starts to do statistics based on message send/ack """ + # data = {'mac':6, 'n':3, 't':30, 's1':10, 's2':30} + try: + # validate input params + mac = int(data['mac']) + num_mess = int(data['n']) + timeout = int(data['t']) + except: + print("statistics_start failed") + print(data) + return 0 + if mac == self.mesh.MAC: + data['mac'] = 2 + res = self.statistics.add_stat_mess(data) + return res + + def statistics_get(self, id): + res = self.statistics.status(id) + print(res) + return res diff --git a/lib/pymesh/lib/mesh_internal.py b/lib/pymesh/lib/mesh_internal.py index d36c039..e2625ef 100644 --- a/lib/pymesh/lib/mesh_internal.py +++ b/lib/pymesh/lib/mesh_internal.py @@ -98,7 +98,7 @@ def __init__(self, meshaging, lora=None): if lora is None: # lora = LoRa(mode=LoRa.LORA, region=LoRa.EU868, # bandwidth=LoRa.BW_125KHZ, sf=7) - lora = LoRa(mode=LoRa.LORA, region=LoRa.EU868, frequency = 863000000, bandwidth=LoRa.BW_250KHZ, sf=7) + lora = LoRa(mode=LoRa.LORA, region=LoRa.EU868, frequency = 863000000, bandwidth=LoRa.BW_500KHZ, sf=7) self.lora = lora # enable Thread interface @@ -116,7 +116,7 @@ def __init__(self, meshaging, lora=None): self.file_packsize = 0 self.file_size = 0 self.send_f = None - pass + pass def create_socket(self): """ create UDP socket """ @@ -133,14 +133,25 @@ def process_messages(self): mess.last_tx_ts = time.time() self.send_message(mess) mess.state = Message.MESS_STATE_SENT - elif mess.state == Message.MESS_STATE_SENT: - # try to resend - if time.time() - mess.last_tx_ts > 15: - print("Re-transmit %x %s" % (mac, mess.ip)) - mess.last_tx_ts = time.time() - self.send_message(mess) + # elif mess.state == Message.MESS_STATE_SENT: + # # try to resend + # if time.time() - mess.last_tx_ts > 15: + # print("Re-transmit %x %s" % (mac, mess.ip)) + # mess.last_tx_ts = time.time() + # self.send_message(mess) pass + def send_message(self, message, answer = None): + """ actual sending of a message on socket """ + payload = message.pack(self.MAC, answer) + pack_type = self.PACK_MESSAGE + if message.type == message.TYPE_IMAGE: + pack_type = self.PACK_FILE_SEND + if payload: + print("Send message ", payload) + self.send_pack(pack_type, payload, message.ip) + pass + def is_connected(self): # if detached erase all leader_data # return true if either child, router or leader @@ -176,7 +187,7 @@ def _process_leader(self): # ask each router self.leader_ts = time.time() router_list = self.mesh.routers_rloc_list(60) - router_num = min(len(router_list), 5) + router_num = min(len(router_list), 5) idx = 0 for router_pair in router_list[:router_num]: (age, router) = router_pair @@ -206,76 +217,22 @@ def process(self): if not self.rx_cb_registered: self.rx_cb_registered = True self.mesh.mesh.rx_cb(self.receive_all_data, None) - + # update internal neighbor table self.mesh.neighbors_update() self.mesh.leader_add_own_neigh() - # if file to be sent - if self.send_f is not None: - data, ip = self.send_f.process(None) - if len(data) > 0: - self.send_pack(self.PACK_FILE_SEND, data, ip) + # # if file to be sent + # if self.send_f is not None: + # data, ip = self.send_f.process(None) + # if len(data) > 0: + # self.send_pack(self.PACK_FILE_SEND, data, ip) - if self.mesh.state == self.mesh.STATE_LEADER: - self._process_leader() - # elif self.mesh.state == self.mesh.STATE_LEADER: + # if self.mesh.state == self.mesh.STATE_LEADER: # self._process_leader() - # else: - # print("No Router or Leader with neigh") return - # def resolve_mac(self, mac): - # """ convert a MAC address into an IP, returns None if MAC not in this Mesh """ - # mac_ip = None - # try: - # mac = int(mac) - # except: - # return None - - # # check if mac is own address ;) - # if mac == self.MAC: - # print("Resolved own address") - # mac_ip = self.mesh.rloc16 - # return mac_ip - - # # first, Maybe the mac is a neighbor - # mac_ip = self.mesh.neighbor_resolve_mac(mac) - # if mac_ip is not None: - # print("Mac %x found as neighbor %x" % (mac, mac_ip.rloc16)) - # return mac_ip.rloc16 - - # # TODO: check if mac is in router table (don't need to interrogate server) - # mac_ip = self.mesh.routers_rloc_list(300, mac) - - # if mac_ip is None: - # # interrogate Leader and wait for Leader answer - # self.require_leader_data() - - # # search for MAC - # mac_ip = self.mesh.resolve_mac_from_leader_data(mac) - - # if mac_ip is not None: - # print("Mac %x found as IP %x" % (mac, mac_ip)) - # # return results - # return mac_ip - - # def require_leader_data(self): - # # if current Node is Leader, we already have latest Leader Data - # if self.mesh.state in (self.mesh.STATE_LEADER, self.mesh.STATE_LEADER_SINGLE): - # return True - - # # maybe we have a recent Leader Data - # if (time.time() - self.interrogate_leader_ts < self.LEADER_INTERVAL and - # self.mesh.leader_data.records_num() > 0): - # return True - - # leader_ip = self.mesh._rloc_ip_net_addr() + self.mesh.LEADER_DEFAULT_RLOC - - # self.send_pack(self.PACK_ROUTER_ASK_LEADER_DATA, '', leader_ip) - # return False - def _check_to_send(self, pack_type, ip): send_it = True try: @@ -380,10 +337,6 @@ def node_info(self, mac): return node_data - def send_message(self, message): - """ actuall sending of a message on socket """ - return self.send_pack(self.PACK_MESSAGE, message.pack(self.MAC), message.ip) - def receive_all_data(self, arg): """ receives all packages on socket """ @@ -393,7 +346,7 @@ def receive_all_data(self, arg): break # out of while, no packet rcv_ip = rcv_addr[0] rcv_port = rcv_addr[1] - print('Incomming %d bytes from %s (port %d):' % + print('Incoming %d bytes from %s (port %d):' % (len(rcv_data), rcv_ip, rcv_port)) # print(rcv_data) @@ -426,6 +379,7 @@ def receive_all_data(self, arg): print("PACK_MESSAGE received") # add new pack received message = Message(rcv_data) + print(message.payload) message.ip = rcv_ip self.messages.add_rcv_message(message) # send back ACK @@ -472,31 +426,42 @@ def receive_all_data(self, arg): elif type == self.PACK_FILE_SEND: print("PACK_FILE_SEND received") - self.send_pack(self.PACK_FILE_SEND_ACK, '123', rcv_ip) - chunk = len(rcv_data) + payload = pack("!Q", self.MAC) + self.send_pack(self.PACK_FILE_SEND_ACK, payload, rcv_ip) + # rcv data contains '!QHH' as header + chunk = len(rcv_data) -12 self.file_size += chunk - #print("\r%7d " % size, end="") print("size: %d, chunk %d" % (self.file_size, chunk)) + file_handler = "ab" # append, by default if chunk > self.file_packsize: # started receiving a new file - self.file = open('/flash/dog_rcv.jpg', "wb") - self.file.write(rcv_data) + print("started receiving a new image") + file_handler = "wb" # write/create new file self.file_packsize = chunk elif chunk < self.file_packsize: + print("DONE receiving the image") # done receiving the file - self.file.write(rcv_data) - self.file.close() self.file_packsize = 0 self.file_size = 0 - else: - #middle of the file, just write data - self.file.write(rcv_data) + self.messages.file_transfer_done(rcv_data[:12]) + # else: + # #middle of the file, just write data + # self.file.write(rcv_data) + with open('/flash/dog_rcv.jpg', file_handler) as file: + file.write(rcv_data[12:]) + print("writing the image") + elif type == self.PACK_FILE_SEND_ACK: - print("PACK_FILE_SEND_ACK received") - data, _ = self.send_f.process(rcv_data) - if len(data) > 0: - self.send_pack(self.PACK_FILE_SEND, data, rcv_ip) + mac_rcv = unpack("!Q", rcv_data) + print("PACK_FILE_SEND_ACK received from MAC %d"%mac_rcv) + mac_rcv = 6 + message = self.messages.dict.get(mac_rcv, None) + if message: + print("message found") + self.send_message(message, rcv_data) + else: + print("message NOT found ", mac_rcv, self.messages.dict) else: print("Unknown packet, type: 0x%X" % (type)) @@ -506,72 +471,8 @@ def receive_all_data(self, arg): #self.mesh.blink(3, .1) pass - def send_file(self, ip, packsize, filename): - self.send_f = Send_File(packsize, filename, ip) - data, _ = self.send_f.process(None) - self.send_pack(self.PACK_FILE_SEND, data, ip) + # def send_file(self, ip, packsize, filename): + # self.send_f = Send_File(packsize, filename, ip) + # data, _ = self.send_f.process(None) + # self.send_pack(self.PACK_FILE_SEND, data, ip) -class Send_File: - INIT = const(1) - WAIT_ACK = const(2) - DONE = const(3) - - RETRIES_MAX = const(3) - - def __init__(self, packsize, filename, ip): - self.buffer = bytearray(packsize) - self.mv = memoryview(self.buffer) - self.ip = ip - self.chunk = 0 - try: - self.file = open(filename, "rb") - except: - print("File %s can't be opened !!!!"%filename) - self.state = DONE - return - self.size = 0 - self.packsize = packsize - - self.start = time.time() - self.state = INIT - - def process(self, last_response): - if self.state == INIT: - self.chunk = self.file.readinto(self.buffer) - self.state = WAIT_ACK - self.retries = 0 - self.size = self.chunk - self.start = time.time() - - elif self.state == WAIT_ACK: - if last_response is not None: - # got ACK, send next chunk - self.chunk = self.file.readinto(self.buffer) - self.size = self.size + self.chunk - print("%d Bytes sent, time: %4d sec" % (self.size, time.time() - self.start)) - if self.chunk == 0: - self._end_transfer() - - self.retries = 0 - else: - print("No answer, so retry?") - if time.time() - self.last_ts < 5: - #if we just sent the retry, don't resend anything, still wait for answer - print("No retry, too soon") - return ('', self.ip) - self.retries = self.retries + 1 - - if self.retries > RETRIES_MAX: - self._end_transfer() - - elif self.state == DONE: - self.chunk = 0 - - self.last_ts = time.time() - return (self.mv[:self.chunk], self.ip) - - def _end_transfer(self): - self.state = DONE - print("Done sending %d B in %s sec"%(self.size, time.time() - self.start)) - self.file.close() - \ No newline at end of file diff --git a/lib/pymesh/lib/meshaging.py b/lib/pymesh/lib/meshaging.py index ed2d47f..241eb8c 100644 --- a/lib/pymesh/lib/meshaging.py +++ b/lib/pymesh/lib/meshaging.py @@ -29,21 +29,16 @@ def __init__(self, lock): self.dict = {} self.rcv_dict = {} self.rcv_mess_new = None - # maybe a periodic process function - #self._timer = Timer.Alarm(self.periodic_cb, self.INTERVAL, periodic=True) - def send_message(self, mac, payload, id, ts): + def send_message(self, mac, msg_type, payload, id, ts): """ send a new message """ - already = None - try: - already = self.dict[mac] - except: - pass - if already is not None: + already = self.dict.get(mac, None) + if already: print('old message deleted for %X' % mac) - message = Message((mac, payload, id, ts)) + message = Message((mac, msg_type, payload, id, ts)) self.dict[mac] = message - print("Added new message for %X: %s" % (mac, payload)) + print("Added new message for %X: %s" % (mac, str(payload))) + return True def add_rcv_message(self, message): @@ -52,6 +47,12 @@ def add_rcv_message(self, message): self.rcv_dict[message.mac] = message self.rcv_mess_new = message + if message.payload == b'dog':#🐕': + message.payload = 'Picture started receiving' + print('Rcv mess about dog, so we start receiving picture') + else: + print('payload is not dog') + if self.on_rcv_message: self.on_rcv_message(message) @@ -68,6 +69,17 @@ def rcv_ack(self, data): if self.on_rcv_ack: self.on_rcv_ack(message) + + # check if message was about picture sending, to start actual file sending + mess = self.dict[message.mac] + if mess.payload == 'dog': + print('ACK from dog message, start picture sending') + del self.dict[message.mac] + self.send_message(message.mac, message.TYPE_IMAGE, 'dog.jpg', message.id, time.time()) + + if self.on_rcv_message: + mess = Message((message.mac, message.TYPE_TEXT, 'Receiving the picture', message.id+1, time.time())) + self.on_rcv_message(mess) else: print(message.mac, self.dict) pass @@ -94,6 +106,17 @@ def get_rcv_message(self): (mac, mess) = list(self.rcv_dict.items())[0] return (mac, mess.id, mess.ts, mess.payload) + def file_transfer_done(self, rcv_data): + message = Message(rcv_data) + message.payload = 'Picture was received' + print('Picture done receiving from %d', message.mac) + message.id = message.id + 1 + if self.on_rcv_message: + self.on_rcv_message(message) + + self.send_message(message.mac, message.TYPE_TEXT, 'Picture was received', message.id+1, time.time()) + + pass class Message: @@ -105,12 +128,19 @@ class Message: MESS_STATE_SENT = const(3) MESS_STATE_ACK = const(4) + # type of message: TEXT or IMAGE + TYPE_TEXT = const(0) + TYPE_IMAGE = const(1) + """ class that holds a message and its properties """ def __init__(self, data=None): self.local_ts = time.time() - self.ip = None + self.ip = "0" self.last_tx_ts = 0 + self.type = TYPE_TEXT + self.send_f = None + self.ts = time.time() if data is None: return @@ -125,21 +155,33 @@ def __init__(self, data=None): def _init_tuple(self, data): # (mac, payload, id, ts) - (self.mac, self.payload, self.id, self.ts) = data - self.state = MESS_STATE_IP_PENDING + (self.mac, self.type, self.payload, self.id, self.ts) = data + self.state = self.MESS_STATE_IP_PENDING + if self.type == TYPE_IMAGE: + self.send_f = Send_File(self.payload) return def _init_bytes(self, data): #print('NeighborData._init_bytes %s'%str(data)) self.mac, self.id, n = unpack(self.PACK_MESSAGE, data) - self.payload = unpack('!' + str(n) + 's', - data[calcsize(self.PACK_MESSAGE):]) + self.payload = data[calcsize(self.PACK_MESSAGE):] + #self.payload = unpack('!' + str(n) + 's', data[calcsize(self.PACK_MESSAGE):]) return - def pack(self, sender_mac): + def pack(self, sender_mac, answer): n = len(self.payload) data = pack(self.PACK_MESSAGE, sender_mac, self.id, n) - data = data + pack('!' + str(n) + 's', self.payload) + if self.type == TYPE_IMAGE: + if self.send_f: + file_chunk = self.send_f.process(answer) + if len(file_chunk) == 0: + self.state = MESS_STATE_ACK + data = None + else: + data = data + file_chunk + else: + #data = data + pack('!' + str(n) + 's', self.payload) + data = data + self.payload return data def pack_ack(self, sender_mac): @@ -149,3 +191,69 @@ def pack_ack(self, sender_mac): def unpack_ack(self, data): (self.mac, self.id) = unpack(self.PACK_MESSAGE_ACK, data) pass + +class Send_File: + INIT = const(1) + WAIT_ACK = const(2) + DONE = const(3) + + RETRIES_MAX = const(3) + + def __init__(self, filename): + self.packsize = 400 # packsize + self.buffer = bytearray(self.packsize) + self.mv = memoryview(self.buffer) + #self.ip = 0 # ip + self.chunk = 0 + self.filename = filename + try: + self.file = open(filename, "rb") + except: + print("File %s can't be opened !!!!"%filename) + self.state = DONE + return + self.size = 0 + + + self.start = time.time() + self.state = INIT + + def process(self, last_response): + if self.state == INIT: + self.chunk = self.file.readinto(self.buffer) + self.state = WAIT_ACK + self.retries = 0 + self.size = self.chunk + self.start = time.time() + + elif self.state == WAIT_ACK: + if last_response is not None: + # got ACK, send next chunk + self.chunk = self.file.readinto(self.buffer) + self.size = self.size + self.chunk + print("%d Bytes sent, time: %4d sec" % (self.size, time.time() - self.start)) + if self.chunk == 0: + self._end_transfer() + + self.retries = 0 + else: + print("No answer, so retry?") + if time.time() - self.last_ts < 5: + #if we just sent the retry, don't resend anything, still wait for answer + print("No retry, too soon") + return '' + self.retries = self.retries + 1 + + if self.retries > RETRIES_MAX: + self._end_transfer() + + elif self.state == DONE: + self.chunk = 0 + + self.last_ts = time.time() + return self.mv[:self.chunk] + + def _end_transfer(self): + self.state = DONE + print("Done sending %d B in %s sec"%(self.size, time.time() - self.start)) + self.file.close() diff --git a/lib/pymesh/lib/statistics.py b/lib/pymesh/lib/statistics.py new file mode 100644 index 0000000..9991a38 --- /dev/null +++ b/lib/pymesh/lib/statistics.py @@ -0,0 +1,241 @@ +# Copyright (c) 2019, Pycom Limited. +# +# This software is licensed under the GNU GPL version 3 or any +# later version, with permitted additional terms. For more information +# see the Pycom Licence v1.0 document supplied with this file, or +# available at https://www.pycom.io/opensource/licensing + +import uos +import time +import ujson + +__version__ = '1' +""" +first draft +""" + +class Statistics: + """ Class for keeping profiling statistics inside Pymesh """ + + TYPE_MESSAGE = const(0) + FILENAME = '/flash/statistics.json' + + def __init__(self, meshaging): + self.meshaging = meshaging + + # dictionary with all ongoing statistics, having key a unique 32bit number + self.dict = {} + self._restore_data() + self.sleep_function = None + + def _restore_data(self): + """ restore all data from file """ + try: + f = open(self.FILENAME, 'r') + except: + print('no ', self.FILENAME) + return + # with open(self.FILENAME, 'r+') as f: + for line in f: + try: + stat = StatJob(ujson.loads(line.strip())) + if stat.valid: + self.dict[stat.id] = stat + print('Stat added: ', stat.to_string()) + except: + print("parsing failed ", line) + continue + f.close() + print("Statistics file ok?!") + pass + + def save_all(self): + """ save all data as json into a file """ + # if len(self.dict) > 0: + with open(self.FILENAME, 'w') as f: + for _, job in self.dict.items(): + f.write(ujson.dumps(job.to_dict()) + '\n') + pass + + def _get_new_id(self): + id = 1 + while (1): + x = self.dict.get(id, None) + if x is None: + break + id = id + 1 + return id + + def num(self): + return len(self.dict) + + def add_stat_mess(self, data): + ret = False + id = self._get_new_id() + print("id:", id) + stat = StatJob([id, TYPE_MESSAGE, data]) + if stat.valid: + self.dict[id] = stat + ret = stat.status() + print("Stat: added ", ret) + return ret + + def process(self): + for id, job in self.dict.items(): + # print(job.to_string()) + if job.state == job.STATE_STARTED: + + # send new message + job.last_ack = False + job.last_send = time.time() + job.last_mess_num = job.last_mess_num + 1 + payload = "Test %d, pack from node %d, #%d/%d"%(job.id, job.mac, job.last_mess_num, job.repetitions) + print("Stat: " + payload) + self.meshaging.send_message(job.mac, 0, payload, id*1000+job.last_mess_num, job.last_send) + + job.state = job.STATE_WAIT_ANS + + elif job.state == job.STATE_WAIT_ANS: + # check if last message was ack + if job.last_ack == False: + job.last_ack = self.meshaging.mesage_was_ack(job.mac, id*1000+job.last_mess_num) + # job.last_ack could be False (0 int value) or True (1 int value) + job.ack_num = job.ack_num + job.last_ack + print("Stat: last mess ack? ", job.last_ack) + + # check if it's ACK or time for a new message + if job.last_ack or time.time() - job.last_send > job.period: + print("Timeout or ACK", job.to_string()) + # check if job is done + + if job.repetitions == job.last_mess_num: + job.state = job.STATE_DONE + print("Stat: done") + self.save_all() # just to be safe + continue # no need to send another message + + job.state = job.STATE_STARTED + self.sleep(job.s1, job.s2) + + def status(self, id): + data = list() + if id == 0: # print all jobs + data = list() + for _, job in self.dict.items(): + data.append(job.status()) + elif id == 1234: # print all Active jobs + for _, job in self.dict.items(): + if job.state != job.STATE_DONE: + data.append(job.status()) + elif id == 123456: # DELETE all done jobs + for idx, job in self.dict.items(): + if job.state == job.STATE_DONE: + del self.dict[idx] + elif id == 123456789: # DELETE ALL jobs + for idx, job in self.dict.items(): + del self.dict[idx] + else: # print a specific job + stat = self.dict.get(id, None) + data.append(stat.status()) + # print(stat.to_string()) + return data + + def sleep(self, s1, s2): + # nothing to do if s2 is 0 + if s2 == 0 or s2 < s1 or not self.sleep_function: + print("no sleep") + return + # random seconds between s1 and s2 (including them) + t = s1 + (uos.urandom(1)[0] % (s2 - s1 + 1)) + self.sleep_function(t) + +class StatJob: + """ Class for keeping a message statistics """ + STATE_STARTED = const(0) + STATE_WAIT_ANS = const(1) + STATE_DONE = const(2) + + def __init__(self, data): + self.type = 0 # by default message TEXT type + self.state = STATE_STARTED + self.valid = False + self.last_send = 0 + self.last_ack = False + self.last_mess_num = 0 + self.ack_num = 0 # num of ack messages + self.s1 = 0 + self.s2 = 0 + + if type(data) is dict: + self._init_dict(data) + elif type(data) is list: + self._init_list(data) + self.last_send = time.time() - self.period + + def _init_list(self, data_list): + id, jobtype, data = data_list + self.id = id + self.type = jobtype + + try: + self.mac = data['mac'] + self.repetitions = data['n'] + self.period = data['t'] + self.s1 = data.get('s1', 0) + self.s2 = data.get('s2', 0) + except: + print("StatJob init failed") + print(data) + return + self.valid = True + self.last_send = -self.period + + def to_string(self): + text = "%d: %s Send %d mess, to %d, every %d sec\n\ + Sent %d,ack %d"%(self.id, + ('Done' if self.state == STATE_DONE else 'Ongoing'), + self.repetitions, self.mac, + self.period, self.last_mess_num, self.ack_num) + return text + + def status(self): + data = {'id':self.id, 'm': self.mac, 'left': (self.repetitions - self.last_mess_num), + 'sc': str(self.ack_num)+':'+str(self.last_mess_num)} + #'done': self.state, + return data + + def to_dict(self): + d = {'id':self.id, + 'mac':self.mac, + 'period': self.period, + 'repetitions': self.repetitions, + 'ack_num': self.ack_num, + 'state': self.state, + 'last_send': self.last_send, + 'last_ack': self.last_ack, + 'last_mess_num': self.last_mess_num, + 'type': self.type, + 's1': self.s1, + 's2': self.s2, + } + return d + + def _init_dict(self, d): + self.valid = True + try: + self.id = d['id'] + self.mac = d['mac'] + self.period = d['period'] + self.repetitions = d['repetitions'] + self.ack_num = d['ack_num'] + self.state = d['state'] + self.last_send = d['last_send'] + self.last_ack = d['last_ack'] + self.last_mess_num = d['last_mess_num'] + self.type = d['type'] + self.s1 = d['s1'] + self.s2 = d['s2'] + except: + print("error parsing ", d) + self.valid = False + return diff --git a/lib/pymesh/main.py b/lib/pymesh/main.py index fed324b..34a0a61 100644 --- a/lib/pymesh/main.py +++ b/lib/pymesh/main.py @@ -27,6 +27,8 @@ from gps import Gps from meshaging import Meshaging +import _thread +from cli import Cli class RXWorker: def __init__(self, ble_comm): @@ -158,11 +160,7 @@ def resolve(self, obj): self.rx_worker.put(message) def demo_fn(self, *args): - global last_mesh_pairs, last_mesh_members - return { - 'p': last_mesh_pairs, - 'm': last_mesh_members, - } + return { 'res': 'demo_fn' } def demo_echo_fn(self, *args): return args @@ -200,8 +198,7 @@ def get_mesh_pairs(self, *args): return last_mesh_pairs - def get_node_info(self, mac_id): - global last_mesh_node_info + def get_node_info(self, mac_id = ' '): """ Returns the debug info for a specified mac address takes max 10 sec { @@ -223,16 +220,8 @@ def get_node_info(self, mac_id): 'n': '', # name, max. 16 chars } } """ - #res = self.mesh.get_node_info(mac_list[0]) - try: - mac = int(mac_id) - node_info = last_mesh_node_info.get(mac, {}) - if len(node_info) == 0: - node_info = mesh.get_node_info(mac) - return node_info - except: - return {} - + node_info = mesh.get_node_info(mac_id) + return node_info def send_message(self, data): """ sends a message with id, to m(MAC) @@ -270,11 +259,59 @@ def receive_message(self): } """ return self.mesh.get_rcv_message() + def send_image(self, data): + """ sends an image + return True if there is buffer to store it (to be sent)""" + print("Send Image ---------------------->>>>>>>> ", data) + start = 0 + filename = 'dog_2.jpg' + to = 0 + # packsize = 500 + image = list() + + try: + filename = data.get('fn', "image.jpg") + start = int(data['start']) + image = bytes(data['image']) + except: + print('parsing failed') + return False + + print("Image chunk size: %d"%len(image)) + file_handling = "ab" # append, by default + if start == 0: + file_handling = "wb" # write/create new + + with open("/flash/" + filename, file_handling) as file: + print("file open") + file.write(image) + print("file written") + + print("done") + return True + + def stat_start(self, data): + # do some statistics + #data = {'mac':6, 'n':3, 't':30} + res = self.mesh.statistics_start(data) + print("rpc stat_start? ", res) + return res + + def stat_status(self, data): + print("rpc stat_status ", data) + try: + id = int(data) + except: + id = 0 + res = mesh.statistics_get(id) + print("rpc stat_status id:"+ str(id) + ", res: " + str(res)) + return res + class Watchdog: def __init__(self, meshaging, mesh): self.INTERVAL = 10 self.meshaging = meshaging - self.mesh = mesh + self.mesh = mesh self._timer = Timer.Alarm(self.interval_cb, self.INTERVAL, periodic=True) def timer_kill(self): @@ -306,11 +343,9 @@ def on_rcv_message(message): 'id' : message.id, } - if message.payload == '🐕': - pycom.rgbled(0xff00ff) - msg = msgpack.packb(['notify', 'msg', message_data]) rx_worker.put(msg) + print(message_data['payload']) print("%d ================= RECEIVED :) :) :) "%time.ticks_ms()) mesh.meshaging.on_rcv_message = on_rcv_message @@ -337,121 +372,46 @@ def ble_on_disconnect(): Gps.init_static() -print("done !") - -last_mesh_pairs = [] -last_mesh_mac_list = [] -last_mesh_node_info = {} +kill_all = False +deepsleep_timeout = 0 watchdog = Watchdog(meshaging, mesh) -try: - while True: - - # print("============ MAIN LOOP >>>>>>>>>>>") - # t0 = time.ticks_ms() - # mesh_mac_list = mesh.get_mesh_mac_list() - # if len(mesh_mac_list) > 0: - # last_mesh_mac_list = mesh_mac_list - # print('mesh_mac_list ', json.dumps(last_mesh_mac_list)) - - # mesh_pairs = mesh.get_mesh_pairs() - # if len(mesh_pairs) > 0: - # last_mesh_pairs = mesh_pairs - # print('last_mesh_pairs', json.dumps(last_mesh_pairs)) - - # # ask node_info for each from the mac list - # for mac in mesh_mac_list: - # node_info = mesh.get_node_info(mac) - # if len(node_info) > 0: - # last_mesh_node_info[mac] = node_info - # print('last_mesh_node_info', json.dumps(last_mesh_node_info)) - # print(">>>>>>>>>>> DONE MAIN LOOP ============ %d\n"%(time.ticks_ms() - t0)) - - # time.sleep(15) - - #todo: if RPC parsing/execution error, then - - - cmd = input('>') - - if cmd == 'rb': - print('resetting unpacker buffer') - rpc_handler = RPCHandler(rx_worker, tx_worker, mesh, ble_comm) +def deepsleep_now(): + """ prepare scripts for graceful exit, deepsleeps if case """ + mesh.timer_kill() + watchdog.timer_kill() + rx_worker.timer_kill() + ble_comm.close() + Gps.terminate() + mesh.statistics.save_all() + print('Cleanup code, all Alarms cb should be stopped') + if deepsleep_timeout > 0: + print('Going to deepsleep for %d seconds'%deepsleep_timeout) + time.sleep(1) + machine.deepsleep(deepsleep_timeout * 1000) - elif cmd == 'mac': - print(mesh.mesh.mesh.MAC) - - elif cmd == 'mml': - #t0 = time.ticks_ms() - mesh_mac_list = mesh.get_mesh_mac_list() - if len(mesh_mac_list) > 0: - last_mesh_mac_list = mesh_mac_list - print('mesh_mac_list ', json.dumps(last_mesh_mac_list)) - - elif cmd == 'mni': - for mac in last_mesh_mac_list: - node_info = mesh.get_node_info(mac) - time.sleep(.5) - if len(node_info) > 0: - last_mesh_node_info[mac] = node_info - print('last_mesh_node_info', json.dumps(last_mesh_node_info)) - #print(">>>>>>>>>>> DONE MAIN LOOP ============ %d\n"%(time.ticks_ms() - t0)) - - elif cmd == 'mp': - mesh_pairs = mesh.get_mesh_pairs() - if len(mesh_pairs) > 0: - last_mesh_pairs = mesh_pairs - print('last_mesh_pairs', json.dumps(last_mesh_pairs)) - - elif cmd == 's': - to = int(input('(to)<')) - txt = input('(txt)<') - data = { - 'to': to, - 'b': txt or 'Hello World!', - 'id': 12345, - 'ts': int(time.time()), - } - print(rpc_handler.send_message(data)) +def deepsleep_init(timeout): + """ initializes an deeppsleep sequence, that will be performed later """ + global deepsleep_timeout, kill_all + deepsleep_timeout = timeout + kill_all = True + return - elif cmd == 'ws': - to = int(input('(to)<')) - print(rpc_handler.send_message_was_sent(to, 12345)) +mesh.statistics.sleep_function = deepsleep_init +mesh.sleep_function = deepsleep_init - elif cmd == 'rm': - print(rpc_handler.receive_message()) +cli = Cli(mesh, rpc_handler, ble_comm) +cli.sleep = deepsleep_init - elif cmd == 'gg': - print("Gps:", (Gps.lat, Gps.lon)) +_thread.start_new_thread(cli.process, (1, 2)) - elif cmd == 'gs': - lat = float(input('(lat)<')) - lon = float(input('(lon)<')) - Gps.set_location(lat, lon) - print("Gps:", (Gps.lat, Gps.lon)) +try: + while True: + if kill_all: + deepsleep_now() - elif cmd == 'f': - try: - to = int(input('(MAC to)<')) - packsize = int(input('(packsize)<')) - filename = input('(filename, Enter for dog.jpg)<') - if len(filename) == 0: - filename = 'dog.jpg' - ip = mesh.mesh.mesh.ip_mac_unique(to) - except: - continue - mesh.send_file(ip, packsize, filename) - - elif cmd == 'exit': - print('exit!') - break - - elif cmd == "rst": - print("Mesh Reset... ") - mesh.mesh.mesh.mesh.deinit() - #mesh.mesh.lora.Mesh() - machine.reset() + time.sleep(.1) pass except KeyboardInterrupt: @@ -459,9 +419,5 @@ def ble_on_disconnect(): except Exception as e: sys.print_exception(e) finally: - mesh.timer_kill() - watchdog.timer_kill() - rx_worker.timer_kill() - ble_comm.close() - Gps.terminate() - print('Cleanup code, all Alarms cb should be stopped') + deepsleep_now() + From 7b53b4954d35311cf2516e9fea2f9998ceab2e31 Mon Sep 17 00:00:00 2001 From: Oliver Gauci Date: Thu, 2 May 2019 09:59:53 +0200 Subject: [PATCH 18/92] sigfoxUplink: Fixed syntax error --- examples/sigfoxUplink/main.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/examples/sigfoxUplink/main.py b/examples/sigfoxUplink/main.py index d16d828..0bde8b9 100644 --- a/examples/sigfoxUplink/main.py +++ b/examples/sigfoxUplink/main.py @@ -13,5 +13,5 @@ # configure it as uplink only s.setsockopt(socket.SOL_SIGFOX, socket.SO_RX, False) -# send some bytes -s.send(bytes([0x01, 0x02, 0x03]) +# send some bytes +s.send(bytes([0x01, 0x02, 0x03])) From 3293541c798df646fb0dcb5f483833a5be419c8d Mon Sep 17 00:00:00 2001 From: Emmanuel Florent Date: Wed, 15 May 2019 15:36:37 +0200 Subject: [PATCH 19/92] Add Google IoT MQTT Client --- GoogleIOT/.gitignore | 3 + GoogleIOT/README.md | 22 +++ GoogleIOT/flash/cert/.gitkeep | 0 GoogleIOT/flash/config.example.py | 12 ++ GoogleIOT/flash/google_iot_core.py | 151 +++++++++++++++++ GoogleIOT/flash/main.py | 64 ++++++++ GoogleIOT/flash/umqtt.py | 249 +++++++++++++++++++++++++++++ GoogleIOT/genkey.sh | 27 ++++ 8 files changed, 528 insertions(+) create mode 100644 GoogleIOT/.gitignore create mode 100644 GoogleIOT/README.md create mode 100644 GoogleIOT/flash/cert/.gitkeep create mode 100644 GoogleIOT/flash/config.example.py create mode 100644 GoogleIOT/flash/google_iot_core.py create mode 100644 GoogleIOT/flash/main.py create mode 100644 GoogleIOT/flash/umqtt.py create mode 100755 GoogleIOT/genkey.sh diff --git a/GoogleIOT/.gitignore b/GoogleIOT/.gitignore new file mode 100644 index 0000000..802aba7 --- /dev/null +++ b/GoogleIOT/.gitignore @@ -0,0 +1,3 @@ +db/* +*.pem +flash/config.py diff --git a/GoogleIOT/README.md b/GoogleIOT/README.md new file mode 100644 index 0000000..3bc62ac --- /dev/null +++ b/GoogleIOT/README.md @@ -0,0 +1,22 @@ +

+ +# Google Cloud Iot Core MQTT connection library + +### requirement + +Pycom Firmware >= 1.20.0.rc11 + +You will need to setup a Google IoT core registry as described here: + +During the activation please collect the following informations: 'project_id', + 'cloud_region' and 'registry_id'. + +### usage + +- create a device registry: +https://cloud.google.com/iot/docs/quickstart#create_a_device_registry +- generate a key using the provided tool genkey.sh and add it to the platform +- add the public key to Google IoT Core : +https://cloud.google.com/iot/docs/quickstart#add_a_device_to_the_registry +- copy config.example.py to config.py and edit the variable +- upload the project using pymakr diff --git a/GoogleIOT/flash/cert/.gitkeep b/GoogleIOT/flash/cert/.gitkeep new file mode 100644 index 0000000..e69de29 diff --git a/GoogleIOT/flash/config.example.py b/GoogleIOT/flash/config.example.py new file mode 100644 index 0000000..9600ff6 --- /dev/null +++ b/GoogleIOT/flash/config.example.py @@ -0,0 +1,12 @@ +''' Set here you setup config in this example +''' +CONFIG = { + 'wifi_ssid': "somewifi", + 'wifi_password': 'iforgot', + 'ntp_server': 'time.google.com', + 'project_id': 'pybytes-101', # replace with your Google project_id + 'cloud_region': 'us-central1', # replace + 'registry_id': 'goinvent', # replace with your Google registry_id + 'topic': '/devices/pysense2/events', # replace so match your device + 'device_id': 'pysense2' # +} diff --git a/GoogleIOT/flash/google_iot_core.py b/GoogleIOT/flash/google_iot_core.py new file mode 100644 index 0000000..d4da76e --- /dev/null +++ b/GoogleIOT/flash/google_iot_core.py @@ -0,0 +1,151 @@ +''' A MQTT wrapper for Google Cloud IoT MQTT bridge + Extended from umqtt.robust by Paul Sokolovsky with wrap of Google credentials + + https://github.com/micropython/micropython-lib/tree/master/umqtt.robust + https://github.com/micropython/micropython-lib/tree/master/umqtt.simple + + Quick API Reference: + connect(...) - Connect to a server. Returns True if this connection uses + persistent session stored on a server (this will be always + False if clean_session=True argument is used (default)). + disconnect() - Disconnect from a server, release resources. + ping() - Ping server (response is processed automatically by wait_msg()). + publish() - Publish a message. + subscribe() - Subscribe to a topic. + set_callback() - Set callback for received subscription messages. + wait_msg() - Wait for a server message. A subscription message will be + delivered to a callback set with set_callback(), any other + messages will be processed internally. + check_msg() - Check if there's pending message from server. If yes, process + the same way as wait_msg(), if not, return immediately. +''' + +import json +from binascii import b2a_base64 +from binascii import a2b_base64 +import ucrypto +import utime +import umqtt + +def _create_unsigned_jwt(project_id, expires=60 * 60 * 24): + header = { + 'alg': "RS256", + 'typ': 'JWT' + } + token = { + 'iat': utime.time(), + 'exp': utime.time() + expires, + 'aud': project_id + } + return b2a_base64(json.dumps(header)) + "." + \ + b2a_base64(json.dumps(token)) + +def _get_google_client_id( + project_id, + cloud_region, + registry_id, + device_id): + return "projects/%s/locations/%s/registries/%s/devices/%s" % ( + project_id, cloud_region, registry_id, device_id) + +def _create_google_jwt(project_id, private_key): + to_sign = _create_unsigned_jwt(project_id) + signed = ucrypto.generate_rsa_signature(to_sign, private_key) + return to_sign + b'.' + b2a_base64(signed) + + +class GoogleMQTTClient(umqtt.MQTTClient): + ''' Instanciate a mqtt client + Args: + var_int (int): An integer. + var_str (str): A string. + project_id (str): your google's project_id + private_key (bytes): private key bytes in pk8s format + cloud_region (str): your google's region + registry_id (str): the name you had given to your registry + device_id: (str): the human friendly device name + ''' + + DELAY = 2 + DEBUG = True + GOOGLE_CA = '/flash/cert/google_roots.pem' + GOOGLE_MQTT = 'mqtt.googleapis.com' + + def __init__( + self, + project_id, + private_key, + cloud_region, + registry_id, + device_id): + self.private_key = private_key + self.project_id = project_id + self.jwt = _create_google_jwt(self.project_id, self.private_key) + google_client_id = _get_google_client_id( + project_id, cloud_region, registry_id, device_id) + google_args = self._get_google_mqtt_args(self.jwt) + super().__init__(google_client_id, self.GOOGLE_MQTT, **google_args) + + def delay(self, i): + utime.sleep(self.DELAY + i) + + def log(self, in_reconnect, err): + if self.DEBUG: + if in_reconnect: + print("mqtt reconnect: %r" % err) + else: + print("mqtt: %r" % err) + + def reconnect(self): + i = 0 + while True: + if not self.is_jwt_valid(): + self.pswd = self.jwt = _create_google_jwt( + self.project_id, self.private_key) + try: + return super().connect(False) + except OSError as exception: + self.log(True, exception) + i += 1 + self.delay(i) + + def publish(self, topic, msg, retain=False, qos=0): + if qos == 2: + raise Exception("qos=2 not supported by mqtt bridge") + + while True: + try: + return super().publish(topic, msg, retain, qos) + except OSError as exception: + self.log(False, exception) + self.reconnect() + + def wait_msg(self): + while True: + try: + return super().wait_msg() + except OSError as exception: + self.log(False, exception) + self.reconnect() + + def _get_google_mqtt_args(self, jwt): + arguments = { + 'user': '', + 'password': jwt, + 'port': 8883, + 'ssl': True, + 'ssl_params': { + 'ca_certs': self.GOOGLE_CA + } + } + return arguments + + def is_jwt_valid(self): + try: + token = json.loads(a2b_base64(self.jwt.decode().split('.')[1])) + except Exception: + return False + return utime.time() - token.get('iat') < 60 * 60 * 24 + + def set_last_will(self, topic, msg, retain=False, qos=0): + raise Exception("set_last_will not supported by mqtt bridge") diff --git a/GoogleIOT/flash/main.py b/GoogleIOT/flash/main.py new file mode 100644 index 0000000..1f8f384 --- /dev/null +++ b/GoogleIOT/flash/main.py @@ -0,0 +1,64 @@ +''' Example Google IoT Core connection +''' +import utime +import machine +import _thread +from network import WLAN +from google_iot_core import GoogleMQTTClient +from config import CONFIG + +# Connect to Wifi +WLAN_I = WLAN(mode=WLAN.STA, max_tx_pwr=78) +print('Connecting to WiFi %s' % CONFIG.get('wifi_ssid')) +WLAN_I.connect(CONFIG.get('wifi_ssid'), (WLAN.WPA2, CONFIG.get('wifi_password')), timeout=60000) +i = 0 +while not WLAN_I.isconnected(): + i = i + 1 + # print(".", end="") + utime.sleep(1) + if i > 60: + print("\nWifi not available") + break + +# Syncing time +RTCI = machine.RTC() +print('Syncing time with %s' % CONFIG.get('ntp_server'), end='') +RTCI.ntp_sync(CONFIG.get('ntp_server')) +while not RTCI.synced(): + print('.', end='') + utime.sleep(1) +print('') + +# read the private key +FILE_HANDLE = open("cert/%s-pk8.key" % CONFIG.get('device_id')) +PRIVATE_KEY = FILE_HANDLE.read() +FILE_HANDLE.close() + +# make a mqtt client, connect and publish an empty message +MQTT_CLIENT = GoogleMQTTClient(CONFIG.get('project_id'), + PRIVATE_KEY, + CONFIG.get('cloud_region'), + CONFIG.get('registry_id'), + CONFIG.get('device_id')) + + +MQTT_CLIENT.connect() +MQTT_CLIENT.publish(CONFIG.get('topic'), b'test') + +# make a demo callback +def _sub_cb(topic, msg): + ''' handle your message received here ... + ''' + print('received:', topic, msg) + +# register callback +MQTT_CLIENT.set_callback(_sub_cb) + +# example subscription +MQTT_CLIENT.subscribe('/devices/%s/config' % CONFIG.get('device_id'), qos=1) +while True: + # Non-blocking wait for message + MQTT_CLIENT.check_msg() + # Then need to sleep to avoid 100% CPU usage (in a real + # app other useful actions would be performed instead) + utime.sleep_ms(100) diff --git a/GoogleIOT/flash/umqtt.py b/GoogleIOT/flash/umqtt.py new file mode 100644 index 0000000..1d627f7 --- /dev/null +++ b/GoogleIOT/flash/umqtt.py @@ -0,0 +1,249 @@ +'''umqtt is a simple MQTT client for MicroPython. + Original code: https://github.com/micropython/micropython-lib/tree/master/umqtt.simple''' +import time +import os +import usocket as socket +import ustruct as struct +from ubinascii import hexlify + + +class MQTTException(Exception): + pass + + +class MQTTClient: + + def __init__(self, client_id, server, port=0, user=None, password=None, keepalive=0, + ssl=False, ssl_params={}): + if port == 0: + port = 8883 if ssl else 1883 + self.client_id = client_id + self.sock = None + self.server = server + self.addr = socket.getaddrinfo(server, port)[0][-1] + self.ssl = ssl + self.ssl_params = ssl_params + self.pid = 0 + self.cb = None + self.user = user + self.pswd = password + self.keepalive = keepalive + self.lastWill_topic = None + self.lastWill_msg = None + self.lastWill_qos = 0 + self.lastWill_retain = False + + def _send_str(self, s): + self.sock.write(struct.pack("!H", len(s))) + self.sock.write(s) + + def _recv_len(self): + n = 0 + sh = 0 + while 1: + b = self.sock.read(1)[0] + n |= (b & 0x7f) << sh + if not b & 0x80: + return n + sh += 7 + + def set_callback(self, f): + self.cb = f + + def set_last_will(self, topic, msg, retain=False, qos=0): + assert 0 <= qos <= 2 + assert topic + self.lastWill_topic = topic + self.lastWill_msg = msg + self.lastWill_qos = qos + self.lastWill_retain = retain + + def connect(self, clean_session=True): + if (self.sock): + # https://pycomiot.atlassian.net/browse/PB-358 + try: + self.sock.send('') # can send == closeable + self.sock.close() + except Exception as e: + self.sock = None # socket is not closable + import gc + gc.collect() + + self.sock = socket.socket() + self.sock.connect(self.addr) + if self.ssl == True: + import ussl + pssl ={} + if self.ssl_params is not None and self.ssl_params.get('ca_certs') is not None: + try: + os.stat(self.ssl_params.get('ca_certs')) + pssl["cert_reqs"] = ussl.CERT_REQUIRED + pssl["ca_certs"] = self.ssl_params.get('ca_certs') + if self.ssl_params.get('keyfile') is not None: + pssl["keyfile"] = self.ssl_params.get('keyfile') + if self.ssl_params.get('certfile') is not None: + pssl["certfile"] = self.ssl_params.get('certfile') + except Exception as e: + print(e) + print("WARNING:TLS certificate validation for MQTT will be disabled",self.ssl_params.get('ca_file'), " is missing") + + else: + print("WARNING: consider enabling TSL certificate validation for MQTT") + # todo check the file if params and print error + # os.stat(self.ssl_params.get('keyfile')) + # os.stat(self.ssl_params.get('certfile')) + self.sock = ussl.wrap_socket(self.sock, **pssl) + else: + print("WARNING: consider enabling TLS for MQTT") + premsg = bytearray(b"\x10\0\0\0\0\0") + msg = bytearray(b"\x04MQTT\x04\x02\0\0") + + size = 10 + 2 + len(self.client_id) + msg[6] = clean_session << 1 + if self.user is not None: + size += 2 + len(self.user) + 2 + len(self.pswd) + msg[6] |= 0xC0 + if self.keepalive: + assert self.keepalive < 65536 + msg[7] |= self.keepalive >> 8 + msg[8] |= self.keepalive & 0x00FF + if self.lastWill_topic: + size += 2 + len(self.lastWill_topic) + 2 + len(self.lastWill_msg) + msg[6] |= 0x4 | (self.lastWill_qos & 0x1) << 3 | (self.lastWill_qos & 0x2) << 3 + msg[6] |= self.lastWill_retain << 5 + + i = 1 + while size > 0x7f: + premsg[i] = (size & 0x7f) | 0x80 + size >>= 7 + i += 1 + premsg[i] = size + + self.sock.write(premsg, i + 2) + self.sock.write(msg) + self._send_str(self.client_id) + + if self.lastWill_topic: + self._send_str(self.lastWill_topic) + self._send_str(self.lastWill_msg) + + if self.user is not None: + self._send_str(self.user) + self._send_str(self.pswd) + + resp = self.sock.read(4) + if len(resp) == 0: + print("[MQTT] ERR: server closed connection.") + return + assert resp[0] == 0x20 and resp[1] == 0x02 + if resp[3] != 0: + raise MQTTException(resp[3]) + print("[MQTT] %s OK!" % self.server) + return resp[2] & 1 + + def disconnect(self): + self.sock.write(b"\xe0\0") + self.sock.close() + + def ping(self): + self.sock.write(b"\xc0\0") + + def publish(self, topic, msg, retain=False, qos=0): + pkt = bytearray(b"\x30\0\0\0") + pkt[0] |= qos << 1 | retain + size = 2 + len(topic) + len(msg) + if qos > 0: + size += 2 + assert size < 2097152 + i = 1 + while size > 0x7f: + pkt[i] = (size & 0x7f) | 0x80 + size >>= 7 + i += 1 + pkt[i] = size + # print('publish', hex(len(pkt)), hexlify(pkt).decode('ascii')) + self.sock.write(pkt, i + 1) + self._send_str(topic) + if qos > 0: + self.pid += 1 + pid = self.pid + struct.pack_into("!H", pkt, 0, pid) + self.sock.write(pkt, 2) + self.sock.write(msg) + + if qos == 1: + while 1: + op = self.wait_msg() + if op == 0x40: + size = self.sock.read(1) + assert size == b"\x02" + rcv_pid = self.sock.read(2) + rcv_pid = rcv_pid[0] << 8 | rcv_pid[1] + if pid == rcv_pid: + return + elif qos == 2: + assert 0 + + def subscribe(self, topic, qos=0): + assert self.cb is not None, "Subscribe callback is not set" + pkt = bytearray(b"\x82\0\0\0") + self.pid += 1 + struct.pack_into("!BH", pkt, 1, 2 + 2 + len(topic) + 1, self.pid) + # print('subscribe', hex(len(pkt)), hexlify(pkt).decode('ascii')) + self.sock.write(pkt) + self._send_str(topic) + self.sock.write(qos.to_bytes(1, "little")) + while 1: + op = self.wait_msg() + if op == 0x90: + resp = self.sock.read(4) + # print('Response subscribe', hexlify(resp).decode('ascii')) + assert resp[1] == pkt[2] and resp[2] == pkt[3] + if resp[3] == 0x80: + raise MQTTException(resp[3]) + return + + # Wait for a single incoming MQTT message and process it. + # Subscribed messages are delivered to a callback previously + # set by .set_callback() method. Other (internal) MQTT + # messages processed internally. + def wait_msg(self): + res = self.sock.read(1) + self.sock.setblocking(True) + if res is None: + return None + if res == b"": + # other tls empty response happens ... + # raise OSError(-1) + return + if res == b"\xd0": # PING RESPONCE + size = self.sock.read(1)[0] + assert size == 0 + return None + op = res[0] + if op & 0xf0 != 0x30: + return op + size = self._recv_len() + topic_len = self.sock.read(2) + topic_len = (topic_len[0] << 8) | topic_len[1] + topic = self.sock.read(topic_len) + size -= topic_len + 2 + if op & 6: + pid = self.sock.read(2) + pid = pid[0] << 8 | pid[1] + size -= 2 + msg = self.sock.read(size) + self.cb(topic, msg) + if op & 6 == 2: + pkt = bytearray(b"\x40\x02\0\0") + struct.pack_into("!H", pkt, 2, pid) + self.sock.write(pkt) + elif op & 6 == 4: + assert 0 + + # Checks whether a pending message from server is available. + # If not, returns immediately with None. Otherwise, does + # the same processing as wait_msg. + def check_msg(self): + self.sock.setblocking(False) + return self.wait_msg() diff --git a/GoogleIOT/genkey.sh b/GoogleIOT/genkey.sh new file mode 100755 index 0000000..082bf79 --- /dev/null +++ b/GoogleIOT/genkey.sh @@ -0,0 +1,27 @@ +# Google Cloud IoT Core +if [[ $# -eq 0 ]] ; then + echo "Usage: $0 device_id" + exit 0 +fi + +DB_DIR='db' +DEVICE_ID=$1 + +if [ ! -f $DB_DIR/$DEVICE_ID-priv.pem ]; then + openssl genrsa -out $DB_DIR/$DEVICE_ID-priv.pem 2048 +fi + +if [ ! -f $DB_DIR/$DEVICE_ID-pub.pem ]; then + openssl rsa -in $DB_DIR/$DEVICE_ID-priv.pem -pubout -out $DB_DIR/$DEVICE_ID-pub.pem +fi + +if [ ! -f flash/cert/$DEVICE_ID-pk8.key ]; then + openssl pkcs8 -topk8 -nocrypt -in $DB_DIR/$DEVICE_ID-priv.pem -out flash/cert/$DEVICE_ID-pk8.key +fi + +if [ ! -f flash/cert/google_roots.pem ]; then + wget "https://pki.google.com/roots.pem" -O flash/cert/google_roots.pem +fi + +echo "Please add this public key to Google Cloud IoT Core Registry" +cat $DB_DIR/$DEVICE_ID-pub.pem From b985685ee4b8bc892d4eb9334208cef9ad38fff0 Mon Sep 17 00:00:00 2001 From: Emmanuel Florent <5731405+emmanuel-florent@users.noreply.github.com> Date: Wed, 15 May 2019 15:38:28 +0200 Subject: [PATCH 20/92] Add Google IoT MQTT Client --- GoogleIOT/README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/GoogleIOT/README.md b/GoogleIOT/README.md index 3bc62ac..8cc8d43 100644 --- a/GoogleIOT/README.md +++ b/GoogleIOT/README.md @@ -6,7 +6,7 @@ Pycom Firmware >= 1.20.0.rc11 -You will need to setup a Google IoT core registry as described here: +You will need to setup a Google IoT core registry as described here: https://cloud.google.com/iot/docs/quickstart#create_a_device_registry During the activation please collect the following informations: 'project_id', 'cloud_region' and 'registry_id'. From 96af79be7abcfca9f41a240decc6bd50b55bf5c4 Mon Sep 17 00:00:00 2001 From: danicampora Date: Wed, 22 May 2019 13:14:34 +0200 Subject: [PATCH 21/92] pycom-libraries: Add missing license headers. --- deepsleep/deepsleep.py | 10 ++++++++++ examples/DS18X20/boot.py | 10 ++++++++++ examples/DS18X20/main.py | 10 ++++++++++ examples/DS18X20/onewire.py | 10 +++++++++- examples/OTA-lorawan/LoraServer.py | 11 +++++++++-- examples/OTA-lorawan/config.py | 11 +++++++++-- examples/OTA-lorawan/diff_match_patch.py | 10 +++++++++- .../firmware/1.17.0/flash/diff_match_patch.py | 10 +++++++++- .../OTA-lorawan/firmware/1.17.0/flash/loranet.py | 10 ++++++++++ examples/OTA-lorawan/firmware/1.17.0/flash/main.py | 10 ++++++++++ examples/OTA-lorawan/firmware/1.17.0/flash/ota.py | 10 ++++++++++ .../OTA-lorawan/firmware/1.17.0/flash/watchdog.py | 10 ++++++++++ .../firmware/1.17.1/flash/diff_match_patch.py | 10 +++++++++- .../OTA-lorawan/firmware/1.17.1/flash/loranet.py | 10 ++++++++++ examples/OTA-lorawan/firmware/1.17.1/flash/main.py | 10 ++++++++++ examples/OTA-lorawan/firmware/1.17.1/flash/ota.py | 10 ++++++++++ .../OTA-lorawan/firmware/1.17.1/flash/watchdog.py | 10 ++++++++++ examples/OTA-lorawan/groupUpdater.py | 10 +++++++++- examples/OTA-lorawan/ota.py | 10 +++++++++- examples/OTA-lorawan/updaterService.py | 10 +++++++++- examples/OTA/1.0.0/flash/config.py | 10 ++++++++++ examples/OTA/1.0.0/flash/get_id.py | 10 ++++++++++ examples/OTA/1.0.0/flash/lib/OTA.py | 10 ++++++++++ examples/OTA/1.0.0/flash/main.py | 10 ++++++++++ examples/OTA/1.0.1/flash/config.py | 10 ++++++++++ examples/OTA/1.0.1/flash/get_id.py | 10 ++++++++++ examples/OTA/1.0.1/flash/lib/OTA.py | 10 ++++++++++ examples/OTA/1.0.1/flash/main.py | 10 ++++++++++ examples/OTA/OTA_server.py | 11 +++++++++-- examples/accelerometer_wake/main.py | 10 ++++++++++ examples/adc/boot.py | 10 ++++++++++ examples/adc/main.py | 10 ++++++++++ examples/bluetooth/boot.py | 10 ++++++++++ examples/bluetooth/main.py | 10 ++++++++++ examples/deepsleep/main.py | 10 ++++++++++ examples/https/boot.py | 10 ++++++++++ examples/https/main.py | 10 ++++++++++ examples/i2c/bh1750fvi.py | 10 ++++++++++ examples/i2c/boot.py | 10 ++++++++++ examples/i2c/main.py | 10 ++++++++++ examples/lopy-lopy/lopy-A/boot.py | 10 ++++++++++ examples/lopy-lopy/lopy-A/main.py | 10 ++++++++++ examples/lopy-lopy/lopy-B/boot.py | 10 ++++++++++ examples/lopy-lopy/lopy-B/main.py | 10 ++++++++++ examples/loraNanoGateway/gateway/boot.py | 10 ++++++++++ examples/loraNanoGateway/gateway/main.py | 10 ++++++++++ examples/loraabp/boot.py | 10 ++++++++++ examples/loraabp/main.py | 10 ++++++++++ examples/loramac/boot.py | 10 ++++++++++ examples/loramac/main.py | 10 ++++++++++ examples/lorawan-nano-gateway/abp_node.py | 10 ++++++++++ examples/lorawan-nano-gateway/abp_node_US915.py | 10 ++++++++++ examples/lorawan-nano-gateway/config.py | 10 ++++++++++ examples/lorawan-nano-gateway/main.py | 10 ++++++++++ examples/lorawan-nano-gateway/nanogateway.py | 10 ++++++++++ examples/lorawan-nano-gateway/otaa_node.py | 10 ++++++++++ examples/lorawan-nano-gateway/otaa_node_US915.py | 10 ++++++++++ examples/lorawan-regional-examples/main_AS923.py | 10 ++++++++++ examples/lorawan-regional-examples/main_AU915.py | 10 ++++++++++ examples/lorawan-regional-examples/main_EU868.py | 10 ++++++++++ examples/lorawan-regional-examples/main_US915.py | 10 ++++++++++ examples/mqtt/boot.py | 10 ++++++++++ examples/mqtt/main.py | 10 ++++++++++ examples/mqtt/mqtt.py | 10 ++++++++++ examples/onlineLog/boot.py | 10 ++++++++++ examples/onlineLog/main.py | 10 ++++++++++ examples/onlineLog/onewire.py | 10 +++++++++- examples/pytrack_pysense_accelerometer/main.py | 10 ++++++++++ examples/sigfoxUplink/boot.py | 10 ++++++++++ examples/sigfoxUplink/main.py | 10 ++++++++++ examples/threading/boot.py | 10 ++++++++++ examples/threading/main.py | 10 ++++++++++ lib/ADS1115/ADS1115.py | 10 ++++++++++ lib/ADS1115/boot.py | 10 ++++++++++ lib/ADS1115/main.py | 0 lib/ALSPT19/ALSPT19.py | 10 ++++++++++ lib/MFRC630/MFRC630.py | 2 +- lib/lora_mesh/loramesh.py | 10 ++++++++++ lib/lora_mesh/main.py | 10 ++++++++++ lib/lora_mesh/main_border_router.py | 10 ++++++++++ lib/mqtt/mqtt.py | 10 ++++++++++ lib/onewire/onewire.py | 1 - lib/pycoproc/pycoproc.py | 10 ++++++++++ lib/sqnsupgrade/sqnsbr.py | 2 +- lib/sqnsupgrade/sqnsbrz.py | 2 +- pybytes/pyscan/lib/LIS2HH12.py | 10 ++++++++++ pybytes/pyscan/lib/LTR329ALS01.py | 10 ++++++++++ pybytes/pyscan/lib/MFRC630.py | 2 +- pybytes/pyscan/lib/pycoproc.py | 10 ++++++++++ pybytes/pyscan/lib/pyscan.py | 10 ++++++++++ pybytes/pyscan/main.py | 13 +++++++++++-- pybytes/pysense/lib/LIS2HH12.py | 10 ++++++++++ pybytes/pysense/lib/LTR329ALS01.py | 10 ++++++++++ pybytes/pysense/lib/MPL3115A2.py | 10 ++++++++++ pybytes/pysense/lib/SI7006A20.py | 10 ++++++++++ pybytes/pysense/lib/pycoproc.py | 10 ++++++++++ pybytes/pysense/lib/pysense.py | 10 ++++++++++ pybytes/pysense/main.py | 10 ++++++++++ pybytes/pytrack/lib/L76GNSS.py | 10 ++++++++++ pybytes/pytrack/lib/LIS2HH12.py | 10 ++++++++++ pybytes/pytrack/lib/pycoproc.py | 10 ++++++++++ pybytes/pytrack/lib/pytrack.py | 10 ++++++++++ pybytes/pytrack/main.py | 10 ++++++++++ pyscan/lib/LIS2HH12.py | 10 ++++++++++ pyscan/lib/LTR329ALS01.py | 10 ++++++++++ pyscan/main.py | 2 +- pyscan/nfc.py | 2 +- pysense/lib/LIS2HH12.py | 10 ++++++++++ pysense/lib/LTR329ALS01.py | 10 ++++++++++ pysense/lib/MPL3115A2.py | 10 ++++++++++ pysense/lib/SI7006A20.py | 10 ++++++++++ pysense/lib/pysense.py | 10 ++++++++++ pysense/main.py | 10 ++++++++++ pytrack/lib/L76GNSS.py | 10 ++++++++++ pytrack/lib/LIS2HH12.py | 10 ++++++++++ pytrack/lib/pytrack.py | 10 ++++++++++ pytrack/main.py | 10 ++++++++++ 117 files changed, 1086 insertions(+), 23 deletions(-) delete mode 100644 lib/ADS1115/main.py diff --git a/deepsleep/deepsleep.py b/deepsleep/deepsleep.py index 10b0c30..80b4754 100644 --- a/deepsleep/deepsleep.py +++ b/deepsleep/deepsleep.py @@ -1,3 +1,13 @@ +#!/usr/bin/env python +# +# Copyright (c) 2019, Pycom Limited. +# +# This software is licensed under the GNU GPL version 3 or any +# later version, with permitted additional terms. For more information +# see the Pycom Licence v1.0 document supplied with this file, or +# available at https://www.pycom.io/opensource/licensing +# + from machine import UART from machine import Pin import pycom diff --git a/examples/DS18X20/boot.py b/examples/DS18X20/boot.py index c9ace5d..f767f86 100644 --- a/examples/DS18X20/boot.py +++ b/examples/DS18X20/boot.py @@ -1,3 +1,13 @@ +#!/usr/bin/env python +# +# Copyright (c) 2019, Pycom Limited. +# +# This software is licensed under the GNU GPL version 3 or any +# later version, with permitted additional terms. For more information +# see the Pycom Licence v1.0 document supplied with this file, or +# available at https://www.pycom.io/opensource/licensing +# + from machine import UART import machine import os diff --git a/examples/DS18X20/main.py b/examples/DS18X20/main.py index c5e5b60..3caecc7 100644 --- a/examples/DS18X20/main.py +++ b/examples/DS18X20/main.py @@ -1,3 +1,13 @@ +#!/usr/bin/env python +# +# Copyright (c) 2019, Pycom Limited. +# +# This software is licensed under the GNU GPL version 3 or any +# later version, with permitted additional terms. For more information +# see the Pycom Licence v1.0 document supplied with this file, or +# available at https://www.pycom.io/opensource/licensing +# + import time from machine import Pin from onewire import DS18X20 diff --git a/examples/DS18X20/onewire.py b/examples/DS18X20/onewire.py index ddf14df..8bf2331 100644 --- a/examples/DS18X20/onewire.py +++ b/examples/DS18X20/onewire.py @@ -1,4 +1,12 @@ -#!/usr/bin/env python3 +#!/usr/bin/env python +# +# Copyright (c) 2019, Pycom Limited. +# +# This software is licensed under the GNU GPL version 3 or any +# later version, with permitted additional terms. For more information +# see the Pycom Licence v1.0 document supplied with this file, or +# available at https://www.pycom.io/opensource/licensing +# """ OneWire library for MicroPython diff --git a/examples/OTA-lorawan/LoraServer.py b/examples/OTA-lorawan/LoraServer.py index 8086c34..263947d 100644 --- a/examples/OTA-lorawan/LoraServer.py +++ b/examples/OTA-lorawan/LoraServer.py @@ -1,5 +1,12 @@ -#!/usr/bin/env python3 - +#!/usr/bin/env python +# +# Copyright (c) 2019, Pycom Limited. +# +# This software is licensed under the GNU GPL version 3 or any +# later version, with permitted additional terms. For more information +# see the Pycom Licence v1.0 document supplied with this file, or +# available at https://www.pycom.io/opensource/licensing +# import urllib.request import binascii diff --git a/examples/OTA-lorawan/config.py b/examples/OTA-lorawan/config.py index f8ccf20..7eff59b 100644 --- a/examples/OTA-lorawan/config.py +++ b/examples/OTA-lorawan/config.py @@ -1,5 +1,12 @@ -#!/usr/bin/env python3 - +#!/usr/bin/env python +# +# Copyright (c) 2019, Pycom Limited. +# +# This software is licensed under the GNU GPL version 3 or any +# later version, with permitted additional terms. For more information +# see the Pycom Licence v1.0 document supplied with this file, or +# available at https://www.pycom.io/opensource/licensing +# #LORASERVER configuration LORASERVER_IP = "127.0.0.1" diff --git a/examples/OTA-lorawan/diff_match_patch.py b/examples/OTA-lorawan/diff_match_patch.py index 906d16d..0d2f225 100644 --- a/examples/OTA-lorawan/diff_match_patch.py +++ b/examples/OTA-lorawan/diff_match_patch.py @@ -1,4 +1,12 @@ -#!/usr/bin/python3 +#!/usr/bin/env python +# +# Copyright (c) 2019, Pycom Limited. +# +# This software is licensed under the GNU GPL version 3 or any +# later version, with permitted additional terms. For more information +# see the Pycom Licence v1.0 document supplied with this file, or +# available at https://www.pycom.io/opensource/licensing +# """Diff Match and Patch Copyright 2018 The diff-match-patch Authors. diff --git a/examples/OTA-lorawan/firmware/1.17.0/flash/diff_match_patch.py b/examples/OTA-lorawan/firmware/1.17.0/flash/diff_match_patch.py index 494f051..f156f86 100644 --- a/examples/OTA-lorawan/firmware/1.17.0/flash/diff_match_patch.py +++ b/examples/OTA-lorawan/firmware/1.17.0/flash/diff_match_patch.py @@ -1,4 +1,12 @@ -#!/usr/bin/python2.7 +#!/usr/bin/env python +# +# Copyright (c) 2019, Pycom Limited. +# +# This software is licensed under the GNU GPL version 3 or any +# later version, with permitted additional terms. For more information +# see the Pycom Licence v1.0 document supplied with this file, or +# available at https://www.pycom.io/opensource/licensing +# #from __future__ import division diff --git a/examples/OTA-lorawan/firmware/1.17.0/flash/loranet.py b/examples/OTA-lorawan/firmware/1.17.0/flash/loranet.py index 573d178..1cdc070 100644 --- a/examples/OTA-lorawan/firmware/1.17.0/flash/loranet.py +++ b/examples/OTA-lorawan/firmware/1.17.0/flash/loranet.py @@ -1,3 +1,13 @@ +#!/usr/bin/env python +# +# Copyright (c) 2019, Pycom Limited. +# +# This software is licensed under the GNU GPL version 3 or any +# later version, with permitted additional terms. For more information +# see the Pycom Licence v1.0 document supplied with this file, or +# available at https://www.pycom.io/opensource/licensing +# + from network import LoRa import socket import binascii diff --git a/examples/OTA-lorawan/firmware/1.17.0/flash/main.py b/examples/OTA-lorawan/firmware/1.17.0/flash/main.py index 0dbf7c6..6475f98 100644 --- a/examples/OTA-lorawan/firmware/1.17.0/flash/main.py +++ b/examples/OTA-lorawan/firmware/1.17.0/flash/main.py @@ -1,3 +1,13 @@ +#!/usr/bin/env python +# +# Copyright (c) 2019, Pycom Limited. +# +# This software is licensed under the GNU GPL version 3 or any +# later version, with permitted additional terms. For more information +# see the Pycom Licence v1.0 document supplied with this file, or +# available at https://www.pycom.io/opensource/licensing +# + from loranet import LoraNet from ota import LoraOTA from network import LoRa diff --git a/examples/OTA-lorawan/firmware/1.17.0/flash/ota.py b/examples/OTA-lorawan/firmware/1.17.0/flash/ota.py index 0fca7db..530a915 100644 --- a/examples/OTA-lorawan/firmware/1.17.0/flash/ota.py +++ b/examples/OTA-lorawan/firmware/1.17.0/flash/ota.py @@ -1,3 +1,13 @@ +#!/usr/bin/env python +# +# Copyright (c) 2019, Pycom Limited. +# +# This software is licensed under the GNU GPL version 3 or any +# later version, with permitted additional terms. For more information +# see the Pycom Licence v1.0 document supplied with this file, or +# available at https://www.pycom.io/opensource/licensing +# + import diff_match_patch as dmp_module from watchdog import Watchdog from machine import RTC diff --git a/examples/OTA-lorawan/firmware/1.17.0/flash/watchdog.py b/examples/OTA-lorawan/firmware/1.17.0/flash/watchdog.py index 31d1e24..299c736 100644 --- a/examples/OTA-lorawan/firmware/1.17.0/flash/watchdog.py +++ b/examples/OTA-lorawan/firmware/1.17.0/flash/watchdog.py @@ -1,3 +1,13 @@ +#!/usr/bin/env python +# +# Copyright (c) 2019, Pycom Limited. +# +# This software is licensed under the GNU GPL version 3 or any +# later version, with permitted additional terms. For more information +# see the Pycom Licence v1.0 document supplied with this file, or +# available at https://www.pycom.io/opensource/licensing +# + from machine import Timer import _thread diff --git a/examples/OTA-lorawan/firmware/1.17.1/flash/diff_match_patch.py b/examples/OTA-lorawan/firmware/1.17.1/flash/diff_match_patch.py index 494f051..f156f86 100644 --- a/examples/OTA-lorawan/firmware/1.17.1/flash/diff_match_patch.py +++ b/examples/OTA-lorawan/firmware/1.17.1/flash/diff_match_patch.py @@ -1,4 +1,12 @@ -#!/usr/bin/python2.7 +#!/usr/bin/env python +# +# Copyright (c) 2019, Pycom Limited. +# +# This software is licensed under the GNU GPL version 3 or any +# later version, with permitted additional terms. For more information +# see the Pycom Licence v1.0 document supplied with this file, or +# available at https://www.pycom.io/opensource/licensing +# #from __future__ import division diff --git a/examples/OTA-lorawan/firmware/1.17.1/flash/loranet.py b/examples/OTA-lorawan/firmware/1.17.1/flash/loranet.py index 573d178..1cdc070 100644 --- a/examples/OTA-lorawan/firmware/1.17.1/flash/loranet.py +++ b/examples/OTA-lorawan/firmware/1.17.1/flash/loranet.py @@ -1,3 +1,13 @@ +#!/usr/bin/env python +# +# Copyright (c) 2019, Pycom Limited. +# +# This software is licensed under the GNU GPL version 3 or any +# later version, with permitted additional terms. For more information +# see the Pycom Licence v1.0 document supplied with this file, or +# available at https://www.pycom.io/opensource/licensing +# + from network import LoRa import socket import binascii diff --git a/examples/OTA-lorawan/firmware/1.17.1/flash/main.py b/examples/OTA-lorawan/firmware/1.17.1/flash/main.py index 47c97ca..f7b8c90 100644 --- a/examples/OTA-lorawan/firmware/1.17.1/flash/main.py +++ b/examples/OTA-lorawan/firmware/1.17.1/flash/main.py @@ -1,3 +1,13 @@ +#!/usr/bin/env python +# +# Copyright (c) 2019, Pycom Limited. +# +# This software is licensed under the GNU GPL version 3 or any +# later version, with permitted additional terms. For more information +# see the Pycom Licence v1.0 document supplied with this file, or +# available at https://www.pycom.io/opensource/licensing +# + from loranet import LoraNet from ota import LoraOTA from network import LoRa diff --git a/examples/OTA-lorawan/firmware/1.17.1/flash/ota.py b/examples/OTA-lorawan/firmware/1.17.1/flash/ota.py index 0fca7db..530a915 100644 --- a/examples/OTA-lorawan/firmware/1.17.1/flash/ota.py +++ b/examples/OTA-lorawan/firmware/1.17.1/flash/ota.py @@ -1,3 +1,13 @@ +#!/usr/bin/env python +# +# Copyright (c) 2019, Pycom Limited. +# +# This software is licensed under the GNU GPL version 3 or any +# later version, with permitted additional terms. For more information +# see the Pycom Licence v1.0 document supplied with this file, or +# available at https://www.pycom.io/opensource/licensing +# + import diff_match_patch as dmp_module from watchdog import Watchdog from machine import RTC diff --git a/examples/OTA-lorawan/firmware/1.17.1/flash/watchdog.py b/examples/OTA-lorawan/firmware/1.17.1/flash/watchdog.py index 31d1e24..299c736 100644 --- a/examples/OTA-lorawan/firmware/1.17.1/flash/watchdog.py +++ b/examples/OTA-lorawan/firmware/1.17.1/flash/watchdog.py @@ -1,3 +1,13 @@ +#!/usr/bin/env python +# +# Copyright (c) 2019, Pycom Limited. +# +# This software is licensed under the GNU GPL version 3 or any +# later version, with permitted additional terms. For more information +# see the Pycom Licence v1.0 document supplied with this file, or +# available at https://www.pycom.io/opensource/licensing +# + from machine import Timer import _thread diff --git a/examples/OTA-lorawan/groupUpdater.py b/examples/OTA-lorawan/groupUpdater.py index 02408d2..2de44df 100644 --- a/examples/OTA-lorawan/groupUpdater.py +++ b/examples/OTA-lorawan/groupUpdater.py @@ -1,4 +1,12 @@ -#!/usr/bin/env python3 +#!/usr/bin/env python +# +# Copyright (c) 2019, Pycom Limited. +# +# This software is licensed under the GNU GPL version 3 or any +# later version, with permitted additional terms. For more information +# see the Pycom Licence v1.0 document supplied with this file, or +# available at https://www.pycom.io/opensource/licensing +# import diff_match_patch as dmp_module import threading diff --git a/examples/OTA-lorawan/ota.py b/examples/OTA-lorawan/ota.py index 60477a2..22a3c2a 100644 --- a/examples/OTA-lorawan/ota.py +++ b/examples/OTA-lorawan/ota.py @@ -1,4 +1,12 @@ -#!/usr/bin/env python3 +#!/usr/bin/env python +# +# Copyright (c) 2019, Pycom Limited. +# +# This software is licensed under the GNU GPL version 3 or any +# later version, with permitted additional terms. For more information +# see the Pycom Licence v1.0 document supplied with this file, or +# available at https://www.pycom.io/opensource/licensing +# from distutils.version import LooseVersion from LoraServer import LoraServerClient diff --git a/examples/OTA-lorawan/updaterService.py b/examples/OTA-lorawan/updaterService.py index e51e3d8..b8ac48c 100644 --- a/examples/OTA-lorawan/updaterService.py +++ b/examples/OTA-lorawan/updaterService.py @@ -1,4 +1,12 @@ -#!/usr/bin/env python3 +#!/usr/bin/env python +# +# Copyright (c) 2019, Pycom Limited. +# +# This software is licensed under the GNU GPL version 3 or any +# later version, with permitted additional terms. For more information +# see the Pycom Licence v1.0 document supplied with this file, or +# available at https://www.pycom.io/opensource/licensing +# import paho.mqtt.client as paho from ota import OTAHandler diff --git a/examples/OTA/1.0.0/flash/config.py b/examples/OTA/1.0.0/flash/config.py index 302f1d4..4d471cd 100644 --- a/examples/OTA/1.0.0/flash/config.py +++ b/examples/OTA/1.0.0/flash/config.py @@ -1,3 +1,13 @@ +#!/usr/bin/env python +# +# Copyright (c) 2019, Pycom Limited. +# +# This software is licensed under the GNU GPL version 3 or any +# later version, with permitted additional terms. For more information +# see the Pycom Licence v1.0 document supplied with this file, or +# available at https://www.pycom.io/opensource/licensing +# + WIFI_SSID = "ENTER_ME" WIFI_PW = "ENTER_ME" SERVER_IP = "ENTER_ME" diff --git a/examples/OTA/1.0.0/flash/get_id.py b/examples/OTA/1.0.0/flash/get_id.py index fa40144..f56041e 100644 --- a/examples/OTA/1.0.0/flash/get_id.py +++ b/examples/OTA/1.0.0/flash/get_id.py @@ -1,3 +1,13 @@ +#!/usr/bin/env python +# +# Copyright (c) 2019, Pycom Limited. +# +# This software is licensed under the GNU GPL version 3 or any +# later version, with permitted additional terms. For more information +# see the Pycom Licence v1.0 document supplied with this file, or +# available at https://www.pycom.io/opensource/licensing +# + from network import LoRa import binascii lora = LoRa(mode=LoRa.LORAWAN) diff --git a/examples/OTA/1.0.0/flash/lib/OTA.py b/examples/OTA/1.0.0/flash/lib/OTA.py index ff00466..333ad91 100644 --- a/examples/OTA/1.0.0/flash/lib/OTA.py +++ b/examples/OTA/1.0.0/flash/lib/OTA.py @@ -1,3 +1,13 @@ +#!/usr/bin/env python +# +# Copyright (c) 2019, Pycom Limited. +# +# This software is licensed under the GNU GPL version 3 or any +# later version, with permitted additional terms. For more information +# see the Pycom Licence v1.0 document supplied with this file, or +# available at https://www.pycom.io/opensource/licensing +# + import network import socket import machine diff --git a/examples/OTA/1.0.0/flash/main.py b/examples/OTA/1.0.0/flash/main.py index 3c90283..8e93085 100644 --- a/examples/OTA/1.0.0/flash/main.py +++ b/examples/OTA/1.0.0/flash/main.py @@ -1,3 +1,13 @@ +#!/usr/bin/env python +# +# Copyright (c) 2019, Pycom Limited. +# +# This software is licensed under the GNU GPL version 3 or any +# later version, with permitted additional terms. For more information +# see the Pycom Licence v1.0 document supplied with this file, or +# available at https://www.pycom.io/opensource/licensing +# + from network import LoRa, WLAN import socket import time diff --git a/examples/OTA/1.0.1/flash/config.py b/examples/OTA/1.0.1/flash/config.py index 302f1d4..780528e 100644 --- a/examples/OTA/1.0.1/flash/config.py +++ b/examples/OTA/1.0.1/flash/config.py @@ -1,3 +1,13 @@ +#!/usr/bin/env python +# +# Copyright (c) 2018, Pycom Limited. +# +# This software is licensed under the GNU GPL version 3 or any +# later version, with permitted additional terms. For more information +# see the Pycom Licence v1.0 document supplied with this file, or +# available at https://www.pycom.io/opensource/licensing +# + WIFI_SSID = "ENTER_ME" WIFI_PW = "ENTER_ME" SERVER_IP = "ENTER_ME" diff --git a/examples/OTA/1.0.1/flash/get_id.py b/examples/OTA/1.0.1/flash/get_id.py index fa40144..03160a0 100644 --- a/examples/OTA/1.0.1/flash/get_id.py +++ b/examples/OTA/1.0.1/flash/get_id.py @@ -1,3 +1,13 @@ +#!/usr/bin/env python +# +# Copyright (c) 2018, Pycom Limited. +# +# This software is licensed under the GNU GPL version 3 or any +# later version, with permitted additional terms. For more information +# see the Pycom Licence v1.0 document supplied with this file, or +# available at https://www.pycom.io/opensource/licensing +# + from network import LoRa import binascii lora = LoRa(mode=LoRa.LORAWAN) diff --git a/examples/OTA/1.0.1/flash/lib/OTA.py b/examples/OTA/1.0.1/flash/lib/OTA.py index 8b26653..24beff8 100644 --- a/examples/OTA/1.0.1/flash/lib/OTA.py +++ b/examples/OTA/1.0.1/flash/lib/OTA.py @@ -1,3 +1,13 @@ +#!/usr/bin/env python +# +# Copyright (c) 2018, Pycom Limited. +# +# This software is licensed under the GNU GPL version 3 or any +# later version, with permitted additional terms. For more information +# see the Pycom Licence v1.0 document supplied with this file, or +# available at https://www.pycom.io/opensource/licensing +# + import network import socket import machine diff --git a/examples/OTA/1.0.1/flash/main.py b/examples/OTA/1.0.1/flash/main.py index f06539d..8c87564 100644 --- a/examples/OTA/1.0.1/flash/main.py +++ b/examples/OTA/1.0.1/flash/main.py @@ -1,3 +1,13 @@ +#!/usr/bin/env python +# +# Copyright (c) 2018, Pycom Limited. +# +# This software is licensed under the GNU GPL version 3 or any +# later version, with permitted additional terms. For more information +# see the Pycom Licence v1.0 document supplied with this file, or +# available at https://www.pycom.io/opensource/licensing +# + from network import LoRa, WLAN import socket import time diff --git a/examples/OTA/OTA_server.py b/examples/OTA/OTA_server.py index 3fb89b1..d03fc16 100644 --- a/examples/OTA/OTA_server.py +++ b/examples/OTA/OTA_server.py @@ -1,7 +1,14 @@ -#!/usr/bin/env python3 +#!/usr/bin/env python +# +# Copyright (c) 2019, Pycom Limited. +# +# This software is licensed under the GNU GPL version 3 or any +# later version, with permitted additional terms. For more information +# see the Pycom Licence v1.0 document supplied with this file, or +# available at https://www.pycom.io/opensource/licensing +# # Firmware over the air update server -# Copyright Pycom Ltd. # # Version History # 1.0 - Initial release (Sebastian Goscik) diff --git a/examples/accelerometer_wake/main.py b/examples/accelerometer_wake/main.py index 5f589f1..ec0c495 100644 --- a/examples/accelerometer_wake/main.py +++ b/examples/accelerometer_wake/main.py @@ -1,3 +1,13 @@ +#!/usr/bin/env python +# +# Copyright (c) 2019, Pycom Limited. +# +# This software is licensed under the GNU GPL version 3 or any +# later version, with permitted additional terms. For more information +# see the Pycom Licence v1.0 document supplied with this file, or +# available at https://www.pycom.io/opensource/licensing +# + from pytrack import Pytrack #from pysense import Pysense from LIS2HH12 import LIS2HH12 diff --git a/examples/adc/boot.py b/examples/adc/boot.py index c9ace5d..f767f86 100644 --- a/examples/adc/boot.py +++ b/examples/adc/boot.py @@ -1,3 +1,13 @@ +#!/usr/bin/env python +# +# Copyright (c) 2019, Pycom Limited. +# +# This software is licensed under the GNU GPL version 3 or any +# later version, with permitted additional terms. For more information +# see the Pycom Licence v1.0 document supplied with this file, or +# available at https://www.pycom.io/opensource/licensing +# + from machine import UART import machine import os diff --git a/examples/adc/main.py b/examples/adc/main.py index db15e21..f292a62 100644 --- a/examples/adc/main.py +++ b/examples/adc/main.py @@ -1,3 +1,13 @@ +#!/usr/bin/env python +# +# Copyright (c) 2019, Pycom Limited. +# +# This software is licensed under the GNU GPL version 3 or any +# later version, with permitted additional terms. For more information +# see the Pycom Licence v1.0 document supplied with this file, or +# available at https://www.pycom.io/opensource/licensing +# + from machine import ADC import time diff --git a/examples/bluetooth/boot.py b/examples/bluetooth/boot.py index c9ace5d..f767f86 100644 --- a/examples/bluetooth/boot.py +++ b/examples/bluetooth/boot.py @@ -1,3 +1,13 @@ +#!/usr/bin/env python +# +# Copyright (c) 2019, Pycom Limited. +# +# This software is licensed under the GNU GPL version 3 or any +# later version, with permitted additional terms. For more information +# see the Pycom Licence v1.0 document supplied with this file, or +# available at https://www.pycom.io/opensource/licensing +# + from machine import UART import machine import os diff --git a/examples/bluetooth/main.py b/examples/bluetooth/main.py index 31fb959..92a28e2 100644 --- a/examples/bluetooth/main.py +++ b/examples/bluetooth/main.py @@ -1,3 +1,13 @@ +#!/usr/bin/env python +# +# Copyright (c) 2019, Pycom Limited. +# +# This software is licensed under the GNU GPL version 3 or any +# later version, with permitted additional terms. For more information +# see the Pycom Licence v1.0 document supplied with this file, or +# available at https://www.pycom.io/opensource/licensing +# + from network import Bluetooth import binascii import time diff --git a/examples/deepsleep/main.py b/examples/deepsleep/main.py index 83d248c..be04712 100644 --- a/examples/deepsleep/main.py +++ b/examples/deepsleep/main.py @@ -1,3 +1,13 @@ +#!/usr/bin/env python +# +# Copyright (c) 2019, Pycom Limited. +# +# This software is licensed under the GNU GPL version 3 or any +# later version, with permitted additional terms. For more information +# see the Pycom Licence v1.0 document supplied with this file, or +# available at https://www.pycom.io/opensource/licensing +# + from deepsleep import DeepSleep import deepsleep diff --git a/examples/https/boot.py b/examples/https/boot.py index c9ace5d..f767f86 100644 --- a/examples/https/boot.py +++ b/examples/https/boot.py @@ -1,3 +1,13 @@ +#!/usr/bin/env python +# +# Copyright (c) 2019, Pycom Limited. +# +# This software is licensed under the GNU GPL version 3 or any +# later version, with permitted additional terms. For more information +# see the Pycom Licence v1.0 document supplied with this file, or +# available at https://www.pycom.io/opensource/licensing +# + from machine import UART import machine import os diff --git a/examples/https/main.py b/examples/https/main.py index 2466a13..15297de 100644 --- a/examples/https/main.py +++ b/examples/https/main.py @@ -1,3 +1,13 @@ +#!/usr/bin/env python +# +# Copyright (c) 2019, Pycom Limited. +# +# This software is licensed under the GNU GPL version 3 or any +# later version, with permitted additional terms. For more information +# see the Pycom Licence v1.0 document supplied with this file, or +# available at https://www.pycom.io/opensource/licensing +# + import socket import ssl diff --git a/examples/i2c/bh1750fvi.py b/examples/i2c/bh1750fvi.py index 5236ef3..b1bbd91 100644 --- a/examples/i2c/bh1750fvi.py +++ b/examples/i2c/bh1750fvi.py @@ -1,3 +1,13 @@ +#!/usr/bin/env python +# +# Copyright (c) 2019, Pycom Limited. +# +# This software is licensed under the GNU GPL version 3 or any +# later version, with permitted additional terms. For more information +# see the Pycom Licence v1.0 document supplied with this file, or +# available at https://www.pycom.io/opensource/licensing +# + # Simple driver for the BH1750FVI digital light sensor class BH1750FVI: diff --git a/examples/i2c/boot.py b/examples/i2c/boot.py index c9ace5d..f767f86 100644 --- a/examples/i2c/boot.py +++ b/examples/i2c/boot.py @@ -1,3 +1,13 @@ +#!/usr/bin/env python +# +# Copyright (c) 2019, Pycom Limited. +# +# This software is licensed under the GNU GPL version 3 or any +# later version, with permitted additional terms. For more information +# see the Pycom Licence v1.0 document supplied with this file, or +# available at https://www.pycom.io/opensource/licensing +# + from machine import UART import machine import os diff --git a/examples/i2c/main.py b/examples/i2c/main.py index d6e8538..d91364a 100644 --- a/examples/i2c/main.py +++ b/examples/i2c/main.py @@ -1,3 +1,13 @@ +#!/usr/bin/env python +# +# Copyright (c) 2019, Pycom Limited. +# +# This software is licensed under the GNU GPL version 3 or any +# later version, with permitted additional terms. For more information +# see the Pycom Licence v1.0 document supplied with this file, or +# available at https://www.pycom.io/opensource/licensing +# + import socket import time import pycom diff --git a/examples/lopy-lopy/lopy-A/boot.py b/examples/lopy-lopy/lopy-A/boot.py index c9ace5d..f767f86 100644 --- a/examples/lopy-lopy/lopy-A/boot.py +++ b/examples/lopy-lopy/lopy-A/boot.py @@ -1,3 +1,13 @@ +#!/usr/bin/env python +# +# Copyright (c) 2019, Pycom Limited. +# +# This software is licensed under the GNU GPL version 3 or any +# later version, with permitted additional terms. For more information +# see the Pycom Licence v1.0 document supplied with this file, or +# available at https://www.pycom.io/opensource/licensing +# + from machine import UART import machine import os diff --git a/examples/lopy-lopy/lopy-A/main.py b/examples/lopy-lopy/lopy-A/main.py index 6ff56ee..233b3c0 100644 --- a/examples/lopy-lopy/lopy-A/main.py +++ b/examples/lopy-lopy/lopy-A/main.py @@ -1,3 +1,13 @@ +#!/usr/bin/env python +# +# Copyright (c) 2019, Pycom Limited. +# +# This software is licensed under the GNU GPL version 3 or any +# later version, with permitted additional terms. For more information +# see the Pycom Licence v1.0 document supplied with this file, or +# available at https://www.pycom.io/opensource/licensing +# + from network import LoRa import socket import time diff --git a/examples/lopy-lopy/lopy-B/boot.py b/examples/lopy-lopy/lopy-B/boot.py index c9ace5d..f767f86 100644 --- a/examples/lopy-lopy/lopy-B/boot.py +++ b/examples/lopy-lopy/lopy-B/boot.py @@ -1,3 +1,13 @@ +#!/usr/bin/env python +# +# Copyright (c) 2019, Pycom Limited. +# +# This software is licensed under the GNU GPL version 3 or any +# later version, with permitted additional terms. For more information +# see the Pycom Licence v1.0 document supplied with this file, or +# available at https://www.pycom.io/opensource/licensing +# + from machine import UART import machine import os diff --git a/examples/lopy-lopy/lopy-B/main.py b/examples/lopy-lopy/lopy-B/main.py index a29d847..5df238b 100644 --- a/examples/lopy-lopy/lopy-B/main.py +++ b/examples/lopy-lopy/lopy-B/main.py @@ -1,3 +1,13 @@ +#!/usr/bin/env python +# +# Copyright (c) 2019, Pycom Limited. +# +# This software is licensed under the GNU GPL version 3 or any +# later version, with permitted additional terms. For more information +# see the Pycom Licence v1.0 document supplied with this file, or +# available at https://www.pycom.io/opensource/licensing +# + from network import LoRa import socket import time diff --git a/examples/loraNanoGateway/gateway/boot.py b/examples/loraNanoGateway/gateway/boot.py index c9ace5d..f767f86 100644 --- a/examples/loraNanoGateway/gateway/boot.py +++ b/examples/loraNanoGateway/gateway/boot.py @@ -1,3 +1,13 @@ +#!/usr/bin/env python +# +# Copyright (c) 2019, Pycom Limited. +# +# This software is licensed under the GNU GPL version 3 or any +# later version, with permitted additional terms. For more information +# see the Pycom Licence v1.0 document supplied with this file, or +# available at https://www.pycom.io/opensource/licensing +# + from machine import UART import machine import os diff --git a/examples/loraNanoGateway/gateway/main.py b/examples/loraNanoGateway/gateway/main.py index 479ec6b..d641ac5 100644 --- a/examples/loraNanoGateway/gateway/main.py +++ b/examples/loraNanoGateway/gateway/main.py @@ -1,3 +1,13 @@ +#!/usr/bin/env python +# +# Copyright (c) 2019, Pycom Limited. +# +# This software is licensed under the GNU GPL version 3 or any +# later version, with permitted additional terms. For more information +# see the Pycom Licence v1.0 document supplied with this file, or +# available at https://www.pycom.io/opensource/licensing +# + import socket import struct from network import LoRa diff --git a/examples/loraabp/boot.py b/examples/loraabp/boot.py index c9ace5d..f767f86 100644 --- a/examples/loraabp/boot.py +++ b/examples/loraabp/boot.py @@ -1,3 +1,13 @@ +#!/usr/bin/env python +# +# Copyright (c) 2019, Pycom Limited. +# +# This software is licensed under the GNU GPL version 3 or any +# later version, with permitted additional terms. For more information +# see the Pycom Licence v1.0 document supplied with this file, or +# available at https://www.pycom.io/opensource/licensing +# + from machine import UART import machine import os diff --git a/examples/loraabp/main.py b/examples/loraabp/main.py index aa7333a..74e4cba 100644 --- a/examples/loraabp/main.py +++ b/examples/loraabp/main.py @@ -1,3 +1,13 @@ +#!/usr/bin/env python +# +# Copyright (c) 2019, Pycom Limited. +# +# This software is licensed under the GNU GPL version 3 or any +# later version, with permitted additional terms. For more information +# see the Pycom Licence v1.0 document supplied with this file, or +# available at https://www.pycom.io/opensource/licensing +# + from network import LoRa import socket import binascii diff --git a/examples/loramac/boot.py b/examples/loramac/boot.py index c9ace5d..f767f86 100644 --- a/examples/loramac/boot.py +++ b/examples/loramac/boot.py @@ -1,3 +1,13 @@ +#!/usr/bin/env python +# +# Copyright (c) 2019, Pycom Limited. +# +# This software is licensed under the GNU GPL version 3 or any +# later version, with permitted additional terms. For more information +# see the Pycom Licence v1.0 document supplied with this file, or +# available at https://www.pycom.io/opensource/licensing +# + from machine import UART import machine import os diff --git a/examples/loramac/main.py b/examples/loramac/main.py index c21f762..c71627b 100644 --- a/examples/loramac/main.py +++ b/examples/loramac/main.py @@ -1,3 +1,13 @@ +#!/usr/bin/env python +# +# Copyright (c) 2019, Pycom Limited. +# +# This software is licensed under the GNU GPL version 3 or any +# later version, with permitted additional terms. For more information +# see the Pycom Licence v1.0 document supplied with this file, or +# available at https://www.pycom.io/opensource/licensing +# + from network import LoRa import socket diff --git a/examples/lorawan-nano-gateway/abp_node.py b/examples/lorawan-nano-gateway/abp_node.py index 0ea9a55..15dadf9 100644 --- a/examples/lorawan-nano-gateway/abp_node.py +++ b/examples/lorawan-nano-gateway/abp_node.py @@ -1,3 +1,13 @@ +#!/usr/bin/env python +# +# Copyright (c) 2019, Pycom Limited. +# +# This software is licensed under the GNU GPL version 3 or any +# later version, with permitted additional terms. For more information +# see the Pycom Licence v1.0 document supplied with this file, or +# available at https://www.pycom.io/opensource/licensing +# + from network import LoRa import socket import binascii diff --git a/examples/lorawan-nano-gateway/abp_node_US915.py b/examples/lorawan-nano-gateway/abp_node_US915.py index c81e756..d5c567f 100644 --- a/examples/lorawan-nano-gateway/abp_node_US915.py +++ b/examples/lorawan-nano-gateway/abp_node_US915.py @@ -1,3 +1,13 @@ +#!/usr/bin/env python +# +# Copyright (c) 2019, Pycom Limited. +# +# This software is licensed under the GNU GPL version 3 or any +# later version, with permitted additional terms. For more information +# see the Pycom Licence v1.0 document supplied with this file, or +# available at https://www.pycom.io/opensource/licensing +# + from network import LoRa import socket import binascii diff --git a/examples/lorawan-nano-gateway/config.py b/examples/lorawan-nano-gateway/config.py index db735ec..552df79 100644 --- a/examples/lorawan-nano-gateway/config.py +++ b/examples/lorawan-nano-gateway/config.py @@ -1,3 +1,13 @@ +#!/usr/bin/env python +# +# Copyright (c) 2019, Pycom Limited. +# +# This software is licensed under the GNU GPL version 3 or any +# later version, with permitted additional terms. For more information +# see the Pycom Licence v1.0 document supplied with this file, or +# available at https://www.pycom.io/opensource/licensing +# + """ LoPy LoRaWAN Nano Gateway configuration options """ import machine diff --git a/examples/lorawan-nano-gateway/main.py b/examples/lorawan-nano-gateway/main.py index 384fc89..c17920e 100644 --- a/examples/lorawan-nano-gateway/main.py +++ b/examples/lorawan-nano-gateway/main.py @@ -1,3 +1,13 @@ +#!/usr/bin/env python +# +# Copyright (c) 2019, Pycom Limited. +# +# This software is licensed under the GNU GPL version 3 or any +# later version, with permitted additional terms. For more information +# see the Pycom Licence v1.0 document supplied with this file, or +# available at https://www.pycom.io/opensource/licensing +# + """ LoPy LoRaWAN Nano Gateway example usage """ import config diff --git a/examples/lorawan-nano-gateway/nanogateway.py b/examples/lorawan-nano-gateway/nanogateway.py index 416694c..76d6c92 100644 --- a/examples/lorawan-nano-gateway/nanogateway.py +++ b/examples/lorawan-nano-gateway/nanogateway.py @@ -1,3 +1,13 @@ +#!/usr/bin/env python +# +# Copyright (c) 2019, Pycom Limited. +# +# This software is licensed under the GNU GPL version 3 or any +# later version, with permitted additional terms. For more information +# see the Pycom Licence v1.0 document supplied with this file, or +# available at https://www.pycom.io/opensource/licensing +# + """ LoPy LoRaWAN Nano Gateway. Can be used for both EU868 and US915. """ import errno diff --git a/examples/lorawan-nano-gateway/otaa_node.py b/examples/lorawan-nano-gateway/otaa_node.py index c6ebcd1..1abe66b 100644 --- a/examples/lorawan-nano-gateway/otaa_node.py +++ b/examples/lorawan-nano-gateway/otaa_node.py @@ -1,3 +1,13 @@ +#!/usr/bin/env python +# +# Copyright (c) 2019, Pycom Limited. +# +# This software is licensed under the GNU GPL version 3 or any +# later version, with permitted additional terms. For more information +# see the Pycom Licence v1.0 document supplied with this file, or +# available at https://www.pycom.io/opensource/licensing +# + """ OTAA Node example compatible with the LoPy Nano Gateway """ from network import LoRa diff --git a/examples/lorawan-nano-gateway/otaa_node_US915.py b/examples/lorawan-nano-gateway/otaa_node_US915.py index b2b3eb6..1008c20 100644 --- a/examples/lorawan-nano-gateway/otaa_node_US915.py +++ b/examples/lorawan-nano-gateway/otaa_node_US915.py @@ -1,3 +1,13 @@ +#!/usr/bin/env python +# +# Copyright (c) 2019, Pycom Limited. +# +# This software is licensed under the GNU GPL version 3 or any +# later version, with permitted additional terms. For more information +# see the Pycom Licence v1.0 document supplied with this file, or +# available at https://www.pycom.io/opensource/licensing +# + """ OTAA Node example compatible with the LoPy Nano Gateway """ from network import LoRa diff --git a/examples/lorawan-regional-examples/main_AS923.py b/examples/lorawan-regional-examples/main_AS923.py index 517b938..ce03f4f 100644 --- a/examples/lorawan-regional-examples/main_AS923.py +++ b/examples/lorawan-regional-examples/main_AS923.py @@ -1,3 +1,13 @@ +#!/usr/bin/env python +# +# Copyright (c) 2019, Pycom Limited. +# +# This software is licensed under the GNU GPL version 3 or any +# later version, with permitted additional terms. For more information +# see the Pycom Licence v1.0 document supplied with this file, or +# available at https://www.pycom.io/opensource/licensing +# + """ OTAA Node example as per LoRaWAN AS923 regional specification - compatible with the LoPy Nano Gateway and all other LoraWAN gateways diff --git a/examples/lorawan-regional-examples/main_AU915.py b/examples/lorawan-regional-examples/main_AU915.py index 568c711..419217c 100644 --- a/examples/lorawan-regional-examples/main_AU915.py +++ b/examples/lorawan-regional-examples/main_AU915.py @@ -1,3 +1,13 @@ +#!/usr/bin/env python +# +# Copyright (c) 2019, Pycom Limited. +# +# This software is licensed under the GNU GPL version 3 or any +# later version, with permitted additional terms. For more information +# see the Pycom Licence v1.0 document supplied with this file, or +# available at https://www.pycom.io/opensource/licensing +# + """ OTAA Node example as per LoRaWAN AU915 regional specification - tested works with a LoRaServer, shall works on TTN servers diff --git a/examples/lorawan-regional-examples/main_EU868.py b/examples/lorawan-regional-examples/main_EU868.py index f346202..646dad6 100644 --- a/examples/lorawan-regional-examples/main_EU868.py +++ b/examples/lorawan-regional-examples/main_EU868.py @@ -1,3 +1,13 @@ +#!/usr/bin/env python +# +# Copyright (c) 2019, Pycom Limited. +# +# This software is licensed under the GNU GPL version 3 or any +# later version, with permitted additional terms. For more information +# see the Pycom Licence v1.0 document supplied with this file, or +# available at https://www.pycom.io/opensource/licensing +# + """ OTAA Node example as per LoRaWAN EU868 regional specification - compatible with the LoPy Nano Gateway and all other LoraWAN gateways diff --git a/examples/lorawan-regional-examples/main_US915.py b/examples/lorawan-regional-examples/main_US915.py index 00ddd23..52d0a4a 100644 --- a/examples/lorawan-regional-examples/main_US915.py +++ b/examples/lorawan-regional-examples/main_US915.py @@ -1,3 +1,13 @@ +#!/usr/bin/env python +# +# Copyright (c) 2019, Pycom Limited. +# +# This software is licensed under the GNU GPL version 3 or any +# later version, with permitted additional terms. For more information +# see the Pycom Licence v1.0 document supplied with this file, or +# available at https://www.pycom.io/opensource/licensing +# + """ OTAA Node example as per LoRaWAN US915 regional specification - tested works with a LoRaServer, shall works on TTN servers diff --git a/examples/mqtt/boot.py b/examples/mqtt/boot.py index c9ace5d..f767f86 100644 --- a/examples/mqtt/boot.py +++ b/examples/mqtt/boot.py @@ -1,3 +1,13 @@ +#!/usr/bin/env python +# +# Copyright (c) 2019, Pycom Limited. +# +# This software is licensed under the GNU GPL version 3 or any +# later version, with permitted additional terms. For more information +# see the Pycom Licence v1.0 document supplied with this file, or +# available at https://www.pycom.io/opensource/licensing +# + from machine import UART import machine import os diff --git a/examples/mqtt/main.py b/examples/mqtt/main.py index 0e5a81f..04c0441 100644 --- a/examples/mqtt/main.py +++ b/examples/mqtt/main.py @@ -1,3 +1,13 @@ +#!/usr/bin/env python +# +# Copyright (c) 2019, Pycom Limited. +# +# This software is licensed under the GNU GPL version 3 or any +# later version, with permitted additional terms. For more information +# see the Pycom Licence v1.0 document supplied with this file, or +# available at https://www.pycom.io/opensource/licensing +# + from network import WLAN from mqtt import MQTTClient import machine diff --git a/examples/mqtt/mqtt.py b/examples/mqtt/mqtt.py index 617c075..9a54d0c 100644 --- a/examples/mqtt/mqtt.py +++ b/examples/mqtt/mqtt.py @@ -1,3 +1,13 @@ +#!/usr/bin/env python +# +# Copyright (c) 2019, Pycom Limited. +# +# This software is licensed under the GNU GPL version 3 or any +# later version, with permitted additional terms. For more information +# see the Pycom Licence v1.0 document supplied with this file, or +# available at https://www.pycom.io/opensource/licensing +# + import usocket as socket import ustruct as struct from ubinascii import hexlify diff --git a/examples/onlineLog/boot.py b/examples/onlineLog/boot.py index 0b803ff..cf85552 100644 --- a/examples/onlineLog/boot.py +++ b/examples/onlineLog/boot.py @@ -1,3 +1,13 @@ +#!/usr/bin/env python +# +# Copyright (c) 2019, Pycom Limited. +# +# This software is licensed under the GNU GPL version 3 or any +# later version, with permitted additional terms. For more information +# see the Pycom Licence v1.0 document supplied with this file, or +# available at https://www.pycom.io/opensource/licensing +# + from machine import UART import machine import os diff --git a/examples/onlineLog/main.py b/examples/onlineLog/main.py index 9cf772a..080515e 100644 --- a/examples/onlineLog/main.py +++ b/examples/onlineLog/main.py @@ -1,3 +1,13 @@ +#!/usr/bin/env python +# +# Copyright (c) 2019, Pycom Limited. +# +# This software is licensed under the GNU GPL version 3 or any +# later version, with permitted additional terms. For more information +# see the Pycom Licence v1.0 document supplied with this file, or +# available at https://www.pycom.io/opensource/licensing +# + import time import machine from onewire import DS18X20 diff --git a/examples/onlineLog/onewire.py b/examples/onlineLog/onewire.py index 935ac46..02768eb 100644 --- a/examples/onlineLog/onewire.py +++ b/examples/onlineLog/onewire.py @@ -1,4 +1,12 @@ -#!/usr/bin/env python3 +#!/usr/bin/env python +# +# Copyright (c) 2019, Pycom Limited. +# +# This software is licensed under the GNU GPL version 3 or any +# later version, with permitted additional terms. For more information +# see the Pycom Licence v1.0 document supplied with this file, or +# available at https://www.pycom.io/opensource/licensing +# """ OneWire library for MicroPython diff --git a/examples/pytrack_pysense_accelerometer/main.py b/examples/pytrack_pysense_accelerometer/main.py index 9fc2c8d..90ceb88 100644 --- a/examples/pytrack_pysense_accelerometer/main.py +++ b/examples/pytrack_pysense_accelerometer/main.py @@ -1,3 +1,13 @@ +#!/usr/bin/env python +# +# Copyright (c) 2019, Pycom Limited. +# +# This software is licensed under the GNU GPL version 3 or any +# later version, with permitted additional terms. For more information +# see the Pycom Licence v1.0 document supplied with this file, or +# available at https://www.pycom.io/opensource/licensing +# + import time # From:https://github.com/pycom/pycom-libraries diff --git a/examples/sigfoxUplink/boot.py b/examples/sigfoxUplink/boot.py index c9ace5d..f767f86 100644 --- a/examples/sigfoxUplink/boot.py +++ b/examples/sigfoxUplink/boot.py @@ -1,3 +1,13 @@ +#!/usr/bin/env python +# +# Copyright (c) 2019, Pycom Limited. +# +# This software is licensed under the GNU GPL version 3 or any +# later version, with permitted additional terms. For more information +# see the Pycom Licence v1.0 document supplied with this file, or +# available at https://www.pycom.io/opensource/licensing +# + from machine import UART import machine import os diff --git a/examples/sigfoxUplink/main.py b/examples/sigfoxUplink/main.py index 0bde8b9..ff0d17c 100644 --- a/examples/sigfoxUplink/main.py +++ b/examples/sigfoxUplink/main.py @@ -1,3 +1,13 @@ +#!/usr/bin/env python +# +# Copyright (c) 2019, Pycom Limited. +# +# This software is licensed under the GNU GPL version 3 or any +# later version, with permitted additional terms. For more information +# see the Pycom Licence v1.0 document supplied with this file, or +# available at https://www.pycom.io/opensource/licensing +# + from network import Sigfox import socket diff --git a/examples/threading/boot.py b/examples/threading/boot.py index c9ace5d..f767f86 100644 --- a/examples/threading/boot.py +++ b/examples/threading/boot.py @@ -1,3 +1,13 @@ +#!/usr/bin/env python +# +# Copyright (c) 2019, Pycom Limited. +# +# This software is licensed under the GNU GPL version 3 or any +# later version, with permitted additional terms. For more information +# see the Pycom Licence v1.0 document supplied with this file, or +# available at https://www.pycom.io/opensource/licensing +# + from machine import UART import machine import os diff --git a/examples/threading/main.py b/examples/threading/main.py index 8516af0..c0f23ff 100644 --- a/examples/threading/main.py +++ b/examples/threading/main.py @@ -1,3 +1,13 @@ +#!/usr/bin/env python +# +# Copyright (c) 2019, Pycom Limited. +# +# This software is licensed under the GNU GPL version 3 or any +# later version, with permitted additional terms. For more information +# see the Pycom Licence v1.0 document supplied with this file, or +# available at https://www.pycom.io/opensource/licensing +# + import _thread import time diff --git a/lib/ADS1115/ADS1115.py b/lib/ADS1115/ADS1115.py index 97a07b7..9e7abc7 100644 --- a/lib/ADS1115/ADS1115.py +++ b/lib/ADS1115/ADS1115.py @@ -1,3 +1,13 @@ +#!/usr/bin/env python +# +# Copyright (c) 2019, Pycom Limited. +# +# This software is licensed under the GNU GPL version 3 or any +# later version, with permitted additional terms. For more information +# see the Pycom Licence v1.0 document supplied with this file, or +# available at https://www.pycom.io/opensource/licensing +# + # Interface for ADS1115 16-bit I2C ADC class ADS1115: diff --git a/lib/ADS1115/boot.py b/lib/ADS1115/boot.py index c9ace5d..f767f86 100644 --- a/lib/ADS1115/boot.py +++ b/lib/ADS1115/boot.py @@ -1,3 +1,13 @@ +#!/usr/bin/env python +# +# Copyright (c) 2019, Pycom Limited. +# +# This software is licensed under the GNU GPL version 3 or any +# later version, with permitted additional terms. For more information +# see the Pycom Licence v1.0 document supplied with this file, or +# available at https://www.pycom.io/opensource/licensing +# + from machine import UART import machine import os diff --git a/lib/ADS1115/main.py b/lib/ADS1115/main.py deleted file mode 100644 index e69de29..0000000 diff --git a/lib/ALSPT19/ALSPT19.py b/lib/ALSPT19/ALSPT19.py index 05835f7..0120c81 100644 --- a/lib/ALSPT19/ALSPT19.py +++ b/lib/ALSPT19/ALSPT19.py @@ -1,3 +1,13 @@ +#!/usr/bin/env python +# +# Copyright (c) 2019, Pycom Limited. +# +# This software is licensed under the GNU GPL version 3 or any +# later version, with permitted additional terms. For more information +# see the Pycom Licence v1.0 document supplied with this file, or +# available at https://www.pycom.io/opensource/licensing +# + from machine import ADC import time diff --git a/lib/MFRC630/MFRC630.py b/lib/MFRC630/MFRC630.py index e342509..dc4aff8 100644 --- a/lib/MFRC630/MFRC630.py +++ b/lib/MFRC630/MFRC630.py @@ -1,6 +1,6 @@ ''' Pyscan NFC library -Copyright (c) 2018, Pycom Limited. +Copyright (c) 2019, Pycom Limited. Based on a library for NXP's MFRC630 NFC IC https://github.com/iwanders/MFRC630 diff --git a/lib/lora_mesh/loramesh.py b/lib/lora_mesh/loramesh.py index d41fe86..571c6e8 100644 --- a/lib/lora_mesh/loramesh.py +++ b/lib/lora_mesh/loramesh.py @@ -1,3 +1,13 @@ +#!/usr/bin/env python +# +# Copyright (c) 2019, Pycom Limited. +# +# This software is licensed under the GNU GPL version 3 or any +# later version, with permitted additional terms. For more information +# see the Pycom Licence v1.0 document supplied with this file, or +# available at https://www.pycom.io/opensource/licensing +# + from network import LoRa import socket import time diff --git a/lib/lora_mesh/main.py b/lib/lora_mesh/main.py index bd714a9..2444d8f 100644 --- a/lib/lora_mesh/main.py +++ b/lib/lora_mesh/main.py @@ -1,3 +1,13 @@ +#!/usr/bin/env python +# +# Copyright (c) 2019, Pycom Limited. +# +# This software is licensed under the GNU GPL version 3 or any +# later version, with permitted additional terms. For more information +# see the Pycom Licence v1.0 document supplied with this file, or +# available at https://www.pycom.io/opensource/licensing +# + from network import LoRa import socket import time diff --git a/lib/lora_mesh/main_border_router.py b/lib/lora_mesh/main_border_router.py index 29a06d7..e86ed01 100644 --- a/lib/lora_mesh/main_border_router.py +++ b/lib/lora_mesh/main_border_router.py @@ -1,3 +1,13 @@ +#!/usr/bin/env python +# +# Copyright (c) 2019, Pycom Limited. +# +# This software is licensed under the GNU GPL version 3 or any +# later version, with permitted additional terms. For more information +# see the Pycom Licence v1.0 document supplied with this file, or +# available at https://www.pycom.io/opensource/licensing +# + from network import LoRa import ubinascii from loramesh import Loramesh diff --git a/lib/mqtt/mqtt.py b/lib/mqtt/mqtt.py index 45a75c1..c183702 100644 --- a/lib/mqtt/mqtt.py +++ b/lib/mqtt/mqtt.py @@ -1,3 +1,13 @@ +#!/usr/bin/env python +# +# Copyright (c) 2019, Pycom Limited. +# +# This software is licensed under the GNU GPL version 3 or any +# later version, with permitted additional terms. For more information +# see the Pycom Licence v1.0 document supplied with this file, or +# available at https://www.pycom.io/opensource/licensing +# + import usocket as socket import ustruct as struct from ubinascii import hexlify diff --git a/lib/onewire/onewire.py b/lib/onewire/onewire.py index ddf14df..2a9b096 100644 --- a/lib/onewire/onewire.py +++ b/lib/onewire/onewire.py @@ -1,4 +1,3 @@ -#!/usr/bin/env python3 """ OneWire library for MicroPython diff --git a/lib/pycoproc/pycoproc.py b/lib/pycoproc/pycoproc.py index f8babb6..59eda6a 100644 --- a/lib/pycoproc/pycoproc.py +++ b/lib/pycoproc/pycoproc.py @@ -1,3 +1,13 @@ +#!/usr/bin/env python +# +# Copyright (c) 2019, Pycom Limited. +# +# This software is licensed under the GNU GPL version 3 or any +# later version, with permitted additional terms. For more information +# see the Pycom Licence v1.0 document supplied with this file, or +# available at https://www.pycom.io/opensource/licensing +# + from machine import Pin from machine import I2C import time diff --git a/lib/sqnsupgrade/sqnsbr.py b/lib/sqnsupgrade/sqnsbr.py index 9e69f21..ba70db2 100644 --- a/lib/sqnsupgrade/sqnsbr.py +++ b/lib/sqnsupgrade/sqnsbr.py @@ -1,4 +1,4 @@ -# Copyright (c) 2018, Pycom Limited. +# Copyright (c) 2019, Pycom Limited. # # This software is licensed under the GNU GPL version 3 or any # later version, with permitted additional terms. For more information diff --git a/lib/sqnsupgrade/sqnsbrz.py b/lib/sqnsupgrade/sqnsbrz.py index 592465a..a1d9923 100644 --- a/lib/sqnsupgrade/sqnsbrz.py +++ b/lib/sqnsupgrade/sqnsbrz.py @@ -1,4 +1,4 @@ -# Copyright (c) 2018, Pycom Limited. +# Copyright (c) 2019, Pycom Limited. # # This software is licensed under the GNU GPL version 3 or any # later version, with permitted additional terms. For more information diff --git a/pybytes/pyscan/lib/LIS2HH12.py b/pybytes/pyscan/lib/LIS2HH12.py index 739009c..49a6b5a 100644 --- a/pybytes/pyscan/lib/LIS2HH12.py +++ b/pybytes/pyscan/lib/LIS2HH12.py @@ -1,3 +1,13 @@ +#!/usr/bin/env python +# +# Copyright (c) 2019, Pycom Limited. +# +# This software is licensed under the GNU GPL version 3 or any +# later version, with permitted additional terms. For more information +# see the Pycom Licence v1.0 document supplied with this file, or +# available at https://www.pycom.io/opensource/licensing +# + import math import time import struct diff --git a/pybytes/pyscan/lib/LTR329ALS01.py b/pybytes/pyscan/lib/LTR329ALS01.py index 748aa54..49e3439 100644 --- a/pybytes/pyscan/lib/LTR329ALS01.py +++ b/pybytes/pyscan/lib/LTR329ALS01.py @@ -1,3 +1,13 @@ +#!/usr/bin/env python +# +# Copyright (c) 2019, Pycom Limited. +# +# This software is licensed under the GNU GPL version 3 or any +# later version, with permitted additional terms. For more information +# see the Pycom Licence v1.0 document supplied with this file, or +# available at https://www.pycom.io/opensource/licensing +# + import time from machine import I2C diff --git a/pybytes/pyscan/lib/MFRC630.py b/pybytes/pyscan/lib/MFRC630.py index 45e9edd..20ad25d 100644 --- a/pybytes/pyscan/lib/MFRC630.py +++ b/pybytes/pyscan/lib/MFRC630.py @@ -1,6 +1,6 @@ ''' Pyscan NFC library -Copyright (c) 2018, Pycom Limited. +Copyright (c) 2019, Pycom Limited. Based on a library for NXP's MFRC630 NFC IC https://github.com/iwanders/MFRC630 The MIT License (MIT) Copyright (c) 2016 Ivor Wanders diff --git a/pybytes/pyscan/lib/pycoproc.py b/pybytes/pyscan/lib/pycoproc.py index 12db08b..0b7772b 100644 --- a/pybytes/pyscan/lib/pycoproc.py +++ b/pybytes/pyscan/lib/pycoproc.py @@ -1,3 +1,13 @@ +#!/usr/bin/env python +# +# Copyright (c) 2019, Pycom Limited. +# +# This software is licensed under the GNU GPL version 3 or any +# later version, with permitted additional terms. For more information +# see the Pycom Licence v1.0 document supplied with this file, or +# available at https://www.pycom.io/opensource/licensing +# + from machine import Pin from machine import I2C import time diff --git a/pybytes/pyscan/lib/pyscan.py b/pybytes/pyscan/lib/pyscan.py index ba6a05d..40a1830 100644 --- a/pybytes/pyscan/lib/pyscan.py +++ b/pybytes/pyscan/lib/pyscan.py @@ -1,3 +1,13 @@ +#!/usr/bin/env python +# +# Copyright (c) 2019, Pycom Limited. +# +# This software is licensed under the GNU GPL version 3 or any +# later version, with permitted additional terms. For more information +# see the Pycom Licence v1.0 document supplied with this file, or +# available at https://www.pycom.io/opensource/licensing +# + from pycoproc import Pycoproc __version__ = '1.0.0' diff --git a/pybytes/pyscan/main.py b/pybytes/pyscan/main.py index 9a48d59..26a58e9 100644 --- a/pybytes/pyscan/main.py +++ b/pybytes/pyscan/main.py @@ -1,7 +1,16 @@ -# main.py -- put your code here! +#!/usr/bin/env python +# +# Copyright (c) 2019, Pycom Limited. +# +# This software is licensed under the GNU GPL version 3 or any +# later version, with permitted additional terms. For more information +# see the Pycom Licence v1.0 document supplied with this file, or +# available at https://www.pycom.io/opensource/licensing +# + ''' Simple Pyscan NFC / MiFare Classic Example -Copyright (c) 2018, Pycom Limited. +Copyright (c) 2019, Pycom Limited. This example runs the NFC discovery loop in a thread. If a card is detected it will read the UID and compare it to VALID_CARDS RGB LED is BLUE while waiting for card, diff --git a/pybytes/pysense/lib/LIS2HH12.py b/pybytes/pysense/lib/LIS2HH12.py index 739009c..49a6b5a 100644 --- a/pybytes/pysense/lib/LIS2HH12.py +++ b/pybytes/pysense/lib/LIS2HH12.py @@ -1,3 +1,13 @@ +#!/usr/bin/env python +# +# Copyright (c) 2019, Pycom Limited. +# +# This software is licensed under the GNU GPL version 3 or any +# later version, with permitted additional terms. For more information +# see the Pycom Licence v1.0 document supplied with this file, or +# available at https://www.pycom.io/opensource/licensing +# + import math import time import struct diff --git a/pybytes/pysense/lib/LTR329ALS01.py b/pybytes/pysense/lib/LTR329ALS01.py index 748aa54..49e3439 100644 --- a/pybytes/pysense/lib/LTR329ALS01.py +++ b/pybytes/pysense/lib/LTR329ALS01.py @@ -1,3 +1,13 @@ +#!/usr/bin/env python +# +# Copyright (c) 2019, Pycom Limited. +# +# This software is licensed under the GNU GPL version 3 or any +# later version, with permitted additional terms. For more information +# see the Pycom Licence v1.0 document supplied with this file, or +# available at https://www.pycom.io/opensource/licensing +# + import time from machine import I2C diff --git a/pybytes/pysense/lib/MPL3115A2.py b/pybytes/pysense/lib/MPL3115A2.py index ecea6e0..28a4297 100644 --- a/pybytes/pysense/lib/MPL3115A2.py +++ b/pybytes/pysense/lib/MPL3115A2.py @@ -1,3 +1,13 @@ +#!/usr/bin/env python +# +# Copyright (c) 2019, Pycom Limited. +# +# This software is licensed under the GNU GPL version 3 or any +# later version, with permitted additional terms. For more information +# see the Pycom Licence v1.0 document supplied with this file, or +# available at https://www.pycom.io/opensource/licensing +# + import time from machine import I2C diff --git a/pybytes/pysense/lib/SI7006A20.py b/pybytes/pysense/lib/SI7006A20.py index 0246f86..d9a4025 100644 --- a/pybytes/pysense/lib/SI7006A20.py +++ b/pybytes/pysense/lib/SI7006A20.py @@ -1,3 +1,13 @@ +#!/usr/bin/env python +# +# Copyright (c) 2019, Pycom Limited. +# +# This software is licensed under the GNU GPL version 3 or any +# later version, with permitted additional terms. For more information +# see the Pycom Licence v1.0 document supplied with this file, or +# available at https://www.pycom.io/opensource/licensing +# + import time from machine import I2C import math diff --git a/pybytes/pysense/lib/pycoproc.py b/pybytes/pysense/lib/pycoproc.py index 12db08b..0b7772b 100644 --- a/pybytes/pysense/lib/pycoproc.py +++ b/pybytes/pysense/lib/pycoproc.py @@ -1,3 +1,13 @@ +#!/usr/bin/env python +# +# Copyright (c) 2019, Pycom Limited. +# +# This software is licensed under the GNU GPL version 3 or any +# later version, with permitted additional terms. For more information +# see the Pycom Licence v1.0 document supplied with this file, or +# available at https://www.pycom.io/opensource/licensing +# + from machine import Pin from machine import I2C import time diff --git a/pybytes/pysense/lib/pysense.py b/pybytes/pysense/lib/pysense.py index 394f812..04d31e7 100644 --- a/pybytes/pysense/lib/pysense.py +++ b/pybytes/pysense/lib/pysense.py @@ -1,3 +1,13 @@ +#!/usr/bin/env python +# +# Copyright (c) 2019, Pycom Limited. +# +# This software is licensed under the GNU GPL version 3 or any +# later version, with permitted additional terms. For more information +# see the Pycom Licence v1.0 document supplied with this file, or +# available at https://www.pycom.io/opensource/licensing +# + from pycoproc import Pycoproc __version__ = '1.4.0' diff --git a/pybytes/pysense/main.py b/pybytes/pysense/main.py index 84c8abf..babb9c3 100644 --- a/pybytes/pysense/main.py +++ b/pybytes/pysense/main.py @@ -1,3 +1,13 @@ +#!/usr/bin/env python +# +# Copyright (c) 2019, Pycom Limited. +# +# This software is licensed under the GNU GPL version 3 or any +# later version, with permitted additional terms. For more information +# see the Pycom Licence v1.0 document supplied with this file, or +# available at https://www.pycom.io/opensource/licensing +# + # See https://docs.pycom.io for more information regarding library specifics from pysense import Pysense diff --git a/pybytes/pytrack/lib/L76GNSS.py b/pybytes/pytrack/lib/L76GNSS.py index dce13ec..8b6fca6 100644 --- a/pybytes/pytrack/lib/L76GNSS.py +++ b/pybytes/pytrack/lib/L76GNSS.py @@ -1,3 +1,13 @@ +#!/usr/bin/env python +# +# Copyright (c) 2019, Pycom Limited. +# +# This software is licensed under the GNU GPL version 3 or any +# later version, with permitted additional terms. For more information +# see the Pycom Licence v1.0 document supplied with this file, or +# available at https://www.pycom.io/opensource/licensing +# + from machine import Timer import time import gc diff --git a/pybytes/pytrack/lib/LIS2HH12.py b/pybytes/pytrack/lib/LIS2HH12.py index 739009c..49a6b5a 100644 --- a/pybytes/pytrack/lib/LIS2HH12.py +++ b/pybytes/pytrack/lib/LIS2HH12.py @@ -1,3 +1,13 @@ +#!/usr/bin/env python +# +# Copyright (c) 2019, Pycom Limited. +# +# This software is licensed under the GNU GPL version 3 or any +# later version, with permitted additional terms. For more information +# see the Pycom Licence v1.0 document supplied with this file, or +# available at https://www.pycom.io/opensource/licensing +# + import math import time import struct diff --git a/pybytes/pytrack/lib/pycoproc.py b/pybytes/pytrack/lib/pycoproc.py index 12db08b..0b7772b 100644 --- a/pybytes/pytrack/lib/pycoproc.py +++ b/pybytes/pytrack/lib/pycoproc.py @@ -1,3 +1,13 @@ +#!/usr/bin/env python +# +# Copyright (c) 2019, Pycom Limited. +# +# This software is licensed under the GNU GPL version 3 or any +# later version, with permitted additional terms. For more information +# see the Pycom Licence v1.0 document supplied with this file, or +# available at https://www.pycom.io/opensource/licensing +# + from machine import Pin from machine import I2C import time diff --git a/pybytes/pytrack/lib/pytrack.py b/pybytes/pytrack/lib/pytrack.py index 9866e63..3e4d39b 100644 --- a/pybytes/pytrack/lib/pytrack.py +++ b/pybytes/pytrack/lib/pytrack.py @@ -1,3 +1,13 @@ +#!/usr/bin/env python +# +# Copyright (c) 2019, Pycom Limited. +# +# This software is licensed under the GNU GPL version 3 or any +# later version, with permitted additional terms. For more information +# see the Pycom Licence v1.0 document supplied with this file, or +# available at https://www.pycom.io/opensource/licensing +# + from pycoproc import Pycoproc __version__ = '1.4.0' diff --git a/pybytes/pytrack/main.py b/pybytes/pytrack/main.py index 6abf4e9..33361d6 100644 --- a/pybytes/pytrack/main.py +++ b/pybytes/pytrack/main.py @@ -1,3 +1,13 @@ +#!/usr/bin/env python +# +# Copyright (c) 2019, Pycom Limited. +# +# This software is licensed under the GNU GPL version 3 or any +# later version, with permitted additional terms. For more information +# see the Pycom Licence v1.0 document supplied with this file, or +# available at https://www.pycom.io/opensource/licensing +# + import machine import math import network diff --git a/pyscan/lib/LIS2HH12.py b/pyscan/lib/LIS2HH12.py index 739009c..49a6b5a 100644 --- a/pyscan/lib/LIS2HH12.py +++ b/pyscan/lib/LIS2HH12.py @@ -1,3 +1,13 @@ +#!/usr/bin/env python +# +# Copyright (c) 2019, Pycom Limited. +# +# This software is licensed under the GNU GPL version 3 or any +# later version, with permitted additional terms. For more information +# see the Pycom Licence v1.0 document supplied with this file, or +# available at https://www.pycom.io/opensource/licensing +# + import math import time import struct diff --git a/pyscan/lib/LTR329ALS01.py b/pyscan/lib/LTR329ALS01.py index 748aa54..49e3439 100644 --- a/pyscan/lib/LTR329ALS01.py +++ b/pyscan/lib/LTR329ALS01.py @@ -1,3 +1,13 @@ +#!/usr/bin/env python +# +# Copyright (c) 2019, Pycom Limited. +# +# This software is licensed under the GNU GPL version 3 or any +# later version, with permitted additional terms. For more information +# see the Pycom Licence v1.0 document supplied with this file, or +# available at https://www.pycom.io/opensource/licensing +# + import time from machine import I2C diff --git a/pyscan/main.py b/pyscan/main.py index cfa1b12..c0d7b4f 100644 --- a/pyscan/main.py +++ b/pyscan/main.py @@ -1,6 +1,6 @@ ''' Simple Pyscan NFC / MiFare Classic Example -Copyright (c) 2018, Pycom Limited. +Copyright (c) 2019, Pycom Limited. This example runs the NFC discovery loop in a thread. If a card is detected it will read the UID and compare it to VALID_CARDS diff --git a/pyscan/nfc.py b/pyscan/nfc.py index 908126c..d4ccc4f 100644 --- a/pyscan/nfc.py +++ b/pyscan/nfc.py @@ -1,6 +1,6 @@ ''' Simple Pyscan NFC / MiFare Classic Example -Copyright (c) 2018, Pycom Limited. +Copyright (c) 2019, Pycom Limited. This example continuously sends a REQA for ISO14443A card type If a card is discovered, it will read the UID diff --git a/pysense/lib/LIS2HH12.py b/pysense/lib/LIS2HH12.py index 8fd8544..0dfefe8 100644 --- a/pysense/lib/LIS2HH12.py +++ b/pysense/lib/LIS2HH12.py @@ -1,3 +1,13 @@ +#!/usr/bin/env python +# +# Copyright (c) 2019, Pycom Limited. +# +# This software is licensed under the GNU GPL version 3 or any +# later version, with permitted additional terms. For more information +# see the Pycom Licence v1.0 document supplied with this file, or +# available at https://www.pycom.io/opensource/licensing +# + import math import time import struct diff --git a/pysense/lib/LTR329ALS01.py b/pysense/lib/LTR329ALS01.py index 748aa54..49e3439 100644 --- a/pysense/lib/LTR329ALS01.py +++ b/pysense/lib/LTR329ALS01.py @@ -1,3 +1,13 @@ +#!/usr/bin/env python +# +# Copyright (c) 2019, Pycom Limited. +# +# This software is licensed under the GNU GPL version 3 or any +# later version, with permitted additional terms. For more information +# see the Pycom Licence v1.0 document supplied with this file, or +# available at https://www.pycom.io/opensource/licensing +# + import time from machine import I2C diff --git a/pysense/lib/MPL3115A2.py b/pysense/lib/MPL3115A2.py index ecea6e0..28a4297 100644 --- a/pysense/lib/MPL3115A2.py +++ b/pysense/lib/MPL3115A2.py @@ -1,3 +1,13 @@ +#!/usr/bin/env python +# +# Copyright (c) 2019, Pycom Limited. +# +# This software is licensed under the GNU GPL version 3 or any +# later version, with permitted additional terms. For more information +# see the Pycom Licence v1.0 document supplied with this file, or +# available at https://www.pycom.io/opensource/licensing +# + import time from machine import I2C diff --git a/pysense/lib/SI7006A20.py b/pysense/lib/SI7006A20.py index 0246f86..d9a4025 100644 --- a/pysense/lib/SI7006A20.py +++ b/pysense/lib/SI7006A20.py @@ -1,3 +1,13 @@ +#!/usr/bin/env python +# +# Copyright (c) 2019, Pycom Limited. +# +# This software is licensed under the GNU GPL version 3 or any +# later version, with permitted additional terms. For more information +# see the Pycom Licence v1.0 document supplied with this file, or +# available at https://www.pycom.io/opensource/licensing +# + import time from machine import I2C import math diff --git a/pysense/lib/pysense.py b/pysense/lib/pysense.py index 394f812..04d31e7 100644 --- a/pysense/lib/pysense.py +++ b/pysense/lib/pysense.py @@ -1,3 +1,13 @@ +#!/usr/bin/env python +# +# Copyright (c) 2019, Pycom Limited. +# +# This software is licensed under the GNU GPL version 3 or any +# later version, with permitted additional terms. For more information +# see the Pycom Licence v1.0 document supplied with this file, or +# available at https://www.pycom.io/opensource/licensing +# + from pycoproc import Pycoproc __version__ = '1.4.0' diff --git a/pysense/main.py b/pysense/main.py index fa08ccd..15b29b3 100644 --- a/pysense/main.py +++ b/pysense/main.py @@ -1,3 +1,13 @@ +#!/usr/bin/env python +# +# Copyright (c) 2019, Pycom Limited. +# +# This software is licensed under the GNU GPL version 3 or any +# later version, with permitted additional terms. For more information +# see the Pycom Licence v1.0 document supplied with this file, or +# available at https://www.pycom.io/opensource/licensing +# + # See https://docs.pycom.io for more information regarding library specifics from pysense import Pysense diff --git a/pytrack/lib/L76GNSS.py b/pytrack/lib/L76GNSS.py index dce13ec..8b6fca6 100644 --- a/pytrack/lib/L76GNSS.py +++ b/pytrack/lib/L76GNSS.py @@ -1,3 +1,13 @@ +#!/usr/bin/env python +# +# Copyright (c) 2019, Pycom Limited. +# +# This software is licensed under the GNU GPL version 3 or any +# later version, with permitted additional terms. For more information +# see the Pycom Licence v1.0 document supplied with this file, or +# available at https://www.pycom.io/opensource/licensing +# + from machine import Timer import time import gc diff --git a/pytrack/lib/LIS2HH12.py b/pytrack/lib/LIS2HH12.py index 739009c..49a6b5a 100644 --- a/pytrack/lib/LIS2HH12.py +++ b/pytrack/lib/LIS2HH12.py @@ -1,3 +1,13 @@ +#!/usr/bin/env python +# +# Copyright (c) 2019, Pycom Limited. +# +# This software is licensed under the GNU GPL version 3 or any +# later version, with permitted additional terms. For more information +# see the Pycom Licence v1.0 document supplied with this file, or +# available at https://www.pycom.io/opensource/licensing +# + import math import time import struct diff --git a/pytrack/lib/pytrack.py b/pytrack/lib/pytrack.py index 9866e63..3e4d39b 100644 --- a/pytrack/lib/pytrack.py +++ b/pytrack/lib/pytrack.py @@ -1,3 +1,13 @@ +#!/usr/bin/env python +# +# Copyright (c) 2019, Pycom Limited. +# +# This software is licensed under the GNU GPL version 3 or any +# later version, with permitted additional terms. For more information +# see the Pycom Licence v1.0 document supplied with this file, or +# available at https://www.pycom.io/opensource/licensing +# + from pycoproc import Pycoproc __version__ = '1.4.0' diff --git a/pytrack/main.py b/pytrack/main.py index e0e0c4a..171a0ba 100644 --- a/pytrack/main.py +++ b/pytrack/main.py @@ -1,3 +1,13 @@ +#!/usr/bin/env python +# +# Copyright (c) 2019, Pycom Limited. +# +# This software is licensed under the GNU GPL version 3 or any +# later version, with permitted additional terms. For more information +# see the Pycom Licence v1.0 document supplied with this file, or +# available at https://www.pycom.io/opensource/licensing +# + import machine import math import network From 1347ec37f17a5981070a30fb8177432eb36a9839 Mon Sep 17 00:00:00 2001 From: danicampora Date: Wed, 22 May 2019 13:22:17 +0200 Subject: [PATCH 22/92] GoogleIOT: Add missing library headers. --- GoogleIOT/flash/config.example.py | 10 ++++++++++ GoogleIOT/flash/google_iot_core.py | 10 ++++++++++ GoogleIOT/flash/main.py | 10 ++++++++++ GoogleIOT/flash/umqtt.py | 10 ++++++++++ 4 files changed, 40 insertions(+) diff --git a/GoogleIOT/flash/config.example.py b/GoogleIOT/flash/config.example.py index 9600ff6..2578470 100644 --- a/GoogleIOT/flash/config.example.py +++ b/GoogleIOT/flash/config.example.py @@ -1,3 +1,13 @@ +#!/usr/bin/env python +# +# Copyright (c) 2019, Pycom Limited. +# +# This software is licensed under the GNU GPL version 3 or any +# later version, with permitted additional terms. For more information +# see the Pycom Licence v1.0 document supplied with this file, or +# available at https://www.pycom.io/opensource/licensing +# + ''' Set here you setup config in this example ''' CONFIG = { diff --git a/GoogleIOT/flash/google_iot_core.py b/GoogleIOT/flash/google_iot_core.py index d4da76e..18330b2 100644 --- a/GoogleIOT/flash/google_iot_core.py +++ b/GoogleIOT/flash/google_iot_core.py @@ -1,3 +1,13 @@ +#!/usr/bin/env python +# +# Copyright (c) 2019, Pycom Limited. +# +# This software is licensed under the GNU GPL version 3 or any +# later version, with permitted additional terms. For more information +# see the Pycom Licence v1.0 document supplied with this file, or +# available at https://www.pycom.io/opensource/licensing +# + ''' A MQTT wrapper for Google Cloud IoT MQTT bridge Extended from umqtt.robust by Paul Sokolovsky with wrap of Google credentials diff --git a/GoogleIOT/flash/main.py b/GoogleIOT/flash/main.py index 1f8f384..2f95055 100644 --- a/GoogleIOT/flash/main.py +++ b/GoogleIOT/flash/main.py @@ -1,3 +1,13 @@ +#!/usr/bin/env python +# +# Copyright (c) 2019, Pycom Limited. +# +# This software is licensed under the GNU GPL version 3 or any +# later version, with permitted additional terms. For more information +# see the Pycom Licence v1.0 document supplied with this file, or +# available at https://www.pycom.io/opensource/licensing +# + ''' Example Google IoT Core connection ''' import utime diff --git a/GoogleIOT/flash/umqtt.py b/GoogleIOT/flash/umqtt.py index 1d627f7..0d75984 100644 --- a/GoogleIOT/flash/umqtt.py +++ b/GoogleIOT/flash/umqtt.py @@ -1,3 +1,13 @@ +#!/usr/bin/env python +# +# Copyright (c) 2019, Pycom Limited. +# +# This software is licensed under the GNU GPL version 3 or any +# later version, with permitted additional terms. For more information +# see the Pycom Licence v1.0 document supplied with this file, or +# available at https://www.pycom.io/opensource/licensing +# + '''umqtt is a simple MQTT client for MicroPython. Original code: https://github.com/micropython/micropython-lib/tree/master/umqtt.simple''' import time From 3d0009129941e7db673d2bc94de1223efef5046c Mon Sep 17 00:00:00 2001 From: Oliver Gauci Date: Fri, 31 May 2019 14:16:40 +0200 Subject: [PATCH 23/92] Lorawan OTA: Minor config changes to server code --- examples/OTA-lorawan/config.py | 3 ++- examples/OTA-lorawan/ota.py | 30 ++++++++++++++++++++------ examples/OTA-lorawan/updaterService.py | 2 ++ 3 files changed, 27 insertions(+), 8 deletions(-) diff --git a/examples/OTA-lorawan/config.py b/examples/OTA-lorawan/config.py index 7eff59b..31ac593 100644 --- a/examples/OTA-lorawan/config.py +++ b/examples/OTA-lorawan/config.py @@ -16,9 +16,10 @@ LORASERVER_USER = 'admin' LORASERVER_PASS = 'admin' -LORASERVER_SERVICE_PROFILE = 'multicast_sp' +LORASERVER_SERVICE_PROFILE = 'ota_sp' LORASERVER_DOWNLINK_DR = 5 LORASERVER_DOWNLINK_FREQ = 869525000 +LORASERVER_APP_ID = 1 # Read from Web Interface / Applications #update configuration UPDATE_DELAY = 300 diff --git a/examples/OTA-lorawan/ota.py b/examples/OTA-lorawan/ota.py index 22a3c2a..f6b2642 100644 --- a/examples/OTA-lorawan/ota.py +++ b/examples/OTA-lorawan/ota.py @@ -24,6 +24,10 @@ class OTAHandler: MSG_HEADER = b'$OTA' MSG_TAIL = b'*' MSG_END = b'' + + FULL_UPDATE = b'F' + DIFF_UPDATE = b'D' + NO_UPDATE = b'N' UPDATE_INFO_MSG = 1 UPDATE_INFO_REPLY = 2 @@ -182,7 +186,7 @@ def _send_update_info(self, dev_eui, msg): version = self.get_latest_version() if LooseVersion(version) > LooseVersion(dev_version): self._init_update_params(dev_eui, dev_version, version) - msg = self._create_update_info_msg(version) + msg = self._create_update_info_msg(version, dev_version) self.send_payload(dev_eui, msg) def get_device_version(self, msg): @@ -241,23 +245,35 @@ def update_proc(self): upater = updateHandler(dev_version, latest_version, self._clientApp, self._loraserver_jwt, multicast_group_id, self) self.multicast_updaters.append(upater) + + def _get_update_type(self, need_updating, device_version): + update_type = b',' + self.NO_UPDATE + print(os.path.isdir(self.firmware_dir + '/' + device_version)) + if need_updating: + if os.path.isdir(self.firmware_dir + '/' + device_version): + return b',' + self.DIFF_UPDATE + else: + return b',' + self.FULL_UPDATE + + return update_type - def _create_update_info_msg(self, version): + def _create_update_info_msg(self, version, device_version): msg = bytearray() msg.extend(self.MSG_HEADER) msg.extend(b',' + str(self.UPDATE_INFO_REPLY).encode()) - msg.extend(b',' + str(int(self._next_update > 0)).encode()) msg.extend(b',' + version.encode()) - msg.extend(b',' + str(int(time.time())).encode()) - if self._next_update > 0: + need_updating = self._next_update > 0 + update_type = self._get_update_type(need_updating, device_version) + msg.extend(update_type) + if need_updating: msg.extend(b',' + str(int(self._next_update)).encode()) else: msg.extend(b',-1') + msg.extend(b',' + str(int(time.time())).encode()) msg.extend(b',' + self.MSG_TAIL) - return msg def send_payload(self, dev_eui, data): b64Data = base64.b64encode(data) payload = '{"reference": "abcd1234" ,"fPort":1,"data": "' + b64Data.decode() + '"}' - self.p_client.publish(topic="application/1/device/" + dev_eui + "/tx",payload=payload) + self.p_client.publish(topic="application/" + str(config.LORASERVER_APP_ID) + "/device/" + dev_eui + "/tx",payload=payload) diff --git a/examples/OTA-lorawan/updaterService.py b/examples/OTA-lorawan/updaterService.py index b8ac48c..54aa8cb 100644 --- a/examples/OTA-lorawan/updaterService.py +++ b/examples/OTA-lorawan/updaterService.py @@ -13,6 +13,7 @@ import signal import time import config +import sys exit = False client = None @@ -48,3 +49,4 @@ def on_publish(mosq, obj, mid): pass ota.stop() + sys.exit(0) From adb22c2d005b8ce83d8a9a6b31bbe5265135018a Mon Sep 17 00:00:00 2001 From: Bruce Rainford Date: Fri, 31 May 2019 14:22:48 +0200 Subject: [PATCH 24/92] Lorawan OTA: Full update case revision is not available --- .../OTA-lorawan/firmware/1.17.0/flash/main.py | 2 +- .../OTA-lorawan/firmware/1.17.0/flash/ota.py | 23 ++++++++++++------- .../OTA-lorawan/firmware/1.17.1/flash/main.py | 6 ++--- .../OTA-lorawan/firmware/1.17.1/flash/ota.py | 23 ++++++++++++------- 4 files changed, 34 insertions(+), 20 deletions(-) diff --git a/examples/OTA-lorawan/firmware/1.17.0/flash/main.py b/examples/OTA-lorawan/firmware/1.17.0/flash/main.py index 6475f98..add8093 100644 --- a/examples/OTA-lorawan/firmware/1.17.0/flash/main.py +++ b/examples/OTA-lorawan/firmware/1.17.0/flash/main.py @@ -16,7 +16,7 @@ def main(): LORA_FREQUENCY = 868100000 - LORA_NODE_DR = 0 + LORA_NODE_DR = 5 LORA_REGION = LoRa.EU868 LORA_DEVICE_CLASS = LoRa.CLASS_C LORA_ACTIVATION = LoRa.OTAA diff --git a/examples/OTA-lorawan/firmware/1.17.0/flash/ota.py b/examples/OTA-lorawan/firmware/1.17.0/flash/ota.py index 530a915..dd20853 100644 --- a/examples/OTA-lorawan/firmware/1.17.0/flash/ota.py +++ b/examples/OTA-lorawan/firmware/1.17.0/flash/ota.py @@ -24,6 +24,10 @@ class LoraOTA: MSG_HEADER = b'$OTA' MSG_TAIL = b'*' + FULL_UPDATE = b'F' + DIFF_UPDATE = b'D' + NO_UPDATE = b'N' + UPDATE_INFO_MSG = 1 UPDATE_INFO_REPLY = 2 @@ -46,6 +50,7 @@ def __init__(self, lora): self.version_file = '/flash/OTA_INFO.py' self.update_version = '0.0.0' self.update_time = -1 + self.update_type = None self.resp_received = False self.update_in_progress = False self.operation_timeout = 10 @@ -221,13 +226,13 @@ def parse_update_info_reply(self, msg): try: token_msg = msg.split(",") - need_updating = int(token_msg[2]) - if need_updating: - self.update_version = token_msg[3] - self.update_time = int(token_msg[5]) + self.update_type = token_msg[3].encode() + if self.update_type in [self.FULL_UPDATE, self.DIFF_UPDATE]: + self.update_version = token_msg[2] + self.update_time = int(token_msg[4]) if utime.time() < 1550000000: - self.sync_clock(int(token_msg[4])) + self.sync_clock(int(token_msg[5])) except Exception as ex: print("Exception getting update information: {}".format(ex)) @@ -374,7 +379,8 @@ def apply_patches(self): to_patch = '' print('Updating file: {}'.format(key)) - if self.file_exists('/flash/' + key): + if self.update_type == self.DIFF_UPDATE and \ + self.file_exists('/flash/' + key): to_patch = self._read_file(key) patched_text, success = self.dmp.patch_apply(self.patch_list, to_patch) @@ -426,7 +432,7 @@ def manifest_failure(self, msg): return False def process_manifest_msg(self, msg): - + if self.manifest_failure(msg): print('Manifest failure: Discarding update ...') self.reset_update_params() @@ -443,7 +449,8 @@ def process_manifest_msg(self, msg): def process_filename_msg(self, msg): self.file_to_patch = self.get_msg_data(msg) - if self.file_exists('/flash/' + self.file_to_patch): + if self.update_type == self.DIFF_UPDATE and \ + self.file_exists('/flash/' + self.file_to_patch): self.device_mainfest["update"] += 1 print("Update file: {}".format(self.file_to_patch)) else: diff --git a/examples/OTA-lorawan/firmware/1.17.1/flash/main.py b/examples/OTA-lorawan/firmware/1.17.1/flash/main.py index f7b8c90..3908377 100644 --- a/examples/OTA-lorawan/firmware/1.17.1/flash/main.py +++ b/examples/OTA-lorawan/firmware/1.17.1/flash/main.py @@ -15,10 +15,10 @@ import utime def main(): - print('Rebooting with new firmware version 1.17.1') - + print('Booting with firmware version 1.17.1') + LORA_FREQUENCY = 868100000 - LORA_NODE_DR = 0 + LORA_NODE_DR = 5 LORA_REGION = LoRa.EU868 LORA_DEVICE_CLASS = LoRa.CLASS_C LORA_ACTIVATION = LoRa.OTAA diff --git a/examples/OTA-lorawan/firmware/1.17.1/flash/ota.py b/examples/OTA-lorawan/firmware/1.17.1/flash/ota.py index 530a915..dd20853 100644 --- a/examples/OTA-lorawan/firmware/1.17.1/flash/ota.py +++ b/examples/OTA-lorawan/firmware/1.17.1/flash/ota.py @@ -24,6 +24,10 @@ class LoraOTA: MSG_HEADER = b'$OTA' MSG_TAIL = b'*' + FULL_UPDATE = b'F' + DIFF_UPDATE = b'D' + NO_UPDATE = b'N' + UPDATE_INFO_MSG = 1 UPDATE_INFO_REPLY = 2 @@ -46,6 +50,7 @@ def __init__(self, lora): self.version_file = '/flash/OTA_INFO.py' self.update_version = '0.0.0' self.update_time = -1 + self.update_type = None self.resp_received = False self.update_in_progress = False self.operation_timeout = 10 @@ -221,13 +226,13 @@ def parse_update_info_reply(self, msg): try: token_msg = msg.split(",") - need_updating = int(token_msg[2]) - if need_updating: - self.update_version = token_msg[3] - self.update_time = int(token_msg[5]) + self.update_type = token_msg[3].encode() + if self.update_type in [self.FULL_UPDATE, self.DIFF_UPDATE]: + self.update_version = token_msg[2] + self.update_time = int(token_msg[4]) if utime.time() < 1550000000: - self.sync_clock(int(token_msg[4])) + self.sync_clock(int(token_msg[5])) except Exception as ex: print("Exception getting update information: {}".format(ex)) @@ -374,7 +379,8 @@ def apply_patches(self): to_patch = '' print('Updating file: {}'.format(key)) - if self.file_exists('/flash/' + key): + if self.update_type == self.DIFF_UPDATE and \ + self.file_exists('/flash/' + key): to_patch = self._read_file(key) patched_text, success = self.dmp.patch_apply(self.patch_list, to_patch) @@ -426,7 +432,7 @@ def manifest_failure(self, msg): return False def process_manifest_msg(self, msg): - + if self.manifest_failure(msg): print('Manifest failure: Discarding update ...') self.reset_update_params() @@ -443,7 +449,8 @@ def process_manifest_msg(self, msg): def process_filename_msg(self, msg): self.file_to_patch = self.get_msg_data(msg) - if self.file_exists('/flash/' + self.file_to_patch): + if self.update_type == self.DIFF_UPDATE and \ + self.file_exists('/flash/' + self.file_to_patch): self.device_mainfest["update"] += 1 print("Update file: {}".format(self.file_to_patch)) else: From 60f2592ab6b8ab99f2a8b35c6ab65ba1bfb9fb61 Mon Sep 17 00:00:00 2001 From: cuca94 <40240701+cuca94@users.noreply.github.com> Date: Thu, 13 Jun 2019 14:28:52 +0200 Subject: [PATCH 25/92] Fix/loramesh example (#103) * fixed receive callback function rc_cb needs two parameters, the callback routine and the sockets which should be checked for incoming data (https://docs.pycom.io/firmwareapi/pycom/network/lora/pymesh.html#meshrxcbhandler-argument) without fixing this, the example will crash after connecting to the mesh network see forum entry: https://forum.pycom.io/topic/4912/loramesh-example-crashing-on-lopy4 * added copyright notes --- lib/lora_mesh/main.py | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/lib/lora_mesh/main.py b/lib/lora_mesh/main.py index 2444d8f..15b127a 100644 --- a/lib/lora_mesh/main.py +++ b/lib/lora_mesh/main.py @@ -39,12 +39,14 @@ break # create UDP socket +sockets = [] s = socket.socket(socket.AF_LORA, socket.SOCK_RAW) myport = 1234 s.bind(myport) +sockets.append(s) # handler responisble for receiving packets on UDP Pymesh socket -def receive_pack(): +def receive_pack(sockets): # listen for incomming packets while True: rcv_data, rcv_addr = s.recvfrom(128) @@ -65,7 +67,7 @@ def receive_pack(): pack_num = 1 msg = "Hello World! MAC: " + MAC + ", pack: " ip = mesh.ip() -mesh.mesh.rx_cb(receive_pack) +mesh.mesh.rx_cb(receive_pack,sockets) # infinite main loop while True: From c6d31d09f78080ed58ac6123265cfc9691da5930 Mon Sep 17 00:00:00 2001 From: Catalin Ioana Date: Thu, 3 Oct 2019 10:29:21 +0300 Subject: [PATCH 26/92] lib/pymesh: Added Pymesh lib This pymesh lib will be include as frozen in Pymesh firmware binary release, not done yet. --- lib/pymesh/README.md | 65 ++- lib/pymesh/copy_fw.sh | 35 ++ lib/pymesh/lib/L76GNSS.py | 94 ----- lib/pymesh/lib/ble_rpc.py | 356 ++++++++++++++++ lib/pymesh/lib/{ble.py => ble_services.py} | 17 +- lib/pymesh/lib/cli.py | 367 +++++++++++------ lib/pymesh/lib/gps.py | 83 ---- lib/pymesh/lib/loramesh.py | 26 +- lib/pymesh/lib/mesh_interface.py | 197 +++++++-- lib/pymesh/lib/mesh_internal.py | 168 +++++++- lib/pymesh/lib/meshaging.py | 5 +- lib/pymesh/lib/pycoproc.py | 292 ------------- lib/pymesh/lib/pymesh.py | 195 +++++++++ lib/pymesh/lib/pymesh_config.py | 127 ++++++ lib/pymesh/lib/pymesh_debug.py | 34 ++ lib/pymesh/lib/pytrack.py | 16 - lib/pymesh/main.py | 455 +++------------------ 17 files changed, 1442 insertions(+), 1090 deletions(-) create mode 100755 lib/pymesh/copy_fw.sh delete mode 100644 lib/pymesh/lib/L76GNSS.py create mode 100644 lib/pymesh/lib/ble_rpc.py rename lib/pymesh/lib/{ble.py => ble_services.py} (80%) delete mode 100644 lib/pymesh/lib/gps.py delete mode 100644 lib/pymesh/lib/pycoproc.py create mode 100644 lib/pymesh/lib/pymesh.py create mode 100644 lib/pymesh/lib/pymesh_config.py create mode 100644 lib/pymesh/lib/pymesh_debug.py delete mode 100644 lib/pymesh/lib/pytrack.py diff --git a/lib/pymesh/README.md b/lib/pymesh/README.md index fac8322..d57a12c 100644 --- a/lib/pymesh/README.md +++ b/lib/pymesh/README.md @@ -1,11 +1,9 @@ # Pymesh micropython code This project exemplifies the use of Pycom's proprietary LoRa Mesh network - **Pymesh**. -These scripts were created and tested on Lopy4 and Fipy, using the minimum release as [1.20.0.rc8](https://forum.pycom.io/topic/4499/firmware-release-candidate-v1-20-0-rc8). +These scripts were created and tested on Lopy4 and Fipy, using the Pymesh binary release. -Official Pymesh docs: https://docs.pycom.io/firmwareapi/pycom/network/lora/pymesh.html - -Simple Pymesh example: https://docs.pycom.io/tutorials/lora/lora-mesh.html +Official Pymesh docs: https://docs.pycom.io/pymesh/ Forum Pymesh announcements: https://forum.pycom.io/topic/4449/pymesh-updates @@ -15,7 +13,7 @@ These scripts were created to prototype different features of Pymesh. They are quite monolithic, as they were developed on par with firmware Pymesh development. Multiple improvement are foreseen to be further performed, into areas like modularity (BLE RPC is the main candidate). Also lots of code is executed in micropython threads, which have limited memory (they should be moved in the *main loop*). Maybe queues for RX/TX on Pymesh should be added, with automatic retransmissions until ACK. ### Important features -* Start Pymesh over LoRa on 863Mhz, bandwidth 250kHz, spreading-factor 7 (check MeshInternal constructor). +* Start Pymesh over LoRa on 863Mhz, bandwidth 250kHz, spreading-factor 7 (check `pymesh_config.py` defaults). * Pymesh parameters are automatically saved in NVM, so in the next restart/deepsleep, the node will try to maintain its IP addresses and connections with neighbour nodes. * Start BLE server with name `PyGo (mac: ` * BLE is used with an RPC protocol, packed using `msgpack` library . @@ -32,6 +30,27 @@ The LED color represents the state of the node in the Mesh network. Cyan - SINGLE LEADER (no other Router in the same Pymesh) ## Internal CLI + +``` +List of available commands +ip - display current IPv6 unicast addresses +mac - set or display the current LoRa MAC address +self - display all info about current node +mml - display the Mesh Mac List (MAC of all nodes inside this Mesh), also inquires Leader +mp - display the Mesh Pairs (Pairs of all nodes connections), also inquires Leader +s - send message +ws - verifies if message sent was acknowledged +rm - verifies if any message was received +sleep - deep-sleep +br - enable/disable or display the current Border Router functionality +brs - send packet for Mesh-external, to BR, if any +rst - reset NOW, including NVM Pymesh IPv6 +buf - display buffer info +ot - sends command to openthread internal CLI +debug - set debug level +config - print config file contents +``` + ``` >mac 1 @@ -98,6 +117,9 @@ PACK_FILE_SEND_ACK received 6165 Bytes sent, time: 27 sec Done sending 6165 B in 27 sec ``` + +*DISABLED* + Sends a file already stored in `/flash` (by default `/flash/dog.jpg`), specifying to which Node and in what chunk size (it can't be bigger than 500 Bytes, limit set in firmware). At destination, the file is stored as `/flash/dog_rcv.jpg`. @@ -111,12 +133,18 @@ Picture files could be stored on Lopy4/Fipy using either Pymakr (over USB) or FT (lon)<4.5 Gps: (2.3, 4.5) ``` + +*DISABLED* + Sets localisation coordinates; useful where no Pytrack is used. ``` >gg Gps: (2.2, 1.1) ``` + +*DISABLED* + Shows latest GPS coordinates. ``` @@ -128,23 +156,16 @@ Resets the Pymesh parameters saved in NVM, and resets the Node. ``` > rb ``` -Resets BLE RPC buffer. -## LoRa MAC address Set/Read +*DISABLED* -### Set LoRa Mac -```python -fo = open("/flash/sys/lpwan.mac", "wb") -mac_write=bytes([0,0,0,0,0,0,0,20]) -fo.write(mac_write) -fo.close() -``` +### New commands to be detailed -### Read LoRa MAC address -```python ->>> from network import LoRa ->>> lora = LoRa(mode=LoRa.LORA, region=LoRa.EU868, frequency = 863000000, bandwidth=LoRa.BW_125KHZ, sf=7) ->>> import ubinascii ->>> ubinascii.hexlify(lora.mac()) -b'0000000000000006' -``` +* sleep - deep-sleep +* br - enable/disable or display the current Border Router functionality +* brs - send packet for Mesh-external, to BR, if any +* rst - reset NOW, including NVM Pymesh IPv6 +* buf - display buffer info +* ot - sends command to openthread internal CLI +* debug - set debug level +* config - print config file contents diff --git a/lib/pymesh/copy_fw.sh b/lib/pymesh/copy_fw.sh new file mode 100755 index 0000000..33d2e6a --- /dev/null +++ b/lib/pymesh/copy_fw.sh @@ -0,0 +1,35 @@ +#!/bin/bash +set -e +#set -x +SOURCE="$(dirname $0)" +if [ -z $1 ]; then + echo "usage: $0 micropython_firmware_directory" + exit 1 +fi +if [ ! -d $1/esp32/frozen/Common ]; then + echo "Need to specify valid micropython firmware directory!" + exit 1 +fi +if [ ! -d $SOURCE ]; then + echo "Can't find source directory $SOURCE" + exit 1 +fi + +# moving main +# if [ -d $1/esp32/frozen/Pybytes ]; then +# cp $SOURCE/main.py $1/esp32/frozen/Pybytes/_main.py +# cp $1/esp32/frozen/Base/_boot.py $1/esp32/frozen/Pybytes/ +# elif [ -d $1/esp32/frozen/Base ]; then +# cp $SOURCE/main.py $1/esp32/frozen/Base/_main.py +# else +# cp $SOURCE/main.py $1/esp32/frozen/_main.py +# fi + +for i in $SOURCE/lib/*.py; do + SRC=$i + FN=$(basename $i) + cp $SRC $1/esp32/frozen/Common/_$FN +done + +cp -r $SOURCE/lib/msgpack $1/esp32/frozen/Common/ +echo "Done copying Pymesh library to $1/esp32/frozen/Common/" \ No newline at end of file diff --git a/lib/pymesh/lib/L76GNSS.py b/lib/pymesh/lib/L76GNSS.py deleted file mode 100644 index 77f2931..0000000 --- a/lib/pymesh/lib/L76GNSS.py +++ /dev/null @@ -1,94 +0,0 @@ - -# Copyright (c) 2019, Pycom Limited. -# -# This software is licensed under the GNU GPL version 3 or any -# later version, with permitted additional terms. For more information -# see the Pycom Licence v1.0 document supplied with this file, or -# available at https://www.pycom.io/opensource/licensing - -from machine import Timer -import time -import gc -import binascii - - -class L76GNSS: - - GPS_I2CADDR = const(0x10) - - def __init__(self, pytrack=None, sda='P22', scl='P21', timeout=None): - if pytrack is not None: - self.i2c = pytrack.i2c - else: - from machine import I2C - self.i2c = I2C(0, mode=I2C.MASTER, pins=(sda, scl)) - - self.chrono = Timer.Chrono() - - self.timeout = timeout - self.timeout_status = True - - self.reg = bytearray(1) - self.i2c.writeto(GPS_I2CADDR, self.reg) - - def _read(self): - self.reg = self.i2c.readfrom(GPS_I2CADDR, 64) - return self.reg - - def _convert_coords(self, gngll_s): - lat = gngll_s[1] - lat_d = (float(lat) // 100) + ((float(lat) % 100) / 60) - lon = gngll_s[3] - lon_d = (float(lon) // 100) + ((float(lon) % 100) / 60) - if gngll_s[2] == 'S': - lat_d *= -1 - if gngll_s[4] == 'W': - lon_d *= -1 - return(lat_d, lon_d) - - def coordinates(self, debug=False): - lat_d, lon_d, debug_timeout = None, None, False - if self.timeout is not None: - self.chrono.reset() - self.chrono.start() - nmea = b'' - while True: - if self.timeout is not None and self.chrono.read() >= self.timeout: - self.chrono.stop() - chrono_timeout = self.chrono.read() - self.chrono.reset() - self.timeout_status = False - debug_timeout = True - if not self.timeout_status: - gc.collect() - break - nmea += self._read().lstrip(b'\n\n').rstrip(b'\n\n') - gngll_idx = nmea.find(b'GNGLL') - gpgll_idx = nmea.find(b'GPGLL') - if gngll_idx < 0 and gpgll_idx >= 0: - gngll_idx = gpgll_idx - if gngll_idx >= 0: - gngll = nmea[gngll_idx:] - e_idx = gngll.find(b'\r\n') - if e_idx >= 0: - try: - gngll = gngll[:e_idx].decode('ascii') - gngll_s = gngll.split(',') - lat_d, lon_d = self._convert_coords(gngll_s) - except Exception: - pass - finally: - nmea = nmea[(gngll_idx + e_idx):] - gc.collect() - break - else: - gc.collect() - if len(nmea) > 410: # i suppose it can be safely changed to 82, which is longest NMEA frame - nmea = nmea[-5:] # $GNGL without last L - time.sleep(0.1) - self.timeout_status = True - if debug and debug_timeout: - print('GPS timed out after %f seconds' % (chrono_timeout)) - return(None, None) - else: - return(lat_d, lon_d) diff --git a/lib/pymesh/lib/ble_rpc.py b/lib/pymesh/lib/ble_rpc.py new file mode 100644 index 0000000..4331a5f --- /dev/null +++ b/lib/pymesh/lib/ble_rpc.py @@ -0,0 +1,356 @@ +''' +Copyright (c) 2019, Pycom Limited. +This software is licensed under the GNU GPL version 3 or any +later version, with permitted additional terms. For more information +see the Pycom Licence v1.0 document supplied with this file, or +available at https://www.pycom.io/opensource/licensing +''' +import _thread +import time +from machine import Timer +from network import Bluetooth +import sys +import json + +import msgpack + +try: + from ble_services import BleServices +except: + from _ble_services import BleServices + +try: + from pymesh_config import PymeshConfig +except: + from _pymesh_config import PymeshConfig + +class BleRpc: + + def __init__(self, config, mesh): + self.config = config + self.mesh = mesh + self.ble_comm = BleServices(config.get('ble_name_prefix', PymeshConfig.BLE_NAME_PREFIX) + str(config.get('MAC'))) + + self.rx_worker = RXWorker(self.ble_comm) + self.tx_worker = TXWorker(self.ble_comm) + + self.rpc_handler = RPCHandler(self.rx_worker, self.tx_worker, self.mesh, self.ble_comm) + + # setting hooks for triggering when new message was received and ACK + self.mesh.meshaging.on_rcv_message = self.on_rcv_message + self.mesh.meshaging.on_rcv_ack = self.on_rcv_ack + + self.ble_comm.on_disconnect = self.ble_on_disconnect + + + def terminate(self): + ''' kill all, to exit nicely ''' + self.rx_worker.timer_kill() + self.ble_comm.close() + + def on_rcv_message(self, message): + ''' hook triggered when a new message arrived ''' + message_data = { + 'mac' : message.mac, + 'payload' : message.payload, + 'ts' : message.ts, + 'id' : message.id, + } + + msg = msgpack.packb(['notify', 'msg', message_data]) + self.rx_worker.put(msg) + print(message_data['payload']) + print("%d ================= RECEIVED :) :) :) "%time.ticks_ms()) + + + def on_rcv_ack(self, message): + ''' hook triggered when the ACK arrived ''' + message_data = { + 'id' : message.id, + } + + msg = msgpack.packb(['notify', 'msg-ack', message_data]) + self.rx_worker.put(msg) + print("%d ================= ACK RECEIVED :) :) :) "%time.ticks_ms()) + + def ble_on_disconnect(self): + ''' if BLE disconnected, it's better to re-instantiate RPC handler ''' + self.rpc_handler = RPCHandler(self.rx_worker, self.tx_worker, self.mesh, self.ble_comm) + +class RXWorker: + def __init__(self, ble_comm): + self.HEADSIZE = 20 + self.INTERVAL = .1 + self.q = b'' + self.ble_comm = ble_comm + self.chr = ble_comm.chr_rx + self.call_cnt = 0 + + # mutex for self.q usage + self.q_lock = _thread.allocate_lock() + + self._timer = Timer.Alarm(self.interval_cb, self.INTERVAL, periodic=True) + + def put(self, bytes): + with self.q_lock: + self.q = self.q + bytes + + # chunks = [ self.q[i:i+self.HEADSIZE] for i in range(0, len(self.q), self.HEADSIZE) ] + # for chunk in chunks: + # self.chr.value(chunk) + + #self.chr.value('') + #self.chr.value(bytes) + + def interval_cb(self, alarm): + self.call_cnt = self.call_cnt + 1 + if self.call_cnt >= 10: + # print('%d: rx worker interval.... %d'%(time.time(), len(self.q))) + self.call_cnt = 0 + + if len(self.q) == 0: + return + + if not self.ble_comm.status['connected']: + #unpacker._buffer = bytearray([]) + with self.q_lock: + self.q = b'' + return + try: + with self.q_lock: + head = self.q[:self.HEADSIZE] + tail = self.q[self.HEADSIZE:] + self.q = tail + #print('consuming {}, {}', head, tail) + + if self.chr and len(head) > 0: + self.chr.value(head) + #print('sending', list(head)) + except: + pass + + def timer_kill(self): + self._timer.cancel() + +class TXWorker: + def __init__(self, ble_comm): + self.ble_comm = ble_comm + self.chr = ble_comm.chr_tx + self.last_value = b'' + self.on_write = lambda value : 1 + + self.chr.callback(trigger=Bluetooth.CHAR_WRITE_EVENT | Bluetooth.CHAR_READ_EVENT, handler=self.cb_handler) + + def cb_handler(self, chr): + events = chr.events() + if events & Bluetooth.CHAR_WRITE_EVENT: + self.last_value = chr.value() + #print("Write request with value = {}".format(self.last_value)) + + self.on_write(self.last_value) + else: + #print('Read request on char 1') + return self.last_value + +class RPCHandler: + def __init__(self, rx_worker, tx_worker, mesh, ble_comm): + self.rx_worker = rx_worker + self.tx_worker = tx_worker + self.mesh = mesh + self.unpacker = msgpack.Unpacker(raw=False) + self.error = False + ble_comm.unpacker_set(self.unpacker) + + tx_worker.on_write = self.feed + + def feed(self, message): + #print('feeding (rpc)', message) + self.unpacker.feed(message) + try: + [self.resolve(x) for x in self.unpacker] + except Exception as e: + sys.print_exception(e) + print('error in unpacking... reset') + self.unpacker._buffer = bytearray() + self.error = True + + + + def resolve(self, obj): + #print('resolving: ', obj) + obj = list(obj) + type = obj[0] + + if type == 'call': + uuid = obj[1] + fn_name = obj[2] + args = obj[3] + fn = getattr(self, fn_name) + + if not fn: + print('fn {} not defined'.format(fn_name)) + return + + try: + result = fn(*args) + result = json.loads(json.dumps(result)) + print('calling RPC: {} - {}'.format(fn_name, result)) + + message = msgpack.packb(['call_result', uuid, result]) + except Exception as e: + sys.print_exception(e) + print('could not send result: {}'.format(result)) + return + + + #print('result', result) + #print('message', message) + self.rx_worker.put(message) + + def demo_fn(self, *args): + return { 'res': 'demo_fn' } + + def demo_echo_fn(self, *args): + return args + + def mesh_is_connected(self): + # True if Node is connected to Mesh; False otherwise + is_connected = self.mesh.is_connected() + return is_connected + + def mesh_ip(self): + # get IP RLOC16 in string + ip = self.mesh.ip() + return ip + + def set_gps(self, lng, lat): + print('settings gps!') + # Gps.set_location(lat, lng) + # with open('/flash/gps', 'w') as fh: + # fh.write('{};{}'.format(lng, lat)) + + def get_mesh_mac_list(self): + """ returns list of distinct MAC address that are in this mesh network + [mac1, mac2, mac 3] """ + last_mesh_mac_list = self.mesh.get_mesh_mac_list() + return last_mesh_mac_list + + def get_mesh_pairs(self, *args): + """ returns list of pairs that is a mesh connection + [ + ('mac1', 'mac2', rssi), + ('mac1', 'mac3', rssi), + #... + ] """ + last_mesh_pairs = self.mesh.get_mesh_pairs() + return last_mesh_pairs + + + def get_node_info(self, mac_id = ' '): + """ Returns the debug info for a specified mac address + takes max 10 sec + { + 'ip': 4c00, # last 2bytes from the ip v6 RLOC16 address + 'r': 3, # not_connected:0 | child:1 | leader:2 | router:3 + 'a': 100, # age[sec], time since last info about this node + 'nn' : 20 # neighbours number + 'nei': { # neighbours enumerated, if any + (mac, ip, role, rssi, age), + (mac, ip, role, rssi, age) + } + 'l': { # location, if available + 'lng': 7, + 'lat': 20, + }, + 'b' : { # BLE infos + 'a': 100 # age, seconds since last ping with that device, None if properly disconnected + 'id': '' # 16byte + 'n': '', # name, max. 16 chars + } + } """ + node_info = self.mesh.get_node_info(mac_id) + return node_info + + def send_message(self, data): + """ sends a message with id, to m(MAC) + return True if there is buffer to store it (to be sent)""" + """ data is dictionary data = { + 'to': 0x5, + 'b': 'text', + 'id': 12345, + 'ts': 123123123, + }""" + print("%d: Send Msg ---------------------->>>>>>>> "%time.ticks_ms()) + return self.mesh.send_message(data) + + def send_message_was_sent(self, mac, msg_id): + """ checks for ACK received for msg_id + returns True if message was delivered to last node connected to BLE mobile """ + error = False + try: + mac_int = int(mac) + msg_id_int = int(msg_id) + except: + error = True + if error: + return False + # mesh.mesage_was_ack(5, 12345) + return self.mesh.mesage_was_ack(mac, msg_id) + + def receive_message(self): + """ + return { + 'b': 'text', + 'from': 'ble_device_id', + 'ts': 123123123, + 'id': '', + } """ + return self.mesh.get_rcv_message() + + def send_image(self, data): + """ sends an image + return True if there is buffer to store it (to be sent)""" + print("Send Image ---------------------->>>>>>>> ", data) + start = 0 + filename = 'dog_2.jpg' + to = 0 + # packsize = 500 + image = list() + + try: + filename = data.get('fn', "image.jpg") + start = int(data['start']) + image = bytes(data['image']) + except: + print('parsing failed') + return False + + print("Image chunk size: %d"%len(image)) + file_handling = "ab" # append, by default + if start == 0: + file_handling = "wb" # write/create new + + with open("/flash/" + filename, file_handling) as file: + print("file open") + file.write(image) + print("file written") + + print("done") + return True + + def stat_start(self, data): + # do some statistics + #data = {'mac':6, 'n':3, 't':30} + res = self.mesh.statistics_start(data) + print("rpc stat_start? ", res) + return res + + def stat_status(self, data): + print("rpc stat_status ", data) + try: + id = int(data) + except: + id = 0 + res = self.mesh.statistics_get(id) + print("rpc stat_status id:"+ str(id) + ", res: " + str(res)) + return res diff --git a/lib/pymesh/lib/ble.py b/lib/pymesh/lib/ble_services.py similarity index 80% rename from lib/pymesh/lib/ble.py rename to lib/pymesh/lib/ble_services.py index 831ef60..42e871f 100644 --- a/lib/pymesh/lib/ble.py +++ b/lib/pymesh/lib/ble_services.py @@ -11,10 +11,12 @@ VERSION = "1.0.0" -class BleCommunication: +class BleServices: - def __init__(self, mesh_mac): - self.mesh_mac = mesh_mac + def __init__(self, ble_name): + # self.mesh_mac = mesh_mac + self.ble_name = ble_name + self.on_disconnect = None self._init() def _init(self): @@ -22,9 +24,12 @@ def _init(self): 'connected' : False } - #bluetooth = Bluetooth(modem_sleep=False) - bluetooth = Bluetooth() - bluetooth.set_advertisement(name='PyGo (mac:' + str(self.mesh_mac) + ')', service_uuid=0xec00) + bluetooth = Bluetooth(modem_sleep=False) + # bluetooth = Bluetooth() + # bluetooth.set_advertisement(name='PyGo (mac:' + str(self.mesh_mac) + ')', service_uuid=0xec00) + adv_name = self.ble_name + bluetooth.set_advertisement(name=adv_name, service_uuid=0xec00) + print("BLE name:", adv_name) bluetooth.callback(trigger=Bluetooth.CLIENT_CONNECTED | Bluetooth.CLIENT_DISCONNECTED, handler=self.conn_cb) bluetooth.advertise(True) diff --git a/lib/pymesh/lib/cli.py b/lib/pymesh/lib/cli.py index 1e7a3ea..a9feadb 100644 --- a/lib/pymesh/lib/cli.py +++ b/lib/pymesh/lib/cli.py @@ -8,6 +8,12 @@ import time import json +import sys + +try: + from pymesh_debug import print_debug +except: + from _pymesh_debug import print_debug __version__ = '1' """ @@ -17,10 +23,10 @@ class Cli: """ class for CLI commands """ - def __init__(self, mesh, rpc_handler, ble_comm): + def __init__(self, mesh): self.mesh = mesh - self.rpc_handler = rpc_handler - self.ble_comm = ble_comm + # self.rpc_handler = rpc_handler + # self.ble_comm = ble_comm # lamda functions self.sleep = None @@ -31,117 +37,248 @@ def process(self, arg1, arg2): last_mesh_mac_list = [] last_mesh_node_info = {} - while True: - time.sleep(.1) - cmd = input('>') - # print(cmd) - - # if cmd == 'rb': - # print('resetting unpacker buffer') - # self.rpc_handler = RPCHandler(rx_worker, tx_worker, mesh, ble_comm) - - if cmd == 'mac': - print(self.mesh.mesh.mesh.MAC) - - elif cmd == 'mml': - mesh_mac_list = self.rpc_handler.get_mesh_mac_list() - if len(mesh_mac_list) > 0: - last_mesh_mac_list = mesh_mac_list - print('mesh_mac_list ', json.dumps(last_mesh_mac_list)) - - elif cmd == 'self': - node_info = self.rpc_handler.get_node_info() - print("self info:", node_info) - - elif cmd == 'mni': - for mac in last_mesh_mac_list: - node_info = self.rpc_handler.get_node_info(mac) - time.sleep(.5) - if len(node_info) > 0: - last_mesh_node_info[mac] = node_info - print('last_mesh_node_info', json.dumps(last_mesh_node_info)) - - elif cmd == 'mp': - mesh_pairs = self.rpc_handler.get_mesh_pairs() - if len(mesh_pairs) > 0: - last_mesh_pairs = mesh_pairs - print('last_mesh_pairs', json.dumps(last_mesh_pairs)) - - elif cmd == 's': - try: + try: + while True: + time.sleep(.1) + cmd = input('>') + # print(cmd) + + # if cmd == 'rb': + # print('resetting unpacker buffer') + # self.rpc_handler = RPCHandler(rx_worker, tx_worker, mesh, ble_comm) + + if cmd == 'ip': + print(self.mesh.ip()) + + elif cmd == 'mac': + # read/write LoRa MAC address + try: + id = int(input('(new LoRa MAC (0-64k) [Enter for read])<')) + except: + print(self.mesh.mesh.mesh.MAC) + continue + id = id & 0xFFFF # just 2B value + # it's actually set in main.py (main thread) + print("LoRa MAC set to", id) + self.sleep(1, id) # force restart + + elif cmd == 'mml': + mesh_mac_list = self.mesh.get_mesh_mac_list() + if len(mesh_mac_list) > 0: + last_mesh_mac_list = mesh_mac_list + print('mesh_mac_list ', json.dumps(last_mesh_mac_list)) + + elif cmd == 'self': + node_info = self.mesh.get_node_info() + print("self info:", node_info) + + elif cmd == 'mni': + for mac in last_mesh_mac_list: + node_info = self.mesh.get_node_info(mac) + time.sleep(.5) + if len(node_info) > 0: + last_mesh_node_info[mac] = node_info + print('last_mesh_node_info', json.dumps(last_mesh_node_info)) + + elif cmd == 'mp': + mesh_pairs = self.mesh.get_mesh_pairs() + if len(mesh_pairs) > 0: + last_mesh_pairs = mesh_pairs + print('last_mesh_pairs', json.dumps(last_mesh_pairs)) + + elif cmd == 's': + try: + to = int(input('(to)<')) + typ = input('(type, 0=text, 1=file, Enter for text)<') + if not typ: + typ = 0 + else: + typ = int(typ) + txt = input('(text/filename)<') + except: + print("Command parsing failed") + continue + data = { + 'to': to, + 'ty': typ, + 'b': txt, + 'id': 12345, + 'ts': int(time.time()), + } + print(self.mesh.send_message(data)) + + elif cmd == 'ws': to = int(input('(to)<')) - typ = input('(type, 0=text, 1=file, Enter for text)<') - if not typ: - typ = 0 + try: + id = int(input('(id, default 12345)<')) + except: + id = 12345 + print(self.mesh.mesage_was_ack(to, id)) + + elif cmd == 'rm': + print(self.mesh.get_rcv_message()) + + # elif cmd == 'gg': + # print("Gps:", (Gps.lat, Gps.lon)) + + # elif cmd == 'gs': + # lat = float(input('(lat)<')) + # lon = float(input('(lon)<')) + # Gps.set_location(lat, lon) + # print("Gps:", (Gps.lat, Gps.lon)) + + elif cmd == 'sleep': + try: + timeout = int(input('(time[sec])<')) + except: + continue + if self.sleep: + self.sleep(timeout) + + # elif cmd == "ble": + # # reset BLE connection + # self.ble_comm.restart() + + # elif cmd == "stat": + # # do some statistics + # # data = [] + # # data[0] = {'mac':6, 'n':3, 't':30, 's1':0, 's2':0} + # # data[0] = {'mac':6, 'n':3, 't':30, 's1':5, 's2':10} + # # data[2] = {'mac':6, 'n':30, 't':60, 's1':10, 's2':45} + # # for line in data: + # # print() + # # print("1 = {'mac':6, 'n':30, 't':60, 's1':10, 's2':45}<'") + # # print("2 = {'mac':6, 'n':30, 't':60, 's1':10, 's2':45}<'") + # # print("3 = {'mac':6, 'n':30, 't':60, 's1':10, 's2':45}<'") + # # id = int(input('(choice 1-..)<')) + # data = {'mac':6, 'n':3, 't':60, 's1':3, 's2':8} + # res = self.mesh.statistics_start(data) + # print("ok? ", res) + + # elif cmd == "stat?": + # try: + # id = int(input('(id [Enter for all])<')) + # except: + # id = 0 + # res = self.mesh.statistics_get(id) + # print("ok? ", res) + + # elif cmd == "rst": + # print("Mesh Reset NVM settings ... ") + # self.mesh.mesh.mesh.mesh.deinit() + # if self.sleep: + # self.sleep(1) + + # elif cmd == "pyb": + # # print("Pybytes debug menu, Pybytes connection is ", Pybytes_wrap.is_connected()) + # state = 1 + # timeout = 120 + # try: + # state = int(input('(Debug 0=stop, 1=start [Default start])<')) + # except: + # pass + # try: + # timeout = int(input('(Pybytes timeout [Default 120 sec])<')) + # except: + # pass + # self.mesh.pybytes_config((state == 1), timeout) + + elif cmd == "br": + state = 2 # default display BR + try: + state = int(input('(state 0=Disable, 1=Enable, 2=Display [Default Display])<')) + except: + pass + + if state == 2: + print("Border Router state: ", self.mesh.mesh.mesh.mesh.border_router()) + elif state == 1: + # Enable BR + prio = 0 # default normal priority + try: + prio = int(input('(priority -1=Low, 0=Normal or 1=High [Default Normal])<')) + except: + pass + self.mesh.br_set(True, prio, self.new_br_message_cb) else: - typ = int(typ) - txt = input('(text/filename)<') - except: - print("Command parsing failed") - continue - data = { - 'to': to, - 'ty': typ, - 'b': txt, - 'id': 12345, - 'ts': int(time.time()), - } - print(self.rpc_handler.send_message(data)) - - elif cmd == 'ws': - to = int(input('(to)<')) - print(self.rpc_handler.send_message_was_sent(to, 12345)) - - elif cmd == 'rm': - print(self.rpc_handler.receive_message()) - - # elif cmd == 'gg': - # print("Gps:", (Gps.lat, Gps.lon)) - - # elif cmd == 'gs': - # lat = float(input('(lat)<')) - # lon = float(input('(lon)<')) - # Gps.set_location(lat, lon) - # print("Gps:", (Gps.lat, Gps.lon)) - - elif cmd == 'sleep': - try: - timeout = int(input('(time[sec])<')) - except: - continue - if self.sleep: - self.sleep(timeout) - - elif cmd == "ble": - # reset BLE connection - self.ble_comm.restart() - - elif cmd == "stat": - # do some statistics - # data = [] - # data[0] = {'mac':6, 'n':3, 't':30, 's1':0, 's2':0} - # data[0] = {'mac':6, 'n':3, 't':30, 's1':5, 's2':10} - # data[2] = {'mac':6, 'n':30, 't':60, 's1':10, 's2':45} - # for line in data: - # print() - # print("1 = {'mac':6, 'n':30, 't':60, 's1':10, 's2':45}<'") - # print("2 = {'mac':6, 'n':30, 't':60, 's1':10, 's2':45}<'") - # print("3 = {'mac':6, 'n':30, 't':60, 's1':10, 's2':45}<'") - # id = int(input('(choice 1-..)<')) - data = {'mac':6, 'n':3, 't':60, 's1':3, 's2':8} - res = self.mesh.statistics_start(data) - print("ok? ", res) - - elif cmd == "stat?": - try: - id = int(input('(id [Enter for all])<')) - except: - id = 0 - res = self.mesh.statistics_get(id) - print("ok? ", res) - - elif cmd == "rst": - print("Mesh Reset NVM settings ... ") - self.mesh.mesh.mesh.mesh.deinit() - if self.sleep: - self.sleep(1) \ No newline at end of file + # disable BR function + self.mesh.br_set(False) + + elif cmd == "brs": + """ send data to BR """ + ip_default = "1:2:3::4" + port = 5555 + try: + payload = input("(message<)") + ip = input("(IP destination, Mesh-external [Default: 1:2:3::4])<") + if len(ip) == 0: + ip = ip_default + port = int(input("(port destination [Default: 5555])<")) + except: + pass + data = { + 'ip': ip, + 'port': port, + 'b': payload + } + print("Send BR message:", data) + self.mesh.send_message(data) + + elif cmd == "buf": + print("Buffer info:",self.mesh.mesh.mesh.mesh.cli("bufferinfo")) + + elif cmd == "ot": + cli = input('(openthread cli)<') + print(self.mesh.mesh.mesh.mesh.cli(cli)) + + elif cmd == "debug": + ret = input('(debug level[0-5])<') + try: + level = int(ret) + self.mesh.debug_level(level) + except: + print_debug(1, "error parsing") + + elif cmd == "config": + print(self.mesh.config) + + else: + print("List of available commands") + print("ip - display current IPv6 unicast addresses") + print("mac - set or display the current LoRa MAC address") + print("self - display all info about current node") + print("mml - display the Mesh Mac List (MAC of all nodes inside this Mesh), also inquires Leader") + print("mp - display the Mesh Pairs (Pairs of all nodes connections), also inquires Leader") + print("s - send message") + print("ws - verifies if message sent was acknowledged") + print("rm - verifies if any message was received") + print("sleep - deep-sleep") + # print("stat - start statistics") + # print("stat? - display statistics") + print("br - enable/disable or display the current Border Router functionality") + print("brs - send packet for Mesh-external, to BR, if any") + print("rst - reset NOW, including NVM Pymesh IPv6") + print("buf - display buffer info") + print("ot - sends command to openthread internal CLI") + print("debug - set debug level") + print("config - print config file contents") + + except KeyboardInterrupt: + print('cli Got Ctrl-C') + except Exception as e: + sys.print_exception(e) + finally: + print('cli finally') + self.sleep(0) + + def new_br_message_cb(self, rcv_ip, rcv_port, rcv_data, dest_ip, dest_port): + ''' callback triggered when a new packet arrived for the current Border Router, + having destination an IP which is external from Mesh ''' + print('CLI BR default handler') + print('Incoming %d bytes from %s (port %d), to external IPv6 %s (port %d)' % + (len(rcv_data), rcv_ip, rcv_port, dest_ip, dest_port)) + print(rcv_data) + + # user code to be inserted, to send packet to the designated Mesh-external interface + # ... + return \ No newline at end of file diff --git a/lib/pymesh/lib/gps.py b/lib/pymesh/lib/gps.py deleted file mode 100644 index 5f4c8c2..0000000 --- a/lib/pymesh/lib/gps.py +++ /dev/null @@ -1,83 +0,0 @@ - -# Copyright (c) 2019, Pycom Limited. -# -# This software is licensed under the GNU GPL version 3 or any -# later version, with permitted additional terms. For more information -# see the Pycom Licence v1.0 document supplied with this file, or -# available at https://www.pycom.io/opensource/licensing - -__version__ = '1' -""" -* initial version -""" - -import time -from pytrack import Pytrack -from L76GNSS import L76GNSS -from machine import Timer - -class Gps: - # Pycom office GPS coordinates - lat = 51.45 - lon = 5.45313 - - l76 = None - _timer = None - #is_set = False - - @staticmethod - def set_location(latitude, longitude): - dlat = str(type(latitude)) - dlon = str(type(longitude)) - if dlat == dlon == "": - Gps.lon = longitude - Gps.lat = latitude - is_set = True - else: - print("Error parsing ", latitude, longitude) - - @staticmethod - def get_location(): - return (Gps.lat, Gps.lon) - - @staticmethod - def init_static(): - is_pytrack = True - try: - py = Pytrack() - Gps.l76 = L76GNSS(py, timeout=30) - #l76.coordinates() - Gps._timer = Timer.Alarm(Gps.gps_periodic, 30, periodic=True) - print("Pytrack detected") - except: - is_pytrack = False - print("Pytrack NOT detected") - #TODO: how to check if GPS is conencted - return is_pytrack - - @staticmethod - def gps_periodic(alarm): - t0 = time.ticks_ms() - coord = Gps.l76.coordinates() - if coord[0] != None: - Gps.lat, Gps.lon = coord - print("New coord ", coord) - dt = time.ticks_ms() - t0 - print(" =====>>>> gps_periodic ", dt) - - @staticmethod - def terminate(): - if Gps._timer is not None: - Gps._timer.cancel() - pass - -""" -from pytrack import Pytrack -from L76GNSS import L76GNSS -py = Pytrack() -l76 = L76GNSS(py, timeout=30) -t0 = time.ticks_ms() -l76.coordinates() -y = time.ticks_ms() - t0 -y -""" diff --git a/lib/pymesh/lib/loramesh.py b/lib/pymesh/lib/loramesh.py index b499daf..017ecbf 100644 --- a/lib/pymesh/lib/loramesh.py +++ b/lib/pymesh/lib/loramesh.py @@ -14,7 +14,11 @@ import pycom from struct import * -from gps import Gps + +try: + from pymesh_debug import print_debug +except: + from _pymesh_debug import print_debug __version__ = '6' """ @@ -55,18 +59,24 @@ class Loramesh: # Leader has an unicast IPv6: fdde:ad00:beef:0:0:ff:fe00:fc00 LEADER_DEFAULT_RLOC = 'fc00' - def __init__(self, lora): + def __init__(self, config): """ Constructor """ - self.lora = lora - self.mesh = lora.Mesh() #start Mesh + self.config = config + config_lora = config.get('LoRa') + self.lora = LoRa(mode=LoRa.LORA, + region = config_lora.get("region"), + frequency = config_lora.get("freq"), + bandwidth = config_lora.get("bandwidth"), + sf = config_lora.get("sf")) + self.mesh = self.lora.Mesh() #start Mesh # get Lora MAC address #self.MAC = str(ubinascii.hexlify(lora.mac()))[2:-1] - self.MAC = int(str(ubinascii.hexlify(lora.mac()))[2:-1], 16) + self.MAC = int(str(ubinascii.hexlify(self.lora.mac()))[2:-1], 16) #last 2 letters from MAC, as integer self.mac_short = self.MAC & 0xFFFF #int(self.MAC[-4:], 16) - print("LoRa MAC: %s, short: %s"%(hex(self.MAC), self.mac_short)) + print_debug(5, "LoRa MAC: %s, short: %s"%(hex(self.MAC), self.mac_short)) self.rloc16 = 0 self.rloc = '' @@ -252,7 +262,7 @@ def neighbors_update(self): """ x = self.mesh.neighbors() - print("Neighbors Table: %s"%x) + print_debug(3,"Neighbors Table: %s"%x) if x is None: # bad read, just keep previous neigbors @@ -264,7 +274,7 @@ def neighbors_update(self): self.router_data.rloc16 = self.rloc16 self.router_data.role = self.state self.router_data.ts = time.time() - self.router_data.coord = Gps.get_location() + self.router_data.coord = (1,2) #Gps.get_location() for nei_rec in x: # nei_rec = (role=3, rloc16=10240, rssi=0, age=28, mac=5) diff --git a/lib/pymesh/lib/mesh_interface.py b/lib/pymesh/lib/mesh_interface.py index d3a579f..d7c7711 100644 --- a/lib/pymesh/lib/mesh_interface.py +++ b/lib/pymesh/lib/mesh_interface.py @@ -8,12 +8,31 @@ import time from machine import Timer -#import _thread - -from mesh_internal import MeshInternal -from statistics import Statistics - -__version__ = '3' +import _thread + +try: + from mesh_internal import MeshInternal +except: + from _mesh_internal import MeshInternal + +try: + from statistics import Statistics +except: + from _statistics import Statistics + +try: + from meshaging import Meshaging +except: + from _meshaging import Meshaging + +try: + from pymesh_debug import print_debug + from pymesh_debug import debug_level +except: + from _pymesh_debug import print_debug + from _pymesh_debug import debug_level + +__version__ = '4' """ * added file send/receive debug @@ -30,13 +49,24 @@ class MeshInterface: INTERVAL = const(10) - def __init__(self, meshaging, lock): - self.lock = lock #_thread.allocate_lock() - self.meshaging = meshaging - self.mesh = MeshInternal(self.meshaging) + def __init__(self, config, message_cb): + self.lock = _thread.allocate_lock() + self.meshaging = Meshaging(self.lock) + self.config = config + self.mesh = MeshInternal(self.meshaging, config, message_cb) self.sleep_function = None self.single_leader_ts = 0 + # Pybytes debugging + self.pyb_dbg = False + self.pyb_ts = 0 + self.pyb_timeout = 1000000 + self.pyb_data = "No data" + self.br_auto = False + self.mesh.br_handler = self.br_handler + + self.end_device_m = False + self.statistics = Statistics(self.meshaging) self._timer = Timer.Alarm(self.periodic_cb, self.INTERVAL, periodic=True) @@ -48,7 +78,7 @@ def __init__(self, meshaging, lock): def periodic_cb(self, alarm): # wait lock forever if self.lock.acquire(): - print("============ MESH THREAD >>>>>>>>>>> ") + print_debug(2, "============ MESH THREAD >>>>>>>>>>> ") t0 = time.ticks_ms() self.mesh.process() @@ -56,25 +86,30 @@ def periodic_cb(self, alarm): self.statistics.process() self.mesh.process_messages() + # if connected to Pybytes enable/disable BR + # if self.pyb_dbg: + # # self.mesh.border_router(Pybytes_wrap.is_connected()) + # self.pybytes_process() + # if Single Leader for 3 mins should reset - if self.mesh.mesh.state == self.mesh.mesh.STATE_LEADER and self.mesh.mesh.mesh.single(): - if self.single_leader_ts == 0: - # first time Single Leader, record time - self.single_leader_ts = time.time() - print("Single Leader", self.mesh.mesh.state, self.mesh.mesh.mesh.single(), - time.time() - self.single_leader_ts) - - if time.time() - self.single_leader_ts > 180: - print("Single Leader, just reset") - if self.sleep_function: - self.sleep_function(1) - else: - # print("Not Single Leader", self.mesh.mesh.state, self.mesh.mesh.mesh.single()) - self.single_leader_ts = 0 + # if self.mesh.mesh.state == self.mesh.mesh.STATE_LEADER and self.mesh.mesh.mesh.single(): + # if self.single_leader_ts == 0: + # # first time Single Leader, record time + # self.single_leader_ts = time.time() + # print("Single Leader", self.mesh.mesh.state, self.mesh.mesh.mesh.single(), + # time.time() - self.single_leader_ts) + + # if time.time() - self.single_leader_ts > 180: + # print("Single Leader, just reset") + # if self.sleep_function: + # self.sleep_function(1) + # else: + # # print("Not Single Leader", self.mesh.mesh.state, self.mesh.mesh.mesh.single()) + # self.single_leader_ts = 0 self.lock.release() - print(">>>>>>>>>>> DONE MESH THREAD ============ %d\n"%(time.ticks_ms() - t0)) + print_debug(2, ">>>>>>>>>>> DONE MESH THREAD ============ %d\n"%(time.ticks_ms() - t0)) pass @@ -118,7 +153,7 @@ def ip(self): self.lock.release() return ip - def get_node_info(self, mac_id): + def get_node_info(self, mac_id = ""): data = {} try: mac = int(mac_id) @@ -134,6 +169,11 @@ def send_message(self, data): ## WARNING: is locking required for just adding ret = False + # check if message is for BR + if len(data.get('ip','')) > 0: + with self.lock: + self.mesh.br_send(data) + return # check input parameters try: mac = int(data['to']) @@ -197,3 +237,106 @@ def statistics_get(self, id): res = self.statistics.status(id) print(res) return res + + def pybytes_process(self): + """ Send data to Pybytes periodically, called from Mesh Task """ + # if not self.pyb_dbg: + # return + if time.time() - self.pyb_ts > self.pyb_timeout: + # with self.lock: + self.pyb_data = self.mesh.debug_data() + + # send data to Pybytes + # res = Pybytes_wrap.send_signal(self.mesh.MAC, self.pyb_data) + self.pyb_ts = time.time() + pass + + def pybytes_config(self, state, timeout = 60): + """ Configure sending data to Pybytes """ + self.pyb_dbg = state + self.pyb_timeout = timeout + + # just set timestamp back, to make sure we're sending first call + if self.pyb_dbg: + self.pyb_ts = time.time() - self.pyb_timeout + + print("Sending Pybytes packets %s, every %s sec"%(self.pyb_dbg, self.pyb_timeout)) + pass + + def br_handler(self, id, data): + """ sending data NOW to Pybytes """ + if not self.pyb_dbg: + return + print("Sending BR data to Pybytes") + # res = Pybytes_wrap.send_signal(self.mesh.MAC, id + ": " + str(data)) + pass + + def br_set(self, enable, prio = 0, br_mess_cb = None): + with self.lock: + self.mesh.border_router(enable, prio, br_mess_cb) + + def ot_cli(self, command): + """ Executes commands in Openthread CLI, + see https://github.com/openthread/openthread/tree/master/src/cli """ + return self.mesh.mesh.mesh.cli(command) + + def end_device(self, state = None): + if state is None: + # read status of end_device + state = self.ot_cli('routerrole') + return state == 'Disabled' + self.end_device_m = False + state_str = 'enable' + if state == True: + self.end_device_m = True + state_str = 'disable' + ret = self.ot_cli('routerrole '+ state_str) + return ret == '' + + def leader_priority(self, weight = None): + if weight is None: + # read status of end_device + ret = self.ot_cli('leaderweight') + try: + weight = int(ret) + except: + weight = -1 + return weight + try: + x = int(weight) + except: + return False + # weight should be uint8, positive and <256 + if weight > 0xFF: + weight = 0xFF + elif weight < 0: + weight = 0 + ret = self.ot_cli('leaderweight '+ str(weight)) + return ret == '' + + def debug_level(self, level = None): + if level is None: + try: + ret = pycom.nvs_get('pymesh_debug') + except: + ret = None + return ret + try: + ret = int(level) + except: + ret = self.debug_level + debug_level(ret) + + def parent(self): + """ Returns the Parent MAC for the current Child node + Returns 0 if node is not Child """ + + if self.mesh.mesh.mesh.state() != self.mesh.mesh.STATE_CHILD: + print("Not Child, no Parent") + return 0 + # try: + parent_mac = int(self.mesh.mesh.mesh.cli('parent').split('\r\n')[0].split('Ext Addr: ')[1], 16) + # except: + # parent_mac = 0 + print('Parent mac is:', parent_mac) + return parent_mac diff --git a/lib/pymesh/lib/mesh_internal.py b/lib/pymesh/lib/mesh_internal.py index e2625ef..58025f0 100644 --- a/lib/pymesh/lib/mesh_internal.py +++ b/lib/pymesh/lib/mesh_internal.py @@ -6,7 +6,6 @@ # see the Pycom Licence v1.0 document supplied with this file, or # available at https://www.pycom.io/opensource/licensing -from network import LoRa import socket import time import utime @@ -15,8 +14,20 @@ from machine import Timer from struct import * -from loramesh import Loramesh -from meshaging import Meshaging, Message +try: + from loramesh import Loramesh +except: + from _loramesh import Loramesh + +try: + from meshaging import * +except: + from _meshaging import * + +try: + from pymesh_debug import print_debug +except: + from _pymesh_debug import print_debug __version__ = '6' """ @@ -37,6 +48,16 @@ class MeshInternal: """ Class for internal protocol inside Mesh network """ +################################################################################ + # Border router constants + + BR_NET_ADDRESS = '2001:cafe:cafe:cafe::/64' + + EXTERNAL_NET = '1:2:3:4::' + BR_HEADER_FMT = '!BHHHHHHHHH' + BR_MAGIC_BYTE = const(0xBB) + PACK_BR = const(0x90) + ################################################################################ # port number opened by all nodes for communicating neighbors @@ -93,16 +114,10 @@ class MeshInternal: ################################################################################ - def __init__(self, meshaging, lora=None): + def __init__(self, meshaging, config, message_cb): """ Constructor """ - if lora is None: - # lora = LoRa(mode=LoRa.LORA, region=LoRa.EU868, - # bandwidth=LoRa.BW_125KHZ, sf=7) - lora = LoRa(mode=LoRa.LORA, region=LoRa.EU868, frequency = 863000000, bandwidth=LoRa.BW_500KHZ, sf=7) - - self.lora = lora # enable Thread interface - self.mesh = Loramesh(self.lora) + self.mesh = Loramesh(config) self.MAC = self.mesh.MAC self.sock = None @@ -116,13 +131,18 @@ def __init__(self, meshaging, lora=None): self.file_packsize = 0 self.file_size = 0 self.send_f = None - pass + self.br_handler = None + self.EXTERNAL_IP = self.EXTERNAL_NET + hex(self.MAC & 0xFFFF)[2:] + self.ext_mesh_ts = -30 + self.message_cb = message_cb + self.br_message_cb = None + pass def create_socket(self): """ create UDP socket """ self.sock = socket.socket(socket.AF_LORA, socket.SOCK_RAW) self.sock.bind(self.PORT_MESH_INTERNAL) - print("Socket created on port %d" % self.PORT_MESH_INTERNAL) + print_debug(5, "Socket created on port %d" % self.PORT_MESH_INTERNAL) def process_messages(self): """ consuming message queue """ @@ -148,9 +168,9 @@ def send_message(self, message, answer = None): if message.type == message.TYPE_IMAGE: pack_type = self.PACK_FILE_SEND if payload: - print("Send message ", payload) + print_debug(4, "Send message " + str(payload)) self.send_pack(pack_type, payload, message.ip) - pass + pass def is_connected(self): # if detached erase all leader_data @@ -197,15 +217,47 @@ def _process_leader(self): if idx < router_num: time.sleep(.5) + def br_send(self, data): + """ if BR is available in whole Mesh, send some data """ + ret = False + # first, make sure this node is not BR (BR data is sent directly) + if len(self.mesh.mesh.border_router()) > 0: + print("Node is BR, so shouldn't send data to another BR") + return False + + # check if we have a BR network prefix in ipaddr + for ip in self.mesh.ipaddr(): + if ip.startswith(self.BR_NET_ADDRESS[0:-4]): + print("found BR address: ", ip) + if time.time() - self.ext_mesh_ts > 5: + ret = True + try: + ip = data['ip'] + port = int(data['port']) + payload = data['b'] + except: + print("Error parsing packet for Mesh-external") + ret = False + if ret: + self.send_pack(self.PACK_BR, payload, ip, port) + # self.send_pack(self.PACK_BR, self.debug_data(False), self.EXTERNAL_IP) + self.ext_mesh_ts = time.time() + else: + print("BR sending too fast") + ret = False + if not ret: + print("no BR (mesh-external IPv6) found") + return ret + def process(self): self.mesh.update_internals() self.mesh.led_state() - print("%d: MAC %s, State %s, Single %s" % (time.time(), - hex(self.MAC), self.mesh.state_string(), str(self.mesh.mesh.single()))) - print(self.mesh.ipaddr()) + print_debug(3, "%d: MAC %s(%d), State %s, Single %s" % (time.time(), + hex(self.MAC), self.MAC, self.mesh.state_string(), str(self.mesh.mesh.single()))) + print_debug(3, self.mesh.ipaddr()) leader = self.mesh.mesh.leader() if leader is not None: - print("Leader: mac %s, rloc %s, net: %s" % + print_debug(3,"Leader: mac %s, rloc %s, net: %s" % (hex(leader.mac), hex(leader.rloc16), hex(leader.part_id))) if not self.mesh.is_connected(): return # nothing to do @@ -233,6 +285,53 @@ def process(self): # self._process_leader() return + def debug_data(self, br = True): + """ Creating a debug string """ + if br: + # BR can send more data + data = "%d: MAC %s(%d), State %s, Single %s" % (time.time(), + hex(self.MAC), self.MAC, self.mesh.state_string(), str(self.mesh.mesh.single())) + data = data + "\n" + str(self.mesh.ipaddr()) + data = data + "\n" + str(self.mesh.mesh.routers()) + data = data + "\n" + str(self.mesh.mesh.neighbors()) + else: + # normal node sends data over Mesh to BR, so less/compressed data + data = "%d: M=%d, %s," % (time.time(), self.MAC, self.mesh.state_string()) + data = data +" nei:" + str(self.mesh.mesh.neighbors()) + return data + + def border_router(self, enable, prio = 0, br_mess_cb = None): + """ Disables/Enables the Border Router functionality, with priority and callback """ + net_list = self.mesh.mesh.border_router() + print("State:", enable, "BR: ", net_list) + + if not enable: + # disable all BR network registrations (possible multiple) + self.br_handler = None + for net in net_list: + self.mesh.mesh.border_router_del(net.net) + print("Done remove BR") + else: + self.br_handler = br_mess_cb + # check if BR already added + try: + # print(net[0].net) + # print(self.BR_NET_ADDRESS) + # if net[0].net != self.BR_NET_ADDRESS: + if not net_list[0].net.startswith(self.BR_NET_ADDRESS[0:-3]): + # enable BR + self.mesh.mesh.border_router(self.BR_NET_ADDRESS, prio) + print("Done add BR") + except: + # enable BR + self.mesh.mesh.border_router(self.BR_NET_ADDRESS, prio) + print("Force add BR") + + # print again the BR, to confirm + net_list = self.mesh.mesh.border_router() + print("BR: ", net_list) + pass + def _check_to_send(self, pack_type, ip): send_it = True try: @@ -292,7 +391,7 @@ def get_type(self, data): len2 = len(data) if len1 != len2: - print("PACK_HEADER lenght not ok %d %d" % (len1, len2)) + print("PACK_HEADER length not ok %d %d" % (len1, len2)) print(data) return @@ -350,6 +449,29 @@ def receive_all_data(self, arg): (len(rcv_data), rcv_ip, rcv_port)) # print(rcv_data) + # check if Node is BR + if self.br_handler: + #check if data is for the external of the Pymesh (for Pybytes) + if rcv_data[0] == self.BR_MAGIC_BYTE and len(rcv_data) >= calcsize(self.BR_HEADER_FMT): + br_header = unpack(self.BR_HEADER_FMT, rcv_data) + print("BR pack, IP dest: %x:%x:%x:%x:%x:%x:%x:%x (port %d)"%( + br_header[1],br_header[2],br_header[3],br_header[4], + br_header[5],br_header[6],br_header[7],br_header[8], br_header[9])) + rcv_data = rcv_data[calcsize(self.BR_HEADER_FMT):] + + dest_ip = "%x:%x:%x:%x:%x:%x:%x:%x"%( + br_header[1],br_header[2],br_header[3],br_header[4], + br_header[5],br_header[6],br_header[7],br_header[8]) + + dest_port = br_header[9] + + print(rcv_data) + (type, rcv_data) = self.get_type(rcv_data) + print(rcv_data) + + self.br_handler(rcv_ip, rcv_port, rcv_data, dest_ip, dest_port) + return # done, no more parsing as this pack was for BR + # check packet type (type, rcv_data) = self.get_type(rcv_data) # LEADER @@ -382,9 +504,14 @@ def receive_all_data(self, arg): print(message.payload) message.ip = rcv_ip self.messages.add_rcv_message(message) + # send back ACK self.send_pack(self.PACK_MESSAGE_ACK, message.pack_ack(self.MAC), rcv_ip) + # forward message to user-application layer + if self.message_cb: + self.message_cb(rcv_ip, rcv_port, message.payload) + elif type == self.PACK_MESSAGE_ACK: print("PACK_MESSAGE_ACK received") @@ -475,4 +602,3 @@ def receive_all_data(self, arg): # self.send_f = Send_File(packsize, filename, ip) # data, _ = self.send_f.process(None) # self.send_pack(self.PACK_FILE_SEND, data, ip) - diff --git a/lib/pymesh/lib/meshaging.py b/lib/pymesh/lib/meshaging.py index 241eb8c..443d79b 100644 --- a/lib/pymesh/lib/meshaging.py +++ b/lib/pymesh/lib/meshaging.py @@ -14,7 +14,6 @@ * initial version """ - class Meshaging: """ class that manages sending/receiving messages inside Mesh network """ @@ -50,8 +49,8 @@ def add_rcv_message(self, message): if message.payload == b'dog':#🐕': message.payload = 'Picture started receiving' print('Rcv mess about dog, so we start receiving picture') - else: - print('payload is not dog') + # else: + # print('payload is not dog') if self.on_rcv_message: self.on_rcv_message(message) diff --git a/lib/pymesh/lib/pycoproc.py b/lib/pymesh/lib/pycoproc.py deleted file mode 100644 index f06c46a..0000000 --- a/lib/pymesh/lib/pycoproc.py +++ /dev/null @@ -1,292 +0,0 @@ - -# Copyright (c) 2019, Pycom Limited. -# -# This software is licensed under the GNU GPL version 3 or any -# later version, with permitted additional terms. For more information -# see the Pycom Licence v1.0 document supplied with this file, or -# available at https://www.pycom.io/opensource/licensing - -from machine import Pin -from machine import I2C -import time -import pycom - -__version__ = '0.0.2' - -""" PIC MCU wakeup reason types """ -WAKE_REASON_ACCELEROMETER = 1 -WAKE_REASON_PUSH_BUTTON = 2 -WAKE_REASON_TIMER = 4 -WAKE_REASON_INT_PIN = 8 - -class Pycoproc: - """ class for handling the interaction with PIC MCU """ - - I2C_SLAVE_ADDR = const(8) - - CMD_PEEK = const(0x0) - CMD_POKE = const(0x01) - CMD_MAGIC = const(0x02) - CMD_HW_VER = const(0x10) - CMD_FW_VER = const(0x11) - CMD_PROD_ID = const(0x12) - CMD_SETUP_SLEEP = const(0x20) - CMD_GO_SLEEP = const(0x21) - CMD_CALIBRATE = const(0x22) - CMD_BAUD_CHANGE = const(0x30) - CMD_DFU = const(0x31) - - REG_CMD = const(0) - REG_ADDRL = const(1) - REG_ADDRH = const(2) - REG_AND = const(3) - REG_OR = const(4) - REG_XOR = const(5) - - ANSELA_ADDR = const(0x18C) - ANSELB_ADDR = const(0x18D) - ANSELC_ADDR = const(0x18E) - - ADCON0_ADDR = const(0x9D) - ADCON1_ADDR = const(0x9E) - - IOCAP_ADDR = const(0x391) - IOCAN_ADDR = const(0x392) - - INTCON_ADDR = const(0x0B) - OPTION_REG_ADDR = const(0x95) - - _ADCON0_CHS_POSN = const(0x02) - _ADCON0_ADON_MASK = const(0x01) - _ADCON1_ADCS_POSN = const(0x04) - _ADCON0_GO_nDONE_MASK = const(0x02) - - ADRESL_ADDR = const(0x09B) - ADRESH_ADDR = const(0x09C) - - TRISC_ADDR = const(0x08E) - - PORTA_ADDR = const(0x00C) - PORTC_ADDR = const(0x00E) - - WPUA_ADDR = const(0x20C) - - WAKE_REASON_ADDR = const(0x064C) - MEMORY_BANK_ADDR = const(0x0620) - - PCON_ADDR = const(0x096) - STATUS_ADDR = const(0x083) - - EXP_RTC_PERIOD = const(7000) - - def __init__(self, i2c=None, sda='P22', scl='P21'): - if i2c is not None: - self.i2c = i2c - else: - self.i2c = I2C(0, mode=I2C.MASTER, pins=(sda, scl)) - - self.sda = sda - self.scl = scl - self.clk_cal_factor = 1 - self.reg = bytearray(6) - self.wake_int = False - self.wake_int_pin = False - self.wake_int_pin_rising_edge = True - - # Make sure we are inserted into the - # correct board and can talk to the PIC - try: - self.read_fw_version() - except Exception as e: - raise Exception('Board not detected: {}'.format(e)) - - # init the ADC for the battery measurements - self.poke_memory(ANSELC_ADDR, 1 << 2) - self.poke_memory(ADCON0_ADDR, (0x06 << _ADCON0_CHS_POSN) | _ADCON0_ADON_MASK) - self.poke_memory(ADCON1_ADDR, (0x06 << _ADCON1_ADCS_POSN)) - # enable the pull-up on RA3 - self.poke_memory(WPUA_ADDR, (1 << 3)) - # make RC5 an input - self.set_bits_in_memory(TRISC_ADDR, 1 << 5) - # set RC6 and RC7 as outputs and enable power to the sensors and the GPS - self.mask_bits_in_memory(TRISC_ADDR, ~(1 << 6)) - self.mask_bits_in_memory(TRISC_ADDR, ~(1 << 7)) - - if self.read_fw_version() < 6: - raise ValueError('Firmware out of date') - - - def _write(self, data, wait=True): - self.i2c.writeto(I2C_SLAVE_ADDR, data) - if wait: - self._wait() - - def _read(self, size): - return self.i2c.readfrom(I2C_SLAVE_ADDR, size + 1)[1:(size + 1)] - - def _wait(self): - count = 0 - time.sleep_us(10) - while self.i2c.readfrom(I2C_SLAVE_ADDR, 1)[0] != 0xFF: - time.sleep_us(100) - count += 1 - if (count > 500): # timeout after 50ms - raise Exception('Board timeout') - - def _send_cmd(self, cmd): - self._write(bytes([cmd])) - - def read_hw_version(self): - self._send_cmd(CMD_HW_VER) - d = self._read(2) - return (d[1] << 8) + d[0] - - def read_fw_version(self): - self._send_cmd(CMD_FW_VER) - d = self._read(2) - return (d[1] << 8) + d[0] - - def read_product_id(self): - self._send_cmd(CMD_PROD_ID) - d = self._read(2) - return (d[1] << 8) + d[0] - - def peek_memory(self, addr): - self._write(bytes([CMD_PEEK, addr & 0xFF, (addr >> 8) & 0xFF])) - return self._read(1)[0] - - def poke_memory(self, addr, value): - self._write(bytes([CMD_POKE, addr & 0xFF, (addr >> 8) & 0xFF, value & 0xFF])) - - def magic_write_read(self, addr, _and=0xFF, _or=0, _xor=0): - self._write(bytes([CMD_MAGIC, addr & 0xFF, (addr >> 8) & 0xFF, _and & 0xFF, _or & 0xFF, _xor & 0xFF])) - return self._read(1)[0] - - def toggle_bits_in_memory(self, addr, bits): - self.magic_write_read(addr, _xor=bits) - - def mask_bits_in_memory(self, addr, mask): - self.magic_write_read(addr, _and=mask) - - def set_bits_in_memory(self, addr, bits): - self.magic_write_read(addr, _or=bits) - - def get_wake_reason(self): - """ returns the wakeup reason, a value out of constants WAKE_REASON_* """ - return self.peek_memory(WAKE_REASON_ADDR) - - def get_sleep_remaining(self): - """ returns the remaining time from sleep, as an interrupt (wakeup source) might have triggered """ - c3 = self.peek_memory(WAKE_REASON_ADDR + 3) - c2 = self.peek_memory(WAKE_REASON_ADDR + 2) - c1 = self.peek_memory(WAKE_REASON_ADDR + 1) - time_device_s = (c3 << 16) + (c2 << 8) + c1 - # this time is from PIC internal oscilator, so it needs to be adjusted with the calibration value - try: - self.calibrate_rtc() - except Exception: - pass - time_s = int((time_device_s / self.clk_cal_factor) + 0.5) # 0.5 used for round - return time_s - - def setup_sleep(self, time_s): - try: - self.calibrate_rtc() - except Exception: - pass - time_s = int((time_s * self.clk_cal_factor) + 0.5) # round to the nearest integer - if time_s >= 2**(8*3): - time_s = 2**(8*3)-1 - self._write(bytes([CMD_SETUP_SLEEP, time_s & 0xFF, (time_s >> 8) & 0xFF, (time_s >> 16) & 0xFF])) - - def go_to_sleep(self, gps=True): - # enable or disable back-up power to the GPS receiver - if gps: - self.set_bits_in_memory(PORTC_ADDR, 1 << 7) - else: - self.mask_bits_in_memory(PORTC_ADDR, ~(1 << 7)) - # disable the ADC - self.poke_memory(ADCON0_ADDR, 0) - - if self.wake_int: - # Don't touch RA3, RA5 or RC1 so that interrupt wake-up works - self.poke_memory(ANSELA_ADDR, ~((1 << 3) | (1 << 5))) - self.poke_memory(ANSELC_ADDR, ~((1 << 6) | (1 << 7) | (1 << 1))) - else: - # disable power to the accelerometer, and don't touch RA3 so that button wake-up works - self.poke_memory(ANSELA_ADDR, ~(1 << 3)) - self.poke_memory(ANSELC_ADDR, ~(1 << 7)) - - self.poke_memory(ANSELB_ADDR, 0xFF) - - # check if INT pin (PIC RC1), should be used for wakeup - if self.wake_int_pin: - if self.wake_int_pin_rising_edge: - self.set_bits_in_memory(OPTION_REG_ADDR, 1 << 6) # rising edge of INT pin - else: - self.mask_bits_in_memory(OPTION_REG_ADDR, ~(1 << 6)) # falling edge of INT pin - self.mask_bits_in_memory(ANSELC_ADDR, ~(1 << 1)) # disable analog function for RC1 pin - self.set_bits_in_memory(TRISC_ADDR, 1 << 1) # make RC1 input pin - self.mask_bits_in_memory(INTCON_ADDR, ~(1 << 1)) # clear INTF - self.set_bits_in_memory(INTCON_ADDR, 1 << 4) # enable interrupt; set INTE) - - self._write(bytes([CMD_GO_SLEEP]), wait=False) - # kill the run pin - Pin('P3', mode=Pin.OUT, value=0) - - def calibrate_rtc(self): - # the 1.024 factor is because the PIC LF operates at 31 KHz - # WDT has a frequency divider to generate 1 ms - # and then there is a binary prescaler, e.g., 1, 2, 4 ... 512, 1024 ms - # hence the need for the constant - self._write(bytes([CMD_CALIBRATE]), wait=False) - self.i2c.deinit() - Pin('P21', mode=Pin.IN) - pulses = pycom.pulses_get('P21', 100) - self.i2c.init(mode=I2C.MASTER, pins=(self.sda, self.scl)) - idx = 0 - for i in range(len(pulses)): - if pulses[i][1] > EXP_RTC_PERIOD: - idx = i - break - try: - period = pulses[idx][1] - pulses[(idx - 1)][1] - except: - period = 0 - if period > 0: - self.clk_cal_factor = (EXP_RTC_PERIOD / period) * (1000 / 1024) - if self.clk_cal_factor > 1.25 or self.clk_cal_factor < 0.75: - self.clk_cal_factor = 1 - - def button_pressed(self): - button = self.peek_memory(PORTA_ADDR) & (1 << 3) - return not button - - def read_battery_voltage(self): - self.set_bits_in_memory(ADCON0_ADDR, _ADCON0_GO_nDONE_MASK) - time.sleep_us(50) - while self.peek_memory(ADCON0_ADDR) & _ADCON0_GO_nDONE_MASK: - time.sleep_us(100) - adc_val = (self.peek_memory(ADRESH_ADDR) << 2) + (self.peek_memory(ADRESL_ADDR) >> 6) - return (((adc_val * 3.3 * 280) / 1023) / 180) + 0.01 # add 10mV to compensate for the drop in the FET - - def setup_int_wake_up(self, rising, falling): - """ rising is for activity detection, falling for inactivity """ - wake_int = False - if rising: - self.set_bits_in_memory(IOCAP_ADDR, 1 << 5) - wake_int = True - else: - self.mask_bits_in_memory(IOCAP_ADDR, ~(1 << 5)) - - if falling: - self.set_bits_in_memory(IOCAN_ADDR, 1 << 5) - wake_int = True - else: - self.mask_bits_in_memory(IOCAN_ADDR, ~(1 << 5)) - self.wake_int = wake_int - - def setup_int_pin_wake_up(self, rising_edge = True): - """ allows wakeup to be made by the INT pin (PIC -RC1) """ - self.wake_int_pin = True - self.wake_int_pin_rising_edge = rising_edge diff --git a/lib/pymesh/lib/pymesh.py b/lib/pymesh/lib/pymesh.py new file mode 100644 index 0000000..478fe1b --- /dev/null +++ b/lib/pymesh/lib/pymesh.py @@ -0,0 +1,195 @@ +''' +Copyright (c) 2019, Pycom Limited. +This software is licensed under the GNU GPL version 3 or any +later version, with permitted additional terms. For more information +see the Pycom Licence v1.0 document supplied with this file, or +available at https://www.pycom.io/opensource/licensing +''' + +import os +import machine +from machine import Timer +import _thread +import sys +import time + +try: + from mesh_interface import MeshInterface +except: + from _mesh_interface import MeshInterface + +try: + from cli import Cli +except: + from _cli import Cli + +try: + from ble_rpc import BleRpc +except: + from _ble_rpc import BleRpc + +try: + from pymesh_debug import print_debug +except: + from _pymesh_debug import print_debug + +class Pymesh: + + def __init__(self, config, message_cb): + # print MAC, set MAC is given and restart + + self.config = config + self.mesh = MeshInterface(config, message_cb) + + self.kill_all = False + self.deepsleep_timeout = 0 + self.new_lora_mac = None + # watchdog = Watchdog(meshaging, mesh) + + self.mesh.statistics.sleep_function = self.deepsleep_init + self.mesh.sleep_function = self.deepsleep_init + + self.cli = Cli(self.mesh) + self.cli.sleep = self.deepsleep_init + _thread.start_new_thread(self.process, (1,2)) + _thread.start_new_thread(self.cli.process, (1, 2)) + + self.ble_rpc = None + if config.get("ble_api", False): + self.ble_rpc = BleRpc(self.config, self.mesh) + + + def deepsleep_now(self): + """ prepare scripts for graceful exit, deepsleeps if case """ + print("deepsleep_now") + self.mesh.timer_kill() + if self.ble_rpc: + self.ble_rpc.terminate() + # watchdog.timer_kill() + # Gps.terminate() + self.mesh.statistics.save_all() + print('Cleanup code, all Alarms cb should be stopped') + if self.new_lora_mac: + fo = open("/flash/sys/lpwan.mac", "wb") + mac_write=bytes([0, 0, 0, 0, 0, 0, (self.new_lora_mac >> 8) & 0xFF, self.new_lora_mac & 0xFF]) + fo.write(mac_write) + fo.close() + print("Really LoRa MAC set to", self.new_lora_mac) + if self.deepsleep_timeout > 0: + print('Going to deepsleep for %d seconds'%self.deepsleep_timeout) + time.sleep(1) + machine.deepsleep(self.deepsleep_timeout * 1000) + else: + raise Exception("Pymesh done") + sys.exit() + + def deepsleep_init(self, timeout, new_MAC = None): + """ initializes an deep-sleep sequence, that will be performed later """ + print("deepsleep_init") + self.deepsleep_timeout = timeout + self.kill_all = True + if new_MAC: + self.new_lora_mac = new_MAC + return + + def process(self, arg1, arg2): + try: + while True: + if self.kill_all: + self.deepsleep_now() + + # sending data to pybytes + # Pybytes_wrap.process() + + time.sleep(.5) + # print("loop") + pass + + except KeyboardInterrupt: + print('Got Ctrl-C') + except Exception as e: + sys.print_exception(e) + finally: + print('finally') + self.deepsleep_now() + + def send_mess(self, mac, mess): + """ send mess to specified MAC address + data is dictionary data = { + 'to': 0x5, + 'b': 'text', + 'id': 12345, + 'ts': 123123123, + } """ + data = { + 'to': mac, + 'b': mess, + 'id': 12345, + 'ts': time.time(), + } + return self.mesh.send_message(data) + + def br_set(self, prio, br_mess_cb): + """ Enable BR functionality on this Node, with priority and callback """ + return self.mesh.br_set(True, prio, br_mess_cb) + + def br_remove(self): + """ Disable BR functionality on this Node """ + return self.mesh.br_set(False) + + def status_str(self): + message = "Role " + str(self.mesh.mesh.mesh.mesh.state()) + \ + ", Single " + str(self.mesh.mesh.mesh.mesh.single()) + \ + ", IPv6: " + str(self.mesh.mesh.mesh.mesh.ipaddr()) + return message + + def is_connected(self): + return self.mesh.is_connected() + + def send_mess_external(self, ip, port, payload): + """ send mess to specified IP+port address + data is dictionary data = { + 'ip': '1:2:3::4', + 'port': 12345, + 'to': 0x5, + 'b': 'text', + 'id': 12345, + 'ts': 123123123, + } """ + data = { + 'ip': '1:2:3::4', + 'port': 12345, + 'b': payload + } + return self.mesh.send_message(data) + + def config_get(self): + return self.config + + def mac(self): + return self.mesh.mesh.MAC + + def ot_cli(self, command): + """ Call OpenThread internal CLI """ + return self.mesh.ot_cli(command) + + def end_device(self, state = None): + """ Set current node and End (Sleepy) Device, always a Child """ + return self.mesh.end_device(state) + + def leader_priority(self, weight = None): + """ Set for the current node the Leader Weight; + it's a 0 to 255 value, which increases/decreases probability to become Leader; + by default any node has weight of 64 """ + return self.mesh.leader_priority(weight) + + def debug_level(self, level = None): + """ Set the debug level, 0 - off; recommended levels are: + DEBUG_DEBG = const(5) + DEBUG_INFO = const(4) + DEBUG_NOTE = const(3) + DEBUG_WARN = const(2) + DEBUG_CRIT = const(1) + DEBUG_NONE = const(0) """ + return self.mesh.debug_level(level) + diff --git a/lib/pymesh/lib/pymesh_config.py b/lib/pymesh/lib/pymesh_config.py new file mode 100644 index 0000000..b734301 --- /dev/null +++ b/lib/pymesh/lib/pymesh_config.py @@ -0,0 +1,127 @@ +''' +Copyright (c) 2019, Pycom Limited. +This software is licensed under the GNU GPL version 3 or any +later version, with permitted additional terms. For more information +see the Pycom Licence v1.0 document supplied with this file, or +available at https://www.pycom.io/opensource/licensing +''' +import ubinascii +import json + +from network import LoRa +import machine +import time + +class PymeshConfig: + + CONFIG_FILENAME = "/flash/pymesh_config.json" + + ############################################################ + # DEFAULT SETTINGS + + # LoRa region is one of LoRa.US915, LoRa.EU868, LoRa.AS923, LoRa.AU915 + LORA_REGION = LoRa.EU868 + + # frequency expressed in Hz, for EU868 863000000 Hz, for US915 904600000 Hz + LORA_FREQ = const(863000000) + + # bandwidth options are: LoRa.BW_125KHZ, LoRa.BW_250KHZ or LoRa.BW_500KHZ + LORA_BW = LoRa.BW_500KHZ + + # spreading factor options are 7 to 12 + LORA_SF = const(7) + + # Pymesh 128b key, used for auth. and encryption + KEY = "112233" + + # if true, Pymesh is auto-started + AUTOSTART = True + DEBUG_LEVEL = 5 + + # if true, it will start as BLE Server, to be connected with mobile app + BLE_API = True + BLE_NAME_PREFIX = "PyGo " + ############################################################ + + # Border router preference priority + BR_PRIORITY_NORM = const(0) + BR_PRIORITY_LOW = const(-1) + BR_PRIORITY_HIGH = const(1) + + def write_config(pymesh_config, force_restart = False): + cf = open(PymeshConfig.CONFIG_FILENAME, 'w') + cf.write(json.dumps(pymesh_config)) + cf.close() + + if force_restart: + print("write_config force restart") + time.sleep(1) + machine.deepsleep(1000) + + def check_mac(pymesh_config): + lora = LoRa(mode=LoRa.LORA, region= LoRa.EU868) + MAC = int(str(ubinascii.hexlify(lora.mac()))[2:-1], 16) + + if pymesh_config.get('MAC') is None: + # if MAC config unspecified, set it to LoRa MAC + print("Set MAC in config file as ", MAC) + pymesh_config['MAC'] = MAC + PymeshConfig.write_config(pymesh_config, False) + else: + mac_from_config = pymesh_config.get('MAC') + if mac_from_config != MAC: + print("MAC different", mac_from_config, MAC) + pymesh_config['MAC'] = MAC + # if MAC in config different than LoRa MAC, set LoRa MAC as in config file + fo = open("/flash/sys/lpwan.mac", "wb") + mac_write=bytes([(MAC >> 56) & 0xFF, (MAC >> 48) & 0xFF, (MAC >> 40) & 0xFF, (MAC >> 32) & 0xFF, (MAC >> 24) & 0xFF, (MAC >> 16) & 0xFF, (MAC >> 8) & 0xFF, MAC & 0xFF]) + fo.write(mac_write) + fo.close() + print("reset") + PymeshConfig.write_config(pymesh_config, True) + + print("MAC ok", MAC) + + def read_config(): + file = PymeshConfig.CONFIG_FILENAME + pymesh_config = {} + error_file = True + + try: + import json + f = open(file, 'r') + jfile = f.read() + f.close() + try: + pymesh_config = json.loads(jfile.strip()) + # pymesh_config['cfg_msg'] = "Pymesh configuration read from {}".format(file) + error_file = False + except Exception as ex: + print("Error reading {} file!\n Exception: {}".format(file, ex)) + except Exception as ex: + print("Final error reading {} file!\n Exception: {}".format(file, ex)) + + if error_file: + # config file can't be read, so it needs to be created and saved + pymesh_config = {} + print("Can't find",file, ", or can't be parsed as json; Set default settings and reset") + # don't write MAC, just to use the hardware one + pymesh_config['LoRa'] = {"region": PymeshConfig.LORA_REGION, + "freq": PymeshConfig.LORA_FREQ, + "bandwidth": PymeshConfig.LORA_BW, + "sf": PymeshConfig.LORA_SF} + pymesh_config['Pymesh'] = {"key": PymeshConfig.KEY} + pymesh_config['autostart'] = PymeshConfig.AUTOSTART + pymesh_config['debug'] = PymeshConfig.DEBUG_LEVEL + pymesh_config['ble_api'] = PymeshConfig.BLE_API + pymesh_config['ble_name_prefix'] = PymeshConfig.BLE_NAME_PREFIX + print("Default settings:", pymesh_config) + PymeshConfig.check_mac(pymesh_config) + print("Default settings:", pymesh_config) + PymeshConfig.write_config(pymesh_config, True) + + PymeshConfig.check_mac(pymesh_config) + print("Settings:", pymesh_config) + return pymesh_config + + diff --git a/lib/pymesh/lib/pymesh_debug.py b/lib/pymesh/lib/pymesh_debug.py new file mode 100644 index 0000000..aa5167d --- /dev/null +++ b/lib/pymesh/lib/pymesh_debug.py @@ -0,0 +1,34 @@ + +# Copyright (c) 2019, Pycom Limited. +# +# This software is licensed under the GNU GPL version 3 or any +# later version, with permitted additional terms. For more information +# see the Pycom Licence v1.0 document supplied with this file, or +# available at https://www.pycom.io/opensource/licensing + +import pycom + +# debug level from the most verbose to off +DEBUG_DEBG = const(5) +DEBUG_INFO = const(4) +DEBUG_NOTE = const(3) +DEBUG_WARN = const(2) +DEBUG_CRIT = const(1) +DEBUG_NONE = const(0) + +try: + DEBUG = pycom.nvs_get('pymesh_debug') +except: + DEBUG = None + + +def print_debug(level, msg): + """Print log messages into console.""" + if DEBUG is not None and level <= DEBUG: + print(msg) + +def debug_level(level): + global DEBUG + DEBUG = level + pycom.nvs_set('pymesh_debug', DEBUG) + \ No newline at end of file diff --git a/lib/pymesh/lib/pytrack.py b/lib/pymesh/lib/pytrack.py deleted file mode 100644 index 929c225..0000000 --- a/lib/pymesh/lib/pytrack.py +++ /dev/null @@ -1,16 +0,0 @@ - -# Copyright (c) 2019, Pycom Limited. -# -# This software is licensed under the GNU GPL version 3 or any -# later version, with permitted additional terms. For more information -# see the Pycom Licence v1.0 document supplied with this file, or -# available at https://www.pycom.io/opensource/licensing - -from pycoproc import Pycoproc - -__version__ = '1.4.0' - -class Pytrack(Pycoproc): - - def __init__(self, i2c=None, sda='P22', scl='P21'): - Pycoproc.__init__(self, i2c, sda, scl) diff --git a/lib/pymesh/main.py b/lib/pymesh/main.py index 34a0a61..2e0f838 100644 --- a/lib/pymesh/main.py +++ b/lib/pymesh/main.py @@ -1,423 +1,72 @@ -VERSION = "1.0.0" - -# Copyright (c) 2019, Pycom Limited. -# -# This software is licensed under the GNU GPL version 3 or any -# later version, with permitted additional terms. For more information -# see the Pycom Licence v1.0 document supplied with this file, or -# available at https://www.pycom.io/opensource/licensing - -import time -import json import pycom -import _thread -import sys -import select -import _thread -import machine -from machine import Timer -from machine import Pin - -from network import Bluetooth - -import msgpack -import ble - -from mesh_interface import MeshInterface -from gps import Gps - -from meshaging import Meshaging -import _thread -from cli import Cli - -class RXWorker: - def __init__(self, ble_comm): - self.HEADSIZE = 20 - self.INTERVAL = .1 - self.q = b'' - self.ble_comm = ble_comm - self.chr = ble_comm.chr_rx - self.call_cnt = 0 - - # mutex for self.q usage - self.q_lock = _thread.allocate_lock() - - self._timer = Timer.Alarm(self.interval_cb, self.INTERVAL, periodic=True) - - def put(self, bytes): - with self.q_lock: - self.q = self.q + bytes - - # chunks = [ self.q[i:i+self.HEADSIZE] for i in range(0, len(self.q), self.HEADSIZE) ] - # for chunk in chunks: - # self.chr.value(chunk) - - #self.chr.value('') - #self.chr.value(bytes) - - def interval_cb(self, alarm): - self.call_cnt = self.call_cnt + 1 - if self.call_cnt >= 10: - # print('%d: rx worker interval.... %d'%(time.time(), len(self.q))) - self.call_cnt = 0 - - if len(self.q) == 0: - return - - if not self.ble_comm.status['connected']: - #unpacker._buffer = bytearray([]) - with self.q_lock: - self.q = b'' - return - try: - with self.q_lock: - head = self.q[:self.HEADSIZE] - tail = self.q[self.HEADSIZE:] - self.q = tail - #print('consuming {}, {}', head, tail) - - if self.chr and len(head) > 0: - self.chr.value(head) - #print('sending', list(head)) - except: - pass - - def timer_kill(self): - self._timer.cancel() - -class TXWorker: - def __init__(self, ble_comm): - self.ble_comm = ble_comm - self.chr = ble_comm.chr_tx - self.last_value = b'' - self.on_write = lambda value : 1 - - self.chr.callback(trigger=Bluetooth.CHAR_WRITE_EVENT | Bluetooth.CHAR_READ_EVENT, handler=self.cb_handler) - - def cb_handler(self, chr): - events = chr.events() - if events & Bluetooth.CHAR_WRITE_EVENT: - self.last_value = chr.value() - #print("Write request with value = {}".format(self.last_value)) - - self.on_write(self.last_value) - else: - #print('Read request on char 1') - return self.last_value - -class RPCHandler: - def __init__(self, rx_worker, tx_worker, mesh, ble_comm): - self.rx_worker = rx_worker - self.tx_worker = tx_worker - self.mesh = mesh - self.unpacker = msgpack.Unpacker(raw=False) - self.error = False - ble_comm.unpacker_set(self.unpacker) - - tx_worker.on_write = self.feed - - def feed(self, message): - #print('feeding (rpc)', message) - self.unpacker.feed(message) - try: - [self.resolve(x) for x in self.unpacker] - except Exception as e: - sys.print_exception(e) - print('error in unpacking... reset') - self.unpacker._buffer = bytearray() - self.error = True - - - - def resolve(self, obj): - #print('resolving: ', obj) - obj = list(obj) - type = obj[0] - - if type == 'call': - uuid = obj[1] - fn_name = obj[2] - args = obj[3] - fn = getattr(self, fn_name) - - if not fn: - print('fn {} not defined'.format(fn_name)) - return - - try: - result = fn(*args) - result = json.loads(json.dumps(result)) - print('calling RPC: {} - {}'.format(fn_name, result)) - - message = msgpack.packb(['call_result', uuid, result]) - except Exception as e: - print('could not send result: {}'.format(result)) - return - - - #print('result', result) - #print('message', message) - self.rx_worker.put(message) - - def demo_fn(self, *args): - return { 'res': 'demo_fn' } - - def demo_echo_fn(self, *args): - return args - - def mesh_is_connected(self): - # True if Node is connected to Mesh; False otherwise - is_connected = self.mesh.is_connected() - return is_connected - - def mesh_ip(self): - # get IP RLOC16 in string - ip = self.mesh.ip() - return ip - - def set_gps(self, lng, lat): - print('settings gps!') - Gps.set_location(lat, lng) - # with open('/flash/gps', 'w') as fh: - # fh.write('{};{}'.format(lng, lat)) - - def get_mesh_mac_list(self): - """ returns list of distinct MAC address that are in this mesh network - [mac1, mac2, mac 3] """ - last_mesh_mac_list = self.mesh.get_mesh_mac_list() - return last_mesh_mac_list - - def get_mesh_pairs(self, *args): - """ returns list of pairs that is a mesh connection - [ - ('mac1', 'mac2', rssi), - ('mac1', 'mac3', rssi), - #... - ] """ - last_mesh_pairs = self.mesh.get_mesh_pairs() - return last_mesh_pairs - - - def get_node_info(self, mac_id = ' '): - """ Returns the debug info for a specified mac address - takes max 10 sec - { - 'ip': 4c00, # last 2bytes from the ip v6 RLOC16 address - 'r': 3, # not_connected:0 | child:1 | leader:2 | router:3 - 'a': 100, # age[sec], time since last info about this node - 'nn' : 20 # neighbours number - 'nei': { # neighbours enumerated, if any - (mac, ip, role, rssi, age), - (mac, ip, role, rssi, age) - } - 'l': { # location, if available - 'lng': 7, - 'lat': 20, - }, - 'b' : { # BLE infos - 'a': 100 # age, seconds since last ping with that device, None if properly disconnected - 'id': '' # 16byte - 'n': '', # name, max. 16 chars - } - } """ - node_info = mesh.get_node_info(mac_id) - return node_info - - def send_message(self, data): - """ sends a message with id, to m(MAC) - return True if there is buffer to store it (to be sent)""" - """ data is dictionary data = { - 'to': 0x5, - 'b': 'text', - 'id': 12345, - 'ts': 123123123, - }""" - print("%d: Send Msg ---------------------->>>>>>>> "%time.ticks_ms()) - return self.mesh.send_message(data) - - def send_message_was_sent(self, mac, msg_id): - """ checks for ACK received for msg_id - returns True if message was delivered to last node connected to BLE mobile """ - error = False - try: - mac_int = int(mac) - msg_id_int = int(msg_id) - except: - error = True - if error: - return False - # mesh.mesage_was_ack(5, 12345) - return self.mesh.mesage_was_ack(mac, msg_id) - - def receive_message(self): - """ - return { - 'b': 'text', - 'from': 'ble_device_id', - 'ts': 123123123, - 'id': '', - } """ - return self.mesh.get_rcv_message() - - def send_image(self, data): - """ sends an image - return True if there is buffer to store it (to be sent)""" - print("Send Image ---------------------->>>>>>>> ", data) - start = 0 - filename = 'dog_2.jpg' - to = 0 - # packsize = 500 - image = list() - - try: - filename = data.get('fn', "image.jpg") - start = int(data['start']) - image = bytes(data['image']) - except: - print('parsing failed') - return False - - print("Image chunk size: %d"%len(image)) - file_handling = "ab" # append, by default - if start == 0: - file_handling = "wb" # write/create new - - with open("/flash/" + filename, file_handling) as file: - print("file open") - file.write(image) - print("file written") - - print("done") - return True - - def stat_start(self, data): - # do some statistics - #data = {'mac':6, 'n':3, 't':30} - res = self.mesh.statistics_start(data) - print("rpc stat_start? ", res) - return res - - def stat_status(self, data): - print("rpc stat_status ", data) - try: - id = int(data) - except: - id = 0 - res = mesh.statistics_get(id) - print("rpc stat_status id:"+ str(id) + ", res: " + str(res)) - return res - -class Watchdog: - def __init__(self, meshaging, mesh): - self.INTERVAL = 10 - self.meshaging = meshaging - self.mesh = mesh - self._timer = Timer.Alarm(self.interval_cb, self.INTERVAL, periodic=True) - - def timer_kill(self): - self._timer.cancel() +import time - def interval_cb(self, *args, **kwargs): - global rpc_handler, rx_worker, tx_worker, mesh, ble_comm +# try: +from pymesh_config import PymeshConfig +# except: +# from _pymesh_config import PymeshConfig - #print("watchdog!") +# try: +from pymesh import Pymesh +# except: +# from _pymesh import Pymesh - if rpc_handler.error: - rpc_handler = RPCHandler(rx_worker, tx_worker, mesh, ble_comm) - print("********** Restarted RPC Handler") +def new_message_cb(rcv_ip, rcv_port, rcv_data): + ''' callback triggered when a new packet arrived ''' + print('Incoming %d bytes from %s (port %d):' % + (len(rcv_data), rcv_ip, rcv_port)) + print(rcv_data) + # user code to be inserted, to send packet to the designated Mesh-external interface + # ... + return -################################################################################ -# Main code pycom.heartbeat(False) -mesh_lock = _thread.allocate_lock() -meshaging = Meshaging(mesh_lock) -mesh = MeshInterface(meshaging, mesh_lock) - -def on_rcv_message(message): - message_data = { - 'mac' : message.mac, - 'payload' : message.payload, - 'ts' : message.ts, - 'id' : message.id, - } - msg = msgpack.packb(['notify', 'msg', message_data]) - rx_worker.put(msg) - print(message_data['payload']) - print("%d ================= RECEIVED :) :) :) "%time.ticks_ms()) -mesh.meshaging.on_rcv_message = on_rcv_message +# read config file, or set default values +pymesh_config = PymeshConfig.read_config() -def on_rcv_ack(message): - message_data = { - 'id' : message.id, - } +#initialize Pymesh +pymesh = Pymesh(pymesh_config, new_message_cb) - msg = msgpack.packb(['notify', 'msg-ack', message_data]) - rx_worker.put(msg) - print("%d ================= ACK RECEIVED :) :) :) "%time.ticks_ms()) -mesh.meshaging.on_rcv_ack = on_rcv_ack +mac = pymesh.mac() +if mac > 10: + pymesh.end_device(True) +elif mac == 5: + pymesh.leader_priority(255) -ble_comm = ble.BleCommunication(mesh.mesh.mesh.MAC) +while not pymesh.is_connected(): + print(pymesh.status_str()) + time.sleep(3) -def ble_on_disconnect(): - rpc_handler = RPCHandler(rx_worker, tx_worker, mesh, ble_comm) -ble_comm.on_disconnect = ble_on_disconnect - -rx_worker = RXWorker(ble_comm) -tx_worker = TXWorker(ble_comm) - -rpc_handler = RPCHandler(rx_worker, tx_worker, mesh, ble_comm) - -Gps.init_static() - -kill_all = False -deepsleep_timeout = 0 - -watchdog = Watchdog(meshaging, mesh) - -def deepsleep_now(): - """ prepare scripts for graceful exit, deepsleeps if case """ - mesh.timer_kill() - watchdog.timer_kill() - rx_worker.timer_kill() - ble_comm.close() - Gps.terminate() - mesh.statistics.save_all() - print('Cleanup code, all Alarms cb should be stopped') - if deepsleep_timeout > 0: - print('Going to deepsleep for %d seconds'%deepsleep_timeout) - time.sleep(1) - machine.deepsleep(deepsleep_timeout * 1000) - -def deepsleep_init(timeout): - """ initializes an deeppsleep sequence, that will be performed later """ - global deepsleep_timeout, kill_all - deepsleep_timeout = timeout - kill_all = True - return +# send message to the Node having MAC address 5 +pymesh.send_mess(5, "Hello World") -mesh.statistics.sleep_function = deepsleep_init -mesh.sleep_function = deepsleep_init +# def new_br_message_cb(rcv_ip, rcv_port, rcv_data, dest_ip, dest_port): +# ''' callback triggered when a new packet arrived for the current Border Router, +# having destination an IP which is external from Mesh ''' +# print('Incoming %d bytes from %s (port %d), to external IPv6 %s (port %d)' % +# (len(rcv_data), rcv_ip, rcv_port, dest_ip, dest_port)) +# print(rcv_data) -cli = Cli(mesh, rpc_handler, ble_comm) -cli.sleep = deepsleep_init +# # user code to be inserted, to send packet to the designated Mesh-external interface +# # ... +# return -_thread.start_new_thread(cli.process, (1, 2)) +# add current node as Border Router, with a priority and a message handler callback +# pymesh.br_set(PymeshConfig.BR_PRIORITY_NORM, new_br_message_cb) -try: - while True: - if kill_all: - deepsleep_now() +# remove Border Router function from current node +#pymesh.br_remove() - time.sleep(.1) - pass +# send data for Mesh-external, basically to the BR +# ip = "1:2:3::4" +# port = 5555 +# pymesh.send_mess_external(ip, port, "Hello World") -except KeyboardInterrupt: - print('Got Ctrl-C') -except Exception as e: - sys.print_exception(e) -finally: - deepsleep_now() +print("done Pymesh init, forever loop, exit/stop with Ctrl+C multiple times") +# set BR with callback +while True: + time.sleep(3) From 6ba94375ba64a25000c0d87c562e5ac59c5a9876 Mon Sep 17 00:00:00 2001 From: iwahdan88 Date: Mon, 7 Oct 2019 00:50:26 +0200 Subject: [PATCH 27/92] Added MQTT aws libs --- lib/mqtt_aws/MQTTClient.py | 426 ++++++++++++++++++++++++++++++ lib/mqtt_aws/MQTTConst.py | 46 ++++ lib/mqtt_aws/MQTTDeviceShadow.py | 233 ++++++++++++++++ lib/mqtt_aws/MQTTLib.py | 119 +++++++++ lib/mqtt_aws/MQTTMsgHandler.py | 279 +++++++++++++++++++ lib/mqtt_aws/MQTTShadowManager.py | 55 ++++ 6 files changed, 1158 insertions(+) create mode 100644 lib/mqtt_aws/MQTTClient.py create mode 100644 lib/mqtt_aws/MQTTConst.py create mode 100644 lib/mqtt_aws/MQTTDeviceShadow.py create mode 100644 lib/mqtt_aws/MQTTLib.py create mode 100644 lib/mqtt_aws/MQTTMsgHandler.py create mode 100644 lib/mqtt_aws/MQTTShadowManager.py diff --git a/lib/mqtt_aws/MQTTClient.py b/lib/mqtt_aws/MQTTClient.py new file mode 100644 index 0000000..f1a5bff --- /dev/null +++ b/lib/mqtt_aws/MQTTClient.py @@ -0,0 +1,426 @@ +import MQTTConst as mqttConst +import MQTTMsgHandler as msgHandler +import time +import struct +import _thread + +class MQTTMessage: + def __init__(self): + self.timestamp = 0 + self.state = 0 + self.dup = False + self.mid = 0 + self.topic = "" + self.payload = None + self.qos = 0 + self.retain = False + +class MQTTClient: + + def __init__(self, clientID, cleanSession, protocol): + self.client_id = clientID + self._cleanSession = cleanSession + self._protocol = protocol + self._userdata = None + self._user = "" + self._password = "" + self._keepAliveInterval = 60 + self._will = False + self._will_topic = "" + self._will_message= None + self._will_qos = 0 + self._will_retain = False + self._connectdisconnectTimeout = 30 + self._mqttOperationTimeout = 5 + self._topic_callback_queue=[] + self._callback_mutex=_thread.allocate_lock() + self._pid = 0 + self._subscribeSent = False + self._unsubscribeSent = False + self._baseReconnectTimeSecond=1 + self._maximumReconnectTimeSecond=32 + self._minimumConnectTimeSecond=20 + self._msgHandler=msgHandler.MsgHandler(self._recv_callback, self.connect) + + def getClientID(self): + return self.client_id + + def configEndpoint(self, srcHost, srcPort): + self._msgHandler.setEndpoint(srcHost, srcPort) + + def configCredentials(self, srcCAFile, srcKey, srcCert): + self._msgHandler.setCredentials(srcCAFile, srcKey, srcCert) + + def setConnectDisconnectTimeoutSecond(self, srcConnectDisconnectTimeout): + self._connectdisconnectTimeout = srcConnectDisconnectTimeout + + def setMQTTOperationTimeoutSecond(self, srcMQTTOperationTimeout): + self._mqttOperationTimeout = srcMQTTOperationTimeout + self._msgHandler.setOperationTimeout(srcMQTTOperationTimeout) + + def clearLastWill(self): + self._will = False + self._will_topic = "" + self._will_message= None + self._will_qos = 0 + self._will_retain = False + + def setLastWill(self, topic, payload=None, QoS=0, retain=False): + self._will=True + self._will_qos = QoS + self._will_retain = retain + self._will_topic = topic.encode('utf-8') + + if isinstance(payload, bytearray): + self._will_message=payload + elif isinstance(payload, str): + self._will_message=payload.encode('utf-8') + elif isinstance(payload, int) or isinstance(payload, float): + self._will_message=str(payload) + + def configIAMCredentials(self, srcAWSAccessKeyID, srcAWSSecretAccessKey, srcAWSSessionToken): + raise NotImplementedError ('Websockets not supported') + + def setOfflinePublishQueueing(self, srcQueueSize, srcDropBehavior): + if srcDropBehavior != mqttConst.DROP_OLDEST and srcDropBehavior != mqttConst.DROP_NEWEST: + raise ValueError("Invalid packet drop behavior") + self._msgHandler.setOfflineQueueConfiguration(srcQueueSize, srcDropBehavior) + + def setDrainingIntervalSecond(self, srcDrainingIntervalSecond): + self._msgHandler.setDrainingInterval(srcDrainingIntervalSecond) + + def setBackoffTiming(self, srcBaseReconnectTimeSecond, srcMaximumReconnectTimeSecond, srcMinimumConnectTimeSecond): + self._baseReconnectTimeSecond=srcBaseReconnectTimeSecond + self._maximumReconnectTimeSecond=srcMaximumReconnectTimeSecond + self._minimumConnectTimeSecond=srcMinimumConnectTimeSecond + + def connect(self, keepAliveInterval=30): + self._keepAliveInterval = keepAliveInterval + + if not self._msgHandler.createSocketConnection(): + return False + + self._send_connect(self._keepAliveInterval, self._cleanSession) + + # delay to check the state + count_10ms = 0 + while(count_10ms <= self._connectdisconnectTimeout * 100 and not self._msgHandler.isConnected()): + count_10ms += 1 + time.sleep(0.01) + + return True if self._msgHandler.isConnected() else False + + def subscribe(self, topic, qos, callback): + if (topic is None or callback is None): + raise TypeError("Invalid subscribe values.") + topic = topic.encode('utf-8') + + header = mqttConst.MSG_SUBSCRIBE | (1<<1) + pkt = bytearray([header]) + + pkt_len = 2 + 2 + len(topic) + 1 # packet identifier + len of topic (16 bits) + topic len + QOS + pkt.extend(self._encode_varlen_length(pkt_len)) # len of the remaining + + self._pid += 1 + pkt.extend(self._encode_16(self._pid)) + pkt.extend(self._pascal_string(topic)) + pkt.append(qos) + + self._subscribeSent = False + self._msgHandler.push_on_send_queue(pkt) + + count_10ms = 0 + while(count_10ms <= self._mqttOperationTimeout * 100 and not self._subscribeSent): + count_10ms += 1 + time.sleep(0.01) + + if self._subscribeSent: + self._callback_mutex.acquire() + self._topic_callback_queue.append((topic, callback)) + self._callback_mutex.release() + return True + + return False + + def publish(self, topic, payload, qos, retain, dup=False): + topic = topic.encode('utf-8') + payload = payload.encode('utf-8') + + header = mqttConst.MSG_PUBLISH | (dup << 3) | (qos << 1) | retain + pkt_len = (2 + len(topic) + + (2 if qos else 0) + + (len(payload))) + + pkt = bytearray([header]) + pkt.extend(self._encode_varlen_length(pkt_len)) # len of the remaining + pkt.extend(self._pascal_string(topic)) + if qos: + self._pid += 1 #todo: I don't think this is the way to deal with the packet id + pkt.extend(self._encode_16(self._pid)) + + pkt = pkt + payload + self._msgHandler.push_on_send_queue(pkt) + + def _encode_16(self, x): + return struct.pack("!H", x) + + def _pascal_string(self, s): + return struct.pack("!H", len(s)) + s + + def _encode_varlen_length(self, length): + i = 0 + buff = bytearray() + while 1: + buff.append(length % 128) + length = length // 128 + if length > 0: + buff[i] = buff[i] | 0x80 + i += 1 + else: + break + + return buff + + def _topic_matches_sub(self, sub, topic): + result = True + multilevel_wildcard = False + + slen = len(sub) + tlen = len(topic) + + if slen > 0 and tlen > 0: + if (sub[0] == '$' and topic[0] != '$') or (topic[0] == '$' and sub[0] != '$'): + return False + + spos = 0 + tpos = 0 + + while spos < slen and tpos < tlen: + if sub[spos] == topic[tpos]: + if tpos == tlen-1: + # Check for e.g. foo matching foo/# + if spos == slen-3 and sub[spos+1] == '/' and sub[spos+2] == '#': + result = True + multilevel_wildcard = True + break + + spos += 1 + tpos += 1 + + if tpos == tlen and spos == slen-1 and sub[spos] == '+': + spos += 1 + result = True + break + else: + if sub[spos] == '+': + spos += 1 + while tpos < tlen and topic[tpos] != '/': + tpos += 1 + if tpos == tlen and spos == slen: + result = True + break + + elif sub[spos] == '#': + multilevel_wildcard = True + if spos+1 != slen: + result = False + break + else: + result = True + break + + else: + result = False + break + + if not multilevel_wildcard and (tpos < tlen or spos < slen): + result = False + + return result + + def _remove_topic_callback(self, topic): + deleted=False + + self._callback_mutex.acquire() + for i in range(0, len(self._topic_callback_queue)): + if self._topic_callback_queue[i][0] == topic: + self._topic_callback_queue.pop(i) + deleted=True + self._callback_mutex.release() + + return deleted + + def unsubscribe(self, topic): + self._unsubscribeSent = False + self._send_unsubscribe(topic, False) + + count_10ms = 0 + while(count_10ms <= self._mqttOperationTimeout * 100 and not self._unsubscribeSent): + count_10ms += 1 + time.sleep(0.01) + + if self._unsubscribeSent: + topic = topic.encode('utf-8') + return self._remove_topic_callback(topic) + + return False + + def disconnect(self): + pkt = struct.pack('!BB', mqttConst.MSG_DISCONNECT, 0) + self._msgHandler.push_on_send_queue(pkt) + + time.sleep(self._connectdisconnectTimeout) + self._msgHandler.disconnect() + + return True + + def _send_connect(self, keepalive, clean_session): + msg_sent = False + + pkt_len = (12 + len(self.client_id) + # 10 + 2 + len(client_id) + (2 + len(self._user) if self._user else 0) + + (2 + len(self._password) if self._password else 0)) + + flags = (0x80 if self._user else 0x00) | (0x40 if self._password else 0x00) | (0x02 if clean_session else 0x00) + + if self._will_message: + flags |= (self._will_retain << 3 | self._will_qos << 1 | 1) << 2 + pkt_len += 4 + len(self._will_topic) + len(self._will_message) + + pkt = bytearray([mqttConst.MSG_CONNECT]) # connect + pkt.extend(self._encode_varlen_length(pkt_len)) # len of the remaining + pkt.extend(b'\x00\x04MQTT\x04') # len of "MQTT" (16 bits), protocol name, and protocol version + pkt.append(flags) + pkt.extend(b'\x00\x00') # disable keepalive + pkt.extend(self._pascal_string(self.client_id)) + if self._will_message: + pkt.extend(self._pascal_string(self._will_topic)) + pkt.extend(self._pascal_string(self._will_message)) + if self._user: + pkt.extend(self._pascal_string(self._user)) + if self._password: + pkt.extend(self._pascal_string(self._password)) + + return self._msgHandler.priority_send(pkt) + + def _send_unsubscribe(self, topic, dup=False): + pkt = bytearray() + msg_type = mqttConst.MSG_UNSUBSCRIBE | (dup<<3) | (1<<1) + pkt.extend(struct.pack("!B", msg_type)) + + remaining_length = 2 + 2 + len(topic) + pkt.extend(self._encode_varlen_length(remaining_length)) + + self._pid += 1 + pkt.extend(self._encode_16(self._pid)) + pkt.extend(self._pascal_string(topic)) + + return self._msgHandler.push_on_send_queue(pkt) + + def _send_puback(self, msg_id): + remaining_length = 2 + pkt = struct.pack('!BBH', mqttConst.MSG_PUBACK, remaining_length, msg_id) + + return self._msgHandler.push_on_send_queue(pkt) + + def _send_pubrec(self, msg_id): + remaining_length = 2 + pkt = struct.pack('!BBH', mqttConst.MSG_PUBREC, remaining_length, msg_id) + + return self._msgHandler.push_on_send_queue(pkt) + + def _parse_connack(self, payload): + if len(payload) != 2: + return False + + (flags, result) = struct.unpack("!BB", payload) + + if result == 0: + self._msgHandler.setConnectionState(mqttConst.STATE_CONNECTED) + return True + else: + self._msgHandler.setConnectionState(mqttConst.STATE_DISCONNECTED) + return False + + def _parse_suback(self, payload): + self._subscribeSent = True + print('Subscribed to topic') + + return True + + def _parse_puback(self, payload): + return True + + def _notify_message(self, message): + notified = False + self._callback_mutex.acquire() + for t_obj in self._topic_callback_queue: + if self._topic_matches_sub(t_obj[0], message.topic): + t_obj[1](self, self._userdata, message) + notified = True + self._callback_mutex.release() + + return notified + + def _parse_publish(self, cmd, packet): + msg = MQTTMessage() + msg.dup = (cmd & 0x08)>>3 + msg.qos = (cmd & 0x06)>>1 + msg.retain = (cmd & 0x01) + + pack_format = "!H" + str(len(packet)-2) + 's' + (slen, packet) = struct.unpack(pack_format, packet) + pack_format = '!' + str(slen) + 's' + str(len(packet)-slen) + 's' + (msg.topic, packet) = struct.unpack(pack_format, packet) + + if len(msg.topic) == 0: + return False + + if msg.qos > 0: + pack_format = "!H" + str(len(packet)-2) + 's' + (msg.mid, packet) = struct.unpack(pack_format, packet) + + msg.payload = packet + + if msg.qos == 0: + self._notify_message(msg) + elif msg.qos == 1: + self._send_puback(msg.mid) + self._notify_message(msg) + elif msg.qos == 2: + self._send_pubrec(msg.mid) + self._notify_message(msg) + else: + return False + + return True + + def _parse_unsuback(self, payload): + self._unsubscribeSent = True + return True + + def _parse_pingresp(self): + self._msgHandler.setPingFlag(True) + return True + + def _recv_callback(self, cmd, payload): + msg_type = cmd & 0xF0 + + if msg_type == mqttConst.MSG_CONNACK: + return self._parse_connack(payload) + elif msg_type == mqttConst.MSG_SUBACK: + return self._parse_suback(payload) + elif msg_type == mqttConst.MSG_PUBACK: + return self._parse_puback(payload) + elif msg_type == mqttConst.MSG_PUBLISH: + return self._parse_publish(cmd, payload) + elif msg_type == mqttConst.MSG_UNSUBACK: + return self._parse_unsuback(payload) + elif msg_type == mqttConst.MSG_PINGRESP: + return self._parse_pingresp() + else: + print('Unknown message type: %d' % msg_type) + return False + + def insertShadowCallback(self, callback, payload, status, token): + self._msgHandler.insertShadowCallback(callback, payload, status, token) diff --git a/lib/mqtt_aws/MQTTConst.py b/lib/mqtt_aws/MQTTConst.py new file mode 100644 index 0000000..4c6d07b --- /dev/null +++ b/lib/mqtt_aws/MQTTConst.py @@ -0,0 +1,46 @@ + +# - Protocol types +MQTTv3_1 = 3 +MQTTv3_1_1 = 4 + +# - OfflinePublishQueueing drop behavior +DROP_OLDEST = 0 +DROP_NEWEST = 1 + +# Message types +MSG_CONNECT = 0x10 +MSG_CONNACK = 0x20 +MSG_PUBLISH = 0x30 +MSG_PUBACK = 0x40 +MSG_PUBREC = 0x50 +MSG_PUBREL = 0x60 +MSG_PUBCOMP = 0x70 +MSG_SUBSCRIBE = 0x80 +MSG_SUBACK = 0x90 +MSG_UNSUBSCRIBE = 0xA0 +MSG_UNSUBACK = 0xB0 +MSG_PINGREQ = 0xC0 +MSG_PINGRESP = 0xD0 +MSG_DISCONNECT = 0xE0 + +# Connection state +STATE_CONNECTED = 0x01 +STATE_CONNECTING = 0x02 +STATE_DISCONNECTED = 0x03 + +class UUID: + int_ = int + bytes_ = bytes + + def __init__(self, bytes=None, version=None): + + self._int = UUID.int_.from_bytes(bytes, 'big') + + self._int &= ~(0xc000 << 48) + self._int |= 0x8000 << 48 + self._int &= ~(0xf000 << 64) + self._int |= version << 76 + + @property + def urn(self): + return 'urn:uuid:' + str(self) diff --git a/lib/mqtt_aws/MQTTDeviceShadow.py b/lib/mqtt_aws/MQTTDeviceShadow.py new file mode 100644 index 0000000..6ea1489 --- /dev/null +++ b/lib/mqtt_aws/MQTTDeviceShadow.py @@ -0,0 +1,233 @@ +import MQTTConst as mqttConst +from machine import Timer +import json +import os +import _thread + +class _basicJSONParser: + + def setString(self, srcString): + self._rawString = srcString + self._dictionObject = None + + def regenerateString(self): + return json.dumps(self._dictionaryObject) + + def getAttributeValue(self, srcAttributeKey): + return self._dictionaryObject.get(srcAttributeKey) + + def setAttributeValue(self, srcAttributeKey, srcAttributeValue): + self._dictionaryObject[srcAttributeKey] = srcAttributeValue + + def validateJSON(self): + try: + self._dictionaryObject = json.loads(self._rawString) + except ValueError: + return False + return True + +class deviceShadow: + def __init__(self, srcShadowName, srcIsPersistentSubscribe, srcShadowManager): + + if srcShadowName is None or srcIsPersistentSubscribe is None or srcShadowManager is None: + raise TypeError("None type inputs detected.") + self._shadowName = srcShadowName + # Tool handler + self._shadowManagerHandler = srcShadowManager + self._basicJSONParserHandler = _basicJSONParser() + # Properties + self._isPersistentSubscribe = srcIsPersistentSubscribe + self._lastVersionInSync = -1 # -1 means not initialized + self._isGetSubscribed = False + self._isUpdateSubscribed = False + self._isDeleteSubscribed = False + self._shadowSubscribeCallbackTable = dict() + self._shadowSubscribeCallbackTable["get"] = None + self._shadowSubscribeCallbackTable["delete"] = None + self._shadowSubscribeCallbackTable["update"] = None + self._shadowSubscribeCallbackTable["delta"] = None + self._shadowSubscribeStatusTable = dict() + self._shadowSubscribeStatusTable["get"] = 0 + self._shadowSubscribeStatusTable["delete"] = 0 + self._shadowSubscribeStatusTable["update"] = 0 + self._tokenPool = dict() + self._dataStructureLock = _thread.allocate_lock() + + def _doNonPersistentUnsubscribe(self, currentAction): + self._shadowManagerHandler.shadowUnsubscribe(self._shadowName, currentAction) + + def _generalCallback(self, client, userdata, message): + # In Py3.x, message.payload comes in as a bytes(string) + # json.loads needs a string input + self._dataStructureLock.acquire() + currentTopic = message.topic + currentAction = self._parseTopicAction(currentTopic) # get/delete/update/delta + currentType = self._parseTopicType(currentTopic) # accepted/rejected/delta + payloadUTF8String = message.payload.decode('utf-8') + # get/delete/update: Need to deal with token, timer and unsubscribe + if currentAction in ["get", "delete", "update"]: + # Check for token + self._basicJSONParserHandler.setString(payloadUTF8String) + if self._basicJSONParserHandler.validateJSON(): # Filter out invalid JSON + currentToken = self._basicJSONParserHandler.getAttributeValue(u"clientToken") + if currentToken is not None and currentToken in self._tokenPool.keys(): # Filter out JSON without the desired token + # Sync local version when it is an accepted response + if currentType == "accepted": + incomingVersion = self._basicJSONParserHandler.getAttributeValue(u"version") + # If it is get/update accepted response, we need to sync the local version + if incomingVersion is not None and incomingVersion > self._lastVersionInSync and currentAction != "delete": + self._lastVersionInSync = incomingVersion + # If it is a delete accepted, we need to reset the version + else: + self._lastVersionInSync = -1 # The version will always be synced for the next incoming delta/GU-accepted response + # Cancel the timer and clear the token + self._tokenPool[currentToken].cancel() + del self._tokenPool[currentToken] + # Need to unsubscribe? + self._shadowSubscribeStatusTable[currentAction] -= 1 + if not self._isPersistentSubscribe and self._shadowSubscribeStatusTable.get(currentAction) <= 0: + self._shadowSubscribeStatusTable[currentAction] = 0 + self._doNonPersistentUnsubscribe(currentAction) + # Custom callback + if self._shadowSubscribeCallbackTable.get(currentAction) is not None: + self._shadowManagerHandler.insertShadowCallback(self._shadowSubscribeCallbackTable[currentAction], payloadUTF8String, currentType, currentToken) + # delta: Watch for version + else: + currentType += "/" + self._parseTopicShadowName(currentTopic) + # Sync local version + self._basicJSONParserHandler.setString(payloadUTF8String) + if self._basicJSONParserHandler.validateJSON(): # Filter out JSON without version + incomingVersion = self._basicJSONParserHandler.getAttributeValue(u"version") + if incomingVersion is not None and incomingVersion > self._lastVersionInSync: + self._lastVersionInSync = incomingVersion + # Custom callback + if self._shadowSubscribeCallbackTable.get(currentAction) is not None: + self._shadowManagerHandler.insertShadowCallback(self._shadowSubscribeCallbackTable[currentAction], payloadUTF8String, currentType, None) + self._dataStructureLock.release() + + def _parseTopicAction(self, srcTopic): + ret = None + fragments = srcTopic.decode('utf-8').split('/') + if fragments[5] == "delta": + ret = "delta" + else: + ret = fragments[4] + return ret + + def _parseTopicType(self, srcTopic): + fragments = srcTopic.decode('utf-8').split('/') + return fragments[5] + + def _parseTopicShadowName(self, srcTopic): + fragments = srcTopic.decode('utf-8').split('/') + return fragments[2] + + def _timerHandler(self, args): + srcActionName = args[0] + srcToken = args[1] + + self._dataStructureLock.acquire() + # Remove the token + del self._tokenPool[srcToken] + # Need to unsubscribe? + self._shadowSubscribeStatusTable[srcActionName] -= 1 + if not self._isPersistentSubscribe and self._shadowSubscribeStatusTable.get(srcActionName) <= 0: + self._shadowSubscribeStatusTable[srcActionName] = 0 + self._shadowManagerHandler.shadowUnsubscribe(self._shadowName, srcActionName) + # Notify time-out issue + if self._shadowSubscribeCallbackTable.get(srcActionName) is not None: + self._shadowSubscribeCallbackTable[srcActionName]("REQUEST TIME OUT", "timeout", srcToken) + self._dataStructureLock.release() + + def shadowGet(self, srcCallback, srcTimeout): + self._dataStructureLock.acquire() + # Update callback data structure + self._shadowSubscribeCallbackTable["get"] = srcCallback + # Update number of pending feedback + self._shadowSubscribeStatusTable["get"] += 1 + # clientToken + currentToken = mqttConst.UUID(bytes=os.urandom(16), version=4).urn[9:] + self._tokenPool[currentToken] = None + self._basicJSONParserHandler.setString("{}") + self._basicJSONParserHandler.validateJSON() + self._basicJSONParserHandler.setAttributeValue("clientToken", currentToken) + currentPayload = self._basicJSONParserHandler.regenerateString() + self._dataStructureLock.release() + # Two subscriptions + if not self._isPersistentSubscribe or not self._isGetSubscribed: + self._shadowManagerHandler.shadowSubscribe(self._shadowName, "get", self._generalCallback) + self._isGetSubscribed = True + # One publish + self._shadowManagerHandler.shadowPublish(self._shadowName, "get", currentPayload) + # Start the timer + self._tokenPool[currentToken] = Timer.Alarm(self._timerHandler, srcTimeout,arg=("get", currentToken),periodic=False) + return currentToken + + def shadowDelete(self, srcCallback, srcTimeout): + self._dataStructureLock.acquire() + # Update callback data structure + self._shadowSubscribeCallbackTable["delete"] = srcCallback + # Update number of pending feedback + self._shadowSubscribeStatusTable["delete"] += 1 + # clientToken + currentToken = mqttConst.UUID(bytes=os.urandom(16), version=4).urn[9:] + self._tokenPool[currentToken] = None + self._basicJSONParserHandler.setString("{}") + self._basicJSONParserHandler.validateJSON() + self._basicJSONParserHandler.setAttributeValue("clientToken", currentToken) + currentPayload = self._basicJSONParserHandler.regenerateString() + self._dataStructureLock.release() + # Two subscriptions + if not self._isPersistentSubscribe or not self._isDeleteSubscribed: + self._shadowManagerHandler.shadowSubscribe(self._shadowName, "delete", self._generalCallback) + self._isDeleteSubscribed = True + # One publish + self._shadowManagerHandler.shadowPublish(self._shadowName, "delete", currentPayload) + # Start the timer + self._tokenPool[currentToken] = Timer.Alarm(self._timerHandler,srcTimeout, arg=("delete", currentToken), periodic=False) + return currentToken + + def shadowUpdate(self, srcJSONPayload, srcCallback, srcTimeout): + # Validate JSON + JSONPayloadWithToken = None + currentToken = None + self._basicJSONParserHandler.setString(srcJSONPayload) + if self._basicJSONParserHandler.validateJSON(): + self._dataStructureLock.acquire() + # clientToken + currentToken = mqttConst.UUID(bytes=os.urandom(16), version=4).urn[9:] + self._tokenPool[currentToken] = None + self._basicJSONParserHandler.setAttributeValue("clientToken", currentToken) + JSONPayloadWithToken = self._basicJSONParserHandler.regenerateString() + # Update callback data structure + self._shadowSubscribeCallbackTable["update"] = srcCallback + # Update number of pending feedback + self._shadowSubscribeStatusTable["update"] += 1 + self._dataStructureLock.release() + # Two subscriptions + if not self._isPersistentSubscribe or not self._isUpdateSubscribed: + self._shadowManagerHandler.shadowSubscribe(self._shadowName, "update", self._generalCallback) + self._isUpdateSubscribed = True + # One publish + self._shadowManagerHandler.shadowPublish(self._shadowName, "update", JSONPayloadWithToken) + # Start the timer + self._tokenPool[currentToken] = Timer.Alarm(self._timerHandler, srcTimeout, arg=("update", currentToken), periodic=False) + else: + raise ValueError("Invalid JSON file.") + return currentToken + + def shadowRegisterDeltaCallback(self, srcCallback): + self._dataStructureLock.acquire() + # Update callback data structure + self._shadowSubscribeCallbackTable["delta"] = srcCallback + self._dataStructureLock.release() + # One subscription + self._shadowManagerHandler.shadowSubscribe(self._shadowName, "delta", self._generalCallback) + + def shadowUnregisterDeltaCallback(self): + self._dataStructureLock.acquire() + # Update callback data structure + del self._shadowSubscribeCallbackTable["delta"] + self._dataStructureLock.release() + # One unsubscription + self._shadowManagerHandler.shadowUnsubscribe(self._shadowName, "delta") diff --git a/lib/mqtt_aws/MQTTLib.py b/lib/mqtt_aws/MQTTLib.py new file mode 100644 index 0000000..49dc0a5 --- /dev/null +++ b/lib/mqtt_aws/MQTTLib.py @@ -0,0 +1,119 @@ +import MQTTConst as mqttConst +import MQTTClient as mqttClient +import MQTTShadowManager as shadowManager +import MQTTDeviceShadow as deviceShadow + +class AWSIoTMQTTClient: + + def __init__(self, clientID, protocolType=mqttConst.MQTTv3_1_1, useWebsocket=False, cleanSession=True): + self._mqttClient = mqttClient.MQTTClient(clientID, cleanSession, protocolType) + + # Configuration APIs + def configureLastWill(self, topic, payload, QoS): + self._mqttClient.setLastWill(topic, payload, QoS) + + def clearLastWill(self): + self._mqttClient.clearLastWill() + + def configureEndpoint(self, hostName, portNumber): + self._mqttClient.configEndpoint(hostName, portNumber) + + def configureIAMCredentials(self, AWSAccessKeyID, AWSSecretAccessKey, AWSSessionToken=""): + self._mqttClient.configIAMCredentials(AWSAccessKeyID, AWSSecretAccessKey, AWSSessionToken) + + def configureCredentials(self, CAFilePath, KeyPath="", CertificatePath=""): # Should be good for MutualAuth certs config and Websocket rootCA config + self._mqttClient.configCredentials(CAFilePath, KeyPath, CertificatePath) + + def configureAutoReconnectBackoffTime(self, baseReconnectQuietTimeSecond, maxReconnectQuietTimeSecond, stableConnectionTimeSecond): + self._mqttClient.setBackoffTiming(baseReconnectQuietTimeSecond, maxReconnectQuietTimeSecond, stableConnectionTimeSecond) + + def configureOfflinePublishQueueing(self, queueSize, dropBehavior=mqttConst.DROP_NEWEST): + self._mqttClient.setOfflinePublishQueueing(queueSize, dropBehavior) + + def configureDrainingFrequency(self, frequencyInHz): + self._mqttClient.setDrainingIntervalSecond(1/float(frequencyInHz)) + + def configureConnectDisconnectTimeout(self, timeoutSecond): + self._mqttClient.setConnectDisconnectTimeoutSecond(timeoutSecond) + + def configureMQTTOperationTimeout(self, timeoutSecond): + self._mqttClient.setMQTTOperationTimeoutSecond(timeoutSecond) + + # MQTT functionality APIs + def connect(self, keepAliveIntervalSecond=30): + return self._mqttClient.connect(keepAliveIntervalSecond) + + def disconnect(self): + return self._mqttClient.disconnect() + + def publish(self, topic, payload, QoS): + return self._mqttClient.publish(topic, payload, QoS, False) # Disable retain for publish by now + + def subscribe(self, topic, QoS, callback): + return self._mqttClient.subscribe(topic, QoS, callback) + + def unsubscribe(self, topic): + return self._mqttClient.unsubscribe(topic) + + +class AWSIoTMQTTShadowClient: + + def __init__(self, clientID, protocolType=mqttConst.MQTTv3_1_1, useWebsocket=False, cleanSession=True): + # AWSIOTMQTTClient instance + self._AWSIoTMQTTClient = AWSIoTMQTTClient(clientID, protocolType, useWebsocket, cleanSession) + # Configure it to disable offline Publish Queueing + self._AWSIoTMQTTClient.configureOfflinePublishQueueing(0) # Disable queueing, no queueing for time-sentive shadow messages + self._AWSIoTMQTTClient.configureDrainingFrequency(10) + # Now retrieve the configured mqttCore and init a shadowManager instance + self._shadowManager = shadowManager.shadowManager(self._AWSIoTMQTTClient._mqttClient) + + # Configuration APIs + def configureLastWill(self, topic, payload, QoS): + self._AWSIoTMQTTClient.configureLastWill(topic, payload, QoS) + + def clearLastWill(self): + self._AWSIoTMQTTClient.clearLastWill() + + def configureEndpoint(self, hostName, portNumber): + self._AWSIoTMQTTClient.configureEndpoint(hostName, portNumber) + + def configureIAMCredentials(self, AWSAccessKeyID, AWSSecretAccessKey, AWSSTSToken=""): + # AWSIoTMQTTClient.configureIAMCredentials + self._AWSIoTMQTTClient.configureIAMCredentials(AWSAccessKeyID, AWSSecretAccessKey, AWSSTSToken) + + def configureCredentials(self, CAFilePath, KeyPath="", CertificatePath=""): # Should be good for MutualAuth and Websocket + self._AWSIoTMQTTClient.configureCredentials(CAFilePath, KeyPath, CertificatePath) + + def configureAutoReconnectBackoffTime(self, baseReconnectQuietTimeSecond, maxReconnectQuietTimeSecond, stableConnectionTimeSecond): + self._AWSIoTMQTTClient.configureAutoReconnectBackoffTime(baseReconnectQuietTimeSecond, maxReconnectQuietTimeSecond, stableConnectionTimeSecond) + + def configureConnectDisconnectTimeout(self, timeoutSecond): + self._AWSIoTMQTTClient.configureConnectDisconnectTimeout(timeoutSecond) + + def configureMQTTOperationTimeout(self, timeoutSecond): + self._AWSIoTMQTTClient.configureMQTTOperationTimeout(timeoutSecond) + + # Start the MQTT connection + def connect(self, keepAliveIntervalSecond=30): + return self._AWSIoTMQTTClient.connect(keepAliveIntervalSecond) + + # End the MQTT connection + def disconnect(self): + return self._AWSIoTMQTTClient.disconnect() + + # Shadow management API + def createShadowHandlerWithName(self, shadowName, isPersistentSubscribe): + # Create and return a deviceShadow instance + return deviceShadow.deviceShadow(shadowName, isPersistentSubscribe, self._shadowManager) + # Shadow APIs are accessible in deviceShadow instance": + ### + # deviceShadow.shadowGet + # deviceShadow.shadowUpdate + # deviceShadow.shadowDelete + # deviceShadow.shadowRegisterDelta + # deviceShadow.shadowUnregisterDelta + + # MQTT connection management API + def getMQTTConnection(self): + # Return the internal AWSIoTMQTTClient instance + return self._AWSIoTMQTTClient diff --git a/lib/mqtt_aws/MQTTMsgHandler.py b/lib/mqtt_aws/MQTTMsgHandler.py new file mode 100644 index 0000000..273f739 --- /dev/null +++ b/lib/mqtt_aws/MQTTMsgHandler.py @@ -0,0 +1,279 @@ +import MQTTConst as mqttConst +import time +import socket +import ssl +import _thread +import select +import struct + +class MsgHandler: + + def __init__(self, receive_callback, connect_helper): + self._host = "" + self._port = -1 + self._cafile = "" + self._key = "" + self._cert = "" + self._sock = None + self._output_queue_size=-1 + self._output_queue_dropbehavior=-1 + self._mqttOperationTimeout = 5 + self._connection_state = mqttConst.STATE_DISCONNECTED + self._conn_state_mutex=_thread.allocate_lock() + self._poll = select.poll() + self._output_queue=[] + self._out_packet_mutex=_thread.allocate_lock() + _thread.stack_size(8192) + _thread.start_new_thread(self._io_thread_func, ()) + self._recv_callback = receive_callback + self._connect_helper = connect_helper + self._pingSent=False + self._ping_interval=20 + self._waiting_ping_resp=False + self._ping_cutoff=3 + self._receive_timeout=3000 + self._draining_interval=2 + self._draining_cutoff=3 + self._shadow_cb_queue=[] + self._shadow_cb_mutex=_thread.allocate_lock() + + def setOfflineQueueConfiguration(self, queueSize, dropBehavior): + self._output_queue_size = queueSize + self._output_queue_dropbehavior = dropBehavior + + def setCredentials(self, srcCAFile, srcKey, srcCert): + self._cafile = srcCAFile + self._key = srcKey + self._cert = srcCert + + def setEndpoint(self, srcHost, srcPort): + self._host = srcHost + self._port = srcPort + + def setOperationTimeout(self, timeout): + self._mqttOperationTimeout=timeout + + def setDrainingInterval(self, srcDrainingIntervalSecond): + self._draining_interval=srcDrainingIntervalSecond + + def insertShadowCallback(self, callback, payload, status, token): + self._shadow_cb_mutex.acquire() + self._shadow_cb_queue.append((callback, payload, status, token)) + self._shadow_cb_mutex.release() + + def _callShadowCallback(self): + self._shadow_cb_mutex.acquire() + if len(self._shadow_cb_queue) > 0: + cbObj = self._shadow_cb_queue.pop(0) + cbObj[0](cbObj[1],cbObj[2], cbObj[3]) + self._shadow_cb_mutex.release() + + def createSocketConnection(self): + self._conn_state_mutex.acquire() + self._connection_state = mqttConst.STATE_CONNECTING + self._conn_state_mutex.release() + try: + if self._sock: + self._poll.unregister(self._sock) + self._sock.close() + self._sock = None + + self._sock = socket.socket() + self._sock.settimeout(30) + if self._cafile: + self._sock = ssl.wrap_socket( + self._sock, + certfile=self._cert, + keyfile=self._key, + ca_certs=self._cafile, + cert_reqs=ssl.CERT_REQUIRED) + + self._sock.connect(socket.getaddrinfo(self._host, self._port)[0][-1]) + self._poll.register(self._sock, select.POLLIN) + except socket.error as err: + print("Socket create error: {0}".format(err)) + + self._conn_state_mutex.acquire() + self._connection_state = mqttConst.STATE_DISCONNECTED + self._conn_state_mutex.release() + + return False + + return True + + def disconnect(self): + if self._sock: + self._sock.close() + self._sock = None + + def isConnected(self): + connected=False + self._conn_state_mutex.acquire() + if self._connection_state == mqttConst.STATE_CONNECTED: + connected = True + self._conn_state_mutex.release() + + return connected + + def setConnectionState(self, state): + self._conn_state_mutex.acquire() + self._connection_state = state + self._conn_state_mutex.release() + + def _drop_message(self): + if self._output_queue_size == -1: + return False + elif (self._output_queue_size == 0) and (self._connection_state == mqttConst.STATE_CONNECTED): + return False + else: + return True if len(self._output_queue) >= self._output_queue_size else False + + def push_on_send_queue(self, packet): + if self._drop_message(): + if self._output_queue_dropbehavior == mqttConst.DROP_OLDEST: + self._out_packet_mutex.acquire() + if self._out_packet_mutex.locked(): + self._output_queue.pop(0) + self._out_packet_mutex.release() + else: + return False + + self._out_packet_mutex.acquire() + if self._out_packet_mutex.locked(): + self._output_queue.append(packet) + self._out_packet_mutex.release() + + return True + + def priority_send(self, packet): + msg_sent = False + self._out_packet_mutex.acquire() + msg_sent = self._send_packet(packet) + self._out_packet_mutex.release() + + return msg_sent + + def _receive_packet(self): + try: + if not self._poll.poll(self._receive_timeout): + return False + except Exception as err: + print("Poll error: {0}".format(err)) + return False + + # Read message type + try: + self._sock.setblocking(False) + msg_type = self._sock.recv(1) + except socket.error as err: + print("Socket receive error: {0}".format(err)) + return False + else: + if len(msg_type) == 0: + return False + msg_type = struct.unpack("!B", msg_type)[0] + self._sock.setblocking(True) + + # Read payload length + multiplier = 1 + bytes_read = 0 + bytes_remaining = 0 + while True: + try: + if self._sock: + byte = self._sock.recv(1) + except socket.error as err: + print("Socket receive error: {0}".format(err)) + return False + else: + bytes_read = bytes_read + 1 + if bytes_read > 4: + return False + + byte = struct.unpack("!B", byte)[0] + bytes_remaining += (byte & 127) * multiplier + multiplier += 128 + + if (byte & 128) == 0: + break + + # Read payload + try: + if self._sock: + if bytes_remaining > 0: + payload = self._sock.recv(bytes_remaining) + else: + payload = b'' + except socket.error as err: + print("Socket receive error: {0}".format(err)) + return False + + return self._recv_callback(msg_type, payload) + + def _send_pingreq(self): + pkt = struct.pack('!BB', mqttConst.MSG_PINGREQ, 0) + return self.priority_send(pkt) + + def setPingFlag(self, flag): + self._pingSent=flag + + def _send_packet(self, packet): + written = -1 + try: + if self._sock: + written = self._sock.write(packet) + if(written == None): + written = -1 + else: + print('Packet sent. (Length: %d)' % written) + except socket.error as err: + print('Socket send error {0}'.format(err)) + return False + + return True if len(packet) == written else False + + def _verify_connection_state(self): + elapsed = time.time() - self._start_time + if not self._waiting_ping_resp and elapsed > self._ping_interval: + if self._connection_state == mqttConst.STATE_CONNECTED: + self._pingSent=False + self._send_pingreq() + self._waiting_ping_resp=True + elif self._connection_state == mqttConst.STATE_DISCONNECTED: + self._connect_helper() + + self._start_time = time.time() + elif self._waiting_ping_resp and (self._connection_state == mqttConst.STATE_CONNECTED or elapsed > self._mqttOperationTimeout): + if not self._pingSent: + if self._ping_failures <= self._ping_cutoff: + self._ping_failures+=1 + else: + self._connect_helper() + else: + self._ping_failures=0 + + self._start_time = time.time() + self._waiting_ping_resp = False + + def _io_thread_func(self): + time.sleep(5.0) + + self._start_time = time.time() + self._ping_failures=0 + while True: + + self._verify_connection_state() + + self._out_packet_mutex.acquire() + if self._ping_failures == 0: + if self._out_packet_mutex.locked() and len(self._output_queue) > 0: + packet=self._output_queue[0] + if self._send_packet(packet): + self._output_queue.pop(0) + self._out_packet_mutex.release() + + self._receive_packet() + self._callShadowCallback() + + if len(self._output_queue) >= self._draining_cutoff: + time.sleep(self._draining_interval) \ No newline at end of file diff --git a/lib/mqtt_aws/MQTTShadowManager.py b/lib/mqtt_aws/MQTTShadowManager.py new file mode 100644 index 0000000..a846317 --- /dev/null +++ b/lib/mqtt_aws/MQTTShadowManager.py @@ -0,0 +1,55 @@ +import _thread +import time + +class shadowManager: + + def __init__(self, MQTTClient): + if MQTTClient is None: + raise ValueError("MQTT Client is none") + + self._mqttClient = MQTTClient + self._subscribe_mutex = _thread.allocate_lock() + + def getClientID(self): + return self._mqttClient.getClientID() + + def _getDeltaTopic(self, shadowName): + return "$aws/things/" + str(shadowName) + "/shadow/update/delta" + + def _getNonDeltaTopics(self, shadowName, actionName): + generalTopic = "$aws/things/" + str(shadowName) + "/shadow/" + str(actionName) + acceptTopic = "$aws/things/" + str(shadowName) + "/shadow/" + str(actionName) + "/accepted" + rejectTopic = "$aws/things/" + str(shadowName) + "/shadow/" + str(actionName) + "/rejected" + + return (generalTopic, acceptTopic, rejectTopic) + + def shadowPublish(self, shadowName, shadowAction, payload): + (generalTopic, acceptTopic, rejectTopic) = self._getNonDeltaTopics(shadowName, shadowAction) + self._mqttClient.publish(generalTopic, payload, 0, False) + + def shadowSubscribe(self, shadowName, shadowAction, callback): + self._subscribe_mutex.acquire() + if shadowAction == "delta": + deltaTopic = self._getDeltaTopic(shadowName) + self._mqttClient.subscribe(deltaTopic, 0, callback) + else: + (generalTopic, acceptTopic, rejectTopic) = self._getNonDeltaTopics(shadowName, shadowAction) + self._mqttClient.subscribe(acceptTopic, 0, callback) + self._mqttClient.subscribe(rejectTopic, 0, callback) + time.sleep(2) + self._subscribe_mutex.release() + + def shadowUnsubscribe(self, srcShadowName, srcShadowAction): + self._subscribe_mutex.acquire() + currentShadowAction = _shadowAction(srcShadowName, srcShadowAction) + if shadowAction == "delta": + deltaTopic = self._getDeltaTopic(shadowName) + self._mqttClient.unsubscribe(deltaTopic) + else: + (generalTopic, acceptTopic, rejectTopic) = self._getNonDeltaTopics(shadowName, shadowAction) + self._mqttClient.unsubscribe(acceptTopic) + self._mqttClient.unsubscribe(rejectTopic) + self._subscribe_mutex.release() + + def insertShadowCallback(self, callback, payload, status, token): + self._mqttClient.insertShadowCallback(callback, payload, status, token) From f6b15a000a68b102e52bcd4413cbb3ce94255400 Mon Sep 17 00:00:00 2001 From: robert Date: Fri, 11 Oct 2019 17:32:56 +0200 Subject: [PATCH 28/92] lorawan-nano-gateway/nanogateway.py: Fix error handling Starting with version 1.20.1, the object returned by: except Exception as exp: does not have the attribute exp.errno any more. Instead, exp.args[0] is used, which is backward compatible. --- examples/lorawan-nano-gateway/nanogateway.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/examples/lorawan-nano-gateway/nanogateway.py b/examples/lorawan-nano-gateway/nanogateway.py index 76d6c92..1810cd5 100644 --- a/examples/lorawan-nano-gateway/nanogateway.py +++ b/examples/lorawan-nano-gateway/nanogateway.py @@ -442,7 +442,7 @@ def _udp_thread(self): except usocket.timeout: pass except OSError as ex: - if ex.errno != errno.EAGAIN: + if ex.args[0] != errno.EAGAIN: self._log('UDP recv OSError Exception: {}', ex) except Exception as ex: self._log('UDP recv Exception: {}', ex) From 7d9e178a49d7bc72f7719e135831cf7afb9d1a1e Mon Sep 17 00:00:00 2001 From: Catalin Ioana Date: Mon, 4 Nov 2019 12:25:37 +0200 Subject: [PATCH 29/92] [Pymesh] Moved Pymesh library in the root --- {lib/pymesh => pymesh}/README.md | 0 {lib/pymesh => pymesh}/copy_fw.sh | 0 {lib/pymesh => pymesh}/lib/ble_rpc.py | 0 {lib/pymesh => pymesh}/lib/ble_services.py | 0 {lib/pymesh => pymesh}/lib/cli.py | 0 {lib/pymesh => pymesh}/lib/loramesh.py | 0 {lib/pymesh => pymesh}/lib/mesh_interface.py | 0 {lib/pymesh => pymesh}/lib/mesh_internal.py | 0 {lib/pymesh => pymesh}/lib/meshaging.py | 0 {lib/pymesh => pymesh}/lib/msgpack/__init__.py | 0 {lib/pymesh => pymesh}/lib/msgpack/_version.py | 0 {lib/pymesh => pymesh}/lib/msgpack/exceptions.py | 0 {lib/pymesh => pymesh}/lib/msgpack/fallback.py | 0 {lib/pymesh => pymesh}/lib/pymesh.py | 0 {lib/pymesh => pymesh}/lib/pymesh_config.py | 0 {lib/pymesh => pymesh}/lib/pymesh_debug.py | 0 {lib/pymesh => pymesh}/lib/statistics.py | 0 {lib/pymesh => pymesh}/main.py | 0 18 files changed, 0 insertions(+), 0 deletions(-) rename {lib/pymesh => pymesh}/README.md (100%) rename {lib/pymesh => pymesh}/copy_fw.sh (100%) rename {lib/pymesh => pymesh}/lib/ble_rpc.py (100%) rename {lib/pymesh => pymesh}/lib/ble_services.py (100%) rename {lib/pymesh => pymesh}/lib/cli.py (100%) rename {lib/pymesh => pymesh}/lib/loramesh.py (100%) rename {lib/pymesh => pymesh}/lib/mesh_interface.py (100%) rename {lib/pymesh => pymesh}/lib/mesh_internal.py (100%) rename {lib/pymesh => pymesh}/lib/meshaging.py (100%) rename {lib/pymesh => pymesh}/lib/msgpack/__init__.py (100%) rename {lib/pymesh => pymesh}/lib/msgpack/_version.py (100%) rename {lib/pymesh => pymesh}/lib/msgpack/exceptions.py (100%) rename {lib/pymesh => pymesh}/lib/msgpack/fallback.py (100%) rename {lib/pymesh => pymesh}/lib/pymesh.py (100%) rename {lib/pymesh => pymesh}/lib/pymesh_config.py (100%) rename {lib/pymesh => pymesh}/lib/pymesh_debug.py (100%) rename {lib/pymesh => pymesh}/lib/statistics.py (100%) rename {lib/pymesh => pymesh}/main.py (100%) diff --git a/lib/pymesh/README.md b/pymesh/README.md similarity index 100% rename from lib/pymesh/README.md rename to pymesh/README.md diff --git a/lib/pymesh/copy_fw.sh b/pymesh/copy_fw.sh similarity index 100% rename from lib/pymesh/copy_fw.sh rename to pymesh/copy_fw.sh diff --git a/lib/pymesh/lib/ble_rpc.py b/pymesh/lib/ble_rpc.py similarity index 100% rename from lib/pymesh/lib/ble_rpc.py rename to pymesh/lib/ble_rpc.py diff --git a/lib/pymesh/lib/ble_services.py b/pymesh/lib/ble_services.py similarity index 100% rename from lib/pymesh/lib/ble_services.py rename to pymesh/lib/ble_services.py diff --git a/lib/pymesh/lib/cli.py b/pymesh/lib/cli.py similarity index 100% rename from lib/pymesh/lib/cli.py rename to pymesh/lib/cli.py diff --git a/lib/pymesh/lib/loramesh.py b/pymesh/lib/loramesh.py similarity index 100% rename from lib/pymesh/lib/loramesh.py rename to pymesh/lib/loramesh.py diff --git a/lib/pymesh/lib/mesh_interface.py b/pymesh/lib/mesh_interface.py similarity index 100% rename from lib/pymesh/lib/mesh_interface.py rename to pymesh/lib/mesh_interface.py diff --git a/lib/pymesh/lib/mesh_internal.py b/pymesh/lib/mesh_internal.py similarity index 100% rename from lib/pymesh/lib/mesh_internal.py rename to pymesh/lib/mesh_internal.py diff --git a/lib/pymesh/lib/meshaging.py b/pymesh/lib/meshaging.py similarity index 100% rename from lib/pymesh/lib/meshaging.py rename to pymesh/lib/meshaging.py diff --git a/lib/pymesh/lib/msgpack/__init__.py b/pymesh/lib/msgpack/__init__.py similarity index 100% rename from lib/pymesh/lib/msgpack/__init__.py rename to pymesh/lib/msgpack/__init__.py diff --git a/lib/pymesh/lib/msgpack/_version.py b/pymesh/lib/msgpack/_version.py similarity index 100% rename from lib/pymesh/lib/msgpack/_version.py rename to pymesh/lib/msgpack/_version.py diff --git a/lib/pymesh/lib/msgpack/exceptions.py b/pymesh/lib/msgpack/exceptions.py similarity index 100% rename from lib/pymesh/lib/msgpack/exceptions.py rename to pymesh/lib/msgpack/exceptions.py diff --git a/lib/pymesh/lib/msgpack/fallback.py b/pymesh/lib/msgpack/fallback.py similarity index 100% rename from lib/pymesh/lib/msgpack/fallback.py rename to pymesh/lib/msgpack/fallback.py diff --git a/lib/pymesh/lib/pymesh.py b/pymesh/lib/pymesh.py similarity index 100% rename from lib/pymesh/lib/pymesh.py rename to pymesh/lib/pymesh.py diff --git a/lib/pymesh/lib/pymesh_config.py b/pymesh/lib/pymesh_config.py similarity index 100% rename from lib/pymesh/lib/pymesh_config.py rename to pymesh/lib/pymesh_config.py diff --git a/lib/pymesh/lib/pymesh_debug.py b/pymesh/lib/pymesh_debug.py similarity index 100% rename from lib/pymesh/lib/pymesh_debug.py rename to pymesh/lib/pymesh_debug.py diff --git a/lib/pymesh/lib/statistics.py b/pymesh/lib/statistics.py similarity index 100% rename from lib/pymesh/lib/statistics.py rename to pymesh/lib/statistics.py diff --git a/lib/pymesh/main.py b/pymesh/main.py similarity index 100% rename from lib/pymesh/main.py rename to pymesh/main.py From 51f3614395f6be653b7e94503d56cf4e33603ae7 Mon Sep 17 00:00:00 2001 From: Catalin Ioana Date: Mon, 4 Nov 2019 12:31:15 +0200 Subject: [PATCH 30/92] [Pymesh] Moved Pymesh lib --- pymesh/{ => pymesh_frozen}/README.md | 0 pymesh/{ => pymesh_frozen}/copy_fw.sh | 0 pymesh/{ => pymesh_frozen}/lib/ble_rpc.py | 0 pymesh/{ => pymesh_frozen}/lib/ble_services.py | 0 pymesh/{ => pymesh_frozen}/lib/cli.py | 0 pymesh/{ => pymesh_frozen}/lib/loramesh.py | 0 pymesh/{ => pymesh_frozen}/lib/mesh_interface.py | 0 pymesh/{ => pymesh_frozen}/lib/mesh_internal.py | 0 pymesh/{ => pymesh_frozen}/lib/meshaging.py | 0 pymesh/{ => pymesh_frozen}/lib/msgpack/__init__.py | 0 pymesh/{ => pymesh_frozen}/lib/msgpack/_version.py | 0 pymesh/{ => pymesh_frozen}/lib/msgpack/exceptions.py | 0 pymesh/{ => pymesh_frozen}/lib/msgpack/fallback.py | 0 pymesh/{ => pymesh_frozen}/lib/pymesh.py | 0 pymesh/{ => pymesh_frozen}/lib/pymesh_config.py | 0 pymesh/{ => pymesh_frozen}/lib/pymesh_debug.py | 0 pymesh/{ => pymesh_frozen}/lib/statistics.py | 0 pymesh/{ => pymesh_frozen}/main.py | 0 18 files changed, 0 insertions(+), 0 deletions(-) rename pymesh/{ => pymesh_frozen}/README.md (100%) rename pymesh/{ => pymesh_frozen}/copy_fw.sh (100%) rename pymesh/{ => pymesh_frozen}/lib/ble_rpc.py (100%) rename pymesh/{ => pymesh_frozen}/lib/ble_services.py (100%) rename pymesh/{ => pymesh_frozen}/lib/cli.py (100%) rename pymesh/{ => pymesh_frozen}/lib/loramesh.py (100%) rename pymesh/{ => pymesh_frozen}/lib/mesh_interface.py (100%) rename pymesh/{ => pymesh_frozen}/lib/mesh_internal.py (100%) rename pymesh/{ => pymesh_frozen}/lib/meshaging.py (100%) rename pymesh/{ => pymesh_frozen}/lib/msgpack/__init__.py (100%) rename pymesh/{ => pymesh_frozen}/lib/msgpack/_version.py (100%) rename pymesh/{ => pymesh_frozen}/lib/msgpack/exceptions.py (100%) rename pymesh/{ => pymesh_frozen}/lib/msgpack/fallback.py (100%) rename pymesh/{ => pymesh_frozen}/lib/pymesh.py (100%) rename pymesh/{ => pymesh_frozen}/lib/pymesh_config.py (100%) rename pymesh/{ => pymesh_frozen}/lib/pymesh_debug.py (100%) rename pymesh/{ => pymesh_frozen}/lib/statistics.py (100%) rename pymesh/{ => pymesh_frozen}/main.py (100%) diff --git a/pymesh/README.md b/pymesh/pymesh_frozen/README.md similarity index 100% rename from pymesh/README.md rename to pymesh/pymesh_frozen/README.md diff --git a/pymesh/copy_fw.sh b/pymesh/pymesh_frozen/copy_fw.sh similarity index 100% rename from pymesh/copy_fw.sh rename to pymesh/pymesh_frozen/copy_fw.sh diff --git a/pymesh/lib/ble_rpc.py b/pymesh/pymesh_frozen/lib/ble_rpc.py similarity index 100% rename from pymesh/lib/ble_rpc.py rename to pymesh/pymesh_frozen/lib/ble_rpc.py diff --git a/pymesh/lib/ble_services.py b/pymesh/pymesh_frozen/lib/ble_services.py similarity index 100% rename from pymesh/lib/ble_services.py rename to pymesh/pymesh_frozen/lib/ble_services.py diff --git a/pymesh/lib/cli.py b/pymesh/pymesh_frozen/lib/cli.py similarity index 100% rename from pymesh/lib/cli.py rename to pymesh/pymesh_frozen/lib/cli.py diff --git a/pymesh/lib/loramesh.py b/pymesh/pymesh_frozen/lib/loramesh.py similarity index 100% rename from pymesh/lib/loramesh.py rename to pymesh/pymesh_frozen/lib/loramesh.py diff --git a/pymesh/lib/mesh_interface.py b/pymesh/pymesh_frozen/lib/mesh_interface.py similarity index 100% rename from pymesh/lib/mesh_interface.py rename to pymesh/pymesh_frozen/lib/mesh_interface.py diff --git a/pymesh/lib/mesh_internal.py b/pymesh/pymesh_frozen/lib/mesh_internal.py similarity index 100% rename from pymesh/lib/mesh_internal.py rename to pymesh/pymesh_frozen/lib/mesh_internal.py diff --git a/pymesh/lib/meshaging.py b/pymesh/pymesh_frozen/lib/meshaging.py similarity index 100% rename from pymesh/lib/meshaging.py rename to pymesh/pymesh_frozen/lib/meshaging.py diff --git a/pymesh/lib/msgpack/__init__.py b/pymesh/pymesh_frozen/lib/msgpack/__init__.py similarity index 100% rename from pymesh/lib/msgpack/__init__.py rename to pymesh/pymesh_frozen/lib/msgpack/__init__.py diff --git a/pymesh/lib/msgpack/_version.py b/pymesh/pymesh_frozen/lib/msgpack/_version.py similarity index 100% rename from pymesh/lib/msgpack/_version.py rename to pymesh/pymesh_frozen/lib/msgpack/_version.py diff --git a/pymesh/lib/msgpack/exceptions.py b/pymesh/pymesh_frozen/lib/msgpack/exceptions.py similarity index 100% rename from pymesh/lib/msgpack/exceptions.py rename to pymesh/pymesh_frozen/lib/msgpack/exceptions.py diff --git a/pymesh/lib/msgpack/fallback.py b/pymesh/pymesh_frozen/lib/msgpack/fallback.py similarity index 100% rename from pymesh/lib/msgpack/fallback.py rename to pymesh/pymesh_frozen/lib/msgpack/fallback.py diff --git a/pymesh/lib/pymesh.py b/pymesh/pymesh_frozen/lib/pymesh.py similarity index 100% rename from pymesh/lib/pymesh.py rename to pymesh/pymesh_frozen/lib/pymesh.py diff --git a/pymesh/lib/pymesh_config.py b/pymesh/pymesh_frozen/lib/pymesh_config.py similarity index 100% rename from pymesh/lib/pymesh_config.py rename to pymesh/pymesh_frozen/lib/pymesh_config.py diff --git a/pymesh/lib/pymesh_debug.py b/pymesh/pymesh_frozen/lib/pymesh_debug.py similarity index 100% rename from pymesh/lib/pymesh_debug.py rename to pymesh/pymesh_frozen/lib/pymesh_debug.py diff --git a/pymesh/lib/statistics.py b/pymesh/pymesh_frozen/lib/statistics.py similarity index 100% rename from pymesh/lib/statistics.py rename to pymesh/pymesh_frozen/lib/statistics.py diff --git a/pymesh/main.py b/pymesh/pymesh_frozen/main.py similarity index 100% rename from pymesh/main.py rename to pymesh/pymesh_frozen/main.py From 16d5c896a8468bfad14e45e69b7f084d9e4b5569 Mon Sep 17 00:00:00 2001 From: Catalin Ioana Date: Mon, 4 Nov 2019 12:32:32 +0200 Subject: [PATCH 31/92] [Pymesh] Added GPS feature --- pymesh/pymesh_frozen/lib/ble_rpc.py | 9 ++- pymesh/pymesh_frozen/lib/ble_services.py | 2 - pymesh/pymesh_frozen/lib/cli.py | 38 +++++++---- pymesh/pymesh_frozen/lib/gps.py | 83 ++++++++++++++++++++++++ pymesh/pymesh_frozen/lib/loramesh.py | 15 +++-- pymesh/pymesh_frozen/lib/pymesh.py | 1 + pymesh/pymesh_frozen/lib/pymesh_debug.py | 2 +- 7 files changed, 126 insertions(+), 24 deletions(-) create mode 100644 pymesh/pymesh_frozen/lib/gps.py diff --git a/pymesh/pymesh_frozen/lib/ble_rpc.py b/pymesh/pymesh_frozen/lib/ble_rpc.py index 4331a5f..7b64366 100644 --- a/pymesh/pymesh_frozen/lib/ble_rpc.py +++ b/pymesh/pymesh_frozen/lib/ble_rpc.py @@ -24,6 +24,11 @@ except: from _pymesh_config import PymeshConfig +try: + from gps import Gps +except: + from _gps import Gps + class BleRpc: def __init__(self, config, mesh): @@ -223,9 +228,9 @@ def mesh_ip(self): ip = self.mesh.ip() return ip - def set_gps(self, lng, lat): + def set_gps(self, latitude, longitude): print('settings gps!') - # Gps.set_location(lat, lng) + Gps.set_location(latitude, longitude) # with open('/flash/gps', 'w') as fh: # fh.write('{};{}'.format(lng, lat)) diff --git a/pymesh/pymesh_frozen/lib/ble_services.py b/pymesh/pymesh_frozen/lib/ble_services.py index 42e871f..3959c5e 100644 --- a/pymesh/pymesh_frozen/lib/ble_services.py +++ b/pymesh/pymesh_frozen/lib/ble_services.py @@ -25,8 +25,6 @@ def _init(self): } bluetooth = Bluetooth(modem_sleep=False) - # bluetooth = Bluetooth() - # bluetooth.set_advertisement(name='PyGo (mac:' + str(self.mesh_mac) + ')', service_uuid=0xec00) adv_name = self.ble_name bluetooth.set_advertisement(name=adv_name, service_uuid=0xec00) print("BLE name:", adv_name) diff --git a/pymesh/pymesh_frozen/lib/cli.py b/pymesh/pymesh_frozen/lib/cli.py index a9feadb..8f83e48 100644 --- a/pymesh/pymesh_frozen/lib/cli.py +++ b/pymesh/pymesh_frozen/lib/cli.py @@ -15,6 +15,11 @@ except: from _pymesh_debug import print_debug +try: + from gps import Gps +except: + from _gps import Gps + __version__ = '1' """ * initial draft @@ -41,7 +46,9 @@ def process(self, arg1, arg2): while True: time.sleep(.1) cmd = input('>') - # print(cmd) + # cmd = " " + # time.sleep(3) + # print("cli") # if cmd == 'rb': # print('resetting unpacker buffer') @@ -118,14 +125,16 @@ def process(self, arg1, arg2): elif cmd == 'rm': print(self.mesh.get_rcv_message()) - # elif cmd == 'gg': - # print("Gps:", (Gps.lat, Gps.lon)) - - # elif cmd == 'gs': - # lat = float(input('(lat)<')) - # lon = float(input('(lon)<')) - # Gps.set_location(lat, lon) - # print("Gps:", (Gps.lat, Gps.lon)) + elif cmd == 'gps': + try: + lat = float(input('(lat [Enter for read])<')) + lon = float(input('(lon)<')) + except: + print("Gps:", (Gps.lat, Gps.lon)) + continue + + Gps.set_location(lat, lon) + print("Gps:", (Gps.lat, Gps.lon)) elif cmd == 'sleep': try: @@ -163,11 +172,11 @@ def process(self, arg1, arg2): # res = self.mesh.statistics_get(id) # print("ok? ", res) - # elif cmd == "rst": - # print("Mesh Reset NVM settings ... ") - # self.mesh.mesh.mesh.mesh.deinit() - # if self.sleep: - # self.sleep(1) + elif cmd == "rst": + print("Mesh Reset NVM settings ... ") + self.mesh.mesh.mesh.mesh.deinit() + if self.sleep: + self.sleep(1) # elif cmd == "pyb": # # print("Pybytes debug menu, Pybytes connection is ", Pybytes_wrap.is_connected()) @@ -262,6 +271,7 @@ def process(self, arg1, arg2): print("ot - sends command to openthread internal CLI") print("debug - set debug level") print("config - print config file contents") + print("gps - get/set location coordinates") except KeyboardInterrupt: print('cli Got Ctrl-C') diff --git a/pymesh/pymesh_frozen/lib/gps.py b/pymesh/pymesh_frozen/lib/gps.py new file mode 100644 index 0000000..956c5a2 --- /dev/null +++ b/pymesh/pymesh_frozen/lib/gps.py @@ -0,0 +1,83 @@ + +# Copyright (c) 2019, Pycom Limited. +# +# This software is licensed under the GNU GPL version 3 or any +# later version, with permitted additional terms. For more information +# see the Pycom Licence v1.0 document supplied with this file, or +# available at https://www.pycom.io/opensource/licensing + +__version__ = '1' +""" +* initial version +""" + +import time +# from pytrack import Pytrack +# from L76GNSS import L76GNSS +from machine import Timer + +class Gps: + # Pycom office GPS coordinates + lat = 51.45 + lon = 5.45313 + + l76 = None + _timer = None + #is_set = False + + @staticmethod + def set_location(latitude, longitude): + dlat = str(type(latitude)) + dlon = str(type(longitude)) + if dlat == dlon == "": + Gps.lat = latitude + Gps.lon = longitude + is_set = True + else: + print("Error parsing ", latitude, longitude) + + @staticmethod + def get_location(): + return (Gps.lat, Gps.lon) + + # @staticmethod + # def init_static(): + # is_pytrack = True + # try: + # py = Pytrack() + # Gps.l76 = L76GNSS(py, timeout=30) + # #l76.coordinates() + # Gps._timer = Timer.Alarm(Gps.gps_periodic, 30, periodic=True) + # print("Pytrack detected") + # except: + # is_pytrack = False + # print("Pytrack NOT detected") + # #TODO: how to check if GPS is conencted + # return is_pytrack + + # @staticmethod + # def gps_periodic(alarm): + # t0 = time.ticks_ms() + # coord = Gps.l76.coordinates() + # if coord[0] != None: + # Gps.lat, Gps.lon = coord + # print("New coord ", coord) + # dt = time.ticks_ms() - t0 + # print(" =====>>>> gps_periodic ", dt) + + # @staticmethod + # def terminate(): + # if Gps._timer is not None: + # Gps._timer.cancel() + # pass + +""" +from pytrack import Pytrack +from L76GNSS import L76GNSS +py = Pytrack() +l76 = L76GNSS(py, timeout=30) +t0 = time.ticks_ms() +l76.coordinates() +y = time.ticks_ms() - t0 +y +""" diff --git a/pymesh/pymesh_frozen/lib/loramesh.py b/pymesh/pymesh_frozen/lib/loramesh.py index 017ecbf..095a243 100644 --- a/pymesh/pymesh_frozen/lib/loramesh.py +++ b/pymesh/pymesh_frozen/lib/loramesh.py @@ -20,6 +20,11 @@ except: from _pymesh_debug import print_debug +try: + from gps import Gps +except: + from _gps import Gps + __version__ = '6' """ __version__ = '6' @@ -274,7 +279,7 @@ def neighbors_update(self): self.router_data.rloc16 = self.rloc16 self.router_data.role = self.state self.router_data.ts = time.time() - self.router_data.coord = (1,2) #Gps.get_location() + self.router_data.coord = Gps.get_location() for nei_rec in x: # nei_rec = (role=3, rloc16=10240, rssi=0, age=28, mac=5) @@ -452,7 +457,7 @@ def node_info_get(self, mac): data['a'] = node.age elif role is self.STATE_ROUTER: data['a'] = time.time() - node.ts - data['l'] = {'lng':node.coord[1], 'lat':node.coord[0]} + data['l'] = {'lat':node.coord[0], 'lng':node.coord[1]} data['nn'] = node.neigh_num() nei_macs = node.get_macs_set() data['nei'] = list() @@ -534,7 +539,7 @@ def __init__(self, data = None): self.ts = 0 self.dict = {} self.pack_index_last = 0 - self.coord = (0.0, 0.0) + self.coord = Gps.get_location() if data is None: return @@ -624,8 +629,8 @@ def as_dict(self): dict['ip'] = self.rloc16 dict['role'] = self.role dict['age'] = time.time() - self.ts - dict['loc'] = self.coord[0] - dict['ble'] = self.coord[1] + dict['loc'] = {"lat":self.coord[0], "lng":self.coord[1]} + dict['ble'] = "ble" return dict def get_all_pairs(self): diff --git a/pymesh/pymesh_frozen/lib/pymesh.py b/pymesh/pymesh_frozen/lib/pymesh.py index 478fe1b..52e9d91 100644 --- a/pymesh/pymesh_frozen/lib/pymesh.py +++ b/pymesh/pymesh_frozen/lib/pymesh.py @@ -102,6 +102,7 @@ def process(self, arg1, arg2): # Pybytes_wrap.process() time.sleep(.5) + # time.sleep(1) # print("loop") pass diff --git a/pymesh/pymesh_frozen/lib/pymesh_debug.py b/pymesh/pymesh_frozen/lib/pymesh_debug.py index aa5167d..c2406c1 100644 --- a/pymesh/pymesh_frozen/lib/pymesh_debug.py +++ b/pymesh/pymesh_frozen/lib/pymesh_debug.py @@ -8,7 +8,7 @@ import pycom -# debug level from the most verbose to off +# recommended debug levels, from the most verbose to off DEBUG_DEBG = const(5) DEBUG_INFO = const(4) DEBUG_NOTE = const(3) From 6f6dbb4d8630abae1212cec659e21c2d471e96f2 Mon Sep 17 00:00:00 2001 From: Catalin Ioana Date: Mon, 4 Nov 2019 12:34:19 +0200 Subject: [PATCH 32/92] [Pymesh] Commented-out Child forcing --- pymesh/pymesh_frozen/main.py | 18 +++++++++++------- 1 file changed, 11 insertions(+), 7 deletions(-) diff --git a/pymesh/pymesh_frozen/main.py b/pymesh/pymesh_frozen/main.py index 2e0f838..a22bd2f 100644 --- a/pymesh/pymesh_frozen/main.py +++ b/pymesh/pymesh_frozen/main.py @@ -18,7 +18,11 @@ def new_message_cb(rcv_ip, rcv_port, rcv_data): print(rcv_data) # user code to be inserted, to send packet to the designated Mesh-external interface - # ... + for _ in range(3): + pycom.rgbled(0x888888) + time.sleep(.2) + pycom.rgbled(0) + time.sleep(.1) return @@ -30,11 +34,11 @@ def new_message_cb(rcv_ip, rcv_port, rcv_data): #initialize Pymesh pymesh = Pymesh(pymesh_config, new_message_cb) -mac = pymesh.mac() -if mac > 10: - pymesh.end_device(True) -elif mac == 5: - pymesh.leader_priority(255) +# mac = pymesh.mac() +# if mac > 10: +# pymesh.end_device(True) +# elif mac == 5: +# pymesh.leader_priority(255) while not pymesh.is_connected(): print(pymesh.status_str()) @@ -58,7 +62,7 @@ def new_message_cb(rcv_ip, rcv_port, rcv_data): # pymesh.br_set(PymeshConfig.BR_PRIORITY_NORM, new_br_message_cb) # remove Border Router function from current node -#pymesh.br_remove() +# pymesh.br_remove() # send data for Mesh-external, basically to the BR # ip = "1:2:3::4" From 73f4a7fbf8a8d50d0b3b368960c64397f3265e3a Mon Sep 17 00:00:00 2001 From: Catalin Ioana Date: Mon, 4 Nov 2019 12:36:56 +0200 Subject: [PATCH 33/92] [Pymesh] Docs directed into docs.pycom.io --- pymesh/pymesh_frozen/README.md | 163 --------------------------------- 1 file changed, 163 deletions(-) diff --git a/pymesh/pymesh_frozen/README.md b/pymesh/pymesh_frozen/README.md index d57a12c..a9f0fa6 100644 --- a/pymesh/pymesh_frozen/README.md +++ b/pymesh/pymesh_frozen/README.md @@ -6,166 +6,3 @@ These scripts were created and tested on Lopy4 and Fipy, using the Pymesh binary Official Pymesh docs: https://docs.pycom.io/pymesh/ Forum Pymesh announcements: https://forum.pycom.io/topic/4449/pymesh-updates - -## Overview -These scripts were created to prototype different features of Pymesh. - -They are quite monolithic, as they were developed on par with firmware Pymesh development. Multiple improvement are foreseen to be further performed, into areas like modularity (BLE RPC is the main candidate). Also lots of code is executed in micropython threads, which have limited memory (they should be moved in the *main loop*). Maybe queues for RX/TX on Pymesh should be added, with automatic retransmissions until ACK. - -### Important features -* Start Pymesh over LoRa on 863Mhz, bandwidth 250kHz, spreading-factor 7 (check `pymesh_config.py` defaults). -* Pymesh parameters are automatically saved in NVM, so in the next restart/deepsleep, the node will try to maintain its IP addresses and connections with neighbour nodes. -* Start BLE server with name `PyGo (mac: ` - * BLE is used with an RPC protocol, packed using `msgpack` library . -* Internal CLI for controlling/triggering Pymesh features, as explained bellow. - -## Color coding LED - -The LED color represents the state of the node in the Mesh network. - - Magenta - LEADER - Green - ROUTER - White - CHILD, - Red - Searching / Detached from any Pymesh - Cyan - SINGLE LEADER (no other Router in the same Pymesh) - -## Internal CLI - -``` -List of available commands -ip - display current IPv6 unicast addresses -mac - set or display the current LoRa MAC address -self - display all info about current node -mml - display the Mesh Mac List (MAC of all nodes inside this Mesh), also inquires Leader -mp - display the Mesh Pairs (Pairs of all nodes connections), also inquires Leader -s - send message -ws - verifies if message sent was acknowledged -rm - verifies if any message was received -sleep - deep-sleep -br - enable/disable or display the current Border Router functionality -brs - send packet for Mesh-external, to BR, if any -rst - reset NOW, including NVM Pymesh IPv6 -buf - display buffer info -ot - sends command to openthread internal CLI -debug - set debug level -config - print config file contents -``` - -``` ->mac -1 -``` -Shows LoRa MAC, this address is used as unique identifier in the Pymesh. Bellow there's a section on how to set MAC specific MAC address (useful for debugging, the MAC could be consecutive small numbers like `0x1`, `0x2`, `...`) - -``` ->mml -mesh_mac_list [1, 6, 2] -``` -Shows the list of all MAC Nodes included into Pymesh. Inquires Leader if doesn't have this info (or if too old). In about 5 sec, a new call will return the latest list. - -``` ->mp -Send pack: 0xF3 to IP fdde:ad00:beef:0:0:ff:fe00:fc00 -last_mesh_pairs [[2, 6, -87], [1, 6, -77]] -``` -Shows Mesh Pairs list, with each direct connected nodes (by their MAC address) and the averaged RSSI value. - -``` ->mni -last_mesh_node_info {1: {"ip": 2048, "l": {"lng": 5.45313, "lat": 51.45}, "a": 10, "r": 3, "nn": 1, "nei": [[6, 55296, 3, -76, 23]]}, 6: {"ip": 55296, "l": {"lng": 5.45313, "lat": 51.45}, "a": 7, "r": 3, "nn": 2, "nei": [[2, 50176, 3, -89, 28], [1, 2048, 3, -77, 23]]}, 2: {"ip": 50176, "l": {"lng": 5.45313, "lat": 51.45}, "a": 7, "r": 3, "nn": 1, "nei": [[6, 55296, 3, -86, 25]]}} -``` -Shows the properties for all the nodes in this Pymesh, together with its neighbors. - -``` ->s -(to)<1 -(txt)>>>>>>> -Added new message for 1: Hello World! -Send pack: 0x10 to IP fdde:ad00:beef:0::1 -True ->Incoming 13 bytes from fdde:ad00:beef:0:f67b:3d1e:f07:8341 (port 1234): -PACK_MESSAGE_ACK received -1945883 ================= ACK RECEIVED :) :) :) -``` -Sends text messages to another Node inside Pymesh. The messaging waits for ACK from the destination node. If not received, it's resent after minimum 15 seconds. - -*Sorry for the messy output and debug info.* - -``` -ws -(to)<1 -ACK? mac 1, id 12345 => 1 -True -``` -Shows if a message was acknowledged by the destination Node. - -``` ->rm -{'b': (b'Hello World!',), 'id': 12345, 'ts': 3301, 'from': 6} -``` -Shows the received messages. - -``` -f -(MAC to)<1 -(packsize)<500 -(filename, Enter for dog.jpg)< -... -Incoming 6 bytes from fdde:ad00:beef:0:160b:8542:2190:c864 (port 1234): -PACK_FILE_SEND_ACK received -6165 Bytes sent, time: 27 sec -Done sending 6165 B in 27 sec -``` - -*DISABLED* - -Sends a file already stored in `/flash` (by default `/flash/dog.jpg`), specifying to which Node and in what chunk size (it can't be bigger than 500 Bytes, limit set in firmware). - -At destination, the file is stored as `/flash/dog_rcv.jpg`. -Picture files could be stored on Lopy4/Fipy using either Pymakr (over USB) or FTP. - -*The file transfer is done naively, the file is not checked at destination, nor individual chunks right order is not verified. These should be addressed in further improvements.* - -``` ->gs -(lat)<2.3 -(lon)<4.5 -Gps: (2.3, 4.5) -``` - -*DISABLED* - -Sets localisation coordinates; useful where no Pytrack is used. - -``` ->gg -Gps: (2.2, 1.1) -``` - -*DISABLED* - -Shows latest GPS coordinates. - -``` -> rst -1 -``` -Resets the Pymesh parameters saved in NVM, and resets the Node. - -``` -> rb -``` - -*DISABLED* - -### New commands to be detailed - -* sleep - deep-sleep -* br - enable/disable or display the current Border Router functionality -* brs - send packet for Mesh-external, to BR, if any -* rst - reset NOW, including NVM Pymesh IPv6 -* buf - display buffer info -* ot - sends command to openthread internal CLI -* debug - set debug level -* config - print config file contents From 0a7fff776fefe6132fcbacc4bbbc3538906d280c Mon Sep 17 00:00:00 2001 From: Catalin Ioana Date: Mon, 4 Nov 2019 12:42:09 +0200 Subject: [PATCH 34/92] [Pymesh] Added Pymesh mobile apps --- pymesh/mobile_app/README.md | 18 ++++++++++++++++++ pymesh/mobile_app/app-release.apk | Bin 0 -> 7708235 bytes 2 files changed, 18 insertions(+) create mode 100644 pymesh/mobile_app/README.md create mode 100644 pymesh/mobile_app/app-release.apk diff --git a/pymesh/mobile_app/README.md b/pymesh/mobile_app/README.md new file mode 100644 index 0000000..9d6e426 --- /dev/null +++ b/pymesh/mobile_app/README.md @@ -0,0 +1,18 @@ + +# Pymesh mobile application + +For demonstrating **Pymesh** features, a mobile application was created. + +It is available for both Android and iOS platforms. + +## Android application + +It is available as `.apk` packet in this directory. + +# iOS mobile application + +Pymesh mobile application is released currently (v0.) as Beta testing, on Apple TestFlight (to be installed for free from App Store). + +Pymesh app can be added afterwards, using the link: https://testflight.apple.com/join/PIxwbTKp + +Requirements: iOS minimum version v12.1 diff --git a/pymesh/mobile_app/app-release.apk b/pymesh/mobile_app/app-release.apk new file mode 100644 index 0000000000000000000000000000000000000000..f48718c02c4e60c509db9099906c90aa02d296a4 GIT binary patch literal 7708235 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 z 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
  • W`< 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≻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

    xT-!tO1Ha-fx_soyiSG) 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%0D3&t<<_HhbJgk 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

    L^0gGu%j=vCPZT8| zbIvA;6(?zlLJw3K4?-dn#eh_*#t`%NKq4!8j3}tObqG~t81fOow^eq*0t>Nm&X)HpCWJ3-q+RkUK!xze`6^F4|X)4j~TM_m8C^ z+C|68aF!@A?w)e%c_IHh19q-r4Dg)*&f@1<#hQKzHOQ6Whg#(tcUkc+3bV>UFkV|- z6b`b{^GyD=3e;kip8ch$V8wL9cnUU640@XmXr!51*kFK6iBlQ$Iox)8Pz4-DqKI$Hy`n5 zScUuNBl0!Tc#+|vtm_oyT1AVIv@93pC__F(9#GFb1WH@0?#Z=DSxVQ*RadE~>MttqJr|U^Z!*U)LQ_>;V5c%4HP= zE^>lRDu-Zh>2PaZ_dsa?`01q2DsH;S%f*7sZkDVG%&K->!2DM8p#?~zB**J|E0h+_ zFk_3P%_@5T!~DXeRrHy9hgI~OdZ$$kn0l9046)v86-6%UMo3W~%a(oSq#ji`6JZ zp{zg<)TDIl9B{0R*-v*&!i1BIpoXZ`pPHwU`e@-G%ZO~o5{(k zrSxk{Mv|y8larSu>RHc85{)j(R*pb?F3P<2k)I^orjHv*qQTS)l7z?93*pJsOOk~D z7rX}LUlJjhjc#=X+&vD5?0n-@c0<+_nQ%AHIypgq@92AbwGLz$eH^M8GnB$ z{yJQ(1rDF6H>U@`8b2RD2*p40zv8ziiS++dX>9IzlZ1^Ekj>xnhKGb1MB{?u1Xd5# zJ&%RrY`|4Fusx*idE%>a?s>@*igW6J#pz2D)8;+jix)G$RL5dwLIF3zqn`_!-=}GY z(!?3?kqm0?tC2)BQA;S2h5r>v(kW&BpOo*1{uP>fr6xeJc51z@lWj@j)|H`8CW$iE zyOPARi`wC+Q2l233Ht3MvvUUNQDgu$1l=}B>IasqA;|_qjcVOR!-~MNf$o{_=K~o! z*qAb1?y|e_P~adFp%Au1cM7umziw_SNlcl^o)aN@-T=XOOVJDYM?SE$Wc36BA`|Gbs!ujGHc+k#p#b6r(0iadgfnEJVUeULL@wNPOOZPe z#n%bAn=Gb(W!BVWF>C50$WPYq!)Xc7hz9TgvXt*prK6~U%B}+{PZmq2=ZDE++0-kO z#lf$FsM(L<_7TuQgw2uRO*w(2^;EgsaC~chp+)Y%-Wog4!{Y$ z1+p0^K$4m`naOG?Bflt{EW&=>|0hKnl7;qb^?5BzewQ zP=eb`@hZd$koRBO)jH%_vYG^MB@3&YHo-FX)NUT=whDL`Vh4D_ufIX=0WRo=oSPgL zy4YjLBj60haSC|?*x}}!uK|~Tz$%mD0&?K~5;6#+Vf7iFf{8p3;7t|_6fH%aaF$=r zOA+2*Pw{I~QMeij?0<>w9Wsk`)VmnSXrPLpp2b0l1-$%0{RAlSDMJ2c?aB%z5g3|< zB^gQ*aKisfOikgl!0K=aL|O`;h~S+;C>cQE0UYH*$pJ=DmGU9;fc2kiQ9F78v>VF% zO?C||B3ZW}i-4VXwdfta7}{;=C~-%>mm(_MbQg4&|4nfpN(nI7{anl1(H}r9<$w@V zIb<17G5t(?yrWk@eF%*IL#x`+A3>{3ku|htN3VkR7?}U3c2xse4K%%}E$`@c&}xCX z4x?e#r-3FWWJhm;*2q>AVoQps zcT+QGH?pfkvUac*wT=O6O))oOLE0qIcJ(eOohj=5q8`X@U{;+BjccG@<)cQykb&w5wUj85RCK z=LpdCfp)dXPJvr*$VAxOw3K4DLc5!m601=GRk1_$TT|C{8zRqzL1$DEd~) z^^2q16azQiyZR0ay^gk(E8i)(-L#uxZgA|@(Y_)hiNfoq1I`iNJUmKadMIu4yZTv* zu+-D3ath*i(=o^zfB4`cMMT!qxw64uvzr23QGY5;EpF2ko+{ehbP3{mA>Y0S(^91= zGF5cA$pR91Q~K(3Q2DU-bKqPSGEL+W>%eX5DmCky{W&z%iP4G30HaoA)#CLb(ID`G^qYJs|ci?f#x#3hh3yjmlRB`2eUK zH`-x&su=$yd&W3j@GwYM{Ymwt!75Y5%qPhcyjz(nF8uTe!L;+Y0;?sh zN)1)Gnp83W$uUoK>u|A_Q~8N@WrM6wRonIsNIOu)_-X(Zf*KK%J>( z`vU0-kwZ6iE7A+m1DyP~@v3{OuzuQYyyD%TDv~~pH^@M$Nd0u@r3`u7O@r5YF_bEz zKZ|ZPa(g&cWPKWG_JJd*BIYw^i@`=y#qG}yeq%gdNEOAO)%-@zC1M(BTm?7@F~M2K zC#|NTOaZHFMgTML^J%^DE&kb5QS#}dH?>{l930I7H~tg74CDeZX1s8@i*DvRvCFCA z;im_0Nz0y_o?Kg2Qbon5gGSh^siN}J+Xh)n6^}mUN3|Ppy$;wWj25(+D(s&I%vb-m zQibEwc9U(V3g@Ti=4$~vslxSXyUBJ_h5OS}KHY$LNPpX*wH2d3_0Hk380L1h6Gc0KW^JxvV zU9AvRo;9~k$44G+S`_uA&8ILE@#LlOE|1ggGr-|K9FaM4y0i5T2#YE`(A4O`}$2>F9a6Q`Udy)TTqJtw^7Y+r-}IAwi|~r ziqk~mZ|xZ7?!m>~H1(Q5K32A+&>b2oK^c?>Y5e&FRdEs;%mpYW-PVS$tiF;P%+=RJ zxGx8`PEm0xp;Q2YiZ^8dsb38s{i^|Fh5~pD_m4Qu>U6^j`kyqj0cSN(waWIoGyzfz z(xm?8mG7r|WwJxqfL0W@lWzsUDDQ@FDb)kf03cWV5I!LIn$~upH$iJmQx9%hAe+

    {;!rO`0k5f`_fhccQk^{1L9oEw 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

    Oa2SSmjO(hETJp%u%zjQ&Q9Dp`s*y9Zu_Zt@faM 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�d_entcgeqQ+*_A}&X(9cUh1AhAb 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

    ;Cz>^I#+v)HIx`}2l?(9CA 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�%u3u)unqEG^SNO(};ehF06Cm z^)T4u-eBA1n9DtYIV)g41HD3rvQDVFk&FX^MtJsxoy}?+C-Z6Or>nPf|2K3`A?5NB zyae^k4tT$}Z$+pB-tR4u>m87PCf?Q2^ShTs=0H|-c$Wh>mxnp&B)nraLV%C5JAqQo zH{g-4dG3BO#&jBE#uDQ^%jp*MQO9~Do{(JE0pG2lcPpiL^GP>An9SW;7qQ;?)V^9; zFW!$D(bpV5j0tBH_gx@Xftc(tR3H{pOw=dQ9ql2GAdz7#C({C2&1AuV9 zBf$L&GD>;flzagnq7_B-|0oB)L(=1ufJ-gGWu*=-qQ4C2+r?l3bH;rrUD#+Vk?#Pm zH@pM*D%Kr9Ng1P^=*w8uL5q`PJ`)M(G+%^x99%qI>w^&52|djJpva(>jTiY)lC^Ap zT&2~rDMGl=UW!^a@^41uS%4C?U9M6)d5rj15 zz{xf?zFgnu)gD~FLs@S4+l!d(5YGe3c@yK*xxo3M-o))c}@`*pzBt~}n>>%ek+2Wawm+lKwu!#kfrKM#Jv?_NHGe!ReE zPFwxBbKJ^@r;;B=Az6^w8a4SLKV+UC=1M=;mr&1|K{1;hK$g3upC$)7laS*qA#P_w zxGp1mUM&CV2}#-u5A4t>0vq7Ku#9tHoxBaB4%t-a2lGcxQz?e(QH6QMI6)x32 zrms)2I?46CAgyPoJ<|8rnSk%_)V*5#^v--3)Yf#< zYD^VTT))1SRUzmFg&?b;9|H4}#qrP=)gS4Pif}6eU92bQX1-Eqs4wv9{y-ZC0>Add zm_sBz>w{*Hqf03^9cz~zSP`;f?XsoDax~um6`_BdBtzqS1@vBb={;;W4E@SnOI7{$ z2J%aq3i8?(JNI3}c0FNTK9E2A0$=VAe0d=7X+QbP;n;5j&nc4N*n{AR-;1|#IkX@3 zjk4h6gJIP#2;cLQ?`=QwSDLlL%HZwSt)n-sqmOPKI6u_Q^z$1+^Gg)of7ZdfAB{I4 zNqApQ?+ww6}K}KNqM(# z(4E;~@QL!5k^e9HBx>VVgucE!tL4f#<2$7B7t;6+-S~wBPodk?nblWJFrENyf0cQ4 z%m!F7IXa#o@7J;83E2B@#g8X=rYXsIf_%5KBT4@DP7~*ENN;mZ=JAgvo*x9~-F+Ls zPeHzwPUlhe@pEbM+OJv_x}Q}JVmpuSy*~86h>I0*>Q7nC>3A~xvx@fTVT1j7rhokX zS(U*43`=%@TyCW_$^H356Sn~u>*|w*-#ek+fA`is+xBPUSd9rjw{m+5^*x6)al7Jh zqP>;dxV;GZPli7JlyW&ZUFA*q&d6;TC(7Y-lTsZ*dsb!w@uyRRVNW*oF_!wcLDA|) zO={vbt3>Q|ZUTM&7W(v1pEppSw~#->u@f%!F18?nzJ>-hKRef7G~3%>D&40Af9Dha z&NaYaB?0`Mp8)2fCH_EQ#00P~-oCC~wBEjlu4k;d49LBj3Ih~Lhj z-!e#7DO3OF^%czS@_!fPaT2&z7PE};Att%4Cj@zHO>RRu)s84&gV|3_~(hE6J3D&Mm{koUOu7fYCVV!^j$~3RI2S( zd-nB}P$a(&`*O`qsARQj%$*_W@@YHf(~JS`Y@&gkV<^*iJv zm+NGQROA0xZTYkKd9vMV5dYUN{&})*OCbKQv3=qfar~7;4{8nQLHJkk=f5%mdQg+> z{8R9UdbUxs2fXA~V*5jl0sS$Ve1}r~xFwB=-T4l{m|)5?a3{zjgVCo~)$_-w@`=B# zO|ywmJr|TQ@g57?&!v0g_j^Xtr{DF8q)!7(VE@ZTtzHfGS@|n&mvi~VoGXaNRIu@G zdXvY9rGY%3?XO^WCjCmPm~VoubTO+NhkgqV&`}UB!rvF;5i$b{dG0c_gGv4db{ZRX zCyezFG4DBkepkcl6ir3@`M6-ZGDfv`r@=fcO6r3)-|S}mL|fp%e{w#E_f`(jH`u)f z*?;xF8QFjH$o}g}A~xveJxEJwe<*%yfN!DdYxCPijDM<5DRwAXdxq-&w};DbLlL&D z#znM^XQ($2618Tm1k*=Ow#D~{g8AH=Bkda$fMlWcrM18;OM+PoG*?v zq01BcyOn1w$;VecNiZ5I`Ejxu5qMwUznbM$*;BNT)pE@cwLvIPp}_0rJs=N`quN70 z)G2Et-oum&P7Pm6|K%myar{Joo1vZk1Q{dz*hpd1Wm6Q2~B7 zps$u%pQ(zSosA=PKBxW#faBGTX|CrQW#3eLNll~0yH@gjA7ki?krT`J-OF|0cz0iC z@8SM@@}3O=++Y5&yJd*7VSfwy2af{%z-sJYhcpD?G_|9aGxRdVCD;qJXKsC?j>$>* zeLLM1eh_p;_+BzQC_O{F&8Dwi1ZVDtSzwm`_bV>Dp-mFyupSia`$F0XHi}pcCW(e(@bcO z^HV7P5BKjDlf9ckbDTo<j-#tgpDeOT>R5tZyaRPQaGsS0oZS4FqT0Zs~)vH85N20SVUPXMr z257#&CiLwkT%YukyoG0PB*ug?nR*oWuSMQ&qW}KwOKw|KV}9Vg;CmR;JKn#L{f_Z0 zg;bO9@CoiShj!;1OlZ!{*r!^fc?_PFPF|2Vo&IX3|BP2=!h7SQ-uolGhvQ+}RehrE z&WyJ;aJ#ctvO6F1bGg7v^1GnP*nVdW*!@$$j^67@`Ka-(5b1caxHmH3b<^(RysoFH zeHepJoCE6;wBk;ab?r7-SMAml5%cR!_X~I4?TT2hxX&D{lM8#2tzV`yXyez~SEzRv zb#Y{G$zL{U`$W!{QTB-l`MdkMi%vPOoE8hCw==R%m*{T*^>?{0zVXRf3EWR#;#OWx!oDhEUeb8H#5(-Ej>#@pGzGkK8#BCE zw-@7Ccnk&R_rN#`%q2Wvn?8=>ipEOUT+mS#uo`ceZyIABCYLPZ`csLM`Qcp3;+!?P z>r%iwqzOO%)JD3IC)7jA<@h&%n^n?zn7$;(wRlB-fae-3(O($kuT3I9fG!t*cU>-i zALZh=mzJ}*cq_BB#>VsAyThJhvYj$r@A-~u&LNa%5J$dT&V3)nT4KdZRDcdOVi(VM zUjcg5ZrT6+8n@z4kUx)t{Tu;2PV6cA!(Rk@>VVJQ=;!IZqNyBIoo6^)&)>!qHIg8R z==>5vL??PnLqrfIdWpLF>Z|Tb2+@1*MDM*@y|a2}_0`*AvAg#1fBC#P*L7yjT=VYC zIrE+SzCTwJglMs+S5>V9R}JP)R*w#qJUI`6dofYa=h(*ncm9~_a;XR2boaPOwGah7 z9kPpaX#)1SA8oiLCLZGdq~x0dxWB)k|58WDUqIS5!lK3s{KkJ2I`5gO@NklN!nM*Mm_ zQxieK>M6Yzk~!E=wG=)->L$*MOQ>-|)Hn?*-thpg8V#uEtkxW&yNl8~QS%T0J))n$ z)5SUFe8;UtxSjuQNhF@{d1G;s5izE6;j6G>7CEdCR`hW_;K4Qu`v+P*%crHEkjnhELlRr7}Y-YHF8Z>u9FSjdqDaC0Boo zYLawU@ik$QXZaT#0J4&tSqi#DF;KCkd&6Jw%+@GCcy^v!u*b>qYeN83t@aC)O!^m* zP-kPV-mP?2qLa7@NoV^Ipikcki?9c-C`cs*4q#sg7B1ps5%uj&&62h_v*TT_Da9=i zw^%9ybg@j~D|_C`2L|{525rD2!>*+U(b2EZ^MN^;jQ7|eBeIS45`ou0jyV85H<%d1X%U;JxjZYF09`edME$S;reHd<)<_T1!g@w-~SkQVx=on?A|GT zf%IaYPYoC$=Q1}=iH&eVo@g9^KGIA1oMQF_^+WL(wE?>Z2UU-v&<#ZBw#cg%wgqha z(<@0r+}|Zxr7_u$?Lh7pO=NTw1TMpW&Rh-83%*e_ha@y+eolmKpcM_~mgZIQtdA#{ zg3*eM*f_M}h}SD8+2B4^VcFn1*ysCBpV?*AoMUwtS&|zcNHktM1X(nKFO0eCPaa%H zX=mPByyERu`f;B50!#{0#&RC*mY$}rQgq2%e!s#t zh;U)=Xwvw7wz+|sA$up2nEfys;e652GiFhtnhUeYAJpZ%jmsRilL$J$;WoL6ycR!F z!J)EXrq`{PACX9jz4Tq=;*vR;yF`T&%iNf)LmJZSFt)NlH2qJR>cLpk2Q*e4y$Q2A z8a<|fUK5xpUN=2E!MgmkgB0FA->?Q_UJJmf0$}}QV<%}e^h*}n^wTV<{2lhCEJkZu zw*`gd_PBthFMry&kQyT_!v{R>QTx<6V6RIqhnf2{ta4D)x#iWpEGg8qs&B*hHw5A@ zbH00Df%Hf16^d@I_zG4T;`4@&_@5CQt~i(oeb%+@+~)XZ*2oX}0DHa039ndIJ}qTS z6)r#iW_?e^*DKOqil(k0M1Sz`Cm@88hn&QV zYwP7PG;2a1b4Z#wX0+o9s(iR|WF{EYFS~;l`sudeJZb7tK)$|HrrKMOi&8pD{Oa1= zqKJk4n6oFyEwn7t}h3PXJztMr!>*|+TV<`?am#7tF8W4-dtlNL#)=Z(czjKz=4sG|t_2UJ21jtHT(L_Bi6&|Y z-CsDx=K(Ix#V7l+lZS+=e-^(T5hj{*fWXJNznPgZ!BH3tSe*-lDY=4Y zIlRFSaIGX8#_ef1T&~q^0`NWjyJd0Stv@ZuV9&V2=gqh%$%)MlWY8kY=iGWM(XQv_ zc|SL}wk@=Z7r<`zf50dapFC6ofMEfl?*bMsh zcLviS;-Ylh-TxZ8aeZ+(5J9kkld*$(eMt>whB~~DL>WJW+@(@w_5X5D!|A2qrihRb z@n1I;%0KUNW6~j%XOF#b;hZcs9=Gj0lMw$og)p9O?8c{Kg&&+gOwUI-*3VxY$MQFd zRA*R8Wtz+d9i31K#_fo-iqzu>JNm`5(2zb3bM8@VpEPkpLKmC2<31l9799?$oS$5Z z7Ku!9Yz4+Vy*7`kS-)29`*A^K%iTPVd;QO94;rSjgW z$~F$`WZeDGaz5`kG&EqoF05&ia#Yr;l{zIE#BW(r%UD&w6fF4RmSa1>M@oLUMt3$< zsCL2klWGKS_*MEbW*xdj?e1lTla{UPl@co2PhBUcoDy9@FdU?|JiQoA1;_iflbnJD z{~*uqwFLHFoind?nbG0q9euCN^tT6?CJqL?f)AL;Skd1f-*J=scEGNlT1TS59k$Cu zXaBs{8hi;kR8m_}LKFR)L>E=%Z|*$N;ty}>};=%LQt0{hl>m?@|64D=-9LqzJJ&RUt5mO)px=#C0~isX25o1=@{TK^L#h0$G)=k2=77{S9RYQ zqio-hNmKR`k1Xu0aI^@bu3sfmCg6-&7IA*PwHccO>kpFN=;y$-3g6u{VzFCD``1dw z$3lLW5vbg~VXf=3W?RPFt^)vv@LkynvSpo40{2EBvEO7_-&k<)B>EMO=?siMgF`!g zfX_f)v-5(sg4YR3XQvB9XQx=Ij)rA|jdi#;pQ2C8cv+ZI6Sy(F;`{U$jlqQZL`^hTO2$Q@T_WJPnxlQNl%yX2LmqB`xla^y82J{%yw#&e;XgYy0I$w<@4@7pY3L*oM0=rEBz=DVo7wi zv`2)w>Lb{ZWqk6IYZ+;&BXMGP4viuTAY%8yvC5jH?FVjx zkVM7~V|R{6?=&kkI9p%v49APE@rBXWjtlZpn>|GbmT_ZWphV8DA(;5 z&*@UsO!@Uy%Il4X(-_E!v+wIFy`efAu%A$2g5X%eJ^z#c*fvn*euM0yAX|7_$1B{R z_-F8D#1FYZf<*1!_NGP5BmQyJ%2eV)rsAMajyT#}ny`8Eeqb{0Fd$?v{Q(wpntoLv z3vbU|zd4nwvdvJY-Oys>oaVw^q|e_Kze@BU5QX{5;cs!#{|C=|aN|ro0OEY#p7ZeB z@Nq!`S<97R(a6O>)X_^Up(pwh^ozs7 z>iJl4p`rR$_b7Fj9Ze$7X+y{xVo|)BIBYdj@~FL}LN)!V4*r;tn_H~h4WCv&4{^Kxy5vrZ)A-5h zE%t1`Cs$Slvf{yXuS0~-^eNTuNF4)o6h|Q*Sh9>7>BK|Qg*XU;dnl9Rr|6C&&5ZGL z6WNKDu-?f!>4A;Dngg*SlV5>VRTYBm#ZuAAt;ShTak{6dLl zD7Nz8&_PdZ&bnG*-&$gfN*qzP;j{cySu?m38v9ANpy9c#R%{5t=@Mh`^5VDMEoMt7L*doBSE_1Lyb}{8ia2g>l$4)b|7kKz4%AGS1vFh2-%npS z6;~XBEcWNPe)I~vr~)4Z|7|?8b|tE2J#OnG0N9gD>PxHCIWU$lsqbp~9zmQey+T95 zz(FMdv_-RpZu|9+vi1SxCX>((JyV$H@8?Dwyc8=O#4fp2*HLPn!#a|x19HM^=aO#@ zznL1gwX92NT^E0J!T!h|iYbmNdA`-CUOJ)nVjscvg!DA=4=*3*6B4gsYwAR^i69yT zt8+{G)aXhKFb9-%lB*v+7+D5ty{^v(ZB-dCY{$_I=62~%JC8YW7F~o?l#(>H zA5F&K^DlpHvUW0jmC07ZS_RRXy3VJ5dEj4@;-EvT3&C4LL>*Q9cAg8KH>TkGdjkJ_ z0B*1EJ1A6aDtS6hEe3J1~izw%{7wHp?hHKnyy(WnuR0lHf^omMLvF)*IXkdB>Vw&F8FWJ%G!y9#*BAHtrs8{QE-Ggq zdh^JB$m&Vjun@a_3V-$Kjfx$GJF3-4v zQxB}3iuiH3pW?K<*hQEf+}GxBq#!~!M5;##@TFXeu(k} zm_3O@XFQm4K9q;0p$hpdmc+lnkvB^7 zGF;$muy(Vkc{rD*Y4#V%%I5C7@cKejV71R41NMsPi4no|8P?3B#bykEc1Mel@3{v1c;${0mXA9!_JMyE@@GQQeROJ!~(G#T|QbWRkRLpCu%_9_L)Y`s8Gh z{;iJWEZD>F;F%41BZy&^v|dq!a=`&ppsMKY#7--%VpuXb&38vPlJJg0U_Xj8JuG) zpMZbTbxRE2jy;hD*hz*jT2d)L_b|pkDIHVMKG>^XEYc)?aX|j`O1nnVq7|U>`2~zW zs#ncH&J#1I#T(l4)ch>%wZ+*}#TP7&WV4x~3BAaes9uo$jJZ={FgLGx!vCIN64*mg z5+fF8LOid7=ms{>zYRoebf58r0$%?Y%94$WxRg` z0OktMzrOiC<8nVK${{?im!ZK~mvQbkGp6_G^?`(2^|g4Mf`-prMa5jq7!Mth;LR;u zYzFz)BT%9$*$%v_r6>YG6s63lDX{#_ymF>bQ*e}0(32b6!H8nGEv4U*x*S&7CkQ!HmaK;Klg2 z{|O8%{HxeEb!2FV?*#_K@@79ebf`N`SqB*=KSHG@ii-IgT<@m

    `#}Nhl(Uj()5c23srx$ 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

    wO1X@XWg*OIF4ij#e_Z*8X$Q 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

    )Y6)AhUZ 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�Gy*YvQU+yzoEK``|ivZh`WTpcx;^y``p8j^S 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%0D8Tk9z{;}szV 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 z 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