Add analog pin autodetection

Author: mesca

README.rst

@@ -44,12 +44,13 @@ Download the `Arduino IDE <https://www.arduino.cc/en/Main/Software>`__ on your c
 
 You're all set!
 
-An example graph for the default A0 analog port can be found `here <https://github.com/timeflux/timeflux_upsidedownlabs/blob/master/examples/uart.yaml>`__.
-You can run it like this:
+With `this example graph <https://github.com/timeflux/timeflux_upsidedownlabs/blob/master/examples/uart.yaml>`__, you can autodetect all the available analog ports and start streaming data.
+
+You can run this graph like this:
 
 ::
 
     $ conda activate timeflux
     $ timeflux -d examples/uart.yaml
 
-For an example of querying multiple ports and naming the channels, see `this graph <https://github.com/timeflux/timeflux_upsidedownlabs/blob/master/examples/channels.yaml>`__.
+For an example of filtering and renaming the channels, see `this graph <https://github.com/timeflux/timeflux_upsidedownlabs/blob/master/examples/channels.yaml>`__.

examples/channels.yaml

@@ -5,7 +5,7 @@ graphs:
         module: timeflux_upsidedownlabs.nodes.driver
         class: UpsideDownLabs
         params:
-          rate: 100
+          rate: 500
           channels:
             0: ECG
             2: EMG1

examples/uart.yaml

@@ -1,10 +1,11 @@
 graphs:
-  - nodes:
+  - id: demo
+    nodes:
       - id: data
         module: timeflux_upsidedownlabs.nodes.driver
         class: UpsideDownLabs
         params:
-          rate: 500
+          rate: 250
       - id: notch
         module: timeflux_dsp.nodes.filters
         class: IIRFilter

timeflux_upsidedownlabs/nodes/driver.py

@@ -19,7 +19,7 @@ class UpsideDownLabs(Node):
             Default: autodetect
         channels (dict): The pin/channel mapping.
             Keys are pin numbers and values are channel names.
-            Default: {1: "signal"}
+            Default: autodetect
         rate (int): The device rate in Hz.
             Default: ``500``.
 
@@ -32,31 +32,34 @@ class UpsideDownLabs(Node):
     def __init__(self, port=None, channels=None, rate=500):
         if not port:
             port = Arduino.AUTODETECT
-        if not channels:
-            channels = {1: "signal"}
         self.channels = channels
         self.rate = rate
-        self.timestamp = 0
         self.board = Arduino(port)
-        self.meta = {"rate": rate}
-        self._lock = Lock()
-        self._blink()
-        self.board.samplingOn(1000 / self.rate)
+        if not self.channels:
+            self.channels = {
+                channel: f"A{channel}" for channel in range(len(self.board.analog))
+            }
         for pin in list(self.channels.keys()):
             if pin >= len(self.board.analog):
                 self.logger.warning(f"Removing invalid pin {pin}")
                 del self.channels[pin]
+        self.meta = {"rate": rate}
+        self._lock = Lock()
+        self._blink()
+        self.board.samplingOn(1000 / self.rate)
         self._reset_buffer()
         self._reset_sample()
         for pin, channel in self.channels.items():
             # See: https://docs.python-guide.org/writing/gotchas/#late-binding-closures
-            self.board.analog[pin].register_callback(lambda data, channel=channel : self._callback(data, channel))
+            self.board.analog[pin].register_callback(
+                lambda data, channel=channel: self._callback(data, channel)
+            )
             self.board.analog[pin].enable_reporting()
 
     def _blink(self):
-        """Show a cool led animation"""
+        """Show a cool led animation."""
         pins = [8, 9, 10, 11, 12, 13]
-        for i in range(10):
+        for i in range(5):
             for pin in pins:
                 self.board.digital[pin].write(1)
                 time.sleep(0.02)
@@ -65,38 +68,44 @@ def _blink(self):
 
     def _callback(self, data, channel):
         """Acquire and cache data."""
-        if self.timestamp == 0:
-            self.timestamp = time.time()
         self._lock.acquire()
+        if self.sample["data"][channel] is not None:
+            self.logger.warn("Corrupted sample")
+            self._reset_sample()
+        self.sample["data"][channel] = data
         self.sample["received"] += 1
-        self.sample["data"][channel].append(data)
-        if not self.sample["timestamp"]:
-            self.sample["timestamp"] = self.timestamp
         if self.sample["received"] == len(self.channels):
             self._commit_sample()
-            self.timestamp += 1 / self.rate
         self._lock.release()
 
     def _reset_buffer(self):
-        """Reset the buffer"""
+        """Reset the buffer."""
         self.timestamps = []
         self.data = {}
         for channel in self.channels.values():
             self.data[channel] = []
 
     def _reset_sample(self):
-        """Reset the sample"""
+        """Reset the sample."""
+        try:
+            timestamp = self.sample["timestamp"]
+            if timestamp == 0:
+                timestamp = time.time()
+            else:
+                timestamp += 1 / self.rate
+        except:
+            timestamp = 0
         self.sample = {
-            "timestamp": None,
-            "data": { channel: [] for channel in self.channels.values() },
-            "received": 0
+            "timestamp": timestamp,
+            "data": {channel: None for channel in self.channels.values()},
+            "received": 0,
         }
 
     def _commit_sample(self):
-        """Append the sample"""
+        """Append the sample."""
         self.timestamps.append(self.sample["timestamp"])
         for channel in self.channels.values():
-            self.data[channel] += self.sample["data"][channel]
+            self.data[channel].append(self.sample["data"][channel])
         self._reset_sample()
 
     def update(self):