def __init__(self): threading.Thread.__init__(self) global gpsd #bring it in scope gpsd = gps("localhost", "2947") gpsd = gps(mode=WATCH_ENABLE) #starting the stream of info self.current_value = None self.running = True #setting the thread running to true
def __init__(self): threading.Thread.__init__(self) #starting the stream of info self.gpsd = gps(mode=WATCH_ENABLE) self.current_value = None #setting the thread running to true self.running = True
class GpsPoller(threading.Thread): def __init__(self): threading.Thread.__init__(self) global gpsd #bring it in scope gpsd = gps(mode=WATCH_ENABLE) #starting the stream of info self.current_value = None self.running = True #setting the thread running to true def run(self): global gpsd while gpsp.running: gpsd.next() #this will continue to loop and grab EACH set of gpsd info to clear the buffer if __name__ == '__main__': gpsp = GpsPoller() # create the thread try: gpsp.start() # start it up while True: #It may take a second or two to get good data print ' GPS mode:' print '----------------------------------------' print 'mode ' , gpsd.fix.mode # all values greather than 1 is a GPS fix. while True: if gpsmode > 1: GPIO.output(24, True) if gpsmode < 1: GPIO.output(24, False)
def __init__(self): threading.Thread.__init__(self) global gpsd #bring it in scope gpsd = gps(mode=WATCH_ENABLE) #starting the stream of info #gpsd.send([0xB5,0x62,0x06,0x08,0x06,0x00,0x64,0x00,0x01,0x00,01,0x7A,0x12,\n]) self.current_value = None self.running = True #setting the thread running to true
def createStartSendThread(dataLevel): global sendingData global tSendCreated1 global tSendRunning1 global tSendCreated2 global tSendRunning2 gpsd = gps(mode=WATCH_ENABLE | WATCH_NEWSTYLE) if (dataLevel == 1): if not tSendCreated1: sendThread = threading.Thread(target=sendPositionData, args=[gpsd, dataLevel]) tSendCreated1 = True if not tSendRunning1: sendThread.start() tSendRunning1 = True if (dataLevel == 2): if not tSendCreated2: sendThread = threading.Thread(target=sendPositionData, args=[gpsd, dataLevel]) tSendCreated2 = True if not tSendRunning2: sendThread.start() tSendRunning2 = True
def __init__(self): logging.info("Starting GPS poller thread") threading.Thread.__init__(self) global gpsd #bring it in scope gpsd = gps(mode=WATCH_ENABLE) #starting the stream of info self.current_value = None self.running = True #setting the thread running to true
def __init__(self, start=True): threading.Thread.__init__(self) global gpsd #bring it in scope self.i = 0 # counter for averaging self.average_number = 10 # number of values for average gpsd = gps(mode=WATCH_ENABLE) #starting the stream of info self.data = [float('nan'), float('nan'), float('nan'), float('nan'), [], float('nan')] # averaged data self.raw_data = self.data # not averaged data self.lat_list = [float('nan')] * self.average_number self.long_list = [float('nan')] * self.average_number self.alt_list = [float('nan')] * self.average_number #data = [gpsd.fix.latitude, gpsd.fix.longitude, gpsd.fix.altitude, gpsd.fix.track, gpsd.satellites, time.time()] self.scale = 0.92 # for compass self.x_offset = 27 # for compass self.y_offset = -133 # for compass self.degree_offset = 188 # offset to north in degree self.sigma = 0.0000075 # standart-deviation for data; CAUTION: has to be adjusted for average_number; # av_nmb = 1 --> sigma = 0.00005 # av_nmb = 5 --> sigma = 0.00001 # av_nmb = 10 --> sigma = 0.0000075 self.is_new = True # tells, whether new data is out of 2-sigma-range since last fetch self.last = [0.0, 0.0] # last fetched data if (start): self.start()
def getGPSData(gps_obj_type, device, tries): gpsd = gps(mode=WATCH_ENABLE | WATCH_NEWSTYLE) if gps_obj_type == 'DEVICES': # If asked for Devices, we're doing LLD and we just need to search for the DEVICES object and return it. while True: gps_data = gpsd.next() if gps_data['class'] == gps_obj_type: return (gps_data) else: # Reset our attempts counter gps_obj_attempts = 0 while gps_obj_attempts < tries: gps_data = gpsd.next() # Search for an object of the right class if gps_data['class'] == gps_obj_type: # Did it come from the correct device? if gps_data['device'] == device: return (gps_data) else: # We only increment when the correct class fails, so VERSIOn, Device and other objects don't throw things off. gps_obj_attempts = gps_obj_attempts + 1 # If we get here, we couldn't find the right data on the right device, so throw an error! print("GPS data not found. Could not find GPS object type '" + gps_obj_type + "' on device '" + device + "' after " + str(tries) + " attempts.", file=sys.stderr) sys.exit(1)
def __init__(self, start=True): threading.Thread.__init__(self) global gpsd #bring it in scope self.i = 0 # counter for averaging self.average_number = 1 #5 # number of values for average gpsd = gps(mode=WATCH_ENABLE) #starting the stream of info self.data = [ float('nan'), float('nan'), float('nan'), float('nan'), [], float('nan') ] self.lat_list = [float('nan')] * self.average_number self.long_list = [float('nan')] * self.average_number self.alt_list = [float('nan')] * self.average_number #data = [gpsd.fix.latitude, gpsd.fix.longitude, gpsd.fix.altitude, gpsd.fix.track, gpsd.satellites, time.time()] self.scale = 0.92 # for compass self.x_offset = 27 # for compass self.y_offset = -133 # for compass self.degree_offset = 188 # offset to north in degree if (start): self.start()
def __init__(self): # Initialize the Thread class Thread.__init__(self) # Check if the GPS module is connected by checking if /dev/ttyUSB0 exists if(os.path.exists('/dev/ttyUSB0')): try: # Start gathering the GPS data stream self.gpsSession = gps(mode=WATCH_ENABLE) # Create a variable to store the thread's running status self.running = False # Set the GPS controller status to connected RoverStatus.gpsControllerStatus = RoverStatus.ready except: # Change the GPS controller status to not connected because USB # failed to communicate with the GPS module RoverStatus.gpsControllerStatus = RoverStatus.notConnected else: # Set the GPS controller status to not connected RoverStatus.gpsControllerStatus = RoverStatus.notConnected
def __init__(self): print("this is init") self.ROOT_DIR = os.path.dirname(os.path.abspath(__file__)) print("Root Directory" + self.ROOT_DIR) #self.home = str(Path.home())+"/cameraProject/" self.home = self.ROOT_DIR + "/" # Inititalize GPS gpsd = gps(mode=WATCH_ENABLE | WATCH_NEWSTYLE) self.gpsd = gpsd # Fetch Intial Storage self.storageLeft = self.getStorageleft() # Initialize GPIO pins GPIO.setmode(GPIO.BCM) GPIO.setup(17, GPIO.IN) # HiGH for keeping the power ON GPIO.setup(18, GPIO.OUT, initial=GPIO.HIGH) # HIGH for LED to imdicate processing GPIO.setup(24, GPIO.OUT, initial=GPIO.HIGH) self.ignitionStatus = GPIO.input(17) self.ledON = True # Initialize camera self.camera = PiCamera() self.initDataLogFile() self.lengthOfVideo = 60 # in seconds print('Init Successfull') self.processStarted = True
def my_gps(): session = gps(mode=WATCH_ENABLE) try: while True: data = session.next() if data['class'] == "TPV": os.system('clear') print print (' GPS Readings') print ('latitude ' , session.fix.latitude) print ('longitude ' , session.fix.longitude) print ('velocity (m/s) ' , session.fix.speed) print except KeyError: pass except KeyboardInterrupt: print print ("Closed By User") except StopIteration: print print ("GPSD has stopped") finally: session = None
def __init__(self, iD): threading.Thread.__init__(self) self.iD = iD global gpsd #bring it in scope gpsd = gps(mode=WATCH_ENABLE) #starting stream of info self.current_value = None self.running = True #setting the thread running to true
def __init__(self): threading.Thread.__init__(self) self.logger = logging.getLogger('FlightDataLogger.GpsReader') self.logger.info('GPS Reader initializing...') self.session = gps("localhost", "2947", mode=WATCH_ENABLE) self.currentValue = None self.running = True
def __init__(self): threading.Thread.__init__(self) self.daemon = True self.gpsd = gps() self.gpsd.stream(WATCH_ENABLE | WATCH_NEWSTYLE) self.current_value = {} self.running = True
def getfix(): global ts whereami = gps(mode=WATCH_ENABLE) whereami.next() while whereami.data['class'] != 'TPV': whereami.next() lat = whereami.fix.latitude lng = whereami.fix.longitude alt = whereami.fix.altitude ts = whereami.data['time'] latlng = str(lat) + "," + str(lng) whereami.close() apiparams = { "latlng": latlng, "location_type": "APPROXIMATE", "key": apikey } response = requests.get(mapurl, params=apiparams) #If you run into problems you can test the URL output by uncommenting the line below #print response.url y = json.loads(response.text, object_hook=findloc) logout = open(logfile, 'a+') logout.write(ts + "\t" + str(lat) + "\t" + str(lng) + "\t" + str(alt) + "\n") logout.close()
def read(self, SIO): gpsd = gps(mode=WATCH_ENABLE | WATCH_NEWSTYLE) report = gpsd.next() retries = 6 while report['class'] != 'TPV' and retries: #print(report['class']) report = gpsd.next() retries -= 1 if report['class'] != 'TPV': return False tstr = getattr(report, 'time', None) self.lat = getattr(report, 'lat', None) self.lon = getattr(report, 'lon', None) self.alt = getattr(report, 'alt', None) self.t = time.time() print("GPS", self.t, tstr, self.lat, "N, ", self.lon, "E, ", self.alt, "m") #print getattr(report,'epv','nan'),"\t", #print getattr(report,'ept','nan'),"\t", #print getattr(report,'speed','nan'),"\t", #print getattr(report,'climb','nan'),"\t" if self.lat is not None: SIO.log_readout(self.lat_id, self.lat, self.t) if self.lon is not None: SIO.log_readout(self.lon_id, self.lon, self.t) if self.alt is not None: SIO.log_readout(self.alt_id, self.alt, self.t)
def __init__(self): threading.Thread.__init__(self) global gpsd gpsd = gps(mode=WATCH_ENABLE) self.current_value = None self.running = True
def getPositionData(self): try: nx = self.gpsd.next() position = "" # For a list of all supported classes and fields refer to: # https://gpsd.gitlab.io/gpsd/gpsd_json.html if nx['class'] == 'TPV': latitude = getattr(nx, 'lat', "Unknown") longitude = getattr(nx, 'lon', "Unknown") speed = getattr(nx, 'speed', "Unknown") time = getattr(nx, 'time', "Unknown") alt = getattr(nx, 'alt', "Unknown") position = "Your position: lon = " + str( longitude ) + ", lat = " + str(latitude) + ", speed =" + str( speed) + ", time = " + str(time) + ", alt = " + str(alt) print(position) return position except BaseException as e: print(str(e)) subprocess.call('sudo systemctl stop gpsd.socket', shell=True) subprocess.call('sudo gpsd /dev/serial0 -F /var/run/gpsd.sock', shell=True) gpsd = gps(mode=WATCH_ENABLE | WATCH_NEWSTYLE) self.gpsd = gpsd print("re initilizing socket") return ""
def gps_data(): #! /usr/bin/python from gps import * import time gpsd = gps(mode=WATCH_ENABLE | WATCH_NEWSTYLE) print 'latitude\tlongitude\tspeed' # '\t' = TAB to try and output the data in columns. try: while True: report = gpsd.next() # if report['class'] == 'TPV': print getattr(report, 'lat', 0.0), "\t", print getattr(report, 'lon', 0.0), "\t", #print getattr(report,'epv','nan'),"\t", #print getattr(report,'ept','nan'),"\t", print getattr(report, 'speed', 'nan'), "\t" time.sleep(1) except (KeyboardInterrupt, SystemExit): #when you press ctrl+c print "Done.\nExiting." return
def __init__(self): threading.Thread.__init__(self) self.gpsd = gps(mode=WATCH_ENABLE) self.current_value = None self.running = True self.fixAge = 0 self.exit = threading.Event()
def main(): gpsd = gps(mode=WATCH_ENABLE|WATCH_JSON) # '\t' = TAB to try and output the data in columns. dbUrl = 'mongodb://*****:*****@ds235053.mlab.com:35053/aed' client = MongoClient(dbUrl) db = client['aed'] collection = db['gp01'] moved = False try: while True: report = gpsd.next() system("clear") print ('latitude\tlongitude\ttime utc\t\taltitude\tspeed' ) if (report['class'] == 'TPV') & (getattr(report,'lat',0.0) != 0): is_moving = False if (getattr(report,'speed', 0.0) <= 2) else True moved = moved ^ is_moving aed_locate = { 'time' : datetime.now(), 'lat' : getattr(report,'lat',0.0), 'long' : getattr(report,'lon',0.0), 'alt' : getattr(report,'alt',0.0), 'speed' : getattr(report,'speed',0.0), 'moved' : moved } map_link = 'http://maps.google.com/?q=' + getattr(report,'lat',0.0) + ',' + getattr(report,'lon',0.0) print (getattr(report,'lat',0.0),"\t", getattr(report,'lon',0.0),"\t", getattr(report,'time',''),"\t", getattr(report,'alt','nan'),"\t", getattr(report,'speed','nan'),"\t") collection.insert_one(aed_locate) except (KeyboardInterrupt): #when you press ctrl+c webbrowser.open(map_link) #open current position information in google map sys.exit()
def __init__(self, window): self.gpsd = None self.num3DFixes = 0 self.rollingLat = 0 self.rollingLon = 0 self.rollingTrack = 0 self.rollingSpeed = 0 self.rollingEpx = 0 self.rollingEpy = 0 self.rollingSatsUsed = 0 self.rollingHdop = 0 self.rollingWindow = window if self.rollingWindow < 3 or self.rollingWindow > 10: logging.error('Rolling average window needs to be between 3 or 10') # we are going to be a thread threading.Thread.__init__(self) logging.debug( 'Setting up gpspoller __init__ class with rolling Average window of: ' + str(self.rollingWindow)) try: self.gpsd = gps(mode=WATCH_ENABLE) #starting the stream of info except: logging.error('GPS thread Ops... gpsd not running right?' + 'Hint: sudo /etc/init.d/gpsd start') self.running = False logging.debug('gpspoller __init__ finished')
def start_gpsd (self): ''' method to connect to the gpsd socket, note that the systemd service has been disabled as following the following adafruit blogpost: https://learn.adafruit.com/adafruit-ultimate-gps-on-the-raspberry-pi?view=all This means that the gpsd daemon needs to be manually started on every boot of the pi. ''' # start the gpsd daemon, if this is a posix system if os.name == 'posix': os.system ('sudo gpsd /dev/ttyUSB0 -F /var/run/gpsd.sock') # now, try to create a link to this socket (this will fail on windows, but that is ok) try: self.ser = gps (mode = WATCH_ENABLE) self.bs['gps_comms_on'] = True except: try: del self.ser except: pass self.bs['gps_comms_on'] = False return
def __init__(self): threading.Thread.__init__(self) global gpsd #bring it in scope gpsd = gps(mode=WATCH_ENABLE, host=HOST, port=PORT) #starting the stream of info self.current_value = None self.running = True #setting the thread running to true
def __init__(self, gps_data_callback=None): super(GPS, self).__init__() self.gpsd = gps(mode=WATCH_ENABLE | WATCH_NEWSTYLE) self.callback = gps_data_callback # (lat, lon, epx, epy, ts) self.last_data = (-1, -1, -1, -1, -1) self.has_more_data = True self.stop_event = threading.Event()
def __init__(self): threading.Thread.__init__(self) self.daemon = True self.paused = True self.state = threading.Condition() self.gpsd = gps(mode=WATCH_ENABLE)
def __init__(self, queue): super().__init__() self.gpsd = None # bring it in scope self.gpsd = gps(mode=WATCH_ENABLE) # starting the stream of info self.current_value = None self.queue = queue self.latitude = None self.longitude = None
def __init__(self, conf, logger, queue): threading.Thread.__init__(self) self.session = gps(mode=WATCH_ENABLE) self.conf = conf self.logger = logger self.queue = queue self.last_speed = 1.0 self.nofix = False
def __init__(self): global session threading.Thread.__init__(self) # session = gps(mode=WATCH_ENABLE) self.current_value = None # Der Thread wird ausgefuehrt self.running = True
def __init__(self, wifiNetworks, interval): self.stopThread = threading.Event() self.wifiNetworks = wifiNetworks self.interval = interval self.setWirelessInterface(None) self.session = gps(mode=WATCH_ENABLE) self.scanning = False threading.Thread.__init__(self)
def __init__(self): threading.Thread.__init__(self) global gpsd # starting the stream of info gpsd = gps(mode=WATCH_ENABLE) self.current_value = None self.running = True
def __init__(self): threading.Thread.__init__(self) global gpsd #bring it in scope gpsd = gps(mode=WATCH_ENABLE) #starting the stream of info self.current_value = None self.running = True #setting the thread running to true writeLog(url, "[INFO] GPS Poller Start", "GPS initialized successfully")
def __init__(self): threading.Thread.__init__(self) global gpsd #bring it in scope global ppid4 ppid4 = os.getpid() gpsd = gps(mode=WATCH_ENABLE) #starting the stream of info self.current_value = None self.running = True #setting the thread running to true
def gps_setup(): try: ## lobal for GPS polling thread. global gps gps = gps(mode=WATCH_ENABLE) except: print("No GPS.") sys.exit()
def __init__(self,): super(GPSReader, self).__init__() try: SharedData.gpsd = gps(mode=WATCH_ENABLE) self.connected = True except socket.error: print "\tGPSReader: gpsd server is not available. GPSReader disabled." self.connected = False
def __init__(self): threading.Thread.__init__(self) #bring it in scope global gpsd #starting the stream of info gpsd = gps(mode=WATCH_ENABLE) self.current_value = None #setting the thread running to true self.running = True
def __init__(self): rospy.init_node('GPSD') self.session = gps() self.session.stream(WATCH_ENABLE|WATCH_NEWSTYLE) self.currentVal = None self.fixPublisherLL = rospy.Publisher('fixLL', GPSFix) self.fixPublisherUTM = rospy.Publisher('fix', NavSatFix) self.currentFixLL = GPSFix() self.currentFixForUTM = NavSatFix()
def __init__(self): rospy.init_node('gpsd_client') #threading.Thread.__init__(self) self.session = gps() self.session.stream(WATCH_ENABLE|WATCH_NEWSTYLE) self.current_value = None self.fixpub = rospy.Publisher('gps/fix', GPSFix) self.statuspub = rospy.Publisher('gps/status', GPSStatus) self.current_fix = GPSFix()
def __init__(self): threading.Thread.__init__(self) # Call global variable into scope global gpsd # Starting datastream from GPS gpsd = gps(mode=WATCH_ENABLE) self.current_value = None # Setting the thread running to true self.running = True
def __init__(self): threading.Thread.__init__(self) global gpsd #bring it in scope # global logging # logging.info('Init GPS') gpsd = gps(mode=WATCH_ENABLE) #starting the stream of info self.current_value = None self.running = True #setting the thread running to true
def run(self): gpsd = gps(mode=WATCH_ENABLE) # starting the stream of info try: while True: self.current_value = gpsd.next() except StopIteration: pass
def latlon(): gpsd = gps(mode = WATCH_ENABLE) try: while True: report = gpsd.next() if report['class'] == 'TPV': gpsd.close() return report['lat'], report['lon'] except: return None, None
def __init__(self): result = False while not result: try: threading.Thread.__init__(self) global gpsd #bring it in scope gpsd = gps(mode=WATCH_ENABLE|WATCH_NEWSTYLE) #starting the stream of info self.current_value = None self.running = True #setting the thread running to true result = True except: pass
def __init__(self, freq): threading.Thread.__init__(self) self.gpsd = gps(mode=WATCH_ENABLE) # starting the stream of info self.running = False self.data_set = GpsDataset() self.new_data_set = GpsDataset() self.new = False self.period = 1/freq
def __init__(self, threadID, name): threading.Thread.__init__(self) self.threadID = threadID self.name = name self.gpsd = gps(mode=WATCH_ENABLE) self.current_value = None self.running = True self.latitude = 0 self.longitude = 0 self.speed = 0 self.compass = 0 self.datetime = 0
def __init__(self, h, p, d): self.host = h self.port = p self.device = d self.update_daemon() threading.Thread.__init__(self) global gpsd #bring it in scope #gpsd = gps.gps("localhost", "99") gpsd = gps(self.host, self.port, mode=WATCH_ENABLE) #starting the stream of info self.current_value = None self.running = True #setting the thread running to true
def run(self): while not self.stopped: try: self.session = gps(mode=WATCH_ENABLE) while not self.stopped: try: self.session.next() if(self.session.fix.mode == MODE_2D or self.session.fix.mode == MODE_3D): self.data = GpsData() try: self.data.time = dateparse(self.session.fix.time) except: self.data.time = datetime.utcnow() self.data.latitude = self.session.fix.latitude self.data.longitude = self.session.fix.longitude self.data.sats = len(filter(lambda x: str(x)[-1:]=='y', self.session.satellites)) if not(isnan(self.session.fix.altitude)): self.data.altitude = self.session.fix.altitude else: self.data.altitude = 0 if not(isnan(self.session.fix.speed)): self.data.speed = self.session.fix.speed else: self.data.speed = 0 if not(isnan(self.session.fix.track)): self.data.track = self.session.fix.track else: self.data.track = 0 sleep(0.1) except: print("[GPS] gpsd polling failed. Retrying..") sleep(2) self.session = gps(mode=WATCH_ENABLE) except StopIteration: break except: print("[GPS] gpsd connection failed. Is it running? Retrying..") sleep(2)
def gpsLocation(): #prerequisite - start gpsd #sudo gpsd -b /dev/ttyUSB0 -F /var/run/gpsd.sock try: gpsd = gps(mode=WATCH_ENABLE) while 1: gpsd.next() print "lat ", gpsd.fix.latitude print "lng ", gpsd.fix.longitude print "alt ", gpsd.fix.altitude time.sleep(1) except: print "!!! get gps location error !!!" sys.exit(1)
def __init__(self): """Initialise GpsController class. Initialise the GpsController class using parameters passed in 'data'. Args: self: self. data: A dict containing the parameters to be used during setup. """ threading.Thread.__init__(self) self.gpsd = gps(mode=WATCH_ENABLE) # starting the stream of info self.running = False
def __init__(self, tick = 0, gps_dict = data.gps_dict): """ Initialize the thread with gps object and tick. @param tick -- time the thread will sleep in seconds (defaults to 0 seconds) @param gps_dict -- reference to a dictionary which will hold current gps data """ threading.Thread.__init__(self) self.running = True self.tick = tick self.gps_dict = gps_dict # init session object with gps moddule self.session = gps(mode=WATCH_ENABLE) print 'GpsPoller initialisiert.'
def my_gps(): global x global y session = gps(mode=WATCH_ENABLE) try: while True: data = session.next() if data['class'] == "TPV": os.system('clear') #m=1 #x= 30.19 #Kafr ElDawar #y= 31.12 #x=29.94145 #y=31.21939 #Smouha SidiGaber #x=29.90421 #y=31.204024 #Raml x = session.fix.longitude print(x) y = session.fix.latitude print(y) cur = con.cursor() cur.execute("SELECT AdPicture FROM Ads WHERE AreaID in ( SELECT AreaID FROM AdsAreas WHERE %s > StartLongitude AND %s < EndLongitude AND %s > StartLatitude AND %s < EndLatitude )",(x,x,y,y)) for i in range(cur.rowcount): row = cur.fetchone() p=subprocess.Popen(["eog","-f",row[0]]) time.sleep(5) #if m==0: # z.kill() # m=1 #row = cur.fetchone() #z=subprocess.Popen(["eog","-f",row[0]]) #time.sleep(5) #if m==1: # p.kill() #m=0 p.kill() except KeyError: pass except KeyboardInterrupt: print print ("Closed By User") except StopIteration: print print ("GPSD has stopped") finally: session = None
def __init__(self, event): """ Description: Initialize the gps thread """ threading.Thread.__init__(self) self._stopped = event self.gpsd = gps(mode=WATCH_ENABLE) self.last_lat = 0 self.last_epx = 0 self.last_lon = 0 self.last_epy = 0 self.last_alt = 0 self.last_epv = 0 self.last_speed = 0 self.last_eps = 0 self.last_time = ''
def run(self): logging.info("GP GPS Listener started") logging.debug("GP connecting to GPSd") gpsok = 0 while gpsok == 0: try: gpsd = gps(mode=WATCH_ENABLE) gpsok = 1 except Exception: logging.warn("GL Could not connect to GPSd .. retrying") time.sleep(3) logging.debug("GP connected to GPSd") for report in gpsd: GPSListener.lat = gpsd.fix.latitude GPSListener.lon = gpsd.fix.longitude GPSListener.alt = gpsd.fix.altitude GPSListener.fix = gpsd.fix.mode
def getGPS(): """ This functions gets the gps data from the gpsd session already started. """ global debug global global_location global threadbreak counter = 0 gps_session = "" gps_flag = False try: gps_session = gps(mode=WATCH_ENABLE) while not threadbreak: if counter > 10: global_location = "" try: location = gps_session.next() location['lon'] location['lat'] if global_location == "": pygame.mixer.music.load('gps.ogg') pygame.mixer.music.play() global_location = location counter = 0 time.sleep(0.5) except: counter = counter + 1 pass except KeyboardInterrupt: print 'Exiting received in getGPS() function. It may take a few seconds.' threadbreak = True except Exception as inst: print 'Exception getGPS() function.' threadbreak = True print 'Ending threads, exiting when finished' print type(inst) # the exception instance print inst.args # arguments stored in .args print inst # _str_ allows args to printed directly x, y = inst # _getitem_ allows args to be unpacked directly print 'x =', x print 'y =', y sys.exit(1)