From 799f7983163c98c84f4a0b56ede01cbc48d16679 Mon Sep 17 00:00:00 2001 From: rxf Date: Sat, 20 Sep 2025 10:50:33 +0200 Subject: [PATCH] First Commit --- .vscode/settings.json | 3 + chatgpt.py | 118 +++++++++++++++++++++++++++++++++++++ claude.py | 116 +++++++++++++++++++++++++++++++++++++ mistral.py | 131 ++++++++++++++++++++++++++++++++++++++++++ 4 files changed, 368 insertions(+) create mode 100644 .vscode/settings.json create mode 100644 chatgpt.py create mode 100644 claude.py create mode 100644 mistral.py diff --git a/.vscode/settings.json b/.vscode/settings.json new file mode 100644 index 0000000..7e68766 --- /dev/null +++ b/.vscode/settings.json @@ -0,0 +1,3 @@ +{ + "python-envs.pythonProjects": [] +} \ No newline at end of file diff --git a/chatgpt.py b/chatgpt.py new file mode 100644 index 0000000..3317bac --- /dev/null +++ b/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() \ No newline at end of file diff --git a/claude.py b/claude.py new file mode 100644 index 0000000..98d471f --- /dev/null +++ b/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() \ No newline at end of file diff --git a/mistral.py b/mistral.py new file mode 100644 index 0000000..9ebc0e7 --- /dev/null +++ b/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()