Winz/Adalm1000_Logger
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

fix

Browse Source
This commit is contained in:
Vincent Hanewinkel 2025-08-14 22:40:44 +02:00
parent 5eb500644c
commit 559f512bee
1 changed files with 26 additions and 52 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

78
DeviceController.py
View File

@ -1,5 +1,5 @@
# device_controller.py
import threading, queue, time, math, os, csv
import threading, queue, time, math, os, csv, statistics
RAW_SAMPLE_RATE = 100_000.0 # M1K nominal
CHUNK_RAW = 2000 # ~20 ms pro Chunk pro Gerät
@ -40,92 +40,66 @@ class DeviceController:
# -------- Reader: liest roh und decimiert --------
def reader_loop(self):
print(f"[{self.serial}] Reader start (decim={self.decim}, eff_rate={self.eff_rate:.0f} S/s)")
filter_window_size = 10 # wie in deinem Logger
interval = 0.1 # 10 Hz Mess-Update
last_log_time = 0
while not self.stop_evt.is_set():
# Kommandos
# Start/Stop Kommandos
try:
cmd, _ = self.cmdq.get_nowait()
if cmd == "start" and not self.running:
self.sm.start() # Session ggf. starten
self.sm.start()
self.running = True
elif cmd == "stop" and self.running:
self.sm.stop()
self.running = False
self.sm.stop() # Session ggf. stoppen
except queue.Empty:
pass
if not self.running:
time.sleep(0.02)
time.sleep(0.05)
continue
try:
# pysmu: Liste von [VA, IA, VB, IB]
samples = self.dev.read(CHUNK_RAW, -1) # je nach Version evtl. .read(CHUNK_RAW)
# Rohdaten holen (filter_window_size Samples)
samples = self.dev.read(filter_window_size, -1)
if not samples:
time.sleep(0.001)
time.sleep(interval)
continue
# Kanäle extrahieren
va_raw = [row[0] for row in samples]
vb_raw = [row[2] for row in samples]
# Kanäle extrahieren & mitteln
va = statistics.mean(row[0] for row in samples)
vb = statistics.mean(row[2] for row in samples)
# -------- Decimation: jedes N-te Sample --------
if self.decim > 1:
va = va_raw[::self.decim]
vb = vb_raw[::self.decim]
else:
va, vb = va_raw, vb_raw
# In Writer-Queue; bei voller Queue ältestes verwerfen (Ringpuffer)
try:
self.writer_q.put_nowait((va, vb))
except queue.Full:
try:
_ = self.writer_q.get_nowait() # drop oldest
except queue.Empty:
pass
finally:
# (erneut versuchen, blockiert jetzt nicht)
try:
self.writer_q.put_nowait((va, vb))
except queue.Full:
# wenn immer noch voll, dann überspringen wir diesen Chunk
pass
now = time.time()
if now - last_log_time >= 1.0: # nur jede Sekunde loggen
self.writer_q.put((now, va, vb))
last_log_time = now
except Exception as e:
print(f"[{self.serial}] Read-Fehler: {e}")
time.sleep(0.01)
print(f"[{self.serial}] Reader stop")
# Loop-Rate steuern
time.sleep(max(0.05, interval))
# -------- Writer: Wide-Format, effektive Zeitachse --------
def writer_loop(self):
os.makedirs(OUTDIR, exist_ok=True)
fn = os.path.join(OUTDIR, f"{time.strftime('%Y%m%d_%H%M%S')}_{self.serial}.csv")
sample_idx = 0
rows_since_flush = 0
print(f"[{self.serial}] Writer -> {fn} (dt={self.dt:.6e}s)")
print(f"[{self.serial}] Writer -> {fn}")
try:
with open(fn, "w", newline="") as f:
w = csv.writer(f)
w.writerow(["t_rel_s", "A", "B"])
w.writerow(["timestamp", "A", "B"])
while not (self.stop_evt.is_set() and self.writer_q.empty()):
try:
va, vb = self.writer_q.get(timeout=0.5)
ts, va, vb = self.writer_q.get(timeout=0.5)
except queue.Empty:
continue
n = min(len(va), len(vb))
# Zeitachse mit effektiver Rate
for i in range(n):
t_rel = (sample_idx + i) * self.dt
w.writerow([t_rel, va[i], vb[i]])
sample_idx += n
rows_since_flush += n
if rows_since_flush >= 10_000: # alle ~10k Samples flushen
f.flush()
rows_since_flush = 0
w.writerow([ts, va, vb])
f.flush()
except Exception as e:
print(f"[{self.serial}] Writer-Fehler: {e}")
finally: