def __init__(self, dev_addr, nwk_swkey, app_swkey):
#Initialise pyscan
py = Pysense()
self.axis_sensor = LIS2HH12(py)
self.light_sensor = LTR329ALS01(py)
self.air_sensor = SI7006A20(py)
self.pressure_sensor = MPL3115A2(py)
self.altitude_sensor = MPL3115A2(py, mode=ALTITUDE)
# Initialise LoRa in LORAWAN mode.
self.lora = LoRa(mode=LoRa.LORAWAN, region=LoRa.EU868)
# create an ABP authentication params
dev_addr = struct.unpack(">l", binascii.unhexlify(dev_addr))[0]
nwk_swkey = ubinascii.unhexlify(nwk_swkey)
app_swkey = ubinascii.unhexlify(app_swkey)
# join a network using ABP (Activation By Personalization)
self.lora.join(activation=LoRa.ABP,
auth=(dev_addr, nwk_swkey, app_swkey))
# create a LoRa socket
self.s = socket.socket(socket.AF_LORA, socket.SOCK_RAW)
# set the LoRaWAN data rate
self.s.setsockopt(socket.SOL_LORA, socket.SO_DR, 5)
# make the socket blocking
# (waits for data to be sent and for the 2 receive windows to expire)
self.s.setblocking(True)
def init(rdr, answerjs, raw_uid):
log("INIT!")
log(answerjs)
if (answerjs["setantiblk"] != ""):
log("initializing sector 0...")
if rdr.auth(rdr.AUTHENT1A, 2, defaultkey, raw_uid) == rdr.OK:
rdr.write(2, nfc_writemessage)
for i in range(1, 16):
log("writing sector %s" % i)
if rdr.auth(rdr.AUTHENT1A, i * 4, defaultkey, raw_uid) == rdr.OK:
#log("auth ok")
for x in range(0, 3):
#write filler data or real hash
numblk = (i * 4) + x
numfiller = (
(i - 4) *
4) + x #Array begins at 0 but blocks begin at 4
if numblk == int(answerjs["setantiblk"]):
log("writing hash to block: %s" % numblk)
rdr.write(int(answerjs["setantiblk"]),
answerjs["txt"].encode())
else:
#log("writing filler to block: %s" % numblk)
rdr.write(numblk,
answerjs["filler"][numfiller].encode())
rdr.setKey(i, ubinascii.unhexlify(answerjs["keya"][i]),
ubinascii.unhexlify(answerjs["keyb"][i]))
log("key set complete")
else:
log("auth error")
else:
log("server response error...")
def test_get_address_from_contract(self):
contracts = [
TezosContractID(
tag=TezosContractType.Implicit,
hash=unhexlify("0090ec585b4d5fa39b20213e46b232cc57a4cfab4b"),
),
TezosContractID(
tag=TezosContractType.Implicit,
hash=unhexlify("017dfb3fef44082eca8cd3eccebd77db44633ffc9e"),
),
TezosContractID(
tag=TezosContractType.Implicit,
hash=unhexlify("02c1fc1b7e503825068ff4fe2f8916f98af981eab1"),
),
TezosContractID(
tag=TezosContractType.Originated,
hash=unhexlify("65671dedc69669f066f45d586a2ecdeddacc95af00"),
),
]
outputs = [
"tz1YrK8Hqt6GAPYRHAaeJmhETYyPSQCHTrkj",
"tz2KoN7TFjhp96V2XikqYSGyDmVVUHXvkzko",
"tz3e1k3QzCwEbRZrfHCwT3Npvw1rezmMQArY",
"KT1HpwLq2AjZgEQspiSnYmdtaHy4NgXw6BDC",
]
for i, contract in enumerate(contracts):
self.assertEqual(_get_address_from_contract(contract), outputs[i])
def decrypt(self, payload):
"""Decrypts the each encrypted item of the payload.
Initialize decryption cipher for each item and and use cipher to decrypt payload items.
:param payload : received MQTT message from Spinner #1. This includes all encrypted data, nodeid, iv, and HMAC
:return : MQTT message to publish to Spinner #1 on Topic "Acknowledge", can be "Successful Decryption"
"""
decrypted_payload = ujson.loads(payload)
decrypted_iv = ubinascii.unhexlify(decrypted_payload['encrypted_iv'])
decrypted_nodeid = ubinascii.unhexlify(decrypted_payload['encrypted_nodeid'])
decrypted_data = ubinascii.unhexlify(decrypted_payload['encrypted_data'])
decrypted_hmac = decrypted_payload['hmac']
decryption_cipher = aes(self.ivkey,2,self.staticiv)
decrypt_iv= decryption_cipher.decrypt(decrypted_iv)
decryption_data = aes(self.datakey,2,decrypt_iv)
decrypt_data = decryption_data.decrypt(decrypted_data)
sensor_data={}
sensor_data['a_x']=float(decrypt_data[0:8])
sensor_data['a_y']=float(decrypt_data[8:16])
sensor_data['a_z']=float(decrypt_data[16:24])
sensor_data['temp']=float(decrypt_data[24:32])
return (0,sensor_data)
def start(self, boot=True):
if not self.sta_if.isconnected():
print('Tentando conectar...', end="")
self.sta_if.active(True)
i = 0
while i < len(self.config) and not self.sta_if.isconnected():
self.connection(
ubinascii.a2b_base64(ubinascii.unhexlify(
self.config[i][0])),
ubinascii.a2b_base64(ubinascii.unhexlify(
self.config[i][1])))
print(".", end="")
time.sleep_ms(200)
i += 1
if not self.sta_if.isconnected() and boot:
self.sta_if.active(False)
print('Rede não conectada')
d = dnsquery.start()
self.connection(d[b's'].decode(), d[b'p'].decode())
if self.sta_if.isconnected():
self.config[self.lconf] = [
ubinascii.hexlify(ubinascii.b2a_base64(d[b's'])[:-1]),
ubinascii.hexlify(ubinascii.b2a_base64(d[b'p'])[:-1])
]
f = open('config.json', 'w')
f.write(ujson.dumps(self.config))
f.close()
machine.reset()
else:
time.sleep(1)
machine.reset()
return self.sta_if
def decrypt(self, payload):
"""Decrypts the each encrypted item of the payload.
Initialize decryption cipher for each item and and use cipher to decrypt payload items.
:param payload : received MQTT message from Spinner #1. This includes all encrypted data, nodeid, iv, and HMAC
:return : MQTT message to publish to Spinner #1 on Topic "Acknowledge", can be "Successful Decryption"
"""
text = json.loads(payload)
rece_HMAC = ubinascii.unhexlify(text["HMAC"])
rece_iv = ubinascii.unhexlify(text["e_iv"])
rece_nodeid = ubinascii.unhexlify(text["e_nodeid"])
rece_sensord = ubinascii.unhexlify(text["e_sd"])
#encrypt iv
myaes = aes(self.ivkey, 2, self.staticiv)
iv = myaes.decrypt(rece_iv)
striv = iv.decode("utf-8")
print(striv)
#encrypt data
myes = aes(self.datakey, 2, striv)
node_id = myes.decrypt(rece_nodeid).decode("utf-8")
byte_sensord = myes.decrypt(rece_sensord)
sensord = byte_sensord.decode("utf-8")
data = sensord.strip(chr(0)).split(' ')
data_x = float(data[0])
data_y = float(data[1])
data_z = float(data[2])
data_temp = float(data[3])
print(data_x, data_y, data_z, data_temp)
return True, node_id, data_x, data_y, data_z, data_temp
def __init__(self, app_eui, app_key, frequency=868100000, dr=5):
'''setup LoRaWAN for the European 868 MHz region with OTAA'''
self.dr = dr
self.frequency = frequency
self.app_eui = ubinascii.unhexlify(app_eui)
self.app_key = ubinascii.unhexlify(app_key)
self.lora = LoRa(mode=LoRa.LORAWAN, region=LoRa.EU868)
self.socket = None
self.setup()
def test_tezos_encode_data_with_bool_prefix(self):
w = bytearray()
_encode_data_with_bool_prefix(w, None)
self.assertEqual(bytes(w), bytes([0]))
data = "afffeb1dc3c0"
w = bytearray()
_encode_data_with_bool_prefix(w, unhexlify(data))
self.assertEqual(bytes(w), unhexlify("ff" + data))
def __init__(self, app_eui, app_key):
"""setup LoRaWAN for the European 868 MHz region with OTAA"""
self.app_eui = ubinascii.unhexlify(app_eui)
self.app_key = ubinascii.unhexlify(app_key)
self.lora = LoRa(mode=LoRa.LORAWAN, region=LoRa.EU868)
self.socket = None
self.setup()
def joinOTAA(self):
app_eui = ubinascii.unhexlify(self.options['lora_app_eui'])
app_key = ubinascii.unhexlify(self.options['lora_app_key'])
self.lora.join(activation=LoRa.OTAA,
auth=(app_eui, app_key),
timeout=0)
self.log("Joining via OTAA")
self.lastJoin = time.time()
def load_secret():
try:
with open(secret_fname, "r") as f:
d = json.loads(f.read())
except:
return False
Secret.secret = unhexlify(d["secret"])
Secret.hmac = unhexlify(d["hmac"])
return True
async def _readline(self) -> (bytearray, bytearray, any):
led = self._led
line = b''
start = utime.ticks_ms()
while True:
if line.endswith(b'\n'):
self._ok = True # Got at least 1 packet after an outage.
if len(line) > 1:
d = uio.StringIO(line)
try:
preheader = bytearray(ubinascii.unhexlify(d.read(6)))
if preheader[1] != 0:
header = bytearray(
ubinascii.unhexlify(d.read(preheader[1] * 2)))
else:
header = None
if len(line
) > 7 + preheader[1] * 2: # preheader+header+\n
line = ujson.load(d)
else:
line = b""
except ValueError as e:
print("Error converting message:", d.read(), "error:",
e)
line = b''
continue
except Exception as e:
print("Error converting sth", e)
continue
finally:
d.close()
gc.collect()
return preheader, header, line
# Got a keepalive: discard, reset timers, toggle LED.
self._feed(0)
line = b''
if led is not None:
if isinstance(led, machine.Pin):
led(not led())
else: # On Pyboard D
led.toggle()
try:
d = self._sock.readline()
except Exception as e:
self._verbose and print('_readline exception')
raise
if d == b'':
self._verbose and print('_readline peer disconnect')
raise OSError
if d is None: # Nothing received: wait on server
if utime.ticks_diff(utime.ticks_ms(), start) > self._to:
self._verbose and print('_readline timeout')
raise OSError
await asyncio.sleep_ms(0)
else: # Something received: reset timer
start = utime.ticks_ms()
line = b''.join((line, d)) if line else d
def handle_incoming_telegram(self,telegram,ticks):
"""Called whenever a new MBus master request has been received.\nParses the request and ensures the correct responses from the tracked devices are collected and sent back.\n"""
if telegram[0] == 0x10:
# SND_NKE
if telegram[1] == 0x40:
# If broadcast to 0xfd, deselect the currently selected device
if telegram[2] == 0xfd:
list(map(lambda device: device.deselect(),self.devices.values()))
# If broadcast to all devices on bus, have them reply or indicate collision
elif telegram[2] == 0xfe:
#map(lambda device: device.select(),self.devices.values())
no_of_devices = len(list(self.devices.values()))
if no_of_devices >= 2:
self.mbus_uart.send_collision()
elif no_of_devices == 1:
self.mbus_uart.send_ack()
# If wanting to select a specific device via primary address
elif telegram[2] in self.devices.keys():
self.mbus_uart.send_ack()
# REQ_UD2
elif ((telegram[1] == 0x5b) or (telegram[1] == 0x7b)):
# If broadcast to 0xFD (selected devices)..
if telegram[2] == 0xfd:
devices_found = [device for device in self.devices.values() if device.is_selected()]
no_of_devices = len(devices_found)
if no_of_devices >=2:
self.mbus_uart.send_collision()
elif no_of_devices == 1:
device = devices_found[0]
resp_bytes = ubinascii.unhexlify(device.get_latest_values())
self.mbus_uart.send_telegram(resp_bytes,ticks)
# If targetting a specific device via primary address
elif (telegram[2] in self.devices.keys()):
device = self.devices[telegram[2]]
resp_bytes = ubinascii.unhexlify(device.get_latest_values())
self.mbus_uart.send_telegram(resp_bytes,ticks)
elif telegram[0] == 0x68:
# SND_UD
if ((telegram[4] == 0x53) or (telegram[4] == 0x73)):
if ((telegram[5] == 0xfd) and (telegram[6] == 0x52)):
search_bytes = list(telegram[7:11])
search_bytes.reverse()
search_string = "".join(['{0:0{1}x}'.format(b,2) for b in search_bytes])
self.log("searching with string {}".format(search_string))
devices_found = [device for device in self.devices.values() if device.matches_secondary_address(search_string)]
devices_not_found = [device for device in self.devices.values() if device not in devices_found]
list(map(lambda device: device.select(),devices_found))
list(map(lambda device: device.deselect(),devices_not_found))
if(len(devices_found) >= 2):
self.log("multiple devices found for search string {}".format(search_string))
for device in devices_found:
self.mbus_uart.send_ack()
elif(len(devices_found) == 1):
device = devices_found[0]
self.log("one device found for search string {}".format(search_string))
self.mbus_uart.send_ack()
def main():
# all from the same private key
prv = ec.PrivateKey.from_wif(
"L2e5y14ZD3U1J7Yr62t331RtYe2hRW2TBBP8qNQHB8nSPBNgt6dM")
pub = prv.get_public_key()
print("Public key:")
print(hexlify(pub.serialize()))
# we will generate regtest addresses
network = NETWORKS['regtest']
print("Legacy (pay to pubkey hash):")
sc = script.p2pkh(pub)
# default network is main
print(sc.address(network))
print("Segwit (pay to witness pubkey hash):")
sc = script.p2wpkh(pub)
print(sc.address(network))
print("Nested segwit (p2sh-p2wpkh):")
sc = script.p2sh(script.p2wpkh(pub))
print(sc.address(network))
print("\nMiltisig address (2 of 3):")
# unsorted
pubs = [
ec.PublicKey.parse(
unhexlify(
"02edd7a58d2ff1e483d35f92a32e53607423f936b29bf95613cab24b0b7f92e0f1"
)),
ec.PublicKey.parse(
unhexlify(
"03a4a6d360acc45cb281e0022b03218fad6ee93881643488ae39d22b854d9fa261"
)),
ec.PublicKey.parse(
unhexlify(
"02e1fdc3b011effbba4b0771eb0f7193dee24cfe101ab7e8b64516d83f7116a615"
)),
]
# 2 of 3 multisig script
sc = script.multisig(2, pubs)
print("Legacy, unsorted (p2sh):")
redeem_sc = script.p2sh(sc)
print(redeem_sc.address(network))
print("Native segwit, sorted (p2wsh):")
sc = script.multisig(2, sorted(pubs))
witness_sc = script.p2wsh(sc)
print(witness_sc.address(network))
print("Nested segwit, sorted (p2sh-p2wsh):")
sc = script.multisig(2, sorted(pubs))
witness_sc = script.p2wsh(sc)
redeem_sc = script.p2sh(witness_sc)
print(redeem_sc.address(network))
def test_addresses(self):
pubkey = unhexlify(
'c5f54ba980fcbb657dbaaa42700539b207873e134d2375efeab5f1ab52f87844')
address = nem.compute_address(pubkey, NEM_NETWORK_MAINNET)
self.assertEqual(address, 'NDD2CT6LQLIYQ56KIXI3ENTM6EK3D44P5JFXJ4R4')
pubkey = unhexlify(
'114171230ad6f8522a000cdc73fbc5c733b30bb71f2b146ccbdf34499f79a810')
address = nem.compute_address(pubkey, NEM_NETWORK_MAINNET)
self.assertEqual(address, 'NCUKWDY3J3THKQHAKOK5ALF6ANJQABZHCH7VN6DP')
def joinABP(self):
net_key = ubinascii.unhexlify(self.options['lora_net_key'])
app_key = ubinascii.unhexlify(self.options['lora_app_key'])
# note: TTN seems to want the reverse bytes of this address
device_address = ubinascii.unhexlify(self.options['lora_dev_adr'])
self.lora.join(activation=LoRa.ABP,
auth=(device_address, net_key, app_key))
self.log("Joining via ABP with device address", device_address)
self.lastJoin = time.time()
def initialize_lorawan_link(self):
#print(ubinascii.hexlify(network.LoRa().mac()))
# Initialise LoRa in LORAWAN mode.
# Please pick the region that matches where you are using the device:
# Asia = LoRa.AS923
# Australia = LoRa.AU915
# Europe = LoRa.EU868
# United States = LoRa.US915
lora = LoRa(mode=LoRa.LORAWAN, region=LoRa.AU915, adr=False)
self.myLora = lora
# create an ABP authentication params
dev_addr = struct.unpack(">l", ubinascii.unhexlify('260211EE'))[0]
nwk_swkey = ubinascii.unhexlify('AB189EFE29DCF9F9830F3A564DC1844E')
app_swkey = ubinascii.unhexlify('A55931ACC412DE51171CEDA45BE6B319')
#for channel in range(0, 72):
# lora.add_channel(channel, frequency=916800000, dr_min=0, dr_max=5)
#lora.add_channel(0, frequency=923300000, dr_min=0, dr_max=5)
for i in range(8, 72):
lora.remove_channel(i)
start = 916800000
f_inc = 200000
curr = start
for i in range(8):
#print(curr)
lora.add_channel(index=i, frequency=curr, dr_min=0, dr_max=5)
curr += f_inc
#lora.callback(trigger=(LoRa.RX_PACKET_EVENT | LoRa.TX_PACKET_EVENT), handler=self.lora_cb)
# join a network using ABP (Activation By Personalization)
lora.join(activation=LoRa.ABP, auth=(dev_addr, nwk_swkey, app_swkey))
#print(lora.has_joined())
# wait until the module has joined the network
while not lora.has_joined():
time.sleep(2.5)
print('Not yet joined...')
#print("Has joined!!!!!")
# create a LoRa socket
s = socket.socket(socket.AF_LORA, socket.SOCK_RAW)
# set the LoRaWAN data rate
s.setsockopt(socket.SOL_LORA, socket.SO_DR, self.data_rate)
s.setsockopt(socket.SOL_LORA, socket.SO_CONFIRMED, False)
return s
def connect():
lora = LoRa(mode=LoRa.LORAWAN, region=LoRa.EU868)
app_eui = ubinascii.unhexlify('70B3D57ED003E9AD')
app_key = ubinascii.unhexlify('F212905C83160EE25DF713181E160274')
dev_eui = ubinascii.unhexlify('70B3D549911BCF55')
lora.join(activation=LoRa.OTAA, auth=(dev_eui, app_eui, app_key), timeout=0)
while not lora.has_joined():
time.sleep(2.5)
print('Not yet joined...')
print('Joined')
def loraConnect():
lora = LoRa(mode=LoRa.LORAWAN, region=LoRa.EU868)
app_eui = ubinascii.unhexlify('70B3D57ED003E4C4')
app_key = ubinascii.unhexlify('2F77C58DD6AB59F1A603976A6792A598')
dev_eui = ubinascii.unhexlify('70B3D549943157B4')
lora.join(activation=LoRa.OTAA,
auth=(dev_eui, app_eui, app_key),
timeout=0)
while not lora.has_joined():
time.sleep(2.5)
print('Not yet joined...')
print('Joined')
def connect(appeui, appkey, force=False, max_retry=20, grace_period=2.5):
"""
Create and connect Socket for LoRa application using OTAA mechanism
"""
# Initialise LoRa in LORAWAN mode.
lora = LoRa(mode=LoRa.LORAWAN, region=LoRa.EU868)
#lora.nvram_erase()
lora.nvram_restore()
if not lora.has_joined() or force:
# create an OTAA authentication parameters
app_eui = ubinascii.unhexlify(appeui)
app_key = ubinascii.unhexlify(appkey)
# join a network using OTAA (Over the Air Activation)
lora.join(activation=LoRa.OTAA, auth=(app_eui, app_key), timeout=0)
# wait until the module has joined the network
i = 0
while not lora.has_joined():
time.sleep(grace_period)
i += 1
print('LORA/OTAA [EUI={}]: Application Join request pending ({}/{})...'.format(appeui, i, max_retry))
if i >= max_retry:
break
else:
print('LORA/OTAA [EUI={}]: Application Join request accepted'.format(appeui))
# create a LoRa socket
sock = socket.socket(socket.AF_LORA, socket.SOCK_RAW)
# set the LoRaWAN data rate
sock.setsockopt(socket.SOL_LORA, socket.SO_DR, 5)
# make the socket blocking
# (waits for the data to be sent and for the 2 receive windows to expire)
sock.setblocking(True)
#sock.send(b'')
# make the socket non-blocking
# (because if there's no data received it will block forever...)
sock.setblocking(False)
#sock.recv(64)
# Save LoRa State:
# https://forum.pycom.io/topic/1668/has-anyone-successfully-used-lora-nvram_save-and-restore/16
lora.nvram_save()
print('LORA/OTAA [EUI={}]: LoRa state saved'.format(appeui))
return sock, lora
def init_lora_wan(lora, timeout):
app_eui = ubinascii.unhexlify('XXX')
app_key = ubinascii.unhexlify('YYY')
# #join a network using OTAA (Over the Air Activation)
lora.join(activation=LoRa.OTAA, auth=(app_eui, app_key), timeout=0)
while not lora.has_joined():
time.sleep(2.5)
print('Not joined LoRa.OTAA yet ...')
# #create a LoRa socket
lorasocket = socket.socket(socket.AF_LORA, socket.SOCK_RAW)
# set the LoRaWAN data rate
lorasocket.setsockopt(socket.SOL_LORA, socket.SO_DR, 5)
return lorasocket
def bytes_from_address(address: str) -> bytes:
if len(address) == 40:
return unhexlify(address)
elif len(address) == 42:
if address[0:2] not in ("0x", "0X"):
raise wire.ProcessError("Klaytn: invalid beginning of an address")
return unhexlify(address[2:])
elif len(address) == 0:
return bytes()
raise wire.ProcessError("Klaytn: Invalid address length")
def init():
teller = 0
lora = LoRa(mode=LoRa.LORAWAN, region=LoRa.EU868)
app_eui = ubinascii.unhexlify('70B3D57ED003E4D4')
app_key = ubinascii.unhexlify('511FCEA75A175980B26A145EAC4C56E9')
lora.join(activation=LoRa.OTAA, auth=(app_eui, app_key), timeout=0)
while not lora.has_joined():
time.sleep(1)
print('Not yet joined...')
teller = teller+1
if teller==10:
break
return(lora)
def abp(address='00124f11',
networkSessionKey='844a432a89b1b23598e4d24d631a9248',
applicationSessionKey='3f1807cd4c7817144147a48b4ec93648',
value=True):
lora = LoRa(mode=LoRa.LORAWAN, region=LoRa.EU868)
# This is to make sure it work with nano gw
LORA_FREQUENCY = 868100000 # sigle channel used on nano gw
lora.add_channel(0, frequency=LORA_FREQUENCY, dr_min=0, dr_max=5)
lora.add_channel(1, frequency=LORA_FREQUENCY, dr_min=0, dr_max=5)
lora.add_channel(2, frequency=LORA_FREQUENCY, dr_min=0, dr_max=5)
# create an ABP authentication params
dev_addr = struct.unpack(">l", ubinascii.unhexlify(address))[0]
nwk_swkey = ubinascii.unhexlify(networkSessionKey)
app_swkey = ubinascii.unhexlify(applicationSessionKey)
# join a network using ABP (Activation By Personalization)
lora.join(activation=LoRa.ABP, auth=(dev_addr, nwk_swkey, app_swkey))
# create a LoRa socket
s = socket.socket(socket.AF_LORA, socket.SOCK_RAW)
# set the LoRaWAN data rate
s.setsockopt(socket.SOL_LORA, socket.SO_DR, 5)
# make the socket blocking
# (waits for the data to be sent and for the 2 receive windows to expire)
s.setblocking(True)
# send some data
lpp = CayenneLPP(size=100, sock=s)
lpp.add_digital_input(value, channel=66)
# sending the packet via the socket
lpp.send()
# s.send(bytes([0x01, 0x02, 0x03]))
# make the socket non-blocking
# (because if there's no data received it will block forever...)
s.setblocking(False)
# get any data received (if any...)
data = s.recv(64)
print(data)
print("done")
pycom.rgbled(0x007f00) # green
time.sleep(5)
pycom.heartbeat(False)
def connect_to_app(app_eui, app_key):
print("start connecting")
# Initialise LoRa in LORAWAN mode.
lora = LoRa(mode=LoRa.LORAWAN, region=LoRa.EU868)
# create an OTAA authentication parameters
app_eui = ubinascii.unhexlify(app_eui)
app_key = ubinascii.unhexlify(app_key)
# join a network using OTAA (Over the Air Activation)
lora.join(activation=LoRa.OTAA, auth=(app_eui, app_key), timeout=0)
# wait until the module has joined the network
while not lora.has_joined():
time.sleep(2.5)
print('Not yet joined...')
print("has joined network. Ready to send data...")
def __init__(self):
super(LoRa, self).__init__()
# check if safety variable is true
if not self.config().get("antenna_connected"):
raise Exception(
"configuration variable 'antenna_connected' is not true")
# get the reset cause
import machine
reset_cause = machine.reset_cause()
# initialize lora network
from network import LoRa as LoRa_drv
self.lora = LoRa_drv(mode=LoRa_drv.LORAWAN,
region=LoRa_drv.EU868,
adr=self.config().get("adr"))
# try to load previous lora connection if waking up from deep sleep
if reset_cause == machine.DEEPSLEEP_RESET:
self.lora.nvram_restore()
if reset_cause == machine.DEEPSLEEP_RESET and self.lora.has_joined():
log_info("Restored previous LoRaWAN join.")
else:
# get authentication parameters
import ubinascii
app_eui = ubinascii.unhexlify(self.config().get("app_eui"))
app_key = ubinascii.unhexlify(self.config().get("app_key"))
# join a network using OTAA (Over the Air Activation)
self.lora.join(activation=LoRa_drv.OTAA,
auth=(app_eui, app_key),
timeout=0,
dr=self.config().get("data_rate"))
# wait until the module has joined the network
log_debug("Waiting until LoRa has joined.")
while not self.lora.has_joined():
pass
log_info("Joined LoRa network.")
# create a lora socket to send data
import socket
self.socket = socket.socket(socket.AF_LORA, socket.SOCK_RAW)
# set the LoRaWAN data rate
self.socket.setsockopt(socket.SOL_LORA, socket.SO_DR,
self.config().get("data_rate"))
def join_lora(force_join=False):
'''Joining The Things Network '''
print('Joining TTN')
# restore previous state
if not force_join:
lora.nvram_restore()
if not lora.has_joined() or force_join == True:
# create an OTA authentication params
dev_eui = ubinascii.unhexlify(config['lora']['otaa']['app_device_eui'])
app_eui = ubinascii.unhexlify(
config['lora']['otaa']
['app_eui']) # these settings can be found from TTN
app_key = ubinascii.unhexlify(
config['lora']['otaa']
['app_key']) # these settings can be found from TTN
# print('key:{}, eui:{}'.format(app_key, app_eui))
# join a network using OTAA (Over the Air Activation) if not previously done
# lora.join(activation=LoRa.OTAA, auth=(app_eui, app_key), timeout=0, dr=0)
lora.join(activation=LoRa.OTAA,
auth=(dev_eui, app_eui, app_key),
timeout=0)
# lora.join(activation=LoRa.ABP, auth=(dev_addr, nwk_swkey, app_swkey))
# wait until the module has joined the network
while not lora.has_joined():
print('Not yet joined...')
pycom.rgbled(0xcc00ff)
time.sleep(3)
pycom.rgbled(0x000000)
time.sleep(0.5)
# saving the state
lora.nvram_save()
# returning whether the join was successful
if lora.has_joined():
flash_led_to(BLUE)
print('LoRa Joined')
return True
else:
flash_led_to(RED)
print('LoRa Not Joined')
return False
else:
return True
def __init__(self, interval, app_eui, app_key, dp_callback):
self.interval = interval # num secs to sleep
self.callback = dp_callback
self.app_eui = ubinascii.unhexlify(
app_eui) # determines app to connect to
self.app_key = ubinascii.unhexlify(app_key) # grants access
self.lora = LoRa(mode=LoRa.LORAWAN,
region=LoRa.EU868) # used to join a network
self.s = socket.socket(
socket.AF_LORA,
socket.SOCK_RAW) # used to send data to joined network
self.connect() # joins application specified through app_eui
self.__alarm = Timer.Alarm(self._uploader, interval, periodic=True)
def load_key():
global entropy
try:
with open(reckless_fname, "r") as f:
d = json.loads(f.read())
entropy = unhexlify(d["entropy"])
if "hmac" in d:
hmac_calc = hmac_sha512(Key.key, entropy)
if unhexlify(d["hmac"]) != hmac_calc:
raise ValueError('Hmac does not match!')
Key.iv = unhexlify(d["iv"])
entropy = entropy_decrypt(entropy)
ask_for_password()
except:
gui.error("Something went wrong, sorry")
def load_key():
global entropy
with open(reckless_fname, "r") as f:
d = json.loads(f.read())
entropy = unhexlify(d["entropy"])
if "hmac" in d:
hmac_calc = hmac_sha512(Key.key, entropy)
if unhexlify(d["hmac"]) != hmac_calc:
raise ValueError('Hmac does not match!')
Key.iv = unhexlify(d["iv"])
entropy = entropy_decrypt(entropy)
if entropy is not None:
ask_for_password()
else:
gui.error("Failed to load your recovery phrase.")
def _push_data(self, data):
token = uos.urandom(2)
packet = bytes([PROTOCOL_VERSION]) + token + bytes([PUSH_DATA]) + ubinascii.unhexlify(self.id) + data
with self.udp_lock:
try:
self.sock.sendto(packet, self.server_ip)
except Exception as ex:
self._log('Failed to push uplink packet to server: {}', ex)
def _pull_data(self):
token = uos.urandom(2)
packet = bytes([PROTOCOL_VERSION]) + token + bytes([PULL_DATA]) + ubinascii.unhexlify(self.id)
with self.udp_lock:
try:
self.sock.sendto(packet, self.server_ip)
except Exception as ex:
self._log('Failed to pull downlink packets from server: {}', ex)
def _ack_pull_rsp(self, token, error):
TX_ACK_PK["txpk_ack"]["error"] = error
resp = ujson.dumps(TX_ACK_PK)
packet = bytes([PROTOCOL_VERSION]) + token + bytes([PULL_ACK]) + ubinascii.unhexlify(self.id) + resp
with self.udp_lock:
try:
self.sock.sendto(packet, self.server_ip)
except Exception as ex:
self._log('PULL RSP ACK exception: {}', ex)
def b16decode(s, casefold=False):
"""Decode a Base16 encoded byte string.
s is the byte string to decode. Optional casefold is a flag
specifying whether a lowercase alphabet is acceptable as input.
For security purposes, the default is False.
The decoded byte string is returned. binascii.Error is raised if
s were incorrectly padded or if there are non-alphabet characters
present in the string.
"""
s = _bytes_from_decode_data(s)
if casefold:
s = s.upper()
if re.search(b'[^0-9A-F]', s):
raise binascii.Error('Non-base16 digit found')
return binascii.unhexlify(s)
def recv_file_from_host(src_file, dst_filename, filesize, dst_mode='wb'):
"""Function which runs on the pyboard. Matches up with send_file_to_remote."""
import sys
import ubinascii
import pyb
usb = pyb.USB_VCP()
if HAS_BUFFER and usb.isconnected():
# We don't want 0x03 bytes in the data to be interpreted as a Control-C
# This gets reset each time the REPL runs a line, so we don't need to
# worry about resetting it ourselves
usb.setinterrupt(-1)
try:
with open(dst_filename, dst_mode) as dst_file:
bytes_remaining = filesize
if not HAS_BUFFER:
bytes_remaining *= 2 # hexlify makes each byte into 2
buf_size = BUFFER_SIZE
write_buf = bytearray(buf_size)
read_buf = bytearray(buf_size)
while bytes_remaining > 0:
read_size = min(bytes_remaining, buf_size)
buf_remaining = read_size
buf_index = 0;
while buf_remaining > 0:
if HAS_BUFFER:
bytes_read = sys.stdin.buffer.readinto(read_buf, bytes_remaining)
else:
bytes_read = sys.stdin.readinto(read_buf, bytes_remaining)
if bytes_read > 0:
write_buf[buf_index:bytes_read] = read_buf[0:bytes_read]
buf_index += bytes_read
buf_remaining -= bytes_read
if HAS_BUFFER:
dst_file.write(write_buf[0:read_size])
else:
dst_file.write(ubinascii.unhexlify(write_buf[0:read_size]))
# Send back an ack as a form of flow control
sys.stdout.write('\x06')
bytes_remaining -= read_size
return True
except:
return False
try:
import ubinascii as binascii
except ImportError:
import binascii
print(binascii.unhexlify(b'0001020304050607'))
print(binascii.unhexlify(b'08090a0b0c0d0e0f'))
print(binascii.unhexlify(b'7f80ff'))
print(binascii.unhexlify(b'313233344142434461626364'))
import ubinascii, gc, usnmp #getresponse s="3081d20201000403414643a281c702043821eea10201000201003081b8300f060a2b0601020102020101010201013013060a2b0601020102020102010405566c616e31300f060a2b0601020102020103010201353010060a2b060102010202010401020205dc3012060a2b06010201020201050142043b9aca003014060a2b0601020102020106010406001b8ff4d1c0300f060a2b060102010202010701020102300f060a2b0601020102020108010201023010060a2b06010201020201090143022c06300f060a2b060102010202010a01410100" b=bytes(ubinascii.unhexlify(s)) usnmp.frombytes_tvat(b,0) usnmp.frombytes_tvat(b,3) usnmp.frombytes_tvat(b,6) usnmp.frombytes_tvat(b,11) usnmp.frombytes_tvat(b,14) usnmp.frombytes_tvat(b,20) usnmp.frombytes_tvat(b,23) usnmp.frombytes_tvat(b,26) usnmp.tobytes_tv(4, "hello world") usnmp.frombytes_tvat(usnmp.tobytes_tv(4, b"hello world"),0) usnmp.frombytes_tvat(usnmp.tobytes_tv(usnmp.ASN1_INT,12311),0)[1] == 12311 usnmp.frombytes_tvat(usnmp.tobytes_tv(usnmp.SNMP_GUAGE,23),0)[1] == 23 usnmp.frombytes_tvat(usnmp.tobytes_tv(usnmp.SNMP_TIMETICKS,65783634),0)[1] == 65783634 usnmp.frombytes_tvat(usnmp.tobytes_tv(usnmp.ASN1_NULL,None),0)[1] == None usnmp.frombytes_tvat(usnmp.tobytes_tv(usnmp.ASN1_OID,"1.3.1.2.2.4324.2"),0)[1] == "1.3.1.2.2.4324.2" usnmp.frombytes_tvat(usnmp.tobytes_tv(usnmp.SNMP_IPADDR,"172.26.235.23"),0)[1] == "172.26.235.23" p = usnmp.SnmpPacket(b) p.ver p.community p.type p.id
try:
try:
import ubinascii as binascii
except ImportError:
import binascii
except ImportError:
import sys
print("SKIP")
sys.exit()
print(binascii.unhexlify(b'0001020304050607'))
print(binascii.unhexlify(b'08090a0b0c0d0e0f'))
print(binascii.unhexlify(b'7f80ff'))
print(binascii.unhexlify(b'313233344142434461626364'))
try:
a = binascii.unhexlify(b'0') # odd buffer length
except ValueError:
print('ValueError')
try:
a = binascii.unhexlify(b'gg') # digit not hex
except ValueError:
print('ValueError')
def b32decode(s, casefold=False, map01=None):
"""Decode a Base32 encoded byte string.
s is the byte string to decode. Optional casefold is a flag
specifying whether a lowercase alphabet is acceptable as input.
For security purposes, the default is False.
RFC 3548 allows for optional mapping of the digit 0 (zero) to the
letter O (oh), and for optional mapping of the digit 1 (one) to
either the letter I (eye) or letter L (el). The optional argument
map01 when not None, specifies which letter the digit 1 should be
mapped to (when map01 is not None, the digit 0 is always mapped to
the letter O). For security purposes the default is None, so that
0 and 1 are not allowed in the input.
The decoded byte string is returned. binascii.Error is raised if
the input is incorrectly padded or if there are non-alphabet
characters present in the input.
"""
s = _bytes_from_decode_data(s)
quanta, leftover = divmod(len(s), 8)
if leftover:
raise binascii.Error('Incorrect padding')
# Handle section 2.4 zero and one mapping. The flag map01 will be either
# False, or the character to map the digit 1 (one) to. It should be
# either L (el) or I (eye).
if map01 is not None:
map01 = _bytes_from_decode_data(map01)
assert len(map01) == 1, repr(map01)
s = s.translate(bytes.maketrans(b'01', b'O' + map01))
if casefold:
s = s.upper()
# Strip off pad characters from the right. We need to count the pad
# characters because this will tell us how many null bytes to remove from
# the end of the decoded string.
padchars = s.find(b'=')
if padchars > 0:
padchars = len(s) - padchars
s = s[:-padchars]
else:
padchars = 0
# Now decode the full quanta
parts = []
acc = 0
shift = 35
for c in s:
val = _b32rev.get(c)
if val is None:
raise binascii.Error('Non-base32 digit found')
acc += _b32rev[c] << shift
shift -= 5
if shift < 0:
parts.append(binascii.unhexlify(bytes('%010x' % acc, "ascii")))
acc = 0
shift = 35
# Process the last, partial quanta
last = binascii.unhexlify(bytes('%010x' % acc, "ascii"))
if padchars == 0:
last = b'' # No characters
elif padchars == 1:
last = last[:-1]
elif padchars == 3:
last = last[:-2]
elif padchars == 4:
last = last[:-3]
elif padchars == 6:
last = last[:-4]
else:
raise binascii.Error('Incorrect padding')
parts.append(last)
return b''.join(parts)
