jacob/OlliTut
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Unified Sensors and Drivers --> Device

Browse Source
This commit is contained in:
Jacob Holder 2022-01-30 21:41:10 +01:00
parent 90b0983160
commit 3b9b0fc06c
Signed by: jacob
GPG Key ID: 2194FC747048A7FD
9 changed files with 53 additions and 198 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

24
CoreLibrary/Driver.py → CoreLibrary/Device.py
View File

@ -1,16 +1,12 @@
from abc import ABC, abstractmethod
from typing import List, Tuple
class Driver(ABC):
class Device(ABC):
"""docstring for Model."""
@abstractmethod
def exit(self):
"""
disconnecting device
"""
@property
def get_data(self) -> Tuple[List, List]:
pass
@abstractmethod
@ -24,7 +20,6 @@ class Driver(ABC):
def get_config(self) -> dict:
pass
@abstractmethod
def get_status(self) -> dict:
"""
@ -32,3 +27,14 @@ class Driver(ABC):
"""
pass
@abstractmethod
def start_measuring(self):
pass
@abstractmethod
def stop_measuring(self):
pass
@abstractmethod
def exit(self):
pass

22
CoreLibrary/ExampleCombined.py → CoreLibrary/ExampleDeviceScalar.py
View File

@ -5,13 +5,12 @@ from random import random
from threading import Thread, Event
from time import sleep
from Driver import Driver
from Sensor import Sensor
from Device import Device
LOGGER = logging.getLogger("my_logger")
class ExampleDriverWorker(Thread):
class ExampleDeviceWorker(Thread):
"""Communicates with the measuring hardware. Here we only produce random data."""
def __init__(self, message_queue):
@ -31,21 +30,23 @@ class ExampleDriverWorker(Thread):
self.message_queue.put((ts, temp))
else:
pass
sleep(1)
sleep(0.2)
class ExampleDriver(Driver, Sensor):
"""docstring for Model."""
class ExampleDeviceScalar(Device):
"""Communicates with the measuring hardware. Here we only produce random data."""
def __init__(self):
super(Driver, self).__init__()
super(Device, self).__init__()
self.measureQueue = Queue()
self.measureThread = ExampleDriverWorker(self.measureQueue)
self.measureThread = ExampleDeviceWorker(self.measureQueue)
self.measureThread.start()
self.measureThread.produceData.set()
self.speed = 10
self.running = False
def exit(self):
self.stop_measuring()
self.measureThread.exit_request.set()
def set_config(self, config: dict):
@ -53,7 +54,6 @@ class ExampleDriver(Driver, Sensor):
def get_config(self):
return {"speed": self.speed}
pass
def get_status(self):
return {"running": self.running}
@ -66,10 +66,6 @@ class ExampleDriver(Driver, Sensor):
self.measureThread.produceData.clear()
LOGGER.info("I stopped meas")
def exit(self):
self.stop_measuring()
self.measureThread.exit_request.set()
@property
def get_data(self):
time = []

47
CoreLibrary/ExampleDriver.py
View File

@ -1,47 +0,0 @@
from abc import abstractmethod
from threading import Thread, Event
from time import sleep
from queue import Queue
from CoreLibrary.Driver import Driver
import logging
LOGGER = logging.getLogger("my_logger")
class ExampleDriverWorker(Thread):
"""Communicates with the measuring hardware. Here we only produce random data."""
def __init__(self, message_queue):
super().__init__(name="Driver")
self.produceData = Event()
self.exit_request = Event()
def run(self):
"""Worker method of a python Thread. Called when the Thread is started."""
while not self.exit_request.is_set():
sleep(1)
class ExampleDriver(Driver):
"""docstring for Model."""
def __init__(self):
super(Driver, self).__init__()
self.measureQueue = Queue()
self.measureThread = ExampleDriverWorker(self.measureQueue)
self.measureThread.start()
self.measureThread.produceData.set()
self.speed = 10
self.running = False
def exit(self):
self.measureThread.exit_request.set()
def set_config(self, config: dict):
self.speed = config["speed"]
def get_status(self):
return {"running": self.running}
def get_config(self):
pass

65
CoreLibrary/ExampleSensor.py
View File

@ -1,65 +0,0 @@
from datetime import datetime
from threading import Thread, Event
from time import sleep
from queue import Queue
from random import random
from CoreLibrary.Sensor import Sensor
import logging
LOGGER = logging.getLogger("my_logger")
class ExampleSensorWorker(Thread):
"""Communicates with the measuring hardware. Here we only produce random data."""
def __init__(self, message_queue):
super().__init__(name="Measure")
self.message_queue = message_queue
self.produceData = Event()
self.exit_request = Event()
self.prev = 0
def run(self):
"""Worker method of a python Thread. Called when the Thread is started."""
while not self.exit_request.is_set():
if self.produceData.is_set():
temp = self.prev + random() / 100.0
self.prev = temp
ts = datetime.utcnow()
self.message_queue.put((ts, temp))
else:
pass
sleep(1)
class ExampleSensor(Sensor):
"""docstring for Model."""
def __init__(self):
super(Sensor, self).__init__()
self.measureQueue = Queue()
self.measureThread = ExampleSensorWorker(self.measureQueue)
self.measureThread.start()
self.measureThread.produceData.set()
def start_measuring(self):
self.measureThread.produceData.set()
LOGGER.info("I started meas")
def stop_measuring(self):
self.measureThread.produceData.clear()
LOGGER.info("I stopped meas")
def exit(self):
self.stop_measuring()
self.measureThread.exit_request.set()
@property
def get_data(self):
time = []
val = []
while not self.measureQueue.empty():
t, data = self.measureQueue.get()
time.append(t)
val.append(data)
return time, val

34
CoreLibrary/Measurement.py
View File

@ -3,8 +3,7 @@ import json
import logging
import os
from CoreLibrary.Driver import Driver
from CoreLibrary.Sensor import Sensor
from CoreLibrary.Device import Device
LOGGER = logging.getLogger("my_logger")
@ -19,42 +18,33 @@ class Measurement:
self.path = os.path.join(path or "./meas_values", self.name)
os.makedirs(self.path)
self.save_version_text(comment)
self.sensors = {}
self.drivers = {}
self.data_files = {}
self.data_files["log"] = self.create_file("log")
self.devices = {}
self.data_files = {"log": self.create_file("log")}
def create_file(self, name: str):
return open(os.path.join(self.path, name), "w")
def attach_sensor(self, sensor: Sensor, name: str):
self.sensors[name] = sensor
def attach_driver(self, driver: Driver, name: str):
self.drivers[name] = driver
def attach_combined(self, comb, name: str):
self.attach_sensor(comb, name)
self.attach_driver(comb, name)
def attach_device(self, device: Device, name: str):
self.devices[name] = device
def write_log(self, text: str):
self.data_files["log"].write(str(datetime.datetime.utcnow()) + ":\t" + text + "\n")
def append_data(self, sensor_name, data):
def append_data(self, device_name, data):
"""
Save data from a sensor. Write it into the corresponding file.
Save data from a device. Write it into the corresponding file.
TODO: file size limit, zip?
data: list of tuples: (timestamp, value)
"""
if sensor_name not in self.sensors:
if device_name not in self.devices:
return
LOGGER.info("append-data: " + sensor_name)
if sensor_name not in self.data_files:
self.data_files[sensor_name] = self.create_file(sensor_name)
LOGGER.info("append-data: " + device_name)
if device_name not in self.data_files:
self.data_files[device_name] = self.create_file(device_name)
for timestamp, value in zip(data[0], data[1]):
self.data_files[sensor_name].write(
self.data_files[device_name].write(
f"{timestamp.isoformat()}, {timestamp.timestamp()}, {value}\n"
)

18
CoreLibrary/Param_Model.py
View File

@ -3,8 +3,7 @@ from logging.handlers import RotatingFileHandler
from time import sleep
from threading import Thread, Event
from CoreLibrary.ExampleDriver import ExampleDriver
from CoreLibrary.ExampleSensor import ExampleSensor
from CoreLibrary.ExampleDeviceScalar import ExampleDeviceScalar
from CoreLibrary.Measurement import Measurement
from CoreLibrary.Plot_Data import Plot_Data
@ -43,8 +42,7 @@ class DataWorker(Thread):
class Param_Model:
def __init__(self):
self.drivers = {"treib1": ExampleDriver()}
self.sensors = {"mess1": ExampleSensor()}
self.devices = {"treib1": ExampleDeviceScalar(), "mess1": ExampleDeviceScalar()}
self.__plot_data = []
self.__measurement = []
self.data_worker = DataWorker(self)
@ -62,25 +60,23 @@ class Param_Model:
def refresh(self):
LOGGER.debug("refresh")
for name, sens in self.sensors.items():
data = sens.get_data
for name, device in self.devices.items():
data = device.get_data
for meas in self.__measurement:
meas.append_data(name, data)
for pd in self.__plot_data:
pd.append_data(name, data)
def stop_measuring(self):
for sens in self.sensors.values():
for sens in self.devices.values():
sens.stop_measuring()
def start_measuring(self):
for sens in self.sensors.values():
for sens in self.devices.values():
sens.start_measuring()
def exit(self):
LOGGER.warning("entering exit method")
for sens in self.sensors.values():
for sens in self.devices.values():
sens.exit()
for drv in self.drivers.values():
drv.exit()
self.data_worker.exit_request.set()

12
CoreLibrary/Plot_Data.py
View File

@ -22,16 +22,16 @@ class Plot_Data:
def get(self, key):
return self.data.get(key, np.full_like(self.data["time"], np.nan, dtype=np.double))
def append_data(self, sensor_name, data):
def append_data(self, device_name, data):
""" """
if sensor_name not in self.data:
self.queues[sensor_name] = ([], [])
self.data[sensor_name] = np.full_like(self.data["time"], np.nan, dtype=np.double)
if device_name not in self.data:
self.queues[device_name] = ([], [])
self.data[device_name] = np.full_like(self.data["time"], np.nan, dtype=np.double)
for time, dat in zip(data[0], data[1]):
self.queues[sensor_name][0].append(
self.queues[device_name][0].append(
(time - self.start_time) / timedelta(milliseconds=self.resolution)
)
self.queues[sensor_name][1].append(dat)
self.queues[device_name][1].append(dat)
self.extend_timeline()
self.sort_in_queue()
self.drop_old()

21
CoreLibrary/Sensor.py
View File

@ -1,21 +0,0 @@
from abc import ABC, abstractmethod
class Sensor(ABC):
"""docstring for Model."""
@abstractmethod
def start_measuring(self):
pass
@abstractmethod
def stop_measuring(self):
pass
@abstractmethod
def exit(self):
pass
@property
def get_data(self):
pass

8
CoreLibrary/mess.py
View File

@ -9,12 +9,12 @@ import matplotlib.pyplot as plt
def clean():
rmtree("meas_values")
rmtree("meas_values", ignore_errors=True)
def main(param_model: Param_Model):
sensor = param_model.sensors["mess1"]
driver = param_model.drivers["treib1"]
sensor = param_model.devices["mess1"]
driver = param_model.devices["treib1"]
driver.set_config({"speed": 2})
status = driver.get_status()
@ -25,7 +25,7 @@ def main(param_model: Param_Model):
driver.set_config({"speed": speed})
measurement = param_model.new_measurement(name=f"penis_{speed}", writer="CSV")
measurement.attach_sensor(sensor=sensor, name="mess1")
measurement.attach_device(device=sensor, name="mess1")
measurement.write_log("ich mag ramen")
param_model.start_measuring()
sleep(2)