forked from awendt/pyrelacs
143 lines
5.1 KiB
Python
143 lines
5.1 KiB
Python
import time
|
|
|
|
import pyqtgraph as pg
|
|
from IPython import embed
|
|
import numpy as np
|
|
from pyqtgraph.Qt.QtCore import QTimer
|
|
|
|
from pyrelacs.dataio.circbuffer import CircBuffer
|
|
from pyrelacs.util.logging import config_logging
|
|
|
|
log = config_logging()
|
|
|
|
|
|
class Continously:
|
|
def __init__(self, figure: pg.GraphicsLayoutWidget, buffer: CircBuffer):
|
|
self.figure = figure
|
|
self.buffer = buffer
|
|
self.last_plotted_index_analog_in_0 = 0
|
|
self.last_plotted_index_analog_in_1 = 0
|
|
self.timer = QTimer()
|
|
|
|
def plot(self, *args, **kwargs):
|
|
self.figure.setBackground("w")
|
|
|
|
prev_plot = self.figure.getItem(row=0, col=0)
|
|
if prev_plot:
|
|
self.figure.removeItem(prev_plot)
|
|
self.analog_in_0 = self.figure.addPlot(row=0, col=0)
|
|
self.analog_in_1 = self.figure.addPlot(row=1, col=0)
|
|
|
|
pen = pg.mkPen("red")
|
|
self.time_analog_in_0 = np.zeros(self.buffer.size)
|
|
self.data_analog_in_0 = np.empty(self.buffer.size)
|
|
self.line_analog_in_0 = self.analog_in_0.plot(
|
|
self.time_analog_in_0,
|
|
self.data_analog_in_0,
|
|
pen=pen,
|
|
# symbol="o",
|
|
)
|
|
|
|
pen = pg.mkPen("red")
|
|
self.time_analog_in_1 = np.zeros(self.buffer.size)
|
|
self.data_analog_in_1 = np.empty(self.buffer.size)
|
|
self.line_analog_in_1 = self.analog_in_1.plot(
|
|
self.time_analog_in_1,
|
|
self.data_analog_in_1,
|
|
pen=pen,
|
|
# symbol="o",
|
|
)
|
|
|
|
# self.plot_index = 0
|
|
self.CHUNK_PLOT = int(self.buffer.samplerate / 6)
|
|
self.PLOT_HISTORY = 500_000 # The amount of data you want to keep on screen
|
|
self.timer.setInterval(150)
|
|
self.timer.timeout.connect(self.update_plot)
|
|
self.timer.timeout.connect(self.update_plot_1)
|
|
self.timer.start()
|
|
|
|
def update_plot(self):
|
|
current_index = self.buffer.write_index()
|
|
total_count = self.buffer.totalcount(channel=0)
|
|
|
|
start_time = time.time()
|
|
if total_count - self.last_plotted_index_analog_in_0 >= self.CHUNK_PLOT:
|
|
try:
|
|
times, items = self.buffer.read(
|
|
self.last_plotted_index_analog_in_0,
|
|
extend=self.CHUNK_PLOT,
|
|
channel=0,
|
|
)
|
|
self.time_analog_in_0 = np.concatenate((self.time_analog_in_0, times))[
|
|
-self.PLOT_HISTORY :
|
|
]
|
|
self.data_analog_in_0 = np.concatenate((self.data_analog_in_0, items))[
|
|
-self.PLOT_HISTORY :
|
|
]
|
|
self.line_analog_in_0.setData(
|
|
self.time_analog_in_0,
|
|
self.data_analog_in_0,
|
|
)
|
|
self.last_plotted_index_analog_in_0 += self.CHUNK_PLOT
|
|
except IndexError:
|
|
log.error("Could not acces the data from the buffer for plotting")
|
|
end_time = time.time()
|
|
log.debug(f"total time for plotting {end_time - start_time}")
|
|
else:
|
|
pass
|
|
|
|
def update_plot_1(self):
|
|
total_count = self.buffer.totalcount(channel=1)
|
|
|
|
start_time = time.time()
|
|
if total_count - self.last_plotted_index_analog_in_1 >= self.CHUNK_PLOT:
|
|
try:
|
|
times, items = self.buffer.read(
|
|
self.last_plotted_index_analog_in_1,
|
|
extend=self.CHUNK_PLOT,
|
|
channel=1,
|
|
)
|
|
self.time_analog_in_1 = np.concatenate((self.time_analog_in_0, times))[
|
|
-self.PLOT_HISTORY :
|
|
]
|
|
self.data_analog_in_1 = np.concatenate((self.data_analog_in_0, items))[
|
|
-self.PLOT_HISTORY :
|
|
]
|
|
self.line_analog_in_1.setData(
|
|
self.time_analog_in_1,
|
|
self.data_analog_in_1,
|
|
)
|
|
self.last_plotted_index_analog_in_1 += self.CHUNK_PLOT
|
|
except IndexError:
|
|
log.error("Could not acces the data from the buffer for plotting")
|
|
end_time = time.time()
|
|
log.debug(f"total time for plotting {end_time - start_time}")
|
|
else:
|
|
pass
|
|
|
|
def stop_plotting(self):
|
|
self.timer.stop()
|
|
if self.last_plotted_index_analog_in_0 > 0:
|
|
total_count = self.buffer.totalcount()
|
|
times, items = self.buffer.read(
|
|
self.last_plotted_index_analog_in_0,
|
|
extend=total_count - self.last_plotted_index_analog_in_0,
|
|
)
|
|
self.time_analog_in_0 = np.concatenate((self.time_analog_in_0, times))[
|
|
-self.PLOT_HISTORY :
|
|
]
|
|
self.data_analog_in_0 = np.concatenate((self.data_analog_in_0, items))[
|
|
-self.PLOT_HISTORY :
|
|
]
|
|
self.line_analog_in_0.setData(
|
|
self.time_analog_in_0,
|
|
self.data_analog_in_0,
|
|
)
|
|
self.last_plotted_index_analog_in_0 += (
|
|
total_count - self.last_plotted_index_analog_in_0
|
|
)
|
|
|
|
def refresh(self):
|
|
self.analog_in_0.enableAutoRange()
|
|
self.analog_in_1.enableAutoRange()
|