ISS Pointer

# Importieren von notwendigen Modulen für die Funktionen im Skript:
import urllib.request  # Ermöglicht das Abrufen von Daten aus dem Internet
import time            # Fügt Wartezeiten hinzu
import datetime        # Arbeitet mit Datums- und Zeitfunktionen
import ephem           # Astronomische Berechnungen (z.B. Position der ISS)
import math            # Mathematische Funktionen
import atexit          # Führt bestimmte Befehle beim Programmende aus
import socket          # Netzwerkeinstellungen wie Timeout

############ BENUTZER-DEFINIERTE VARIABLEN
DEBUG = 0  # Debug-Modus (0=aus, 1=an)
INFO  = 1  # Anzeige der Ephemeriden-Informationen

# ORT DES BENUTZERS
LAT = 51.6     # Breitengrad des Beobachtungsortes (+N) in Grad
LON = 8.3      # Längengrad des Beobachtungsortes (+E) in Grad
ELV = 94.0     # Höhe des Beobachtungsortes in Metern

# NETZWERKADRESSEN FÜR VERBUNDENE GERÄTE
STEPIP = "http://192.168.1.27/"  # IP-Adresse des Schrittmotorsteuergeräts
LEDIP = "http://192.168.1.73/"   # IP-Adresse der LED-Steuerung
STEPS  = 2048                    # Schritte pro Umdrehung des Motors

########### ENDE BENUTZER-DEFINIERTE VARIABLEN

# Globale Konstanten und Variablen
FLOAT_A = float(STEPS) / 360.0    # Umrechnungsfaktor Schritte zu Grad
HOR = 10.0                        # Mindesthöhe über dem Horizont, um sichtbar zu sein
TLE = "https://api.wheretheiss.at/v1/satellites/25544/tles?format=text"  # ISS-TLE-Datenquelle

# Globale Variablen für die Verfolgung der ISS
glob_tle = []         # Wird für TLE-Daten der ISS genutzt
glob_azOld = 0        # Differenzberechnung des alten und neuen Azimuts
glob_azReset = 0      # Zurücksetzen des Zeigers auf Norden am Ende

# Funktion zur TLE-Abfrage und Speicherung
def getTLE():
    global glob_tle
    try:
        resp = urllib.request.urlopen(TLE)  # Holt TLE-Daten
        glob_tle = resp.read().decode('utf-8').split('\n')
        if DEBUG:
            print(glob_tle)
    except Exception as e:
        print("ERROR: Cannot retrieve coordinate data, retrying...", e)
        time.sleep(60)  # Warte eine Minute und versuche erneut

# LCD-Steuerung mit neuer Zeit
def doLCD(new_time):
    lcdUrl = STEPIP
    try:
        cmd = lcdUrl + str(new_time)
        resp = urllib.request.urlopen(cmd)
        if DEBUG:
            print(cmd)
            print(resp.read().decode('utf-8'))
        resp.close()
        time.sleep(0.1)  # Wartezeit für den WiFi-Buffer des Geräts
    except Exception as e:
        print("ERROR: LCD comm failure", e)

# LED-Steuerung (z.B. an oder aus)
def doLED(state):
    ledUrl = LEDIP
    try:
        cmd = ledUrl + "led/" + str(state)
        resp = urllib.request.urlopen(cmd)
        if DEBUG:
            print(cmd)
            print(resp.read().decode('utf-8'))
        resp.close()
        time.sleep(0.1)
    except Exception as e:
        print("ERROR: LED comm failure", e)

# Steuerung des Azimut-Schrittmotors für Ausrichtung
def doStepper(steps):
    if steps == 0:
        return
    try:
        stepperUrl = STEPIP
        # Sende Befehle zum Starten, Einstellen der Geschwindigkeit und Schritte, Stoppen
        for cmd_part in ["start", "rpm?10", f"steps?{steps}", "stop"]:
            cmd = f"{stepperUrl}stepper/{cmd_part}"
            resp = urllib.request.urlopen(cmd)
            if DEBUG:
                print(cmd)
                print(resp.read().decode('utf-8'))
            resp.close()
            time.sleep(0.1)
    except Exception as e:
        print("Stepper comm failure", e)
        time.sleep(5)
        # Fehlerbehandlung bei Verbindungsfehlern während "Stop"
        try:
            cmd = stepperUrl + "stepper/stop"
            resp = urllib.request.urlopen(cmd)
            print(cmd)
            print(resp.read().decode('utf-8'))
            resp.close()
        except Exception as e:
            print("Stepper comm failure during stop", e)

# Servo-Steuerung für Höhenwinkel des Zeigers
def doServo(angle):
    angle = max(0, min(90, angle))  # Begrenzung des Winkels auf 0-90°
    servoUrl = STEPIP
    try:
        cmd = servoUrl + "servo/value?" + str(angle)
        resp = urllib.request.urlopen(cmd)
        if DEBUG:
            print(cmd)
            print(resp.read().decode('utf-8'))
        resp.close()
        time.sleep(0.1)
    except Exception as e:
        print("Servo comm failure", e)

# Funktion zum Zurücksetzen des Zeigers nach Norden
def doAzReset():
    global glob_azOld, glob_azReset
    glob_azOld = 0
    if DEBUG:
        print(f"doAzReset({glob_azReset})")
    if glob_azReset != 0:
        steps = glob_azReset
        time.sleep(0.2)
        doStepper(-steps)
        glob_azReset = 0
        doServo(0)
        doLED('off')

# Programmende mit Nachricht
def exit():
    try:
        print("EXITING")
    except Exception:
        pass

###### HAUPTTEIL DES PROGRAMMS
if __name__ == '__main__':
    atexit.register(exit)  # Registriere Exit-Funktion

    timeout = 10  # Setzt Timeout auf 10 Sekunden
    socket.setdefaulttimeout(timeout)

    if DEBUG:
        print("DEBUG MODE")

    pt = datetime.datetime.now(datetime.timezone.utc) - datetime.timedelta(hours=1)
    duration = 0

    while True:
        print("\nISS PASS INFO")
        # Aktualisiert TLE-Daten alle 20 Minuten
        ct = datetime.datetime.now(datetime.timezone.utc)
        next_seconds = int((ct - pt).total_seconds())
        if DEBUG:
            print(f"Seconds since last TLE check: {next_seconds}")
        if next_seconds > (20 * 60):
            getTLE()
            pt = ct

        # Beobachter (Benutzer) und ISS-Parameter festlegen
        iss = ephem.readtle(glob_tle[0], glob_tle[1], glob_tle[2])
        site = ephem.Observer()
        site.date = datetime.datetime.now(datetime.timezone.utc)
        site.lat = str(LAT)
        site.lon = str(LON)
        site.horizon = str(HOR)
        site.elevation = ELV
        site.pressure = 0

        print(f"Current UTC time  : {site.date}")
        print(f"Current Local time: {ephem.localtime(site.date)}")

        # Informationen zum nächsten Überflug der ISS
        tr, azr, tt, altt, ts, azs = site.next_pass(iss)
        if ts > tr:
            duration = int((ts - tr) * 60 * 60 * 24)

        doLCD(ephem.localtime(tr))
        print(f"Next Pass (Localtime): {ephem.localtime(tr)}")
        if INFO:
            print(f"UTC Rise Time   : {tr}")
            print(f"UTC Max Alt Time: {tt}")
            print(f"UTC Set Time    : {ts}")
            print(f"Rise Azimuth: {azr}")
            print(f"Set Azimuth : {azs}")
            print(f"Max Altitude: {altt}")
            print(f"Duration    : {duration}")

        # Aktuelle Position der ISS berechnen
        iss.compute(site)
        degrees_per_radian = 180.0 / math.pi
        altDeg = int(iss.alt * degrees_per_radian)
        azDeg = int(iss.az * degrees_per_radian)
        iss.compute(ct)
        if INFO:
            print("\nCURRENT LOCATION:")
            print(f"Latitude : {iss.sublat}")
            print(f"Longitude: {iss.sublong}")
            print(f"Azimuth  : {azDeg}")
            print(f"Altitude : {altDeg}")

        # Überprüft, ob die ISS sichtbar ist und richtet den Zeiger aus
        if altDeg > int(HOR):
            if INFO:
                print("ISS IS VISIBLE")
            if altDeg > int(45):
                if INFO:
                    print("ISS IS OVERHEAD")

            next_check = 5
            doLED('on')

            azDiff = azDeg - glob_azOld
            glob_azOld = azDeg
            steps = int(float(azDiff) * FLOAT_A)
            doStepper(steps)