class Main: def __init__(self, args): self.__init_logging() self.__logger.info("Going to initialize Gps()") self.__gps = Gps() self.__logger.debug("Going to read position and direction") start, start_bear = self.__gps.fetch_get_pos_bearing() self.__logger.debug("start=" + str(start)) self.__logger.debug("start_bear=" + str(start_bear)) destination = Point(args.lon, args.lat) announcer_manager = AnnouncerManager() self.__logger.debug("Going to initialize router") router = OrsRouter(start, start_bear, destination, announcer_manager) while self.__update_pos_wrapped(self.__gps.fetch_get_pos_bearing(), router) == False: time.sleep(config.routing['main_poll_interval']) self.__logger.info("Arrival at destination") def __update_pos_wrapped(self, pos_bear, router): return router.update_pos(pos_bear[0], pos_bear[1]) def __init_logging(self): logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(name)s - %(levelname)s - %(message)s') self.__logger = logging.getLogger(__name__) self.__logger.setLevel("DEBUG") # level for this class only
def test__degreesFromString(self): degrees = Gps._degreesFromString("""38°59'26.348\"""") self.assertAlmostEqual(degrees, 38.99, 2) degrees = Gps._degreesFromString("""300.34°""") self.assertAlmostEqual(degrees, 300.34, 2) self.assertRaises(ValueError, Gps._degreesFromString, """300.34° """) self.assertRaises(ValueError, Gps._degreesFromString, """blah""")
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 test_fromString(self): gps = Gps.fromString("""38°59'26.348"N, 5°24'47.948"E""") self.assertAlmostEqual(gps.latitude, 38.99, 2); self.assertEqual(gps.latitude_ref, 'N') self.assertAlmostEqual(gps.longtitude, 5.41, 2) self.assertEqual(gps.longtitude_ref, 'E') self.assertEqual(gps.altitude, None) gps = Gps.fromString("""38°59'26.348"N, 5°24'47.948"E, 254""") self.assertAlmostEqual(gps.latitude, 38.99, 2); self.assertEqual(gps.latitude_ref, 'N') self.assertAlmostEqual(gps.longtitude, 5.41, 2) self.assertEqual(gps.longtitude_ref, 'E') self.assertEqual(gps.altitude, 254.) self.assertRaises(ValueError, Gps.fromString, "blah")
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 new_lora_mac: fo = open("/flash/sys/lpwan.mac", "wb") mac_write = bytes([ 0, 0, 0, 0, 0, 0, (new_lora_mac >> 8) & 0xFF, new_lora_mac & 0xFF ]) fo.write(mac_write) fo.close() print("Really LoRa MAC set to", new_lora_mac) if deepsleep_timeout > 0: print('Going to deepsleep for %d seconds' % deepsleep_timeout) time.sleep(1) machine.deepsleep(deepsleep_timeout * 1000)
def __init__(self, args): self.__init_logging() self.__logger.info("Going to initialize Gps()") self.__gps = Gps() self.__logger.debug("Going to read position and direction") start, start_bear = self.__gps.fetch_get_pos_bearing() self.__logger.debug("start=" + str(start)) self.__logger.debug("start_bear=" + str(start_bear)) destination = Point(args.lon, args.lat) announcer_manager = AnnouncerManager() self.__logger.debug("Going to initialize router") router = OrsRouter(start, start_bear, destination, announcer_manager) while self.__update_pos_wrapped(self.__gps.fetch_get_pos_bearing(), router) == False: time.sleep(config.routing['main_poll_interval']) self.__logger.info("Arrival at destination")
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 __init__(self, waypointFile=None): """Constructor for the boat object""" self.arduino = Arduino() self.gps = Gps() self.xbee = Xbee() self._waypointN = 0 self._waypointE = 0 self._waypointNumber = 0 self._waypointDist = 0 self._waypointHeading = 0 self._targetHeading = 0 self._targetDistance = 0 self.s = 0 self.c = 0 self.r = 250
def get(self): """Returns GPS position information or None, if not present""" proc = Popen(["exiv2", "-g", "Exif.GPSInfo.GPSAltitude", "-g", "Exif.GPSInfo.GPSAltitudeRef", "-g", "Exif.GPSInfo.GPSLatitude", "-g", "Exif.GPSInfo.GPSLatitudeRef", "-g", "Exif.GPSInfo.GPSLongitude", "-g", "Exif.GPSInfo.GPSLongitudeRef", "-g", "Exif.GPSInfo.GPSMapDatum", "-g", "Exif.GPSInfo.GPSVersionID", self._file_name], stdout=PIPE, universal_newlines=True) res = proc.communicate()[0] if proc.returncode is not 0 and proc.returncode is not 253: raise ExivGps.ExivError("Nonzero stare returnet from cmd: %s" % repr(proc.returncode)) lines = res.splitlines() gps_lat = gps_lat_ref = None gps_lon = gps_lon_ref = None for line in lines: line = [l for l in line.split(' ') if l] line = line[0:3] + [' '.join(line[3:]), ] tag, form, num, val = line if tag == "Exif.GPSInfo.GPSLatitude": gps_lat = Gps._degreesFromString(val.replace('deg', '°')) elif tag == "Exif.GPSInfo.GPSLatitudeRef": gps_lat_ref = {'North': 'N', 'South': 'S', }[val] elif tag == "Exif.GPSInfo.GPSLongitude": gps_lon = Gps._degreesFromString(val.replace('deg', '°')) elif tag == "Exif.GPSInfo.GPSLongitudeRef": gps_lon_ref = {'East': 'E', 'West': 'W', }[val] elif tag == "Exif.GPSInfo.GPSAltitude": gps_alt = val elif tag == "Exif.GPSInfo.GPSVersionID": if val < "2.0.0.0": raise ValueError("Unsupported GPSInfo version '%s'" % val) elif tag == "Exif.GPSInfo.GPSMapDatum": if val != "WGS-84": raise ValueError("Unsupported GPSInfo Datum '%s'" % val) else: raise ValueError("Invalid exiv2 resutl: %s" % repr(res)) gps = Gps() if gps_lat or gps_lat_ref: gps.setLatitude(gps_lat, gps_lat_ref) if gps_lon or gps_lon_ref: gps.setLongtitude(gps_lon, gps_lon_ref) return gps
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 = Gps.get_location() if data is None: return datatype = str(type(data)) if datatype == "<class 'bytes'>": self._init_bytes(data) elif datatype == "<class 'NeighborData'>": self._init_neighbordata(data)
def process(self, file_name): exivGps = ExivGps(file_name) try: gps = exivGps.get() gps = gps or "N/A" except ExivGps.ExivError: print("Failed to get exif information, skipping: '%s'" % file_name) return tabs = 6 - divmod((len(file_name) + 2 + 7), 8)[0] if tabs < 0: tabs = 0 tabs = "\t" * tabs print("'%s'%s - [%s] : " % (file_name, tabs, str(gps)), end="", flush=True) newGps = stdin.readline().strip() if newGps: newGps = Gps.fromString(newGps, gps) exivGps.set(newGps)
def main(): # Bootsplash anzeigen # und 1sek warten. Wichtig: in dieser Zeit hat man die Möglichkeit über serial ein neues Programm hochzuladen # Beim ESP32 ist das nicht mehr wichtig, da dieser zwei serial Schnittstellen hat. display = Display(scl=4, sda=0) display.println("RSSI") display.println("Location") display.println("Logger") display.println("") # display.print_dot() # Systeme konfigurieren try: # nur zum Testen # wlan = network.WLAN(network.STA_IF) # wlan.active(True) # wlan.connect('Freifunk') # while not wlan.isconnected(): # display.print_dot() # time.sleep(0.5) # display.println(str(wlan.status('rssi'))) # time.sleep(10) display.println("===CONF START==") display.println("scan wlan") # Wlan Objekt erstellen, dass selbständig einen scan macht und das stärkste Freifunk zurück gibt. # display.print_dot() wlan = Wlan("Freifunk") # display.println(wlan.ff_ap_bssid) wlan.connect() display.println("connect") #display.println(ubinascii.hexlify(wlan.ff_list[0][1])+str(wlan.ff_list[0][3])) while not wlan.isconnected(): display.print_dot() time.sleep(0.5) gps = Gps() s = 0.1 display.println("init uart 9600") display.print_dot() uart = Uart(0, 9600) time.sleep(s) display.println("set baud 115200") display.print_dot() uart.send_command(b'PMTK251,115200') time.sleep(s) display.println("init UART 115200") display.print_dot() uart = Uart(0, 115200) time.sleep(s) display.println("set 2Hz") display.print_dot() uart.send_command(b'PMTK220,500') time.sleep(s) display.println("set RMC, GGA") display.print_dot() uart.send_command(b'PMTK314,0,1,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,00') time.sleep(s) display.println("===CONF END===") while True: line = uart.readline() # display.println(str(line)) gps.refresh(line) quality = False if wlan.isconnected() and int( gps.sats) > 7 and gps.is_fix and float(gps.hdop) < 2: quality = True if not (wlan.isconnected()): # display.println("") # display.println("lost wlan :(") # display.println("reconnect...") wlan.reconnect() # else: display.print_info(gps, quality, wlan) # display.println(str(wlan.wlan.status('rssi'))) time.sleep(0.1) except Exception as ex: display.println(repr(ex)) for e in ex.args: display.println(e[:16]) time.sleep(1) display.println(e[16:32]) time.sleep(1) display.println(e[32:48]) display.println("") time.sleep(10)
class Ui_MainWindow(): def __init__(self): self.a=Gps() self.setupUi(MainWindow) ''' Setting up UI ''' def setupUi(self, MainWindow): MainWindow.setObjectName("MainWindow") MainWindow.resize(800, 480) self.centralwidget = QtWidgets.QWidget(MainWindow) self.centralwidget.setObjectName("centralwidget") self.label = QtWidgets.QLabel(self.centralwidget) self.label.setGeometry(QtCore.QRect(0, 0, 800, 480)) self.label.setText("") self.label.setPixmap(QtGui.QPixmap("normal.png")) self.label.setScaledContents(True) self.label.setObjectName("label") self.msgBox = QtWidgets.QLabel(self.centralwidget) self.msgBox.setGeometry(QtCore.QRect(50,10,711,31)) font= QtGui.QFont() font.setPointSize(20) self.msgBox.setFont(font) self.msgBox.setStyleSheet("color:rgb(255,255,255)") self.msgBox.setTextFormat(QtCore.Qt.AutoText) self.msgBox.setScaledContents(True) self.msgBox.setObjectName("msgBox") MainWindow.setCentralWidget(self.centralwidget) self.menubar = QtWidgets.QMenuBar(MainWindow) self.menubar.setGeometry(QtCore.QRect(0, 0, 800, 22)) self.menubar.setObjectName("menubar") MainWindow.setMenuBar(self.menubar) self.statusbar = QtWidgets.QStatusBar(MainWindow) self.statusbar.setObjectName("statusbar") MainWindow.setStatusBar(self.statusbar) self.retranslateUi(MainWindow) QtCore.QMetaObject.connectSlotsByName(MainWindow) def retranslateUi(self, MainWindow): _translate = QtCore.QCoreApplication.translate MainWindow.setWindowTitle(_translate("MainWindow", "MainWindow")) ''' very 50ms this method will get the current distance from the Hazardous area/intersection ''' def getDistance(self): self.temp=self.a.getLocation()# stores current location in self.temp threshold=900.0000 #This is the threshold value in meter that user wants to have visual alarm before he/she enters into the Hazardous area. data = [500,600,700,800,900,1000]#Random numers describing the number of accident occured in listed 5 intersections accordingly if self.temp: self.distanceHB = Haversine(self.temp,Haversine.HomerBlock)#stores current distance from Homerwatson/Block line intersection self.distanceFW = Haversine(self.temp,Haversine.FairwayWilson)#stores current distance from Fairway/Wilson intersection self.distanceHBishop = Haversine(self.temp,Haversine.HasplarBishop)#stores current distance from Hasplar/Bishop intersectiomn self.distanceHM = Haversine(self.temp,Haversine.HasplarMaple)#stores current distance from haslpar/maple intersection self.distanceHQ = Haversine(self.temp,Haversine.HasplarQueen)#stores current distance from hasplar/Queen intersection ''' Storing all the distance in one dictionary ''' self.dict1= {"Homer Block":self.distanceHB.m(),"Fairview Wilson":self.distanceFW.m(),"Hasplar Bishop":self.distanceHBishop.m(),\ "Hasplar Maple":self.distanceHM.m(),"Hasplar Queen":self.distanceHQ.m()} print("_____________________________________________") ''' conditioning for visual alarm ''' if self.distanceHB.m() < threshold or self.distanceFW.m() < threshold or self.distanceHBishop.m() < threshold or \ self.distanceHM.m() < threshold or self.distanceHQ.m() <threshold: print("\nHazardous Area Ahead\n") self.label.setPixmap(QtGui.QPixmap("warning.png")) if self.distanceHB.m() < threshold: self.msgBox.setText(str(data[0])+" "+"Accidents happend at the next intersection") elif self.distanceFW.m() <threshold: self.msgBox.setText(str(data[1])+" "+"Accidents happend at the next intersection") elif self.distanceHBishop.m() < threshold: self.msgBox.setText(str(data[2])+" "+"Accidents happend at the next intersection") elif self.distanceHM.m() <threshold: self.msgBox.setText(str(data[3])+" "+"Accidents happend at the next intersection") elif self.distanceHQ.m() < threshold: self.msgBox.setText(str(data[4])+" "+"Accidents happend at the next intersection") else: print("\n you are safe\n") self.label.setPixmap(QtGui.QPixmap("normal.png")) self.msgBox.setText("You are good to go !!!") ''' Printing all Keys and values from the disctionary on the shell ''' for x in self.dict1: print(self.dict1,"\n") if self.dict1[x]<threshold: print(x,"->",self.dict1[x])
# furnished to do so, subject to the following conditions: # # The above copyright notice and this permission notice shall be included in all # copies or substantial portions of the Software. # # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR # IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, # FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE # AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER # LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE # SOFTWARE. if __name__ == '__main__': parser = ArgumentParser(prog="gps.py") parser.add_argument("profile_name", dest="user", nargs="?", type=str, help="Your GitHub profile name") args = parser.parse_args() user = args.user if not user: user = input("Profile's name: ") if len(user) == 0: print("ERROR: No username was provided!") quit(1) g = Gps() g.gps_for(user) print(g.formatted_res())
iodef.init() if config.hw_rev >= 3: import ble import ble_gatt_dsc as ble_gatt ble.init_ble() crypto = Crypto() message = Message(crypto, config, heartbeat_message) message.start() radio = Radio("/dev/serial0", config, message, heartbeat_radio) radio.start() gps = Gps() gps.start() if config.hw_rev < 3: display = Display(message, version, config, revision, heartbeat_display) display.start() ui = UI(display, message, crypto, radio, config, heartbeat_ui) ui.start() ui.splash() if config.hw_rev >= 3: dscGatt = ble_gatt.DscGatt(quitdsc, message, config, radio) dscGatt.start() """
def process(self, arg1, arg2): last_mesh_pairs = [] last_mesh_mac_list = [] last_mesh_node_info = {} try: while True: time.sleep(.1) cmd = input('>') 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('(message)<') except: continue data = { 'to': to, # 'ty': 0, 'b': txt, 'id': 12345, 'ts': int(time.time()), } print(self.mesh.send_message(data)) elif cmd == 'ws': to = int(input('(to)<')) 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 == '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: 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: # 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") print("gps - get/set location coordinates") except KeyboardInterrupt: print('cli Got Ctrl-C') except Exception as e: sys.print_exception(e) finally: print('cli finally') self.sleep(0)
ble_comm = ble.BleCommunication(str(mesh.mesh.mesh.mac_short)) 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 new_lora_mac = None 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()
def set_gps(self, latitude, longitude): print('settings gps!') Gps.set_location(latitude, longitude)
def set_gps(self, lng, lat): print('settings gps!') Gps.set_location(lat, lng)
def __init__(self): self.a=Gps() self.setupUi(MainWindow)
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()