First Commit

.vscode/settings.json

@@ -0,0 +1,3 @@
+{
+    "python-envs.pythonProjects": []
+}

chatgpt.py

@@ -0,0 +1,118 @@
+import pygame
+import math
+
+# Observatoriums-Simulation — mit NFC-Tag-Logik
+
+WIDTH, HEIGHT = 700, 700
+CENTER = (WIDTH // 2, HEIGHT // 2)
+RADIUS = 260
+TAG_COUNT = 36  # oder 72
+TAG_STEP = 360.0 / TAG_COUNT
+
+# Farben
+WHITE = (255, 255, 255)
+BLACK = (0, 0, 0)
+RED = (200, 50, 50)
+BLUE = (50, 50, 200)
+GREEN = (50, 200, 50)
+
+# Anfangswerte
+telescope_angle = 0.0  # Grad
+dome_angle = 0.0       # Grad (Mittelachse des Spalts)
+slot_width = 20.0      # Spaltbreite in Grad
+
+dome_speed = TAG_STEP       # maximal ein Tag-Schritt pro Frame
+tele_speed = 2.5            # Grad pro Frame (Teleskop-Schritt)
+
+pygame.init()
+screen = pygame.display.set_mode((WIDTH, HEIGHT))
+pygame.display.set_caption("Kuppel-Simulation — mit NFC-Tags")
+clock = pygame.time.Clock()
+font = pygame.font.SysFont(None, 22)
+
+
+def angle_diff(target, source):
+    d = (target - source + 180.0) % 360.0 - 180.0
+    return d
+
+def get_tag_index(angle):
+    return int(round(angle / TAG_STEP)) % TAG_COUNT
+
+def tag_to_angle(tag_idx):
+    return (tag_idx % TAG_COUNT) * TAG_STEP
+
+running = True
+while running:
+    for event in pygame.event.get():
+        if event.type == pygame.QUIT:
+            running = False
+
+    # Steuerung Teleskop (Pfeiltasten)
+    keys = pygame.key.get_pressed()
+    if keys[pygame.K_LEFT]:
+        telescope_angle = (telescope_angle - tele_speed) % 360.0
+    if keys[pygame.K_RIGHT]:
+        telescope_angle = (telescope_angle + tele_speed) % 360.0
+
+    # --- Kuppelsteuerung mit NFC-Tag-Quantisierung ---
+    diff = angle_diff(telescope_angle, dome_angle)
+    half_slot = slot_width / 2.0
+
+    move_dir = "STOP"
+    used_step = 0.0
+    active_tag = get_tag_index(dome_angle)
+
+    if abs(diff) > half_slot + 1e-6:
+        sign = math.copysign(1.0, diff)
+        # Schritt = 1 Tag weiter in jeweilige Richtung
+        new_angle = (dome_angle + sign * TAG_STEP) % 360.0
+        active_tag = get_tag_index(new_angle)
+        dome_angle = tag_to_angle(active_tag)
+        used_step = TAG_STEP
+        move_dir = "+" if sign > 0 else "-"
+
+    # --- Zeichnen ---
+    screen.fill(WHITE)
+
+    # Tags
+    for i in range(TAG_COUNT):
+        a = -2.0 * math.pi * i / TAG_COUNT
+        x = CENTER[0] + math.cos(a) * RADIUS
+        y = CENTER[1] + math.sin(a) * RADIUS
+        color = GREEN if i == active_tag else BLACK
+        pygame.draw.circle(screen, color, (int(x), int(y)), 5 if i == active_tag else 3)
+
+    # Spaltbogen
+    mid_angle = -math.radians(dome_angle)
+    half = math.radians(slot_width / 2.0)
+    rect = (CENTER[0] - RADIUS, CENTER[1] - RADIUS, 2 * RADIUS, 2 * RADIUS)
+    pygame.draw.arc(screen, BLUE, rect, mid_angle - half, mid_angle + half, 12)
+
+    # Teleskoplinie
+    tx = CENTER[0] + math.cos(math.radians(-telescope_angle)) * (RADIUS - 60)
+    ty = CENTER[1] + math.sin(math.radians(-telescope_angle)) * (RADIUS - 60)
+    pygame.draw.line(screen, RED, CENTER, (int(tx), int(ty)), 6)
+    pygame.draw.circle(screen, RED, (int(tx), int(ty)), 8)
+
+    # Mittelpunkt
+    pygame.draw.circle(screen, BLACK, CENTER, 6)
+
+    # Debug-Infos
+    diff_after = angle_diff(telescope_angle, dome_angle)
+    lines = [
+        f"Telescope: {telescope_angle:.1f}°",
+        f"Dome (Spaltmittel): {dome_angle:.1f}°",
+        f"Diff (tel - dome): {diff_after:.2f}°",
+        f"Slot width: {slot_width}°",
+        f"Tags: {TAG_COUNT}",
+        f"Active Tag: {active_tag}",
+        f"Move: {move_dir} step: {used_step:.2f}°"
+    ]
+    for i, txt in enumerate(lines):
+        surf = font.render(txt, True, BLACK)
+        screen.blit(surf, (10, 10 + i * 20))
+
+    pygame.display.flip()
+    clock.tick(60)
+
+pygame.quit()

claude.py

@@ -0,0 +1,116 @@
+import pygame
+import math
+
+# Observatoriums-Simulation – Anzeige und Richtung harmonisiert
+
+WIDTH, HEIGHT = 700, 700
+CENTER = (WIDTH // 2, HEIGHT // 2)
+RADIUS = 260
+TAG_COUNT = 36  # oder 72
+
+# Farben
+WHITE = (255, 255, 255)
+BLACK = (0, 0, 0)
+RED = (200, 50, 50)
+BLUE = (50, 50, 200)
+
+# Anfangswerte
+telescope_angle = 0.0  # Grad
+dome_angle = 0.0       # Grad (Mittelachse des Spalts)
+slot_width = 20.0      # Spaltbreite in Grad
+
+dome_speed = 2.5       # Grad pro Frame (maximal)
+tele_speed = 2.5       # Grad pro Frame (Teleskop-Schritt)
+
+pygame.init()
+screen = pygame.display.set_mode((WIDTH, HEIGHT))
+pygame.display.set_caption("Kuppel-Simulation – Anzeige fix")
+clock = pygame.time.Clock()
+font = pygame.font.SysFont(None, 22)
+
+
+def angle_diff(target, source):
+    d = (target - source + 180.0) % 360.0 - 180.0
+    return d
+
+
+running = True
+while running:
+    for event in pygame.event.get():
+        if event.type == pygame.QUIT:
+            running = False
+
+    # Steuerung Teleskop (Pfeiltasten) - wie in Version 15
+    keys = pygame.key.get_pressed()
+    if keys[pygame.K_LEFT]:
+        telescope_angle = (telescope_angle + tele_speed) % 360.0
+    if keys[pygame.K_RIGHT]:
+        telescope_angle = (telescope_angle - tele_speed) % 360.0
+
+    # --- Kuppelsteuerung (wie Version 15 + Spaltlogik) ---
+    half_slot = slot_width / 2.0
+    
+    # Kuppel folgt dem NEGATIVEN Teleskop-Winkel (funktionierte in Version 15)
+    target_dome = -telescope_angle
+    diff = angle_diff(target_dome, dome_angle)
+    
+    move_dir = "STOP"
+    used_step = 0.0
+
+    # NEU: Kuppel bewegt sich nur bei Erreichen des rechten (CW) Randes
+    if diff < -half_slot - 1e-6:  # Teleskop hat rechten Rand erreicht
+        # Bewege Kuppel so, dass Teleskop exakt am linken Rand steht
+        # target_dome für linken Rand = -telescope_angle + half_slot
+        target_dome_new = -telescope_angle + half_slot
+        movement_needed = angle_diff(target_dome_new, dome_angle)
+        
+        dome_angle = (dome_angle + movement_needed) % 360.0
+        if movement_needed > 0:
+            move_dir = "+"
+        else:
+            move_dir = "-"
+        used_step = abs(movement_needed)
+
+    # --- Zeichnen ---
+    screen.fill(WHITE)
+
+    # Tags (Bildschirmkonvention: Winkel im Uhrzeigersinn positiv)
+    for i in range(TAG_COUNT):
+        a = -2.0 * math.pi * i / TAG_COUNT
+        x = CENTER[0] + math.cos(a) * RADIUS
+        y = CENTER[1] + math.sin(a) * RADIUS
+        pygame.draw.circle(screen, BLACK, (int(x), int(y)), 4)
+
+    # Spaltbogen (Mittelachse wie Teleskop mit -angle)
+    mid_angle = -math.radians(dome_angle)
+    half = math.radians(slot_width / 2.0)
+    rect = (CENTER[0] - RADIUS, CENTER[1] - RADIUS, 2 * RADIUS, 2 * RADIUS)
+    pygame.draw.arc(screen, BLUE, rect, mid_angle - half, mid_angle + half, 12)
+
+    # Teleskoplinie (ebenfalls -angle)
+    tx = CENTER[0] + math.cos(math.radians(-telescope_angle)) * (RADIUS - 60)
+    ty = CENTER[1] + math.sin(math.radians(-telescope_angle)) * (RADIUS - 60)
+    pygame.draw.line(screen, RED, CENTER, (int(tx), int(ty)), 6)
+    pygame.draw.circle(screen, RED, (int(tx), int(ty)), 8)
+
+    # Mittelpunkt
+    pygame.draw.circle(screen, BLACK, CENTER, 6)
+
+    # Debug-Infos
+    diff_after = angle_diff(telescope_angle, dome_angle)
+    lines = [
+        f"Telescope: {telescope_angle:.1f}°",
+        f"Dome (Spaltmittel): {dome_angle:.1f}°",
+        f"Diff (tel - dome): {diff_after:.2f}°",
+        f"Slot width: {slot_width}°",
+        f"Tags: {TAG_COUNT}",
+        f"Move: {move_dir} step: {used_step:.2f}°"
+    ]
+    for i, txt in enumerate(lines):
+        surf = font.render(txt, True, BLACK)
+        screen.blit(surf, (10, 10 + i * 20))
+
+    pygame.display.flip()
+    clock.tick(60)
+
+pygame.quit()

mistral.py

@@ -0,0 +1,131 @@
+import pygame
+import math
+
+class Kuppel:
+    def __init__(self, radius, num_tags):
+        self.radius = radius
+        self.tags = [i for i in range(num_tags)]  # NFC-Tag-IDs
+        self.position = 0  # Aktuelle Drehposition in Grad
+
+    def drehe(self, winkel):
+        self.position = (self.position + winkel) % 360
+
+    def lies_tag(self):
+        # Simuliert das Lesen des NFC-Tags an der aktuellen Position
+        tag_index = int((self.position / 360) * len(self.tags)) % len(self.tags)
+        return self.tags[tag_index]
+
+class Teleskop:
+    def __init__(self):
+        self.winkel = 0  # Aktuelle Ausrichtung in Grad
+
+    def setze_winkel(self, winkel):
+        self.winkel = winkel
+
+class Controller:
+    def __init__(self, kuppel, teleskop, spalt_groesse, drehgeschwindigkeit=1.5):
+        self.kuppel = kuppel
+        self.teleskop = teleskop
+        self.spalt_groesse = spalt_groesse  # in Grad
+        self.drehgeschwindigkeit = drehgeschwindigkeit  # Grad pro Frame
+        self.kuppel_dreht = False  # Flag, ob die Kuppel gerade dreht
+        self.drehrichtung = 0  # 1 für CW, -1 für CCW
+
+    def aktualisiere_kuppel(self):
+        # Berechne die aktuellen Ränder des Spalts
+        linker_rand = (self.kuppel.position - self.spalt_groesse / 2) % 360
+        rechter_rand = (self.kuppel.position + self.spalt_groesse / 2) % 360
+
+        # Prüfe, ob das Teleskop einen der Ränder erreicht hat
+        if not self.kuppel_dreht:
+            # CW-Bewegung: Teleskop erreicht rechten Rand
+            if (rechter_rand > linker_rand and self.teleskop.winkel >= rechter_rand) or \
+               (rechter_rand < linker_rand and (self.teleskop.winkel >= rechter_rand or self.teleskop.winkel <= linker_rand)):
+                self.kuppel_dreht = True
+                self.drehrichtung = 1  # CW
+
+            # CCW-Bewegung: Teleskop erreicht linken Rand
+            elif (rechter_rand > linker_rand and self.teleskop.winkel <= linker_rand) or \
+                 (rechter_rand < linker_rand and self.teleskop.winkel <= linker_rand):
+                self.kuppel_dreht = True
+                self.drehrichtung = -1  # CCW
+
+        # Wenn die Kuppel dreht: langsam in die Zielrichtung
+        if self.kuppel_dreht:
+            # Drehe die Kuppel in die gewünschte Richtung
+            self.kuppel.position = (self.kuppel.position + self.drehrichtung * self.drehgeschwindigkeit) % 360
+
+            # Prüfe, ob das Teleskop jetzt am Zielrand steht
+            linker_rand_aktuell = (self.kuppel.position - self.spalt_groesse / 2) % 360
+            rechter_rand_aktuell = (self.kuppel.position + self.spalt_groesse / 2) % 360
+
+            if self.drehrichtung == 1:  # CW: Ziel ist linker Rand
+                if abs((self.teleskop.winkel - linker_rand_aktuell) % 360) < 1:  # Toleranz von 1°
+                    self.kuppel_dreht = False
+            else:  # CCW: Ziel ist rechter Rand
+                if abs((self.teleskop.winkel - rechter_rand_aktuell) % 360) < 1:  # Toleranz von 1°
+                    self.kuppel_dreht = False
+
+
+
+# Grafik mit Pygame
+pygame.init()
+screen = pygame.display.set_mode((800, 600))
+clock = pygame.time.Clock()
+
+kuppel = Kuppel(200, 36)
+teleskop = Teleskop()
+spalt_groesse = 30  # Spaltbreite in Grad
+controller = Controller(kuppel, teleskop, spalt_groesse, drehgeschwindigkeit=1.5)
+
+# Spaltgröße in Grad
+spalt_dicke = 10    # Dicke des Bogens in Pixel
+
+running = True
+while running:
+    for event in pygame.event.get():
+        if event.type == pygame.QUIT:
+            running = False
+        elif event.type == pygame.KEYDOWN:
+            if event.key == pygame.K_LEFT:  # CCW
+                teleskop.setze_winkel((teleskop.winkel - 2) % 360)
+            elif event.key == pygame.K_RIGHT:  # CW
+                teleskop.setze_winkel((teleskop.winkel + 2) % 360)
+
+    controller.aktualisiere_kuppel()
+    tag = kuppel.lies_tag()
+
+
+    # Zeichnen
+    screen.fill((0, 0, 0))
+    # Kuppel zeichnen
+    pygame.draw.circle(screen, (50, 50, 50), (400, 300), kuppel.radius)
+
+    # Kuppelspalt als roten Bogen zeichnen
+    spalt_mitte = math.radians(kuppel.position)
+    spalt_halb = math.radians(spalt_groesse / 2)
+    # Bogen als Serie von kurzen Linien zeichnen
+    for i in range(-spalt_groesse//2, spalt_groesse//2):
+        winkel = spalt_mitte + math.radians(i)
+        start_x = 400 + kuppel.radius * math.cos(winkel)
+        start_y = 300 + kuppel.radius * math.sin(winkel)
+        end_x = 400 + (kuppel.radius + spalt_dicke) * math.cos(winkel)
+        end_y = 300 + (kuppel.radius + spalt_dicke) * math.sin(winkel)
+        pygame.draw.line(screen, (255, 0, 0), (start_x, start_y), (end_x, end_y), 2)
+
+    # Teleskoprichtung zeichnen
+    teleskop_winkel = math.radians(teleskop.winkel)
+    teleskop_x = 400 + kuppel.radius * 1.5 * math.cos(teleskop_winkel)
+    teleskop_y = 300 + kuppel.radius * 1.5 * math.sin(teleskop_winkel)
+    pygame.draw.line(screen, (0, 255, 0), (400, 300), (teleskop_x, teleskop_y), 3)
+
+    # Tag-ID anzeigen
+    font = pygame.font.SysFont(None, 36)
+    text = font.render(f"Tag: {tag}", True, (255, 255, 255))
+    screen.blit(text, (10, 10))
+
+    pygame.display.flip()
+    clock.tick(30)
+
+
+pygame.quit()