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 join_otaa(): """Joins the LoRaWAN network using Over The Air Activation (OTAA)""" lora = LoRa(mode=LoRa.LORAWAN, region=LoRa.AS923) log('Initializing LoRaWAN (OTAA), DEV EUI: {} ...'.format( hexlify(lora.mac()).decode('ascii').upper())) if not LORA_OTAA_KEY: log('ERROR: LoRaWAN APP KEY not set!') log('Send your DEV EUI to [email protected] to obtain one.') return None pycom.rgbled(RGB_LORA) authentication = (unhexlify(LORA_OTAA_EUI), unhexlify(LORA_OTAA_KEY)) lora.join(activation=LoRa.OTAA, auth=authentication, timeout=0) while not lora.has_joined(): log('Joining...') pycom.rgbled(RGB_OFF) time.sleep(LED_TIMEOUT) pycom.rgbled(RGB_LORA) time.sleep(2.5) # if no connection in a few seconds, then reboot if utime.time() > 15: print("Possible timeout") machine.reset() pycom.rgbled(RGB_OFF) return lora
def init_lora(): """Initialize LoRaWAN connection""" lora = LoRa(mode=LoRa.LORAWAN) log('Initializing LoRaWAN, DEV EUI: {} ...'.format( hexlify(lora.mac()).decode('ascii').upper())) if not app_key: log('ERROR: LoRaWAN APP KEY not set!') log('Send your DEV EUI to [email protected] to obtain one.') return (None, None) pycom.rgbled(RGB_LORA_JOIN) lora.join(activation=LoRa.OTAA, auth=(dev_eui, app_eui, app_key), timeout=0) while not lora.has_joined(): log('Joining...') pycom.rgbled(RGB_OFF) time.sleep(LED_TIMEOUT) pycom.rgbled(RGB_LORA_JOIN) time.sleep(2.5) pycom.rgbled(RGB_OFF) # Setup socket sock = socket.socket(socket.AF_LORA, socket.SOCK_RAW) sock.setsockopt(socket.SOL_LORA, socket.SO_DR, 5) # Set data rate sock.setblocking(False) log('Done!') return (lora, sock)
def reset_configuration(self, logger): """ Resets configuration to the default one and fetches device_id and device_eui :param logger: status logger :type logger: LoggerFactory object """ try: self.configuration.clear() # clear configuration self.set_config( self.default_configuration) # set configuration to default self.set_config({ "device_id": hexlify(unique_id()).upper().decode("utf-8") }) # set new device_id lora = LoRa(mode=LoRa.LORAWAN) self.set_config({ "device_eui": hexlify(lora.mac()).upper().decode('utf-8') }) # set new device_EUI del lora logger.info('Configurations were reset') logger.warning('Please configure your device!') except Exception as e: logger.exception('Failed to reset configurations') raise ConfigurationException(str(e))
class EasyLoraConnect(object): def __init__(self, resetOnFailure=True): self.lora = LoRa(mode=LoRa.LORAWAN, region=LoRa.AS923, tx_retries=config.N_TX, device_class=LoRa.CLASS_A) self.resetOnFailure = resetOnFailure self._join_lora() def _join_lora(self, force_join=True): # create an OTA authentication params app_eui = binascii.unhexlify(config.APP_EUI.replace(' ', '')) app_key = binascii.unhexlify(config.APP_KEY.replace(' ', '')) # Switch the red led on pycom.rgbled(0xFF0000) # join a network using OTAA if not previously done self.lora.join(activation=LoRa.OTAA, auth=(app_eui, app_key), timeout=0) print(binascii.hexlify(self.lora.mac()).upper().decode('utf-8')) print("Joining Lora") # wait until the module has joined the network nb_try = 0 while not self.lora.has_joined(): time.sleep(2.5) print("Not joined yet in try " + str(nb_try)) if self.resetOnFailure and nb_try > config.MAX_TRY: print("Cannot join so rebooting") machine.reset() nb_try = nb_try + 1 print("LoRa Joined") # Switch the red led off pycom.rgbled(0x006400) def send(self, payload): '''Sending data over LoraWan ''' pycom.rgbled(0xFF8C00) # 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, config.DATA_RATE) # make the socket blocking s.setblocking(True) s.send(payload) pycom.rgbled(0x006400) # closing the socket and saving the LoRa state s.close() self.lora.nvram_save()
def go_LoRa(): # Initialize LoRa in LORAWAN mode. lora = LoRa(mode=LoRa.LORAWAN) # Device EUI: 70 B3 D5 49 95 7A 21 5F - LoAirRohr01 print(binascii.hexlify(lora.mac()).upper().decode('utf-8')) # Join LoRa network and TTN app "environment" # using "Over the Air Activation (OTAA)" app_eui = binascii.unhexlify('xx xx xx xx xx xx xx xx'.replace(' ', '')) app_key = binascii.unhexlify('xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx') lora.join(activation=LoRa.OTAA, auth=(app_eui, app_key), timeout=0) # Wait until the module has joined the network pycom.rgbled(red) while not lora.has_joined(): print('Could not join LoRa network...') pycom.rgbled(off) time.sleep(0.1) pycom.rgbled(red) time.sleep(2) print('Joined LoRa network...') if useLED: pycom.rgbled(orange) else: pycom.rgbled(off) # 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) #s.setsockopt(socket.SOL_LORA, socket.SO_CONFIRMED, True) s.setblocking(True) while True: t, h, p = readBME280() pm10, pm25 = readSDS011() bytesSent = s.send(t + ";" + h + ";" + p + ";" + pm10 + ";" + pm25) print('Sent %s bytes' % bytesSent) #print(lora.stats()) # only for received packets! if useLED: pycom.rgbled(green) time.sleep(0.1) pycom.rgbled(blue) time.sleep(4.9)
def reset_configuration(self, logger): try: self.configuration.clear() # clear configuration self.set_config(self.default_configuration) # set configuration to default self.set_config({"device_id": hexlify(unique_id()).upper().decode("utf-8")}) # set new device_id lora = LoRa(mode=LoRa.LORAWAN) self.set_config({"device_eui": hexlify(lora.mac()).upper().decode('utf-8')}) # set new device_EUI del lora logger.info('Configurations were reset') logger.warning('Please configure your device!') except Exception as e: logger.exception('Failed to reset configurations') raise ConfigurationException(str(e))
def LORAConnection_OOTA(LoraConnectionTimeout): LoraConnected = False lora = LoRa(mode=LoRa.LORAWAN, region=LoRa.EU868) print("LoRa MAC Address: ", binascii.hexlify(lora.mac()).upper().decode('utf-8')) print("LoRa EUI: ", binascii.hexlify(machine.unique_id())) # create an OTAA authentication parameters app_eui = binascii.unhexlify('8493983621D5A1BC') app_key = binascii.unhexlify('9F68AE5FD1CE35D1F83CD48446CF7BBF') # L2 # app_key = binascii.unhexlify('3F4A90ABF82EBD4067CCA30FD1D7ACDE') # L10 # app_key = binascii.unhexlify('F8165748326F03346935F84BDE710AE4') # L12 # app_key = binascii.unhexlify('38F812962FDF2BD64A78223F398381F3') # L13 # app_key = binascii.unhexlify('8C0DF8D758F1B9340C9545B05DE3820B') # L14 # app_key = binascii.unhexlify('82FBAED74A43BA32225751F9BC2BB693') #lora.callback(trigger = LoRa.RX_PACKET_EVENT | LoRa.TX_PACKET_EVENT | LoRa.TX_FAILED_EVENT, handler = OPCLoraEvent) #lora.callback(trigger = LoRa.TX_PACKET_EVENT, handler = OPCLoraTx) #lora.callback(trigger = LoRa.TX_FAILED_EVENT, handler = OPCLoraTxFail) # join a network using OTAA (Over the Air Activation) #lora.join(activation=LoRa.OTAA, auth=(app_eui, app_key), timeout=0) try: lora.join(activation=LoRa.OTAA, auth=(app_eui, app_key), timeout=LoraConnectionTimeout) time.sleep_ms(8000) if (lora.has_joined()): LoraConnected = True except TimeoutError: print("timeout expired") LoraConnected = False # wait until the module has joined the network #while not lora.has_joined(): # time.sleep_ms(2500) # print('Not yet joined...') #pass #print('Joined!') print('Lora connected = ', LoraConnected) return LoraConnected, lora
def join_abp(): """Joins the LoRaWAN network using Activation By Personalization (ABP)""" lora = LoRa(mode=LoRa.LORAWAN) log('Initializing LoRaWAN (ABP), DEV EUI: {} ...'.format( hexlify(lora.mac()).decode('ascii').upper())) authentication = (unpack(">l", unhexlify(LORA_ABP_DEVADDR))[0], unhexlify(LORA_ABP_NETKEY), unhexlify(LORA_ABP_APPKEY)) lora.join(activation=LoRa.ABP, auth=authentication, timeout=0) for _ in range(1, 4): pycom.rgbled(RGB_LORA) time.sleep(LED_TIMEOUT) pycom.rgbled(RGB_OFF) time.sleep(LED_TIMEOUT) return lora
def __init__(self): lora = LoRa(mode=LoRa.LORAWAN, frequency=868000000) #lora.init(mode=LoRa.LORAWAN, frequency=868000000,sf=12) self.loraSocket = None print("MacAddress: ", [hex(x) for x in lora.mac()]) app_eui = binascii.unhexlify('00 00 00 00 00 00 00 00'.replace( ' ', '')) app_key = binascii.unhexlify( '00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00'.replace(' ', '')) if not lora.has_joined(): while not lora.has_joined(): lora.join(activation=LoRa.OTAA, auth=(app_eui, app_key), timeout=0, dr=1) time.sleep(6) print('Not yet joined...') # create a LoRa socket self.loraSocket = socket.socket(socket.AF_LORA, socket.SOCK_RAW) # set the LoRaWAN data rate self.loraSocket.setsockopt(socket.SOL_LORA, socket.SO_DR, 3)
from machine import UART from network import LoRa import binascii import os import pycom pycom.heartbeat(False) # Setting up the UART to dump the output to the console uart = UART(0, 115200) os.dupterm(uart) # Getting the LoRa MAC lora = LoRa(mode=LoRa.LORAWAN, public=1, adr=0, tx_retries=0) print("LORA MAC") print(binascii.hexlify(lora.mac()))
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, config): """ Constructor """ 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(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_debug( 5, "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(0x000A0A) time.sleep(1) pycom.rgbled(0) elif self.state == STATE_DETACHED: pycom.rgbled(0x0A0000) time.sleep(1) pycom.rgbled(0) else: do_nothing = "yes" # 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 slow_blink(): # supposed to be for continually blink status in a thread till state change color = self.RGBLED[self.state] for _ in range(num): pycom.rgbled(0) time.sleep(1) pycom.rgbled(color) time.sleep(1) pycom.rgbled(0) 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_debug(3, "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_debug(3, "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'] = {'lat': node.coord[0], 'lng': node.coord[1]} 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
def send_datatoLWGW(socket, dataString): print("Send data to the LWGW") data = dataString taille = str(len(data)) + 's' databytes = struct.pack(taille, data) socket.send(databytes) lora = LoRa(mode=LoRa.LORAWAN, region=LoRa.EU868) app_eui = binascii.unhexlify('70 B3 D5 7E F0 00 49 E1'.replace(' ', '')) app_key = binascii.unhexlify( '30 4C 99 26 3E A5 E6 43 B5 A0 8C B3 25 4A 61 FA'.replace(' ', '')) dev_eui = binascii.unhexlify( (binascii.hexlify(lora.mac()).decode('ascii')).upper()) #dev_addr = struct.unpack(">l", binascii.unhexlify('00 00 00 05'.replace(' ','')))[0] 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('connected to Objenious LoRaWAN!') s = socket.socket(socket.AF_LORA, socket.SOCK_RAW) s.setsockopt(socket.SOL_LORA, socket.SO_DR, 5) s.setblocking(True) changetoLoRa(lora) changetoLW() send_datatoLWGW(s, "toto,23:") changetoLoRa(lora) s.setblocking(False)
from network import LoRa import socket import time import ubinascii # micropython module import struct # for ABP import pycom pycom.heartbeat(False) pycom.rgbled(0xECEB1A) # create LoRa asia region lora = LoRa(mode=LoRa.LORAWAN, region=LoRa.AS923, device_class=LoRa.CLASS_C) print('Device EUI:', ubinascii.hexlify(lora.mac()).upper().decode('utf-8')) ################ # OTAA ################ app_eui = ubinascii.unhexlify('D8DF149D1DA65EF9') app_key = ubinascii.unhexlify('E8F1B92F79A72A8C2AA8AE182ADF2B35') lora.join(activation=LoRa.OTAA, auth=(app_eui, app_key), timeout=0) while not lora.has_joined(): time.sleep(2.5) print('Not yet joined...') pycom.rgbled(0x27ED00) print('Joined!') # create a LoRa socket s = socket.socket(socket.AF_LORA, socket.SOCK_RAW) s.setsockopt(socket.SOL_LORA, socket.SO_DR, 5) s.setblocking(False)
import struct import time import pycom # Configuration for India LORA_FREQUENCY = 866000000 LORA_NODE_DR = 5 # Turn off WiFi see also https://forum.pycom.io/topic/156/disable-wifi-for-low-power-operation wlan = WLAN() wlan.deinit() print('WiFi OFF') # Initialize LoRa in LORAWAN mode. lora = LoRa(mode=LoRa.LORAWAN) print('Device ID: ' + binascii.hexlify(lora.mac()).lower().decode('utf-8')) # create an OTA authentication params # these settings can be found from TTN dev_eui = binascii.unhexlify(' '.replace(' ', '')) app_eui = binascii.unhexlify(' '.replace(' ', '')) app_key = binascii.unhexlify(' '.replace(' ', '')) # remove all the non-default channels for i in range(3, 16): lora.remove_channel(i) # set the 3 default channels to the same frequency lora.add_channel(0, frequency=LORA_FREQUENCY, dr_min=0, dr_max=LORA_NODE_DR) lora.add_channel(1, frequency=LORA_FREQUENCY, dr_min=0, dr_max=LORA_NODE_DR) lora.add_channel(2, frequency=LORA_FREQUENCY, dr_min=0, dr_max=LORA_NODE_DR)
print('Lora packet received') data = s.recv(64) print(data) if events & LoRa.TX_PACKET_EVENT: print('Lora packet sent') def flash_led_to(color): pycom.rgbled(color) pycom.heartbeat(False) # Disable the heartbeat LED # Getting the LoRa MAC lora = LoRa(mode=LoRa.LORAWAN, region=LoRa.EU868) print("Device LoRa MAC:", binascii.hexlify(lora.mac())) flash_led_to(BLUE) # joining TTN join_lora(True) # Type 0 = dht11 # Type 1 = dht22 dht11 = 0 dht22 = 1 dht_type = dht11 th = DTH(Pin('P23', mode=Pin.OPEN_DRAIN), dht_type) # py = Pysense() #tempHum = SI7006A20(py)
print('Lora packet sent') lora.nvram_erase() #lora.nvram_restore() # remove all the channels the gateway doesn't use for channel in range(16, 72): lora.remove_channel(channel) for channel in range(0, 7): lora.remove_channel(channel) #create an OTAA authentication parameters for test lopy dev_eui = ubinascii.unhexlify( '70B3D54997802DF8') # these settings can be found from TTN app_eui = ubinascii.unhexlify('70B3D57ED0028A4F') app_key = ubinascii.unhexlify('CE46C01958A612D102F0D106AB415862') # create an OTAA authentication parameters for lopy with ring/ckt #dev address = 26012DBE #dev_eui = ubinascii.unhexlify('70B3D549952757BF') # these settings can be found from TTN #app_eui = ubinascii.unhexlify('70B3D57ED0028A4F') #app_key = ubinascii.unhexlify('88397B010F71D34BEDF77DA003C3A54C') # create an OTAA authentication parameters for no ring lopy #dev address = 260125A9 #dev_eui = ubinascii.unhexlify('70B3D54990435DFE') # these settings can be found from TTN #app_eui = ubinascii.unhexlify('70B3D57ED0028A4F') #app_key = ubinascii.unhexlify('CE46C01958A612D102F0D106AB415862') # join a network using OTAA (Over the Air Activation) print(binascii.hexlify(lora.mac()).upper().decode('utf-8'))
print("Acceleration: " + str(li.acceleration())) print("Roll: " + str(li.roll())) print("Pitch: " + str(li.pitch())) print("Battery voltage: " + str(py.read_battery_voltage())) ### from network import LoRa import config # initialize LORAWAN mode for EU region lora = LoRa(mode=LoRa.LORAWAN, region=LoRa.EU868) # print DevEUI of the device, use this when provisioning it in your network server print("DevEUI: " + binascii.hexlify(lora.mac()).decode('utf-8').upper()) # OTAA authentication parameters, replace these with your own print("Joining network using OTAA (Over the Air Activation)") lora.join(activation=LoRa.OTAA, auth=(config.app_eui, config.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("Joined network")
from network import LoRa import socket import time import binascii import pycom from machine import I2C i2c = I2C(0, I2C.MASTER, baudrate=400000) print(i2c.scan()) bme = BME280.BME280(i2c=i2c) lora = LoRa(mode=LoRa.LORAWAN, region=LoRa.EU868) print("devEUI {}".format(binascii.hexlify(lora.mac()))) app_eui = binascii.unhexlify('00 00 00 00 00 00 00 00'.replace(' ', '')) app_key = binascii.unhexlify( '11 22 33 44 55 66 77 88 11 22 33 44 55 66 77 88'.replace(' ', '')) lora.join(activation=LoRa.OTAA, auth=(app_eui, app_key), timeout=0) pycom.heartbeat(False) pycom.rgbled(0x111111) while not lora.has_joined(): time.sleep(2.5) print('Not yet joined...') pycom.rgbled(0x000000)
from loramesh import Loramesh from Networkmesh import * pycom.wifi_on_boot(False) pycom.heartbeat(False) lora = LoRa(mode=LoRa.LORA, region=LoRa.US915, tx_power=20, bandwidth=LoRa.BW_125KHZ, sf=11) print(lora.tx_power()) #lora = LoRa(mode=LoRa.LORA, region=LoRa.US915, bandwidth=LoRa.BW_125KHZ, sf=11) #lora = LoRa(mode=LoRa.LORA, region=LoRa.US915,frequency=903000000,tx_power=19, bandwidth=LoRa.BW_125KHZ, sf=12) MAC = str(ubinascii.hexlify(lora.mac()))[2:-1] print("LoRa MAC: %s" % MAC) loram = Loramesh(lora) mesh = NetworkMesh(loram, MAC, 1) #-------------------------------------------------------------------------------- # waiting until it connected to Mesh network # se queda intentando conectarse y muestra los vecinos mesh.connect() # create UDP socket #creo un socket LoRa mesh.createSocket(1234) # infinite main loop #funcion principal mesh.listen()
# Colors used for status LED RGB_OFF = 0x000000 RGB_POS_UPDATE = 0x101000 RGB_POS_FOUND = 0x001000 RGB_POS_NFOUND = 0x100000 RGB_LORA = 0x000010 LED_TIMEOUT = 0.2 pycom.heartbeat(False) # Set up the LoRa in longer range mode lora = LoRa(mode=LoRa.LORA, region=LoRa.AS923) s = socket.socket(socket.AF_LORA, socket.SOCK_RAW) s.setblocking(False) DevEUI = ubinascii.hexlify(lora.mac()).decode('ascii') # Enable garbage collection time.sleep(2) gc.enable() # Set up GPS with modest timeout py = Pytrack() l76 = L76GNSS(py) last_lat = 13.736717 last_lon = 100.523186 last_alt = 0
# see the Pycom Licence v1.0 document supplied with this file, or # available at https://www.pycom.io/opensource/licensing # from network import LoRa from machine import Pin import binascii import pycom import os EXPECTED_MAC_ADDRESS = b"{MAC_ADDRESS}" red_led = Pin('P10', mode=Pin.OUT, value=0) green_led = Pin('P11', mode=Pin.OUT, value=0) lora = LoRa(mode=LoRa.LORA) if binascii.hexlify(lora.mac()) == EXPECTED_MAC_ADDRESS and os.uname( ).release == "{FW_VERSION}" and 'LoPy' in os.uname().machine: pycom.heartbeat(False) pycom.rgbled(0x008000) # green green_led(1) print('Test OK') while True: pass else: pycom.heartbeat(False) pycom.rgbled(0x800000) # red red_led(1) print('Test failed')
import binascii import sys import ustruct import json from machine import PWM from machine import UART from machine import I2C from adafruit_bus_device.i2c_device import I2CDevice import drivers.adafruit_sht31d import uhashlib # Retrieve the dev_eui from the LoRa chip (Only needed for OTAA to retrieve once) lora = LoRa(mode=LoRa.LORAWAN, adr=True, region=LoRa.EU868) dev_eui = binascii.hexlify(lora.mac()).upper().decode('utf-8') uart = UART(0, 115200) uart.init(115200, bits=8, parity=None, stop=1) try: f = open("preset", "r") exists = True f.close() except: exists = False if not exists: while True: value = uart.read() if value != None: if str(value, 'utf-8') == "dev":
# if net.ssid == 'iotakl': # print(net.ssid + ' found!') # wlan.connect(net.ssid, auth=(net.sec, 'iotworkshop'), timeout=5000) # connectingToWiFi = True # break # # # use john's router # if net.ssid == 'iotakl24': # print(net.ssid + ' found!') # wlan.connect(net.ssid, auth=(net.sec, 'iotakl17'), timeout=5000) # connectingToWiFi = True # break if connectingToWiFi: while not wlan.isconnected(): pycom.rgbled(green) time.sleep(0.1) pycom.rgbled(off) time.sleep(2) machine.idle() # save power while waiting print('WLAN connection succeeded!') # get the EUI lora = LoRa() print("LoRa EUI:", binascii.hexlify(lora.mac())) #get the IP on the WiFi print("IP:", wlan.ifconfig()[0]) print("Try typing a command like os.uname()") print("Or run the LoRa OTAA demo execfile(\"otaa.py\")")
class Lora_Link_Layer: def __init__(self, receive_msg_cb): print("Initializing Link Layer...") self.receive_msg_cb = receive_msg_cb self.msg_buffer_list = [] self.incoming_cts_key = -1 self.wait = False #Use other name, e.g. wait_for_channel self.wait_time = 0 #use int instead of boolean. If multiple cts/rts arrive sum. self.lora = LoRa(mode=LoRa.LORA, region=LoRa.EU868) self.s = socket.socket(socket.AF_LORA, socket.SOCK_RAW) self.s.setblocking(False) self.lora.callback(trigger=(LoRa.RX_PACKET_EVENT | LoRa.TX_PACKET_EVENT), handler=self.lora_cb) self.lora_mac_address_b = binascii.hexlify(self.lora.mac()) self.lora_mac_address = str(self.lora_mac_address_b, "utf-8") #_thread.start_new_thread(self.process_msg_pipeline, ()) def get_lora_mac(self): return self.lora_mac_address def lora_cb(self, lora): events = lora.events() if events & LoRa.RX_PACKET_EVENT: msg = self.s.recv(250) #print(msg) #unpack message and pass meta information (like mac address or protocol) as parameter #meta, data = self.unpack_frame(msg.decode("utf-8")) #msg_utf8 = data #msg_1 = msg.decode("utf-8") #print('Link Layer: Lora packet received. ' + str(msg_utf8, "utf-8")) #if (msg_1.startswith("cts")): # self.handle_incoming_cts(msg_1) #elif (msg_1.startswith("rts")): # self.handle_incoming_rts(msg_1) #send cts. what if cts gets lost? Ignore? CSMA sending messages #only one rts at a time. identify rts if it is repeated. #else: print('Link Layer: Passing received data to Network Layer') self.receive_msg_cb(msg) #if events & LoRa.TX_PACKET_EVENT: #print('Lora packet sent') def append_msg_to_pipeline(self, msg, use_ca): #self.msg_buffer_list.append([msg, use_ca]) self.lora_send_csma_ca(msg, use_ca) #Buffer Länge definieren und Nachrichten verwerfen oder auf Teilpackete aufteilen. #Time on air -> vielfaches (zufällig) warten, falls Kanal nicht frei. def process_msg_pipeline(self): while True: if (len(self.msg_buffer_list) > 0): msg_and_ca = self.msg_buffer_list.pop(0) msg = msg_and_ca[0] use_ca = msg_and_ca[1] self.lora_send_csma_ca(msg, use_ca) time.sleep(1) def lora_send_csma_ca(self, msg, use_ca): if (use_ca): print("Link Layer: using CA") #do not send rts if wait = true rts_random_key_b = binascii.hexlify(os.urandom(2)) rts_random_key = str(rts_random_key_b, "utf-8") rts = "rts." + rts_random_key while not (rts_random_key == self.incoming_cts_key): #and not wait. Probably? #maximum repetition if not self.wait: self.lora_send_csma(rts) print("Link Layer: Waiting for cts. expected: " + str(rts_random_key) + " received: " + str(self.incoming_cts_key)) else: print("Link Layer: Waiting..." + str(self.wait_time)) #change delay randomly/exponential #Wie lange warten? cts soll nicht mit nächstem rts versuch überlagert werden? time.sleep(2) else: print("Link Layer: NOT using CA") #blocking function self.lora_send_csma(msg) def lora_send_csma(self, msg): #Semtech LoRa: High sensitivity -111 to -148dBm (Datasheet: https://semtech.my.salesforce.com/sfc/p/#E0000000JelG/a/2R0000001OKs/Bs97dmPXeatnbdoJNVMIDaKDlQz8q1N_gxDcgqi7g2o) while not self.lora.ischannel_free(-100,100): #max rep. print("Link Layer: channel not free") print("Link Layer: channel free (CSMA). Sending data...") self.lora_send(msg) def lora_send(self, msg): #frame = self.pack_frame("c", msg) frame = msg print("Link Layer | Sending data: " + str(frame)) self.s.send(frame) def handle_incoming_cts(self, incoming_cts): print("Link Layer: CTS received. Key=" + incoming_cts) self.incoming_cts_key = str(incoming_cts.split(".")[1], "utf-8") #Important: Wait also if CTS is for other lora. Use MAC adress as identifier #Combine with incoming RTS def handle_incoming_rts(self, incoming_rts): incoming_rts_key = str(incoming_rts.split(".")[1], "utf-8") print("Link Layer: RTS received. Key=" + incoming_rts_key) #send cts. what if cts gets lost? Ignore? CSMA sending messages #only one rts at a time. identify rts if it is repeated. #check if rts is new. Problem: other lora did not receive cts. Important: Waiting time if (not self.wait): _thread.start_new_thread(self.wait_timer, (5,)) print("Link Layer: CTS other lora. Waiting for other lora...") #save mac address of other lora and wait until packet from this lora arrived or max cts = "cts." + incoming_rts_key #self.lora_send_csma(cts.encode("utf-8")) self.lora_send_csma(cts) def wait_timer(self, wait_time): self.wait_time = wait_time self.wait = True print("Wait timer") while self.wait_time > 0: time.sleep(1) self.wait_time = self.wait_time - 1 print(str(self.wait_time)) self.wait = False #This field states whether the frame is a data frame or it is used for control functions like error and flow control or link management etc. def pack_frame(self, type, data): #Use single bits for control and 8 bytes for MAC without delimiters. character delimiters can cause problems and need much space. frame = type + "::" + self.get_lora_mac() + "::" + data print("Link Layer:" + frame) return frame def unpack_frame(self, frame): meta = [frame.split("::")[0], frame.split("::")[1]] data = frame.split("::")[2] return meta, data
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(): time.sleep(1.5) print('Not joined yet...') print('Network joined!') print("LoRa Ready") print("Frequency: "+ str(lora.frequency())) print("Spreading Factor: "+ str(lora.sf())) print("Coding Rate: "+ str(lora.coding_rate())) print("Bandwidth: "+ str(lora.bandwidth())) print(lora.mac()) pycom.rgbled(0x00ff00) s = socket.socket(socket.AF_LORA, socket.SOCK_RAW) s.setsockopt(socket.SOL_LORA, socket.SO_DR, 0) s.setblocking(True) while True: print('Sending Packet...') pycom.rgbled(0x00ff00) s.send('0') print('Done sending') data = s.recv(64) time.sleep(2000)
RM.addRule (rule_coap1) RM.addRule (rule_coap2) p = Parser() comp = Compressor(RM) dec = Decompressor(RM) coapC = CoAP.CoAPSM(p, comp, dec, IPv6_source, IPv6_dest, increase_delivary_chances_function) app_eui = binascii.unhexlify('00 00 00 00 00 00 00 00'.replace(' ','')) app_key = binascii.unhexlify('11 22 33 44 55 66 77 88 11 22 33 44 55 66 77 88'.replace(' ','')) pycom.heartbeat(False) if LORAWAN: mac = lora.mac() print ('MAC:') print(hex(mac[0]), end='-') print(hex(mac[1]), end='-') print(hex(mac[2]), end='-') print(hex(mac[3]), end='-') print(hex(mac[4]), end='-') print(hex(mac[5]), end='-') print(hex(mac[6]), end='-') print(hex(mac[7])) for i in range (0, 255): led = i<< 16| i <<8 | i pycom.rgbled(led) time.sleep(0.01)
from network import LoRa from machine import Pin import binascii import pycom import os EMPTY_MAC_ADDRESS = b'ffffffffffffffff' red_led = Pin('P10', mode=Pin.OUT, value=0) green_led = Pin('P11', mode=Pin.OUT, value=0) lora = LoRa(mode=LoRa.LORA) pycom.heartbeat(False) try: if binascii.hexlify(lora.mac()) != EMPTY_MAC_ADDRESS and os.uname( ).release == "{FW_VERSION}" and 'LoPy' in os.uname().machine: pycom.rgbled(0x008000) # green green_led(1) print('QA Test OK') else: pycom.rgbled(0x800000) # red red_led(1) print('QA Test failed') except Exception: pycom.rgbled(0x800000) # red red_led(1) print('QA Test failed') while True: pass
def lora_task(): with thread_list_mutex: thread_list[_thread.get_ident()] = 'LORA' # 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.EU868, tx_power=14) printt("DevEUI: %s" % (ubinascii.hexlify(lora.mac()).decode('ascii'))) # create an OTAA authentication parameters app_eui = ubinascii.unhexlify(conf['lora']['app_eui']) app_key = ubinascii.unhexlify(conf['lora']['app_key']) printt("Joining LORAWAN with EUI: %s and KEY: %s" % (conf['lora']['app_eui'], conf['lora']['app_key'])) # join a network using OTAA (Over the Air Activation) lora.join(activation=LoRa.OTAA, auth=(app_eui, app_key), timeout=0) lora_setup_done = False while (True): # Set LORA battery state lora_set_battery() # wait until the module has joined the network if (not lora.has_joined()): pycom.rgbled(0x100000) printt('Joining network...') time.sleep(2.5) else: if (not lora_setup_done): # Succesfully joined pycom.rgbled(0x001000) # 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) lora_setup_done = True # make the socket blocking # (waits for the data to be sent and for the 2 receive windows to expire) s.setblocking(True) # send some data s.send(bytes([0x01, 0x02, 0x03])) # make the socket non-blocking # (because if there's no data received it will block forever...) s.setblocking(False) # get any data received (if any...) data = s.recv(64) print(data) time.sleep(0.1)
print(msg) if events & LoRa.TX_FAILED_EVENT: print("Warning: no ACK after {} attempts".format(stats[5])) def flash_led(color=LED_RED, on=0.1, pause=0.2, repeat=1): """ flash RGB LED on LoPy """ for _ in range(0, repeat): pycom.rgbled(color) utime.sleep(on) pycom.rgbled(LED_OFF) utime.sleep(pause) # setup LoRaWAN stack with presets for Europe (868 MHz) print("\nInit LoRaWAN stack on {} running {}...".format(uos.uname()[0], uos.uname()[2])) lora = LoRa(mode=LoRa.LORAWAN, region=LoRa.EU868) print("LoRa DevEUI: {}".format(ubinascii.hexlify(lora.mac()).upper().decode())) # join network either using OTAA or ABP if LORA_OTAA: app_eui = ubinascii.unhexlify(OTAA_APP_EUI) app_key = ubinascii.unhexlify(OTAA_APP_KEY) lora.join(activation=LoRa.OTAA, auth=(app_eui, app_key), timeout=0, dr=LORA_DR_JOIN) print("Starting OTAA join...", end="") otaa_timer = 0 start_join = utime.ticks_ms() while not lora.has_joined() and otaa_timer < OTAA_JOIN_TIMEOUT: otaa_timer = int(utime.ticks_diff(utime.ticks_ms(), start_join)/1000) print(".", end="") flash_led(LED_BLUE, 0.1, 0.9) if lora.has_joined(): print("OK.")