enabled reading buffered states from API

app.py

@@ -51,12 +51,16 @@ def xml_transfer():
     except Exception as e:
         return {'error' : str(e)}
   
-@app.route('/device/<device_name>/', methods=["GET", "POST"])
-def api_devices(device_name):
+@app.route('/device/<device_name>/', defaults={'buffering': None}, methods=["GET", "POST"])
+@app.route('/device/<device_name>/<buffering>/', methods=["GET", "POST"])
+def api_devices(device_name: str, buffering: str):
     try:
         if request.method == "POST":
             response = interface_handler.write(device_name,request.data.get("output"))
-        return {'state': interface_handler.read(device_name)}
+        if buffering == 'buffer':
+            return {'buffer': interface_handler.read_buffer(device_name)}
+        else:
+            return {'state': interface_handler.read(device_name)}
     except Exception as e:
         return {'error': str(e)}
 

interface_handler.py

@@ -1,12 +1,16 @@
 from enum import Enum
 import RPi.GPIO as GPIO
 import sys
+import threading
+import time
 
 sys.path.append('/home/pi/aped_device')
 
 from xml_reader import Xml_reader
 from ring_buffer import Ring_buffer
 
+BUFFER_SPEED = 0.01 #1/s
+
 class Interface_handler:
     """handles the access to the various interfaces (e.g. GPIO)
     """
@@ -54,6 +58,8 @@ class Interface_handler:
         self.pwms = [None] * 41
         self.pwm_dutycycles = [None] * 41
         self.buffers = [None] * 41
+        self.buffer_device_names = []
+        self.buffer_thread = None
         self.init_gpio()
         self.init_buffer()
 
@@ -85,13 +91,38 @@ class Interface_handler:
                     raise NotImplementedError('the protocol of the device %s is not implemented' % device_name)
 
     def init_buffer(self):
+        if self.buffer_thread != None:
+            self.buffer_thread.stop()
         for device_name in self.xml_reader.get_device_names():
             port_info = self.xml_reader.get_port(device_name)
             pins = port_info["pins"]
-            buffer_size = self.xml_reader.get_buffer_size(device_name)
+            buffer_size = int(self.xml_reader.get_buffer_size(device_name))
             if buffer_size != 0:
                 for pin in pins:
                     self.buffers[self.Pin[pin].value] = Ring_buffer(buffer_size)
+                self.buffer_device_names += [device_name]
+        if len(self.buffer_device_names) > 0: 
+            self.buffer_thread = threading.Thread(target=self.buffering)
+            self.buffer_thread.start()
+
+    def read_buffer(self, device_name:str) -> dict:
+        if self.xml_reader.get_port(device_name) == None:
+            raise NameError('the device with the name %s is unknown' % device_name)
+
+        returnValues = dict()
+
+        port_info = self.xml_reader.get_port(device_name)
+        protocol = port_info["protocol"]
+        pins = port_info["pins"]
+
+        for pin in self.xml_reader.get_port(device_name)["pins"]:
+            if protocol in ["DO","DI","PWM"]:
+                returnValues.update({
+                    pin : str(self.buffers[self.Pin[pin].value])
+                })
+            else: #throw error for protocols without write functionality
+                raise ValueError("you can not read from device %s" % device_name)
+        return returnValues 
                 
 
     def read(self, device_name:str) -> dict:
@@ -182,9 +213,21 @@ class Interface_handler:
         else: #throw error for protocols without write functionality
             raise ValueError("you cannot write to device %s" % device_name)
 
+    def buffering(self):
+        while True:
+            for device_name in self.buffer_device_names:
+                output = self.read(device_name)
+                port_info = self.xml_reader.get_port(device_name)
+                protocol = port_info["protocol"]
+                pins = port_info["pins"]
+                time.sleep(BUFFER_SPEED)
+                for pin in pins:
+                    ring_buffer: Ring_buffer = self.buffers[self.Pin[pin].value]
+                    ring_buffer.append(output[pin])
+
 
 # ##test
 # interface_handler = Interface_handler(Xml_reader('XML/config.xml','XML/config.xsd'))
 # print(interface_handler.read('example'))
 # print(interface_handler.read('sensorarray'))
-# print(interface_handler.write('example',"test")) #shuld throw not writable error
+# # print(interface_handler.write('example',"test")) #shuld throw not writable error

ring_buffer.py

@@ -6,4 +6,8 @@ class Ring_buffer:
     def append(self, data):
         self.data.append(data)
         if len(self.data) == self.size:
-            self.data.pop(0)
+            self.data.pop(0)
+
+    def __str__(self):
+        return_str = str(self.data)
+        return return_str