====== virtuelles Arduino-Teleskop ======

===== Übersicht =====

Zwei (virtuelle, d.h. simulierte) Teleskope werden entwickelt.
  - einfaches Teleskop mit Stellarium als Client
  - virtuelles Teleskop mit INDI-Treiber
Verwendet wird jeweils ein Arduino-Nano. Die erste Variante zeigt wie man das Java-Beispiel (Projekt A) auf ein Arduino überträgt. 

Die zweite Variante ist dann der Skelett-Treiber, der  mit der INDI-Schnittstelle kommuniziert. Dadurch können alle INDI-Clients (Stellarium, Skychart, KStars,...) verwendet werden. 

===== einfaches Teleskop mit Stellarium als Client =====




==== Installation und Inbetriebnahme ====
Öffnen der //Arduino-IDE// (einstellen des Nano und des verwendeten USB-Ports). Das Programm auf einen //Nano// übertragen. Die IDE kann geöffnet bleiben. Jetzt in //Stellarium// ein Teleskop hinzufügen und den von der IDE verwendeten USB-Port eintragen. Damit steht ein minimales (virtuelles da keine weitere Hardware verwendet wird) //Arduino-Teleskop// zur Verfügung.

== Details ==

Im Vergleich zu dem Java-Programm (Projekt A) wird das Meade-Protokoll hier exakt verwendet. Stellarium verwendet allerdings wird in zwei Befehlen ein zusätzliches Leerzeichen, welches im Protokoll nicht vermerkt ist. Da im Java Programm (Projekt A) mit //Strings// und //Trim// (entfernen von Leerzeichen ) gearbeitet wird, im Arduino C-Programm aber mit Byte-Array muss man hier sehr sorgfältig vorgehen.

Beim Schwenken in //Stellarium// werden gleich die Zielkoordinaten auf die aktuellen  Koordinaten übertragen, um den Code einfacher zu gestalten. 
==== Quellcode Arduino-Stellarium Teleskop ====


<code c>

/*
 * driver demo Stellarium-Arduino
 */
 
byte buffer[1];
char input[20];
byte currentRA[9];
byte currentDEC[10];


/* serial communication protocol lx200 */
byte cmd;
const byte PROTOCOL_GR =  54; // :GR#   get RA
const byte PROTOCOL_GD =  55; // :GD#   get DEC
const byte PROTOCOL_Q =  56;  // :Q# Bewegung stoppen
const byte PROTOCOL_SR =  57; // setze RA FORMAT  :Sr HH:MM:SS#
const byte PROTOCOL_SD =  58; // setze DEC FORMAT :Sd sDD*MM:SS#
const byte PROTOCOL_MS =  59; // :MS# Bewegung zum Ziel starten

void setup()
{
  Serial.begin(9600);
  //set currentRA = "02:31:50#";
  currentRA[0] = 48; currentRA[1] = 50; currentRA[2] = 58; currentRA[3] = 51;
  currentRA[4] = 49; currentRA[5] = 58; currentRA[6] = 53; currentRA[7] = 48; currentRA[8] = 35;
  // set currentDE = "+89*15:00#";
  currentDEC[0] = 43;  currentDEC[1] = 56;  currentDEC[2] = 57;  currentDEC[3] = 42;  currentDEC[4] = 49;
  currentDEC[5] = 53;  currentDEC[6] = 58;  currentDEC[7] = 48;  currentDEC[8] = 48;  currentDEC[9] = 35;
}

void loop()
{

  if (Serial.available() > 0) {

    cmd =  read();

    switch (cmd) {

      case PROTOCOL_GR:
        send(currentRA, 9);
        break;

      case PROTOCOL_GD:
        send(currentDEC, 10);
        break;

      case PROTOCOL_Q:
        // do nothing!
        break;

      case PROTOCOL_SR:
        // RA empfangen bestätigen mit 1
        buffer[0] = 49;
        send(buffer, 1);
        break;

      case PROTOCOL_SD:
        // DEC empfangen bestätigen mit 1
        buffer[0] = 49;
        send(buffer, 1);
        break;

      case PROTOCOL_MS:
        // bestätigen mit 0
        buffer[0] = 48;
        send(buffer, 1);
        break;
    }

  }

}


byte read() {

  int i = 0;
  input[i++] = Serial.read();
  delay(5);

  while ((input[i++] = Serial.read()) != '#') {
    delay(5);
  }
  delay(100);
  input[i] = '\0';

  if (input[1] == ':' && input[2] == 'G' && input[3] == 'R' && input[4] == '#') {
    return PROTOCOL_GR;
  }

  if (input[1] == ':' && input[2] == 'G' && input[3] == 'D' && input[4] == '#') {
    return PROTOCOL_GD;
  }

  if (input[1] == ':' && input[2] == 'Q' && input[3] == '#') {
    return PROTOCOL_Q;
  }

  if (input[0] == ':' && input[1] == 'S' && input[2] == 'r') {
    // RA empfangen :Sr HH:MM:SS#
    // Leerzeichen fehlt im LX-Protokoll!
    currentRA[0] = input[4];
    currentRA[1] = input[5];
    currentRA[2] = 58;
    currentRA[3] = input[7];
    currentRA[4] = input[8];
    currentRA[5] = 58;
    currentRA[6] = input[10];
    currentRA[7] = input[11];
    currentRA[8] = 35;

    return PROTOCOL_SR;
  }

  if (input[0] == ':' && input[1] == 'S' && input[2] == 'd') {
    // DEC empfangen :Sd sDD*MM#
    //Leerzeichen fehlt im LX-Protokoll!
    currentDEC[0] = input[4];
    currentDEC[1] = input[5];
    currentDEC[2] = input[6];
    currentDEC[3] = 42 ;
    currentDEC[4] = input[8];
    currentDEC[5] = input[9];
    currentDEC[6] = 58;
    currentDEC[7] = 48;
    currentDEC[8] = 48;
    currentDEC[9] = 35;


    return PROTOCOL_SD;
  }

  if (input[0] == ':' && input[1] == 'M' && input[2] == 'S' && input[3] == '#') {
    return PROTOCOL_MS;
  }

  return -1;
}

void send(byte lsData[], int len) {

  for (int i = 0; i < len; i++ ) {
    Serial.write(lsData[i]);
  }

}
</code>



===== virtuelles Teleskop mit INDI-Treiber =====

Der INDI-Treiber ist in C(C++) geschrieben, diese Treiber sind standardisiert. Das bedeutet man muss sich zuvor in die INDI-Treiber-Entwicklung  https://indilib.org/ einlesen. Und die mitgelieferten Beispiele und Tutorials durcharbeiten. Voraussetzung sind neben Linux gute Kenntnisse von C/C++ ansonsten kann es etwas holprig werden. 

Sind die voraussetzen erfüllt ist es relativ einfach die mitgelieferten Beispiele zu verstehen und sich nach einigen Tagen einen Überblick über die Materie zu verschaffen.

Der grundsätzliche Aufbau entspricht dem folgenden Schema:
{{ :arduino-skelett.png?600 |}}





==== Installation und Inbetriebnahme ====

Im INDI //Developer Manual// ist beschrieben, wie eine Entwicklungsumgebung eingerichtet werden kann und wie Software (Eigene, Third-Party oder Beispiel-Programme) übersetzt werden.

  * https://github.com/indilib/indi/tree/master/libindi/drivers/skeleton Startpunkt für den eigenen Teleskoptreiber ist: //mount_driver//. Dieser Treiber wird in ein eigenes Verzeichnis kopiert und angepasst.
== Details ==

== Software ==