#!/usr/bin/env python3 import tkinter as tk from tkinter import filedialog, messagebox, ttk, scrolledtext import re import os import sys import math import numpy as np import sounddevice as sd from scipy.io import wavfile import threading import time from scipy.signal import butter, sosfilt import mido import pygame import pygame.midi FREQ_TABLE = { "0": 0, "C3": 130.81, "C3#": 138.59, "D3b": 138.59, "D3": 146.83, "D3#": 155.56, "E3b": 155.56, "E3": 164.81, "F3": 174.61, "F3#": 185.00, "G3b": 185.00, "G3": 196.00, "G3#": 207.65, "A3b": 207.65, "A3": 220.00, "A3#": 233.08, "B3b": 233.08, "B3": 246.94, "C4": 261.63, "C4#": 277.18, "D4b": 277.18, "D4": 293.66, "D4#": 311.13, "E4b": 311.13, "E4": 329.63, "F4": 349.23, "F4#": 369.99, "G4b": 369.99, "G4": 392.00, "G4#": 415.30, "A4b": 415.30, "A4": 440, "A4#": 466.16, "B4b": 466.16, "B4": 493.88, "C5": 523.25, "C5#": 554.37, "D5b": 554.37, "D5": 587.33, "D5#": 622.25, "E5b": 622.25, "E5": 659.25, "F5": 698.46, "F5#": 739.99, "G6b": 739.99, "G5": 783.99, "G5#": 830.61, "A5b": 830.61, "A5": 880.00, "A5#": 932.33, "B5b": 932.33, "B5": 987.77, } NOTE_NAMES = ['C', 'C#', 'D', 'D#', 'E', 'F', 'F#', 'G', 'G#', 'A', 'A#', 'B'] ## # @class CNCStudioApp # @brief Main Application class for the CNC Studio Tool. # Handles GUI, Audio processing, MIDI conversion and G-Code generation. class CNCStudioApp: ## # @brief Constructor for the CNCStudioApp. # @param root The Tkinter root window. def __init__(self, root): self.recorded_events = [] self.start_time = 0 self.root = root pygame.midi.init() self.root.title("CNC Studio") self.center_window(750, 850) # State variables for new features self.fullscreen_state = False self.monitoring_active = False self.monitor_thread = None # --- Menu Bar --- self.create_menubar() # --- Tabs --- self.notebook = ttk.Notebook(self.root) self.notebook.pack(fill="both", expand=True) self.tab_main = tk.Frame(self.notebook) self.notebook.add(self.tab_main, text="CNC Studio") self.tab_midi = tk.Frame(self.notebook) self.notebook.add(self.tab_midi, text="MIDI Converter") self.tab_monitor = tk.Frame(self.notebook) self.notebook.add(self.tab_monitor, text="MIDI Monitor") self.notebook.bind("<>", self.on_tab_change) # --- Variables --- self.filepath_var = tk.StringVar() self.use_x = tk.BooleanVar(value=True) self.steps_x = tk.IntVar(value=320) self.limit_x = tk.IntVar(value=700) self.use_y = tk.BooleanVar(value=True) self.steps_y = tk.IntVar(value=320) self.limit_y = tk.IntVar(value=400) self.use_z = tk.BooleanVar(value=True) self.steps_z = tk.IntVar(value=800) self.limit_z = tk.IntVar(value=150) self.tempo_var = tk.DoubleVar(value=120.0) self.speed_factor_var = tk.DoubleVar(value=1.0) self.wav_threshold_var = tk.DoubleVar(value=0.1) self.sim_mode_var = tk.StringVar(value="gcode") self.freq_split_x = (40, 250) self.freq_split_y = (250, 1500) self.freq_split_z = (1500, 6000) # --- Initialize Tabs --- self.create_widgets(self.tab_main) self.create_midi_tab(self.tab_midi) self.create_monitor_tab(self.tab_monitor) ## # @brief Creates the main menu bar with File, Edit, View, Options, Help. def create_menubar(self): menubar = tk.Menu(self.root) # 1. File Menu file_menu = tk.Menu(menubar, tearoff=0) file_menu.add_command(label="Open", command=self.load_file) file_menu.add_command(label="Save", command=self.save_gcode) file_menu.add_command(label="Save Set", command=self.dummy_action) file_menu.add_separator() file_menu.add_command(label="Quit", command=self.root.quit) menubar.add_cascade(label="File", menu=file_menu) # 2. Edit Menu edit_menu = tk.Menu(menubar, tearoff=0) edit_menu.add_command(label="Undo", command=self.dummy_action) edit_menu.add_command(label="Redo", command=self.dummy_action) edit_menu.add_separator() edit_menu.add_command(label="Apply selected items to all tabs", command=self.dummy_action) menubar.add_cascade(label="Edit", menu=edit_menu) # 3. View Menu view_menu = tk.Menu(menubar, tearoff=0) view_menu.add_command(label="Maximize", command=self.maximize_window) view_menu.add_command(label="Minimize", command=self.root.iconify) view_menu.add_command(label="Fullscreen", command=self.toggle_fullscreen) menubar.add_cascade(label="View", menu=view_menu) # 4. Options Menu options_menu = tk.Menu(menubar, tearoff=0) options_menu.add_command(label="Settings", command=self.dummy_action) menubar.add_cascade(label="Options", menu=options_menu) # 5. Help Menu help_menu = tk.Menu(menubar, tearoff=0) help_menu.add_command(label="About the program", command=lambda: messagebox.showinfo("About", "CNC Studio v1.0")) help_menu.add_command(label="Help", command=self.dummy_action) menubar.add_cascade(label="Help", menu=help_menu) self.root.config(menu=menubar) def dummy_action(self): print("Feature not implemented yet.") def maximize_window(self): try: self.root.state('zoomed') except: self.root.attributes('-zoomed', True) def toggle_fullscreen(self): self.fullscreen_state = not self.fullscreen_state self.root.attributes("-fullscreen", self.fullscreen_state) def center_window(self, width, height): sw = self.root.winfo_screenwidth() sh = self.root.winfo_screenheight() x = (sw // 2) - (width // 2) y = (sh // 2) - (height // 2) self.root.geometry(f'{width}x{height}+{x}+{y}') def create_widgets(self, parent): frame_file = tk.LabelFrame(parent, text="1. Select File", padx=10, pady=10) frame_file.pack(fill="x", padx=10, pady=5) tk.Entry(frame_file, textvariable=self.filepath_var, width=50).pack(side=tk.LEFT, padx=5) tk.Button(frame_file, text="Search...", command=self.load_file).pack(side=tk.LEFT) frame_cnc = tk.LabelFrame(parent, text="2. Machine settings", padx=10, pady=10) frame_cnc.pack(fill="x", padx=10, pady=5) tk.Label(frame_cnc, text="Axis", font=("Arial", 9, "bold")).grid(row=0, column=0) tk.Label(frame_cnc, text="Active", font=("Arial", 9, "bold")).grid(row=0, column=1) tk.Label(frame_cnc, text="Gear ratio [Steps/mm]", font=("Arial", 9, "bold")).grid(row=0, column=2) tk.Label(frame_cnc, text="Limit [mm]", font=("Arial", 9, "bold")).grid(row=0, column=3) tk.Label(frame_cnc, text="Maximum Speed [mm/min]", font=("Arial", 9, "bold")).grid(row=0, column=4) self.max_feed_x = tk.IntVar(value=5000) tk.Entry(frame_cnc, textvariable=self.max_feed_x, width=8).grid(row=1, column=4) self.max_feed_y = tk.IntVar(value=2500) tk.Entry(frame_cnc, textvariable=self.max_feed_y, width=8).grid(row=2, column=4) self.max_feed_z = tk.IntVar(value=469) tk.Entry(frame_cnc, textvariable=self.max_feed_z, width=8).grid(row=3, column=4) tk.Label(frame_cnc, text="X").grid(row=1, column=0) tk.Checkbutton(frame_cnc, variable=self.use_x).grid(row=1, column=1) tk.Entry(frame_cnc, textvariable=self.steps_x, width=8).grid(row=1, column=2) tk.Entry(frame_cnc, textvariable=self.limit_x, width=8).grid(row=1, column=3) tk.Label(frame_cnc, text="Low", fg="blue").grid(row=1, column=5, sticky="w") tk.Label(frame_cnc, text="Y").grid(row=2, column=0) tk.Checkbutton(frame_cnc, variable=self.use_y).grid(row=2, column=1) tk.Entry(frame_cnc, textvariable=self.steps_y, width=8).grid(row=2, column=2) tk.Entry(frame_cnc, textvariable=self.limit_y, width=8).grid(row=2, column=3) tk.Label(frame_cnc, text="Mid", fg="red", font=("Arial", 9, "bold")).grid(row=2, column=5, sticky="w") tk.Label(frame_cnc, text="Z (inv.)").grid(row=3, column=0) tk.Checkbutton(frame_cnc, variable=self.use_z).grid(row=3, column=1) tk.Entry(frame_cnc, textvariable=self.steps_z, width=8).grid(row=3, column=2) tk.Entry(frame_cnc, textvariable=self.limit_z, width=8).grid(row=3, column=3) tk.Label(frame_cnc, text="Hi", fg="green").grid(row=3, column=5, sticky="w") frame_p = tk.Frame(frame_cnc); frame_p.grid(row=4, column=0, columnspan=5, pady=10, sticky="w") tk.Label(frame_p, text="Tempo (BPM for TXT):").pack(side=tk.LEFT, padx=5) tk.Entry(frame_p, textvariable=self.tempo_var, width=6).pack(side=tk.LEFT) tk.Label(frame_p, text=" WAV-Threshold:").pack(side=tk.LEFT, padx=5) tk.Entry(frame_p, textvariable=self.wav_threshold_var, width=6).pack(side=tk.LEFT) frame_sim = tk.LabelFrame(parent, text="3. Audio sim", padx=10, pady=10) frame_sim.pack(fill="x", padx=10, pady=5) frame_sim_top = tk.Frame(frame_sim) frame_sim_top.pack(fill="x", pady=5) tk.Label(frame_sim_top, text="Speed:").pack(side=tk.LEFT, padx=5) tk.Entry(frame_sim_top, textvariable=self.speed_factor_var, width=6).pack(side=tk.LEFT) tk.Label(frame_sim_top, text=" Modus:").pack(side=tk.LEFT, padx=15) tk.Radiobutton(frame_sim_top, text="(Gcode) CNC-Sim", variable=self.sim_mode_var, value="gcode").pack(side=tk.LEFT, padx=5) tk.Radiobutton(frame_sim_top, text="Letter Notes Sim", variable=self.sim_mode_var, value="clean").pack(side=tk.LEFT, padx=5) frame_sim_bot = tk.Frame(frame_sim) frame_sim_bot.pack(fill="x", pady=5) tk.Button(frame_sim_bot, text="▶ START AUDIO", command=self.play_audio_live, bg="#ccffcc", width=20).pack(side=tk.LEFT, padx=20) tk.Button(frame_sim_bot, text="⬛ STOP", command=self.stop_audio_live, bg="#ffcccc", width=10).pack(side=tk.LEFT, padx=5) frame_ex = tk.LabelFrame(parent, text="4. Export", padx=10, pady=10) frame_ex.pack(fill="x", padx=10, pady=5) tk.Button(frame_ex, text="Save G-Code", command=self.save_gcode, bg="#dddddd", height=2).pack(fill="x") frame_bottom = tk.Frame(parent) frame_bottom.pack(fill="both", expand=True, padx=10, pady=5) frame_log = tk.LabelFrame(frame_bottom, text="Log", padx=5, pady=5) frame_log.pack(side=tk.LEFT, fill="both", expand=True, padx=(0, 5)) self.log_text = tk.Text(frame_log, height=8, state='disabled', bg="#f0f0f0", width=40) self.log_text.pack(fill="both", expand=True) frame_preview = tk.LabelFrame(frame_bottom, text="G-Code", padx=5, pady=5) frame_preview.pack(side=tk.LEFT, fill="both", expand=True, padx=(5, 0)) self.gcode_text = tk.Text(frame_preview, height=8, bg="white", width=40) self.gcode_text.pack(fill="both", expand=True) self.gcode_text.tag_config("highlight", background="#ffff99", foreground="black") def create_midi_tab(self, parent): lbl_info = tk.Label(parent, text="Select an MIDI File.\nThe tool automatically creates a .txt file.", pady=10) lbl_info.pack() btn_frame = tk.Frame(parent) btn_frame.pack(pady=10) self.btn_load_midi = tk.Button(btn_frame, text="Select MIDI File", command=self.process_midi_file, bg="#dddddd", height=2, width=30) self.btn_load_midi.pack() tk.Label(parent, text="Log:", anchor="w").pack(fill="x", padx=10) self.txt_log_midi = scrolledtext.ScrolledText(parent, height=15, state='disabled') self.txt_log_midi.pack(fill="both", expand=True, padx=10, pady=5) ## # @brief Creates the content for the MIDI Monitor Tab. def create_monitor_tab(self, parent): # 1. Device & Filter Selection frame_sel = tk.Frame(parent, pady=10) frame_sel.pack(fill="x", padx=10) # -- Geräte Auswahl -- tk.Label(frame_sel, text="MIDI Gerät:", font=("Arial", 10, "bold")).pack(side=tk.LEFT) self.combo_midi_ports = ttk.Combobox(frame_sel, state="readonly", width=30) self.combo_midi_ports.pack(side=tk.LEFT, padx=5) tk.Button(frame_sel, text="⟳", command=self.refresh_midi_ports, width=3).pack(side=tk.LEFT, padx=(0, 20)) # -- Filter Auswahl -- tk.Label(frame_sel, text="Filter:", font=("Arial", 10, "bold")).pack(side=tk.LEFT) self.combo_filter = ttk.Combobox(frame_sel, state="readonly", width=20) self.combo_filter['values'] = ["Alle anzeigen", "Clock (248) ignorieren"] self.combo_filter.current(1) self.combo_filter.pack(side=tk.LEFT, padx=5) # 2. Log Area tk.Label(parent, text="Incoming MIDI Messages:", anchor="w").pack(fill="x", padx=10, pady=(5,0)) self.monitor_log = scrolledtext.ScrolledText(parent, height=18, state='disabled', bg="#f0f0f0") self.monitor_log.pack(fill="both", expand=True, padx=10, pady=5) # 3. Controls btn_frame = tk.Frame(parent, pady=10) btn_frame.pack(fill="x") self.btn_mon_start = tk.Button(btn_frame, text="Start Record", command=self.start_monitor_record, bg="#ccffcc", width=15) self.btn_mon_start.pack(side=tk.LEFT, padx=20) self.btn_mon_stop = tk.Button(btn_frame, text="Stop", command=self.stop_monitor_record, bg="#ffcccc", width=10, state='disabled') self.btn_mon_stop.pack(side=tk.LEFT, padx=5) self.btn_mon_clear = tk.Button(btn_frame, text="🗑 Clear Log", command=self.clear_monitor_log, bg="#dddddd", width=12) self.btn_mon_clear.pack(side=tk.RIGHT, padx=20) self.btn_mon_save = tk.Button(btn_frame, text="💾 Save MIDI", command=self.save_captured_midi, bg="#dddddd", width=12) self.btn_mon_save.pack(side=tk.RIGHT, padx=5) def log_monitor(self, msg): self.monitor_log.config(state='normal') self.monitor_log.insert(tk.END, str(msg) + "\n") self.monitor_log.see(tk.END) self.monitor_log.config(state='disabled') def clear_monitor_log(self): self.monitor_log.config(state='normal') self.monitor_log.delete('1.0', tk.END) self.monitor_log.config(state='disabled') def on_tab_change(self, event): # Prüfen, welcher Tab aktiv ist selected_tab_id = self.notebook.select() # Vergleiche ID mit dem Monitor-Widget if selected_tab_id == str(self.tab_monitor): self.refresh_midi_ports() def refresh_midi_ports(self): if self.monitoring_active: messagebox.showwarning("Warnung", "Bitte erst die Aufnahme stoppen!") return try: pygame.midi.quit() pygame.midi.init() except Exception as e: self.log_monitor(f"Fehler beim MIDI-Reset: {e}") self.combo_midi_ports['values'] = [] inputs = [] try: count = pygame.midi.get_count() for i in range(count): r = pygame.midi.get_device_info(i) # r = (interface, name, input, output, opened) if r and r[2] == 1: try: name = r[1].decode("utf-8") except: name = str(r[1]) # Fallback inputs.append(f"{i}: {name}") self.combo_midi_ports['values'] = inputs if inputs: current = self.combo_midi_ports.get() if current not in inputs: self.combo_midi_ports.current(0) else: self.combo_midi_ports.set("Keine MIDI-Geräte gefunden") except Exception as e: self.log_monitor(f"Fehler bei Gerätesuche: {e}") def save_captured_midi(self): if not self.recorded_events: messagebox.showwarning("Leer", "Keine Daten aufgenommen!") return path = filedialog.asksaveasfilename(defaultextension=".mid", filetypes=[("MIDI File", "*.mid")]) if not path: return try: mid = mido.MidiFile() track = mido.MidiTrack() mid.tracks.append(track) ticks_per_beat = 480 bpm = 120 mid.ticks_per_beat = ticks_per_beat # Startzeitpunkt für Delta-Berechnung setzen last_timestamp = self.start_timestamp for data, timestamp in self.recorded_events: # 1. Delta-Zeit berechnen (in Sekunden umwandeln) delta_ms = timestamp - last_timestamp if delta_ms < 0: delta_ms = 0 # Sekunden -> Ticks delta_seconds = delta_ms / 1000.0 ticks = int(mido.second2tick(delta_seconds, ticks_per_beat, mido.bpm2tempo(bpm))) # 2. Daten korrekt zuschneiden status = data[0] bytes_data = [] if status >= 0xF0: bytes_data = [status] elif 0xC0 <= status <= 0xDF: bytes_data = data[:2] else: bytes_data = data[:3] try: msg = mido.Message.from_bytes(bytes_data) msg.time = ticks track.append(msg) last_timestamp = timestamp except ValueError as ve: print(f"Skipped invalid msg: {data} -> {bytes_data} ({ve})") mid.save(path) messagebox.showinfo("Erfolg", f"Datei gespeichert ({len(self.recorded_events)} Events):\n{path}") except Exception as e: messagebox.showerror("Fehler", f"Konnte MIDI nicht speichern: {e}") def start_monitor_record(self): selection = self.combo_midi_ports.get() if not selection or selection == "Keine MIDI-Geräte gefunden": messagebox.showerror("Error", "Bitte wähle ein gültiges MIDI-Gerät aus!") self.refresh_midi_ports() return try: device_id = int(selection.split(":")[0]) except: return try: pygame.midi.quit() pygame.midi.init() except: pass self.recorded_events = [] self.start_timestamp = pygame.midi.time() self.btn_mon_start.config(state='disabled') self.btn_mon_stop.config(state='normal') self.combo_midi_ports.config(state='disabled') self.monitoring_active = True self.log_monitor(f"--- Listening on Device ID: {device_id} ---") self.monitor_thread = threading.Thread(target=self._monitor_loop, args=(device_id,), daemon=True) self.monitor_thread.start() def stop_monitor_record(self): self.monitoring_active = False self.btn_mon_start.config(state='normal') self.btn_mon_stop.config(state='disabled') self.combo_midi_ports.config(state='readonly') time.sleep(0.2) # Input schließen if hasattr(self, 'pyg_input') and self.pyg_input: self.pyg_input.close() self.pyg_input = None pygame.midi.quit() pygame.midi.init() self.log_monitor("--- Stopped ---") def _monitor_loop(self, device_id): try: self.pyg_input = pygame.midi.Input(device_id) while self.monitoring_active: if self.pyg_input.poll(): midi_events = self.pyg_input.read(1024) filter_mode = self.combo_filter.get() for midi_ev in midi_events: # midi_ev Struktur: [[status, data1, data2, data3], timestamp] data = midi_ev[0] timestamp = midi_ev[1] status_byte = data[0] if filter_mode == "Clock (248)" and status_byte == 248: continue if status_byte == 254: continue # Speichern: Rohdaten + Zeitstempel self.recorded_events.append((data, timestamp)) try: msg = mido.Message.from_bytes(data[:3]) self.root.after(0, lambda m=msg: self.log_monitor(m)) except: self.root.after(0, lambda d=data: self.log_monitor(f"Raw: {d}")) time.sleep(0.001) except Exception as e: self.root.after(0, lambda err=e: self.log_monitor(f"Error: {err}")) self.root.after(0, self.stop_monitor_record) def log_midi(self, msg): self.txt_log_midi.config(state='normal') self.txt_log_midi.insert(tk.END, msg + "\n") self.txt_log_midi.see(tk.END) self.txt_log_midi.config(state='disabled') self.root.update() def midi_note_to_custom_format(self, note_number): """ Converts MIDI 60 to 'C4'. Format: 'Note + Octave + #' (e.g. 'D5#'). """ octave = note_number // 12 - 1 note_index = note_number % 12 raw_name = NOTE_NAMES[note_index] if '#' in raw_name: return f"{raw_name[0]}{octave}#" else: return f"{raw_name}{octave}" def ticks_to_fraction(self, ticks, ticks_per_beat): """ Verbesserte Quantisierung: Unterstützt nun auch Triolen und 1/32 Noten. """ if ticks_per_beat == 0 or ticks == 0: return "1/16" length = ticks / ticks_per_beat known_lengths = [ (4.0, "1/1"), (3.0, "1/2."), (2.0, "1/2"), (1.5, "1/4."), (1.0, "1/4"), (0.75, "1/8."), (0.6666, "1/6"), # Viertel-Triole (0.5, "1/8"), (0.375, "1/16."), (0.3333, "1/12"), # Achtel-Triole (0.25, "1/16"), (0.1666, "1/24"), # Sechzehntel-Triole (0.125, "1/32") ] best_match = "1/16" min_diff = 999.0 for val, name in known_lengths: diff = abs(length - val) if diff < min_diff: min_diff = diff best_match = name if length > 3.8: return "1/1" if length < 0.08: return "1/32" return best_match def process_midi_file(self): filepath = filedialog.askopenfilename(filetypes=[("MIDI File", "*.mid *.midi"), ("All Files", "*.*")]) if not filepath: return self.log_midi(f"--- Processing: {os.path.basename(filepath)} ---") try: mid = mido.MidiFile(filepath) ticks_per_beat = mid.ticks_per_beat all_notes = [] for track in mid.tracks: curr_ticks = 0 active_notes = {} for msg in track: curr_ticks += msg.time if msg.type == 'note_on' and msg.velocity > 0: active_notes[msg.note] = curr_ticks elif (msg.type == 'note_off') or (msg.type == 'note_on' and msg.velocity == 0): if msg.note in active_notes: start_t = active_notes.pop(msg.note) end_t = curr_ticks if end_t - start_t > 0: all_notes.append([start_t, end_t, msg.note]) if not all_notes: self.log_midi("Error: Keine Noten gefunden.") return all_notes.sort(key=lambda x: (x[0], -x[2])) clean_notes = [] if all_notes: current = all_notes[0] for i in range(1, len(all_notes)): next_note = all_notes[i] if next_note[0] < current[1]: current[1] = next_note[0] if current[1] > current[0]: clean_notes.append(current) if next_note[0] >= current[0]: current = next_note if current[1] > current[0]: clean_notes.append(current) output_lines = [] last_end_ticks = 0 for start, end, note_val in clean_notes: gap = start - last_end_ticks if gap > (ticks_per_beat * 0.1): frac = self.ticks_to_fraction(gap, ticks_per_beat) if frac != "1/16": output_lines.append(f"0\t{frac}") dur = end - start frac = self.ticks_to_fraction(dur, ticks_per_beat) note_str = self.midi_note_to_custom_format(note_val) output_lines.append(f"{note_str}\t{frac}") self.log_midi(f"{note_str}\t{frac}") last_end_ticks = start + dur out_path = os.path.splitext(filepath)[0] + ".txt" with open(out_path, "w") as f: f.write("\n".join(output_lines)) self.log_midi(f"\nSaved: {os.path.basename(out_path)}") messagebox.showinfo("Fertig", "Datei erfolgreich konvertiert!") except Exception as e: self.log_midi(f"ERROR: {e}") def log(self, msg): self.log_text.config(state='normal') self.log_text.insert(tk.END, msg + "\n") self.log_text.see(tk.END) self.log_text.config(state='disabled') self.root.update_idletasks() def load_file(self): filetypes = [("Supported", "*.txt *.wav *.gcode *.nc"), ("All Files", "*.*")] fn = filedialog.askopenfilename(filetypes=filetypes) if fn: self.filepath_var.set(fn) self.log(f"File: {os.path.basename(fn)}") self.log("Generating preview...") self.root.update_idletasks() lines = self.calculate_gcode() if lines: self.update_gcode_view(lines) self.log("Preview updated.") def get_axis_config(self): cfg = {} if self.use_x.get(): cfg['X'] = {'steps': self.steps_x.get(), 'limit': self.limit_x.get(), 'max_feed': self.max_feed_x.get(), 'range': self.freq_split_x} if self.use_y.get(): cfg['Y'] = {'steps': self.steps_y.get(), 'limit': self.limit_y.get(), 'max_feed': self.max_feed_y.get(), 'range': self.freq_split_y} if self.use_z.get(): cfg['Z'] = {'steps': self.steps_z.get(), 'limit': self.limit_z.get(), 'max_feed': self.max_feed_z.get(), 'range': self.freq_split_z} return cfg def freq_to_midi(self, f): return 0 if f<=0 else 69+12*math.log2(f/440.0) def midi_to_freq(self, m): return 0 if m<=0 else 440.0*2**((m-69)/12.0) def quantize(self, f): if f < 20: return 0 return self.midi_to_freq(round(self.freq_to_midi(f))) def calculate_gcode(self): infile = self.filepath_var.get() if not infile: return None ext = infile.lower().rsplit('.',1)[-1] if ext in ['gcode','nc','tap','ngc']: try: with open(infile,'r') as f: return [l.strip() for l in f] except: return None axes = self.get_axis_config() if not axes: self.log("No axis active!"); return None if ext == 'wav': return self.convert_wav_poly(infile, axes) else: return self.convert_txt(infile, axes) def convert_txt(self, fn, axes): self.log(f"Converting TXT...") try: bpm = self.tempo_var.get() if bpm <= 0: bpm = 120 axis_state = {} for ax in axes: steps_per_mm = axes[ax]['steps'] max_feed_mm_min = axes[ax]['max_feed'] if steps_per_mm <= 0: steps_per_mm = 1 axis_state[ax] = { 'pos': 0.0, 'dir': True, 'steps_per_mm': steps_per_mm, 'limit_feed_mm': max_feed_mm_min, 'limit_pos': axes[ax]['limit'] } lines = ["M5", "G21", "G90", "G92 " + " ".join([f"{ax}0" for ax in axes]), "G91"] with open(fn, 'r') as f: content = f.readlines() for line in content: line = line.strip() if not line or line.startswith("#"): continue try: m = re.findall(r"(.*?)\s+(\d/?\d*)(\.?\.?\.?)", line)[0] note, note_str_val, dots = m[0], m[1], m[2] try: raw_val = float(eval(note_str_val + ".0")) except: raw_val = 4.0 if raw_val >= 2: note_fraction = 1.0 / raw_val else: note_fraction = raw_val if dots == 0: dot_multiplier = 1 elif dots == 1: dot_multiplier = 1.5 elif dots == 2: dot_multiplier = 1.75 else: dot_multiplier = 1 duration_sec = note_fraction * dot_multiplier * (240.0 / bpm) duration_min = duration_sec / 60.0 frequency = FREQ_TABLE.get(note, 0) if frequency == 0: lines.append(f"G04 P{round(duration_sec * 1000)}") else: cmd = "G01" feeds = [] for ax, state in axis_state.items(): calc_feed = frequency * (60.0 / state['steps_per_mm']) if calc_feed > state['limit_feed_mm']: calc_feed = state['limit_feed_mm'] distance = calc_feed * duration_min if not state['dir']: distance = -distance projected = state['pos'] + distance if projected > state['limit_pos']: state['dir'] = False; distance = -distance projected = state['pos'] + distance elif projected < 0: state['dir'] = True; distance = -distance projected = state['pos'] + distance state['pos'] = projected cmd += f" {ax}{distance:.3f}" feeds.append(calc_feed) if feeds: cmd += f" F{int(feeds[0])}" lines.append(cmd) except Exception as e: pass cmd = "G00" for ax, state in axis_state.items(): cmd += f" {ax}{-state['pos']:.3f}" lines.append(cmd); lines.append("M5"); lines.append("G90") return lines except Exception as e: self.log(f"Error: {e}") return None def butter_bandpass_filter(self, data, lowcut, highcut, fs, order=5): nyq = 0.5 * fs low = lowcut / nyq if lowcut else 0.001 high = highcut / nyq if highcut else 0.99 if low <= 0: low = 0.001 if high >= 1: high = 0.99 sos = butter(order, [low, high], btype='band', output='sos') y = sosfilt(sos, data) return y def convert_wav_poly(self, fn, axes): self.log(f"Starting WAV analysis...") try: thresh = self.wav_threshold_var.get() sr, data = wavfile.read(fn) if len(data.shape) > 1: data = data.mean(axis=1) max_val = np.max(np.abs(data)) if max_val > 0: data = data / max_val bands = {} if 'X' in axes: bands['X'] = self.butter_bandpass_filter(data, 20, 250, sr, order=4) if 'Y' in axes: bands['Y'] = self.butter_bandpass_filter(data, 250, 2000, sr, order=4) if 'Z' in axes: bands['Z'] = self.butter_bandpass_filter(data, 2000, 8000, sr, order=4) lines = ["M5","G21","G90","G92 X0 Y0 Z0","G91"] chunk_ms = 50 chunk_sz = int(sr * (chunk_ms / 1000.0)) num_chunks = len(data) // chunk_sz pos = {ax: 0.0 for ax in axes} direc = {ax: 1 for ax in axes} window = np.hanning(chunk_sz) freqs_spect = np.fft.fftfreq(chunk_sz, 1/sr)[:chunk_sz//2] for i in range(num_chunks): start_idx = i * chunk_sz end_idx = (i + 1) * chunk_sz active_freqs = {} for ax, ax_data in bands.items(): chunk = ax_data[start_idx:end_idx] * window rms = np.sqrt(np.mean(chunk**2)) if rms < thresh: active_freqs[ax] = 0; continue w = np.fft.fft(chunk) magnitudes = np.abs(w[:chunk_sz//2]) if len(magnitudes) == 0: active_freqs[ax] = 0; continue peak_idx = np.argmax(magnitudes) raw_f = freqs_spect[peak_idx] note_f = self.quantize(raw_f) if note_f > 10: active_freqs[ax] = note_f else: active_freqs[ax] = 0 if all(f == 0 for f in active_freqs.values()): lines.append(f"G04 P{chunk_ms:.2f}") continue cmd = "G01" feeds_calc = [] dur_sec = chunk_ms / 1000.0 dist_components = {} for ax in axes: freq = active_freqs.get(ax, 0) if freq > 0: steps_mm = axes[ax]['steps'] limit_feed_mm = axes[ax]['max_feed'] target_feed_mm = freq * (60.0 / steps_mm) final_feed = min(target_feed_mm, limit_feed_mm) dist = final_feed * dur_sec dist_components[ax] = dist feeds_calc.append(final_feed) else: dist_components[ax] = 0 feeds_calc.append(0) vec_feed = math.sqrt(sum([f**2 for f in feeds_calc])) if vec_feed < 1: lines.append(f"G04 P{chunk_ms:.2f}") continue for ax in axes: d_abs = dist_components[ax] if d_abs > 0: if direc[ax] == 1: if pos[ax] + d_abs > axes[ax]['limit']: direc[ax] = -1; d_signed = -d_abs else: d_signed = d_abs else: if pos[ax] - d_abs < 0: direc[ax] = 1; d_signed = d_abs else: d_signed = -d_abs pos[ax] += d_signed val_out = -d_signed if ax == 'Z' else d_signed cmd += f" {ax}{val_out:.3f}" cmd += f" F{int(vec_feed)}" lines.append(cmd) cmd = "G00" for ax in axes: val = -pos[ax] val_out = -val if ax == 'Z' else val cmd += f" {ax}{val_out:.3f}" lines.append(cmd); lines.append("M5"); lines.append("G90") return lines except Exception as e: self.log(f"WAV Error: {e}") return None def update_gcode_view(self, lines): """Fill the right window with the generated G-code.""" self.gcode_text.delete(1.0, tk.END) self.gcode_text.insert(tk.END, "\n".join(lines)) def highlight_line(self, line_idx): """Highlight the line in the G-code window""" try: self.gcode_text.tag_remove("highlight", "1.0", tk.END) start = f"{line_idx + 1}.0" end = f"{line_idx + 1}.end" self.gcode_text.tag_add("highlight", start, end) self.gcode_text.see(start) except Exception: pass def play_audio_live(self): self.stop_audio_live() mode = self.sim_mode_var.get() fn = self.filepath_var.get() if not fn: return if mode == "clean": threading.Thread(target=self._play_clean_thread, args=(fn,), daemon=True).start() return self.log("Calculating G-Code...") lines = self.calculate_gcode() if not lines: return self.update_gcode_view(lines) self.log("Starting simulation...") self.stop_flag = False self.audio_thread = threading.Thread(target=self._play_sim_thread, args=(lines,), daemon=True) self.audio_thread.start() def _play_sim_thread(self, lines): """Generates all audio and synchronizes GUI""" try: self.log("Generating audio buffer...") axes = self.get_axis_config() speed = self.speed_factor_var.get() sr = 44100 full_audio = [] line_timestamps = [] current_sample = 0 cur_feed = 0 for i, line in enumerate(lines): if self.stop_flag: return line_u = line.upper() chunk = None fm = re.search(r'F(\d+\.?\d*)', line_u) if fm: cur_feed = float(fm.group(1)) if 'G01' in line_u or (line_u.startswith('G1') and 'G10' not in line_u): if cur_feed > 0: dists = {} vec_dist = 0 for ax in ['X','Y','Z']: m = re.search(fr'{ax}([-]?\d+\.?\d*)', line_u) if m: d = abs(float(m.group(1))) dists[ax] = d; vec_dist += d**2 else: dists[ax] = 0 if vec_dist > 0: vec_dist = math.sqrt(vec_dist) dur = (vec_dist / cur_feed) * 60.0 dur /= speed num_samples = int(sr * dur) if num_samples > 0: t = np.linspace(0, dur, num_samples, endpoint=False) mixed_wave = np.zeros_like(t) for ax, d in dists.items(): if d > 0 and ax in axes: scale = 60.0 / axes[ax]['steps'] ax_feed = cur_feed * (d / vec_dist) freq = ax_feed / scale saw = 2*(freq*t%1)-1 mixed_wave += (0.3 * saw) fl = min(200, num_samples//2) if fl>0: mixed_wave[:fl]*=np.linspace(0,1,fl) mixed_wave[-fl:]*=np.linspace(1,0,fl) chunk = mixed_wave elif 'G04' in line_u or 'G4 ' in line_u: p = re.search(r'[P|X](\d+\.?\d*)', line_u) if p: val = float(p.group(1)) dur = (val/1000.0) / speed chunk = np.zeros(int(sr*dur)) if chunk is not None: line_timestamps.append((current_sample, i)) full_audio.append(chunk) current_sample += len(chunk) else: line_timestamps.append((current_sample, i)) if not full_audio: self.log("No audio generated.") return total_wave = np.concatenate(full_audio) m = np.max(np.abs(total_wave)) if m > 1: total_wave /= m self.log(f"Playing ({len(total_wave)/sr:.1f}s)...") sd.play(total_wave, sr) start_time = time.time() idx_pointer = 0 max_idx = len(line_timestamps) - 1 while sd.get_stream().active and not self.stop_flag: elapsed = time.time() - start_time current_play_sample = elapsed * sr while idx_pointer < max_idx and line_timestamps[idx_pointer+1][0] < current_play_sample: idx_pointer += 1 line_idx = line_timestamps[idx_pointer][1] self.root.after(0, lambda idx=line_idx: self.highlight_line(idx)) time.sleep(0.05) if self.stop_flag: sd.stop() self.root.after(0, lambda: self.log("Done.")) except Exception as e: self.root.after(0, lambda: self.log(f"Sim Thread Error: {e}")) def _play_clean_thread(self, fn): """Thread for Preview Modus""" try: self.root.after(0, lambda: self.play_clean_preview(fn)) except Exception as e: print(e) def stop_audio_live(self): self.stop_flag = True sd.stop() self.log("Stop.") def play_clean_preview(self, fn): try: bpm = self.tempo_var.get() speed = self.speed_factor_var.get() if bpm <= 0: bpm = 120 sr = 44100 audio = [] with open(fn,'r') as f: content = f.readlines() for line in content: line = line.strip() if not line or line.startswith("#"): continue try: m = re.findall(r"(.*?)\s+(\d/?\d*)(\.?\.?\.?)", line)[0] note, val_str, dots = m[0], m[1], m[2] # Punktierung berechnen dm = 1.0 if "." in dots: dm = 1.5 if ".." in dots: dm = 1.75 if "/" in val_str: num, den = val_str.split("/") base_val = float(num) / float(den) else: try: v = float(val_str) if v >= 1 and v <= 32: base_val = 1.0 / v else: base_val = v except: base_val = 0.25 # Berechnung der Dauer in Sekunden dur = (240.0 / bpm) * base_val * dm dur /= speed num_samples = int(sr * dur) if num_samples <= 0: continue freq = FREQ_TABLE.get(note, 0) if freq > 0: t = np.linspace(0, dur, num_samples, endpoint=False) wave = 0.3 * np.sin(2 * np.pi * freq * t) fade = min(500, num_samples//2) if fade > 0: wave[:fade] *= np.linspace(0, 1, fade) wave[-fade:] *= np.linspace(1, 0, fade) audio.append(wave) else: # Pause audio.append(np.zeros(num_samples)) except Exception as e: print(f"Skipped line: {line} ({e})") if audio: full = np.concatenate(audio) self.log(f"Preview: {len(full)/sr:.1f}s @ {bpm} BPM") sd.play(full, sr) else: self.log("Keine abspielbaren Noten gefunden.") except Exception as e: self.log(f"Preview Error: {e}") def save_gcode(self): lines = self.calculate_gcode() if not lines: return fn = self.filepath_var.get() if not fn: messagebox.showerror("Error", "No file loaded") return d = os.path.splitext(fn)[0]+".gcode" p = filedialog.asksaveasfilename(initialfile=os.path.basename(d), defaultextension=".gcode") if p: with open(p,"w") as f: f.write('\n'.join(lines)) self.log(f"Saved: {p}"); messagebox.showinfo("OK","Finish!") if __name__ == "__main__": try: import sounddevice import mido import pygame except ImportError as e: root=tk.Tk(); root.withdraw() messagebox.showerror("Missing library", f"Error: {e}\nPlease install:\npip install sounddevice mido pygame") sys.exit(1) root = tk.Tk() app = CNCStudioApp(root) root.mainloop()