Jan/Adalm1000_Battery_SMU
1
1
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

MainCode/adalm1000_logger.py aktualisiert

Browse Source 
erste messwerte auslesbar

D
This commit is contained in:
Jan 2025-08-06 23:58:43 +02:00
parent 60839ac886
commit c2f91999c2
1 changed files with 72 additions and 59 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

131
MainCode/adalm1000_logger.py
View File

@ -25,12 +25,15 @@ class PatchedSession(pysmu.Session):
try: try:
super().__init__(ignore_dataflow=ignore_dataflow, queue_size=queue_size) super().__init__(ignore_dataflow=ignore_dataflow, queue_size=queue_size)
except SessionError as e: except SessionError as e:
if "failed scanning and/or adding all supported devices" in str(e): if "failed scanning" in str(e):
print("⚠️ Ignored add_all() busy-device error, continuing...") print("Warning: Session initialization quirk, continuing...")
# The parent __init__ still runs and creates a session object
# We'll manually add devices later in init_device()
else: else:
raise 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: class DeviceManager:
def __init__(self, dev): def __init__(self, dev):
@ -68,9 +71,9 @@ class DeviceManager:
} }
def start_measurement(self, interval=0.1): 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.stop()
self.measurement_thread.wait(500)
self.measurement_thread = MeasurementThread(self.dev, interval) self.measurement_thread = MeasurementThread(self.dev, interval)
self.measurement_thread.start() self.measurement_thread.start()
self.is_running = True self.is_running = True
@ -126,6 +129,35 @@ class MeasurementThread(QThread):
while self._running: while self._running:
try: try:
samples = self.device.read(self.filter_window_size, 500, True) 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: if not samples:
raise DeviceDisconnectedError("No samples received") raise DeviceDisconnectedError("No samples received")
@ -517,14 +549,6 @@ class BatteryTester(QMainWindow):
os.makedirs(self.log_dir, exist_ok=True) os.makedirs(self.log_dir, exist_ok=True)
# Data buffers # 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 = { self.aggregation_buffer = {
'time': [], 'voltage': [], 'current': [], 'time': [], 'voltage': [], 'current': [],
'count': 0, 'last_plot_time': 0 'count': 0, 'last_plot_time': 0
@ -916,35 +940,17 @@ class BatteryTester(QMainWindow):
self.status_bar.showMessage(f"Mode changed to {mode_name}") self.status_bar.showMessage(f"Mode changed to {mode_name}")
def reset_test(self): def reset_test(self):
"""Reset test state for the active device"""
if not self.active_device: if not self.active_device:
return return
dev_manager = self.active_device dev_manager = self.active_device
dev_manager.reset_data() # Reset in DeviceManager
# Reset data buffers
with self.plot_mutex: # UI zurücksetzen
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
self.capacity_label.setText("0.0000") self.capacity_label.setText("0.0000")
self.energy_label.setText("0.0000") self.energy_label.setText("0.0000")
self.cycle_label.setText("0") self.cycle_label.setText("0")
self.phase_label.setText(dev_manager.test_phase) self.phase_label.setText("Idle")
def toggle_recording(self): def toggle_recording(self):
"""Toggle data recording in Live Monitoring mode""" """Toggle data recording in Live Monitoring mode"""
@ -1050,13 +1056,16 @@ class BatteryTester(QMainWindow):
self.session_active = False self.session_active = False
self.active_device = None # Sicherstellen, dass es None ist self.active_device = None # Sicherstellen, dass es None ist
return return
self.session.start(0)
self.devices.clear() self.devices.clear()
for dev in self.session.devices: for dev in self.session.devices:
manager = DeviceManager(dev) manager = DeviceManager(dev)
manager.start_measurement(interval=self.interval) manager.start_measurement(interval=self.interval)
self.devices[dev.serial] = manager self.devices[dev.serial] = manager
self.session.start(0)
# Erstes Gerät aktivieren # Erstes Gerät aktivieren
first_serial = self.session.devices[0].serial first_serial = self.session.devices[0].serial
self.active_device = self.devices[first_serial] self.active_device = self.devices[first_serial]
@ -1153,34 +1162,30 @@ class BatteryTester(QMainWindow):
print(f"Manual init failed: {e}") print(f"Manual init failed: {e}")
def change_device(self, index): def change_device(self, index):
if not self.session_active or index < 0: if not self.session_active or index < 0:
return return
serial = self.device_combo.itemText(index) serial = self.device_combo.itemText(index)
if serial not in self.devices: if serial not in self.devices:
return return
# Stoppe aktuelle Messung (UI) # Stoppe aktuelles Gerät
was_running = self.test_running if self.active_device:
if was_running: self.active_device.stop_measurement()
self.stop_test() if self.measurement_thread:
self.measurement_thread.update_signal.disconnect()
# Trenne alten Thread-Slot
if hasattr(self, 'measurement_thread'): # Neues Gerät aktivieren
self.measurement_thread.update_signal.disconnect()
# Setze neues aktives Gerät
self.active_device = self.devices[serial] self.active_device = self.devices[serial]
self.measurement_thread = self.active_device.measurement_thread self.measurement_thread = self.active_device.measurement_thread
self.measurement_thread.update_signal.connect(self.update_measurements) self.measurement_thread.update_signal.connect(self.update_measurements)
self.measurement_thread.error_signal.connect(self.handle_device_error)
# Aktualisiere UI
self.connection_label.setText(f"Connected: {serial}") # Starte Messung erst NACH Verbindung der Signale
self.status_bar.showMessage(f"Switched to device {serial}") self.active_device.start_measurement(self.interval)
# Reset Plot + UI mit Daten des neuen Geräts # UI aktualisieren
self.update_ui_from_active_device() self.update_ui_from_active_device()
if was_running:
self.start_test() # Nur wenn vorher aktiv
def update_ui_from_active_device(self): def update_ui_from_active_device(self):
dev = self.active_device dev = self.active_device
@ -1216,10 +1221,14 @@ class BatteryTester(QMainWindow):
def update_measurements(self, voltage, current, current_time): def update_measurements(self, voltage, current, current_time):
if not self.active_device: if not self.active_device:
return return
dev_manager = self.active_device
dev = self.active_device dev = self.active_device
with self.plot_mutex: 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.time_data.append(current_time)
dev.voltage_data.append(voltage) dev.voltage_data.append(voltage)
dev.current_data.append(current) dev.current_data.append(current)
@ -1232,7 +1241,7 @@ class BatteryTester(QMainWindow):
agg_buf['count'] += 1 agg_buf['count'] += 1
now = time.time() 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_time = np.mean(agg_buf['time'])
agg_voltage = np.mean(agg_buf['voltage']) agg_voltage = np.mean(agg_buf['voltage'])
agg_current = np.mean(agg_buf['current']) 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'].mode = pysmu.Mode.HI_Z
dev.channels['A'].constant(0) dev.channels['A'].constant(0)
dev.channels['B'].mode = pysmu.Mode.HI_Z dev.channels['B'].mode = pysmu.Mode.HI_Z
dev.channels['B'].constant(0)
except Exception as e: except Exception as e:
QMessageBox.critical(self, "Device Error", f"Failed to reset device: {e}") QMessageBox.critical(self, "Device Error", f"Failed to reset device: {e}")
return return
@ -1902,6 +1912,7 @@ class BatteryTester(QMainWindow):
dev.channels['A'].mode = pysmu.Mode.HI_Z dev.channels['A'].mode = pysmu.Mode.HI_Z
dev.channels['A'].constant(0) dev.channels['A'].constant(0)
dev.channels['B'].mode = pysmu.Mode.HI_Z dev.channels['B'].mode = pysmu.Mode.HI_Z
dev.channels['B'].constant(0)
# Reset UI # Reset UI
self.test_running = True 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'].mode = pysmu.Mode.HI_Z
self.active_device.dev.channels['A'].constant(0) 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'].mode = pysmu.Mode.HI_Z
self.active_device.dev.channels['B'].constant(0)
except Exception as e: except Exception as e:
print(f"Error resetting device in finalize: {e}") print(f"Error resetting device in finalize: {e}")
@ -2349,6 +2361,7 @@ class BatteryTester(QMainWindow):
@pyqtSlot(str) @pyqtSlot(str)
def handle_device_error(self, error_msg): def handle_device_error(self, error_msg):
"""Handle device errors gracefully""" """Handle device errors gracefully"""
print(f"EXAKTER FEHLER: {error_msg}")
self.status_bar.showMessage(f"Device error: {error_msg}") self.status_bar.showMessage(f"Device error: {error_msg}")
self.status_light.setStyleSheet("background-color: red; border-radius: 10px;") self.status_light.setStyleSheet("background-color: red; border-radius: 10px;")
self.session_active = False self.session_active = False