From c2f91999c2b4b0b2440bddcfa50c07f6498a30d9 Mon Sep 17 00:00:00 2001 From: Jan Date: Wed, 6 Aug 2025 23:58:43 +0200 Subject: [PATCH] MainCode/adalm1000_logger.py aktualisiert erste messwerte auslesbar D --- MainCode/adalm1000_logger.py | 131 +++++++++++++++++++---------------- 1 file changed, 72 insertions(+), 59 deletions(-) diff --git a/MainCode/adalm1000_logger.py b/MainCode/adalm1000_logger.py index e7b47d6..801be9b 100644 --- a/MainCode/adalm1000_logger.py +++ b/MainCode/adalm1000_logger.py @@ -25,12 +25,15 @@ class PatchedSession(pysmu.Session): try: super().__init__(ignore_dataflow=ignore_dataflow, queue_size=queue_size) except SessionError as e: - if "failed scanning and/or adding all supported devices" in str(e): - print("⚠️ Ignored add_all() busy-device error, continuing...") - # The parent __init__ still runs and creates a session object - # We'll manually add devices later in init_device() + if "failed scanning" in str(e): + print("Warning: Session initialization quirk, continuing...") else: raise + finally: # Ensure scan happens regardless of exception + self.scan() # Move scan into finally block + + if not self.devices: + print("No devices found after manual scan") class DeviceManager: def __init__(self, dev): @@ -68,9 +71,9 @@ class DeviceManager: } def start_measurement(self, interval=0.1): - if self.measurement_thread: + if self.measurement_thread and self.measurement_thread.isRunning(): self.measurement_thread.stop() - self.measurement_thread.wait(500) + self.measurement_thread = MeasurementThread(self.dev, interval) self.measurement_thread.start() self.is_running = True @@ -126,6 +129,35 @@ class MeasurementThread(QThread): while self._running: try: samples = self.device.read(self.filter_window_size, 500, True) + + # --- VOLLSTÄNDIGER DEBUG-REPLACEMENT AB HIER --- + print(f"\n{'='*50}") + print(f"DEBUG: Neue Messung - Zeit: {time.time():.3f}") + print(f"DEBUG: Anzahl empfangener Samples: {len(samples) if samples else 'None'}") + + if not samples: + print("DEBUG: FEHLER - Keine Samples empfangen!") + raise DeviceDisconnectedError("No samples received") + + # Zeige die komplette Struktur der ersten 3 Samples + for i, sample in enumerate(samples[:3]): + print(f"DEBUG: Sample[{i}] = {sample}") + if len(sample) >= 2: + print(f" Channel A: Strom={sample[0][1]:.6f}A, Spannung={sample[0][0]:.6f}V") + print(f" Channel B: Strom={sample[1][1]:.6f}A, Spannung={sample[1][0]:.6f}V") + + # Berechne raw_voltage und zeige Zwischenergebnisse + voltage_values = [s[1][0] for s in samples] + raw_voltage = np.mean(voltage_values) + print(f"DEBUG: Channel B Spannung - Werte: {voltage_values}, Mittelwert: {raw_voltage:.6f}V") + + # Berechne raw_current und zeige Zwischenergebnisse + current_values = [s[0][1] for s in samples] + raw_current = np.mean(current_values) * self.current_direction + print(f"DEBUG: Channel A Strom - Werte: {current_values}, Mittelwert: {np.mean(current_values):.6f}A, mit Richtung: {raw_current:.6f}A") + print(f"{'='*50}") + # --- DEBUG-ENDE --- + if not samples: raise DeviceDisconnectedError("No samples received") @@ -517,14 +549,6 @@ class BatteryTester(QMainWindow): os.makedirs(self.log_dir, exist_ok=True) # Data buffers - max_data_points = 36000 # Define this first - self.time_data = deque(maxlen=max_data_points) - self.voltage_data = deque(maxlen=max_data_points) - self.current_data = deque(maxlen=max_data_points) - self.max_points_to_keep = 10000 - self.display_time_data = deque(maxlen=self.max_points_to_keep) - self.display_voltage_data = deque(maxlen=self.max_points_to_keep) - self.display_current_data = deque(maxlen=self.max_points_to_keep) self.aggregation_buffer = { 'time': [], 'voltage': [], 'current': [], 'count': 0, 'last_plot_time': 0 @@ -916,35 +940,17 @@ class BatteryTester(QMainWindow): self.status_bar.showMessage(f"Mode changed to {mode_name}") def reset_test(self): - """Reset test state for the active device""" if not self.active_device: return - + dev_manager = self.active_device - - # Reset data buffers - with self.plot_mutex: - dev_manager.time_data.clear() - dev_manager.voltage_data.clear() - dev_manager.current_data.clear() - dev_manager.display_time_data.clear() - dev_manager.display_voltage_data.clear() - dev_manager.display_current_data.clear() - - # Reset state variables - dev_manager.capacity_ah = 0.0 - dev_manager.energy = 0.0 - dev_manager.charge_capacity = 0.0 - dev_manager.coulomb_efficiency = 0.0 - dev_manager.cycle_count = 0 - dev_manager.start_time = time.time() - dev_manager.test_phase = "Idle" - - # Reset UI + dev_manager.reset_data() # Reset in DeviceManager + + # UI zurücksetzen self.capacity_label.setText("0.0000") self.energy_label.setText("0.0000") self.cycle_label.setText("0") - self.phase_label.setText(dev_manager.test_phase) + self.phase_label.setText("Idle") def toggle_recording(self): """Toggle data recording in Live Monitoring mode""" @@ -1050,13 +1056,16 @@ class BatteryTester(QMainWindow): self.session_active = False self.active_device = None # Sicherstellen, dass es None ist return - + + self.session.start(0) self.devices.clear() for dev in self.session.devices: manager = DeviceManager(dev) manager.start_measurement(interval=self.interval) self.devices[dev.serial] = manager + self.session.start(0) + # Erstes Gerät aktivieren first_serial = self.session.devices[0].serial self.active_device = self.devices[first_serial] @@ -1153,34 +1162,30 @@ class BatteryTester(QMainWindow): print(f"Manual init failed: {e}") def change_device(self, index): - if not self.session_active or index < 0: + if not self.session_active or index < 0: return + serial = self.device_combo.itemText(index) if serial not in self.devices: return - # Stoppe aktuelle Messung (UI) - was_running = self.test_running - if was_running: - self.stop_test() - - # Trenne alten Thread-Slot - if hasattr(self, 'measurement_thread'): - self.measurement_thread.update_signal.disconnect() - - # Setze neues aktives Gerät + # Stoppe aktuelles Gerät + if self.active_device: + self.active_device.stop_measurement() + if self.measurement_thread: + self.measurement_thread.update_signal.disconnect() + + # Neues Gerät aktivieren self.active_device = self.devices[serial] self.measurement_thread = self.active_device.measurement_thread self.measurement_thread.update_signal.connect(self.update_measurements) - - # Aktualisiere UI - self.connection_label.setText(f"Connected: {serial}") - self.status_bar.showMessage(f"Switched to device {serial}") - - # Reset Plot + UI mit Daten des neuen Geräts + self.measurement_thread.error_signal.connect(self.handle_device_error) + + # Starte Messung erst NACH Verbindung der Signale + self.active_device.start_measurement(self.interval) + + # UI aktualisieren self.update_ui_from_active_device() - if was_running: - self.start_test() # Nur wenn vorher aktiv def update_ui_from_active_device(self): dev = self.active_device @@ -1216,10 +1221,14 @@ class BatteryTester(QMainWindow): def update_measurements(self, voltage, current, current_time): if not self.active_device: return - + + dev_manager = self.active_device dev = self.active_device with self.plot_mutex: + dev_manager.time_data.append(current_time) + dev_manager.voltage_data.append(voltage) + dev_manager.current_data.append(current) dev.time_data.append(current_time) dev.voltage_data.append(voltage) dev.current_data.append(current) @@ -1232,7 +1241,7 @@ class BatteryTester(QMainWindow): agg_buf['count'] += 1 now = time.time() - if agg_buf['count'] >= dev.downsample_factor or now - agg_buf['last_plot_time'] >= 1.0: + if now - dev_manager.aggregation_buffer['last_plot_time'] >= 0.1: agg_time = np.mean(agg_buf['time']) agg_voltage = np.mean(agg_buf['voltage']) agg_current = np.mean(agg_buf['current']) @@ -1423,6 +1432,7 @@ class BatteryTester(QMainWindow): dev.channels['A'].mode = pysmu.Mode.HI_Z dev.channels['A'].constant(0) dev.channels['B'].mode = pysmu.Mode.HI_Z + dev.channels['B'].constant(0) except Exception as e: QMessageBox.critical(self, "Device Error", f"Failed to reset device: {e}") return @@ -1902,6 +1912,7 @@ class BatteryTester(QMainWindow): dev.channels['A'].mode = pysmu.Mode.HI_Z dev.channels['A'].constant(0) dev.channels['B'].mode = pysmu.Mode.HI_Z + dev.channels['B'].constant(0) # Reset UI self.test_running = True @@ -2082,6 +2093,7 @@ class BatteryTester(QMainWindow): self.active_device.dev.channels['A'].mode = pysmu.Mode.HI_Z self.active_device.dev.channels['A'].constant(0) self.active_device.dev.channels['B'].mode = pysmu.Mode.HI_Z + self.active_device.dev.channels['B'].constant(0) except Exception as e: print(f"Error resetting device in finalize: {e}") @@ -2349,6 +2361,7 @@ class BatteryTester(QMainWindow): @pyqtSlot(str) def handle_device_error(self, error_msg): """Handle device errors gracefully""" + print(f"EXAKTER FEHLER: {error_msg}") self.status_bar.showMessage(f"Device error: {error_msg}") self.status_light.setStyleSheet("background-color: red; border-radius: 10px;") self.session_active = False