Avatar

GPS L1 Qualität Abschätzung Berechnungsmethode (Geodäsie/Vermessung)

MichaeL ⌂, Bad Vilbel, Freitag, 17. Februar 2017, 17:02 (vor 3 Tagen) @ Ulrich

Hallo,

GPS ist schon lange keine "blackbox" mehr sondern die verschiedenen Chips liefern standardisierte Daten die geodätisch ausgewertet werden können.

Das habe ich auch nicht angezweifelt. Dennoch kommst Du, wie Du selbst schon zugegeben hast, eben nicht an die Datenverarbeitung heran, die von der Firmware vorgenommen wird.

Diese billigen Chips liefern für statische Beobachtungen RINEX Daten die mit Standardanwendungen (RTKLIB) im Postprocessing ausgewertet werden können.

Ich weiß, aber das sind ja bereits Daten, die intern Aufbereitet wurden durch die Firmeware. Ich hatte Deine Frage so verstanden, dass Du wissen willst, nach welchen Kriterien entscheiden wird, Basislinien bestimmter Länge zu prozessieren.

Neben den präzisen Daten liefern diese Chips aber auch die NMEA Datensätze und ich hatte mir erhofft das sich jemand damit beschäftigt mittels dieser einfachen NMEA Meldungen einen Beobachtungstimer, der während Messung abgelesen wird, entwickelt zu haben.

Das Auslesen von bspw. u-blox stellt ja auch kein Problem dar und habe ich auch schon gemacht und die NMEA abgegriffen mit bspw. 1 Hz. Und natürlich kann ich nun diese Daten über einen Zeitraum sammeln und dann mitteln und Dir eine Genauigkeit ausrechnen. Dass kann ich Dir gern zur Verfügung stellen, wenn es Dir weiterhilft - siehe unten.

Viele Grüße
Micha

package com.derletztekick.geodesy.instrument.gnss.ublox;
 
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;
import java.util.TimeZone;
import java.util.TooManyListenersException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
 
import gnu.io.CommPort;
import gnu.io.CommPortIdentifier;
import gnu.io.PortInUseException;
import gnu.io.SerialPort;
import gnu.io.SerialPortEvent;
import gnu.io.SerialPortEventListener;
import gnu.io.UnsupportedCommOperationException;
 
import com.derletztekick.geodesy.instrument.gnss.GNSSLogger;
import com.derletztekick.geodesy.instrument.gnss.GNSSPosition;
 
public class TEPUB353 extends GNSSLogger {
 private class SerialReader implements SerialPortEventListener {
  // http://aprs.gids.nl/nmea/
  private String responseMessageGPGGA = "";
  private Calendar systemDate = Calendar.getInstance(TimeZone.getTimeZone("UTC"));
  @Override
 
  public synchronized void serialEvent(SerialPortEvent event) {   
   if (event.getEventType() == SerialPortEvent.DATA_AVAILABLE) {
    byte[] readBuffer = new byte[0xFFFF];
 
    try {
     int readBytes;
     String resStr = new String();
     while (inputStream.available() > 0) {
      readBytes = inputStream.read(readBuffer);
      resStr = new String(readBuffer, 0, readBytes);
      this.responseMessageGPGGA += resStr;
     }
 
     int beginIndex = this.responseMessageGPGGA.lastIndexOf("$GPGGA");
     int endIndex   = this.responseMessageGPGGA.lastIndexOf("\n");
     this.systemDate = Calendar.getInstance(TimeZone.getTimeZone("UTC"));
 
     if (beginIndex != -1 && endIndex != -1 && beginIndex < endIndex) {
      lastPosition = exploidResponse(this.responseMessageGPGGA.substring(beginIndex, endIndex));
      this.responseMessageGPGGA = "";
     }
    } 
    catch (IOException e) {
     this.responseMessageGPGGA = "";
     System.err.println("Fehler beim Datenempfang!");
     e.printStackTrace();
    }
   }
  }
  // $GPGGA,hhmmss.ss,llll.ll,a,yyyyy.yy,a
  // $GPGGA,153933.00,5011.28964,N,00844.51181,E,1,08,1.08,103.7,M,47.5,M,,*50
  private GNSSPosition exploidResponse(String response) {
   GNSSPosition gnssPosition = null;
   Calendar receivedDate = Calendar.getInstance(TimeZone.getTimeZone("UTC"));
   String regexp = new String("^\\$GPGGA,(\\d{2})(\\d{2})(\\d{2})\\.(\\d*),");
   Pattern pattern = Pattern.compile(regexp);
   Matcher matcher = pattern.matcher(response);
   if (matcher != null && matcher.find() && matcher.groupCount() >= 4) { // 10
    int hh    = Integer.parseInt(matcher.group(1), 10);
    int mm    = Integer.parseInt(matcher.group(2), 10);
    int ss    = Integer.parseInt(matcher.group(3), 10);
    int SS    = Integer.parseInt(matcher.group(4), 10)*10;
 
    receivedDate.set(Calendar.HOUR_OF_DAY, hh);
    receivedDate.set(Calendar.MINUTE, mm);
    receivedDate.set(Calendar.SECOND, ss);
    receivedDate.set(Calendar.MILLISECOND, SS);
 
    double latitude = 0, longitude = 0;
    char ns = 'N', ew = 'E';
    gnssPosition = new GNSSPosition(
      latitude, 
      GNSSPosition.GeographicDirectionLatitude.getGeographicDirectionLatitudeByChar(ns),
      longitude, 
      GNSSPosition.GeographicDirectionLongitude.getGeographicDirectionLongitudeByChar(ew), 
      new Date(receivedDate.getTimeInMillis()), 
      new Date(systemDate.getTimeInMillis()));
   }
 
   return gnssPosition;
 
  }  
 }
 
 private GNSSPosition lastPosition;
 private int baudRate = 9600; //4800; //9600;
 private int dataBits = SerialPort.DATABITS_8;
 private int stopBits = SerialPort.STOPBITS_1;
 private int parity   = SerialPort.PARITY_NONE;
 private CommPortIdentifier portId;
 private SerialPort serialPort;
 
 private InputStream  inputStream;
 private OutputStream outputStream;
 
 public CommPortIdentifier getCommPortIdentifier() {
  return portId;
 }
 
 public int getBaudRate() {
  return baudRate;
 }
 
 public int getDataBits() {
  return dataBits;
 }
 
 public int getStopBits() {
  return stopBits;
 }
 
 public int getParity() {
  return parity;
 }
 
 public void setBaudRate(int baudRate) {
  this.baudRate = baudRate;
 }
 
 public void setDataBits(int dataBits) {
  this.dataBits = dataBits;
 }
 
 public void setStopBits(int stopBits) {
  this.stopBits = stopBits;
 }
 
 public void setParity(int parity) {
  this.parity = parity;
 }
 
 public void setCommPortIdentifier(CommPortIdentifier portId) {
  this.portId = portId;
 }
 
 @Override
 public boolean connect() {
  try {
   if (portId == null || baudRate % 1200 != 0 || dataBits < 5 || dataBits > 8 || stopBits < 1 || stopBits > 2 || parity < 0 || parity > 2) {
    System.err.println(this.getClass().getSimpleName() + " Fehler, invalide Verbindungseinstellungen!");
    return false;
   }
 
   if (portId.isCurrentlyOwned() ) {
    System.err.println(this.getClass().getSimpleName() + " Fehler, PORT " + portId.getName() + " wird bereits verwendet von " + portId.getCurrentOwner() + "!");
    return false;
   }
 
   CommPort commPort = portId.open(this.getClass().getSimpleName(),2000);
   if (commPort instanceof SerialPort) {
    this.serialPort = (SerialPort)commPort;
 
    this.serialPort.setSerialPortParams(
      baudRate, 
      dataBits, 
      stopBits, 
      parity
    );
 
    this.inputStream  = serialPort.getInputStream();
    this.outputStream = serialPort.getOutputStream();
 
    this.serialPort.removeEventListener();
    this.serialPort.addEventListener(new SerialReader());
    this.serialPort.notifyOnDataAvailable(true);
   }
   else {
    System.err.println(this.getClass().getSimpleName() + " Fehler, PORT " + portId.getName() + " ist kein SerialPort!");
    //             this.fireErrorOccurred("WRONG_PORT_TYPE");
    return false;
   }
  } catch (PortInUseException e) {
   e.printStackTrace();
   return false;
  } catch (UnsupportedCommOperationException e) {
   e.printStackTrace();
   return false;
  } catch (TooManyListenersException e) {
   e.printStackTrace();
   return false;
  } catch (IOException e) {
   e.printStackTrace();
   return false;
  }
  return true;
 }
 
 @Override
 public boolean disconnect() {
  ExecutorService executorService = Executors.newSingleThreadExecutor();
  executorService.execute(new Runnable() {
   @Override
   public void run() {
    try {if (outputStream != null) outputStream.close();} catch (IOException e) {e.printStackTrace();}
    try {if (inputStream != null) inputStream.close(); } catch (IOException e) {e.printStackTrace();}
    try {
     if (serialPort != null) {
      synchronized(this){
       serialPort.removeEventListener();
       serialPort.addEventListener(null);    
       serialPort.close();
      }
     }
    } catch (Exception e) {e.printStackTrace();}
   }
  });
 
  executorService.shutdown();
  try {
   executorService.awaitTermination(5, TimeUnit.SECONDS);
   if (!executorService.awaitTermination(5, TimeUnit.SECONDS)) {
    executorService.shutdownNow(); // Cancel currently executing tasks
    if (!executorService.awaitTermination(5, TimeUnit.SECONDS))
     System.err.println(this.getClass().getSimpleName() + " PORT closing did not terminate!");
   }
  } catch (InterruptedException e) {
   executorService.shutdownNow(); // (Re-)Cancel if current thread also interrupted
   Thread.currentThread().interrupt(); // Preserve interrupt status
   return false;
  }
  return true;
 }
 
 @Override
 public GNSSPosition getLastPosition() {
  return lastPosition;
 }
 
 public static void main (String args[]) throws Exception {
  SimpleDateFormat simpleDateFormat = new SimpleDateFormat("hh:mm:ss.SSS");
  TEPUB353 usbLogger = new TEPUB353();
  usbLogger.setCommPortIdentifier(CommPortIdentifier.getPortIdentifier("COM5")); 
  usbLogger.connect();
 
  int i=1;
  while (i++ > 0) {
   Thread.sleep(100);
   GNSSPosition pos = usbLogger.getLastPosition();
 
   if (pos != null)
    System.out.println(i+"  "+(pos.getReceivedDate().getTime() - pos.getSystemDate().getTime())+"  "+simpleDateFormat.format(pos.getReceivedDate())+"    "+simpleDateFormat.format(pos.getSystemDate()));
  }
  usbLogger.disconnect();
 }
 
}
package com.derletztekick.geodesy.instrument.gnss;
 
public abstract class GNSSLogger {
 
 
 public abstract boolean connect();
 
 public abstract boolean disconnect();
 
 public abstract GNSSPosition getLastPosition();
 
}


package com.derletztekick.geodesy.instrument.gnss;
 
import java.util.Date;
 
public class GNSSPosition {
 public enum GeographicDirectionLatitude {
  NORTH, SOUTH;
 
  public static GeographicDirectionLatitude getGeographicDirectionLatitudeByChar(char c) {
   return c == 'N' || c == 'n' ? NORTH : SOUTH;
  }
 }
 
 public enum GeographicDirectionLongitude {
  EAST, WEST;
 
  public static GeographicDirectionLongitude getGeographicDirectionLongitudeByChar(char c) {
   return c == 'E' || c == 'e' ? EAST : WEST;
  }
 }
 
 private double longitude, latitude;
 private GeographicDirectionLatitude  oriLat;
 private GeographicDirectionLongitude oriLon;
 private Date receivedDate, systemDate;
 public GNSSPosition(double latitude, GeographicDirectionLatitude oriLat, double longitude, GNSSPosition.GeographicDirectionLongitude oriLon, Date receivedDate, Date systemDate) {
  this.longitude = longitude;
  this.latitude = latitude;
  this.oriLat = oriLat;
  this.oriLon = oriLon;
  this.receivedDate = receivedDate;
  this.systemDate = systemDate;
 }
 public double getLongitude() {
  return longitude;
 }
 public double getLatitude() {
  return latitude;
 }
 public Date getReceivedDate() {
  return receivedDate;
 }
 public Date getSystemDate() {
  return systemDate;
 }
 @Override
 public String toString() {
  return "GNSSPosition [longitude=" + longitude + "(" + oriLon + "), latitude="
    + latitude + "(" + oriLat + "), receivedDate=" + receivedDate + ", systemDate="
    + systemDate + "]";
 }
}

--
freie Tools zur Netzausgleichung, Transformation und Formanalyse


gesamter Thread:

 RSS-Feed dieser Diskussion