Amateur Astronomie

Benutzer-Werkzeuge

Webseiten-Werkzeuge

Zuletzt angesehen:
virtuelles_java-teleskop

Unterschiede

Hier werden die Unterschiede zwischen zwei Versionen angezeigt.

Link zu dieser Vergleichsansicht

Beide Seiten der vorigen RevisionVorhergehende Überarbeitung
Nächste Überarbeitung		Vorhergehende Überarbeitung
virtuelles_java-teleskop [2019/06/26 19:54] – [Quellcode Projekt A] torsten.roehlvirtuelles_java-teleskop [2020/11/22 16:19] (aktuell) – Externe Bearbeitung 127.0.0.1
Zeile 52: Zeile 52:
 == Test 1: Konsole == == Test 1: Konsole ==
  
-Ein erste Test erfolgt mit einer User-Konsole, indem folgender Befehlt an das Gerät gesendet wird, zuvor muss das Programm (z.B. über Eclipse gestartet werden).+Ein erste Test erfolgt mit einer User-Konsole, indem folgender Befehl an das Gerät gesendet wird, zuvor muss das Programm (z.B. über Eclipse gestartet werden).
  
   echo ":GD#" > /dev/ttyUSB61   echo ":GD#" > /dev/ttyUSB61
      
 Auf der Konsole (Eclipse) sollten jetzt die Anzahl der gelesenen Bytes angezeigt werden. Damit funktioniert die Kommunikation über die virtuelle serielle Schnittstelle. Auf der Konsole (Eclipse) sollten jetzt die Anzahl der gelesenen Bytes angezeigt werden. Damit funktioniert die Kommunikation über die virtuelle serielle Schnittstelle.
 +
 +  - Schnittstelle einrichten (socat,chmod)
 +  - Java //SimulatorTeleskop// starten
 +  - In einer Userkonsole //echo ":GD#" > /dev/ttyUSB61// eingeben
  
  
Zeile 62: Zeile 66:
    
 Der zweite Test ist spannender, da wir mit Stellarium kommunizieren. Der zweite Test ist spannender, da wir mit Stellarium kommunizieren.
-lx200 Teleskop einrichten mit /dev/ttyUSB61 als Device+  - LX200 Teleskop einrichten mit /dev/ttyUSB61 als Device (__noch nicht verbinden!__) 
 +  - Schnittstelle einrichten (socat, chmod) 
 +  - Java //SimulatorTeleskop// starten 
 +  - LX200 Teleskop in Stellarium verbinden
  
  
-  +===== Quellcode Projekt A ===== 
 + 
 +Das Protokoll kann hier eingesehen werden {{ :telescopeprotocol_lx200.pdf | LX200 Seriell-Protokoll}}
  
-==== Quellcode Projekt A ====+Das Javaprogramm implementiert nur wenige Kommandos des Protokolls. Nachdem Stellarium sich mit dem "Teleskop" (Javaprogramm) verbunden hat, sendet es permanent Anfragen um die Rektaszension //(#:GR#)// und die Deklination //(#:GE#)// des Telekops zu erhalten.
  
 +Wenn mit Stellarium geschwenkt werden soll, d.h. ein bestimmtes Objekt angefahren werden soll, werden drei Kommandos geschickt. Die ersten beiden Kommandos übermitteln die Zielkoordinaten, während das dritte Kommando //(:MS#)// eine Bestätigung erwartet um das Teleskop zu schwenken. Diese Befehle sind im {{ :telescopeprotocol_lx200.pdf | LX200 Seriell-Protokoll}} aufgelistet. Damit wir bei Stellarium eine animierte Bewegung sehen, wurde die Methode //simulateMove()// hinzugefügt, die lediglich die RA-Achse in zehn Schritten von den aktuellen Koordinaten //currentRA// zu den Zielkoordinaten //targetRA// bewegt.
 <code java> <code java>
  
Zeile 91: Zeile 101:
  
  static String dev = "/dev/ttyUSB60";  static String dev = "/dev/ttyUSB60";
 +
 + public enum Protocol // some serial lx200 commands
 + {
 + CMD_GR, CMD_GD, CMD_QS, CMD_SD, CMD_MS, CMD_UNKNOWN
 + }
  
  public static void main(String[] args) throws InterruptedException {  public static void main(String[] args) throws InterruptedException {
Zeile 108: Zeile 123:
  while (true) {  while (true) {
  
- // read message 
  String msg = decode(serialPort);  String msg = decode(serialPort);
 + Protocol cmd = protocol(msg);
  
- // run through protocol + switch (cmd) { 
- if (isMessage(msg)) { + case CMD_GR: 
-  + writeMessage(serialPort, currentRA); 
- System.out.println("Received: " + msg); + break; 
- + case CMD_GD: 
- if (msg.startsWith("#:GR#")) { // GET RA + writeMessage(serialPort, currentDE); 
- writeMessage(serialPort, currentRA); + break; 
- } + case CMD_QS: 
- if (msg.startsWith("#:GD#")) { // GET DEC + targetRA = msg.substring(msg.indexOf(' ')).trim(); 
- writeMessage(serialPort, currentDE); + writeMessage(serialPort, "1"); 
- } + break; 
- if (msg.startsWith("#:Q#:S")) { // SYNC to Slew 1/2 + case CMD_SD: 
- targetRA = msg.substring(msg.indexOf(' ')).trim(); + currentDE = msg.substring(msg.indexOf(' ')).trim(); 
- writeMessage(serialPort, "1"); + targetDE = currentDE; 
- } + writeMessage(serialPort, "1"); 
- if (msg.startsWith(":Sd ")) { // SYNC to Slew 2/2 sDD*MM:SS + break; 
- + case CMD_MS: 
- currentDE = msg.substring(msg.indexOf(' ')).trim(); + writeMessage(serialPort, "0"); 
- targetDE = currentDE; + simulateMove(); 
- writeMessage(serialPort, "1"); + break; 
- } + case CMD_UNKNOWN: 
- if (msg.startsWith(":MS#")) { // Slew to Target Object + if (!msg.startsWith("zero")) 
- writeMessage(serialPort, "0"); + System.out.println("...received unknown serial command: " + msg); 
- simulateMove(); + break;
- } +
  }  }
  
Zeile 152: Zeile 165:
  }  }
  
 + }
 +
 + private static Protocol protocol(String msg) {
 +
 + if (msg.startsWith("#:GR#"))
 + return Protocol.CMD_GR;
 + if (msg.startsWith("#:GD#"))
 + return Protocol.CMD_GD;
 + if (msg.startsWith("#:Q#:S"))
 + return Protocol.CMD_QS;
 + if (msg.startsWith(":Sd "))
 + return Protocol.CMD_SD;
 + if (msg.startsWith(":MS#"))
 + return Protocol.CMD_MS;
 +
 + return Protocol.CMD_UNKNOWN;
  }  }
  
  static String decode(SerialPort serialPort) {  static String decode(SerialPort serialPort) {
  try {  try {
- 
  // step 1: read bytes from port  // step 1: read bytes from port
  byte[] buffer = serialPort.readBytes();  byte[] buffer = serialPort.readBytes();
  // step 2: verify  // step 2: verify
  if (buffer == null)  if (buffer == null)
- return "UNKNOW COMMAND";+ return "zero buffer";
  
  int numRead = buffer.length;  int numRead = buffer.length;
  if (buffer.length <= 0)  if (buffer.length <= 0)
- return "UNKNOW COMMAND";+ return "zero length";
  
  // step 3: convert buffer to string  // step 3: convert buffer to string
Zeile 185: Zeile 213:
  }  }
  
- return "UNKNOW COMMAND";+ return "should not happen"; 
 + } 
 + 
 + static void writeMessage(SerialPort p, String msg) { 
 + try { 
 + byte[] buffer = msg.getBytes(); 
 + p.writeBytes(buffer); 
 + } catch (SerialPortException e) { 
 + e.printStackTrace(); 
 + }
  }  }
  
Zeile 253: Zeile 290:
  }  }
  
- static boolean isMessage(String msg) { +}
- if (msg.equals("UNKNOW COMMAND")) +
- return false; +
- return true; +
- }+
  
- static void writeMessage(SerialPort p, String msg) { 
  
- try { +</code> 
- byte[] buffer = msg.getBytes(); +<WRAP center round info 90%> 
- p.writeBytes(buffer); +Das dieses einfache Programm (die nur wenige Kommandos des Protokolls implementiert) funktioniert, verdanken wir den  saloppen Umgang von Stellarium (getestet mit 0.18.0) mit dem Protokoll. Eine verfünftige Initialisierung (Handschake) ist beispielsweise nicht erforderlich. 
- } catch (SerialPortException e) { +</WRAP>
- e.printStackTrace(); +
- } +
- }+
  
-} 
- 
-</code> 
  
virtuelles_java-teleskop.1561578894.txt.gz · Zuletzt geändert: (Externe Bearbeitung)