Squashed commit of the following:

    Ran code through black for formatting
    added raspberry pi to valuelogger supported devices list
    Kill update thread on shutdown and return single value or list if more than one
    Getting RPi code working for temperature sensors
    lowered priory of debug message sand added sin wave to simulated data synthesis
    first draft of a ValueLogger class with simulated device
    This devcie has some discussion in issue #272

Author: iandobbie

doc/architecture/supported-devices.rst

@@ -72,6 +72,14 @@ DigitalIO
 
 - Raspberry Pi (:class:`microsocpe.digitalio.raspberrypi`)
 
+
+ValueLogger
+===========
+
+- Raspberry Pi (:class:`microsocpe.valuelogger.raspberrypi`)
+  includes support for the MCP9808 and TSYS01 I2C temperature sensors
+
+
 Other
 =====
 

microscope/abc.py

@@ -1668,3 +1668,33 @@ def read_all_lines(self):
         for i in range(self._numLines):
             readarray[i] = self.read_line(i)
         return readarray
+
+
+class ValueLogger(DataDevice, metaclass=abc.ABCMeta):
+    """ABC for Value logging device.
+
+    Value logging Devices utilise the DataDevice infrastrucrure to send
+    values to a receiving client. A typical example of data is temperature
+    measurements.
+
+    Args:
+        numSensors: total number of measurements.
+
+    """
+
+    def __init__(self, numSensors: int, **kwargs) -> None:
+        super().__init__(**kwargs)
+        if numSensors < 1:
+            raise ValueError(
+                "NumSensors must be a positive number (was %d)" % numSensors
+            )
+        self._numSensors = numSensors
+
+    @abc.abstractmethod
+    def initialize(self):
+        """Inialize sensors to start sending data back."""
+        raise NotImplementedError()
+
+    def get_num_sensors(self):
+        """Returns the number of sensors lines present in this instance"""
+        return self._numSensors

microscope/digitalio/raspberrypi.py

@@ -29,7 +29,6 @@
 import typing
 import logging
 import queue
-
 import microscope.abc
 
 import RPi.GPIO as GPIO
@@ -102,9 +101,7 @@ def register_HW_interupt(self, line):
     def HW_trigger(self, pin):
         state = GPIO.input(pin)
         line = self._gpioMap.index(pin)
-        print(pin, state, line)
         self.inputQ.put((line, state))
-        print(self.inputQ.empty())
 
     def get_IO_state(self, line: int) -> bool:
         # returns
@@ -148,7 +145,6 @@ def _fetch_data(self):
         if self.inputQ.empty():
             return None
         (line, state) = self.inputQ.get()
-        # print(self.inputQ.get())
         _logger.info("Line %d chnaged to %s" % (line, str(state)))
         return (line, state)
 

microscope/simulators/__init__.py

@@ -29,6 +29,7 @@
 import logging
 import random
 import time
+import math
 import typing
 from typing import Tuple
 
@@ -534,3 +535,39 @@ def _do_enable(self):
 # raise exception if line <0 or line>num_lines
 # read all lines to return True,Flase if readable and None if an output
 #
+
+
+class SimulatedValueLogger(microscope.abc.ValueLogger):
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+        self._cache = [None] * self._numSensors
+        self.lastDataTime = time.time()
+
+    def initialize(self):
+        # init simulated sensors
+        for i in range(self._numSensors):
+            self._cache[i] = 20 + i
+
+    # functions required as we are DataDevice returning data to the server.
+    def _fetch_data(self):
+        if (time.time() - self.lastDataTime) > 5.0:
+            for i in range(self._numSensors):
+                self._cache[i] = (
+                    19.5
+                    + i
+                    + 5 * math.sin(self.lastDataTime / 100)
+                    + random.random()
+                )
+                _logger.debug("Sensors %d returns %s" % (i, self._cache[i]))
+            self.lastDataTime = time.time()
+            return self._cache
+        return None
+
+    def abort(self):
+        pass
+
+    def _do_enable(self):
+        return True
+
+    def _do_shutdown(self) -> None:
+        pass

microscope/valuelogger/raspberrypi.py

@@ -0,0 +1,163 @@
+#!/usr/bin/env python3
+
+## Copyright (C) 2020 David Miguel Susano Pinto <carandraug@gmail.com>
+## Copyright (C) 2023 Ian Dobbie <ian.dobbie@jhu.edu>
+##
+##
+## This file is part of Microscope.
+##
+## Microscope is free software: you can redistribute it and/or modify
+## it under the terms of the GNU General Public License as published by
+## the Free Software Foundation, either version 3 of the License, or
+## (at your option) any later version.
+##
+## Microscope is distributed in the hope that it will be useful,
+## but WITHOUT ANY WARRANTY; without even the implied warranty of
+## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+## GNU General Public License for more details.
+##
+## You should have received a copy of the GNU General Public License
+## along with Microscope.  If not, see <http://www.gnu.org/licenses/>.
+
+"""Raspberry Pi Value Logger module.
+"""
+
+import contextlib
+import re
+import threading
+import time
+import typing
+import logging
+import queue
+import Adafruit_MCP9808.MCP9808 as MCP9808
+
+# library for TSYS01 sensor
+# import TSYS01.TSYS01 as TSYS01
+
+import microscope.abc
+
+
+# Support for async digital IO control on the Raspberryy Pi.
+# Currently supports digital input and output via GPIO lines
+
+
+# Use BCM GPIO references (naming convention for GPIO pins from Broadcom)
+# instead of physical pin numbers on the Raspberry Pi board
+
+_logger = logging.getLogger(__name__)
+
+
+class RPiValueLogger(microscope.abc.ValueLogger):
+    """ValueLogger device for a Raspberry Pi with support for
+    MCP9808 and TSYS01 I2C thermometer chips."""
+
+    def __init__(self, sensors=[], **kwargs):
+        super().__init__(**kwargs)
+        # setup Q for fetching data.
+        self.inputQ = queue.Queue()
+        self._sensors = []
+        for sensor in sensors:
+            sensor_type, i2c_address = sensor
+            print(
+                "adding sensor: " + sensor_type + " Adress: %d " % i2c_address
+            )
+            if sensor_type == "MCP9808":
+                self._sensors.append(MCP9808.MCP9808(address=i2c_address))
+                # starts the last one added
+                self._sensors[-1].begin()
+                print(self._sensors[-1].readTempC())
+            elif sensor_type == "TSYS01":
+                self._sensors.append(TSYS01.TSYS01(address=i2c_address))
+                print(self._sensors[-1].readTempC())
+            self.initialize()
+
+    def initialize(self):
+        self.updatePeriod = 1.0
+        self.readsPerUpdate = 10
+        # Open and start all temp sensors
+        # A thread to record periodic temperature readings
+        # This reads temperatures and logs them
+        if self._sensors:
+            # only strart thread if we have a sensor
+            self.statusThread = threading.Thread(target=self.updateTemps)
+            self.stopEvent = threading.Event()
+            self.statusThread.Daemon = True
+            self.statusThread.start()
+
+    def debug_ret_Q(self):
+        if not self.inputQ.empty():
+            return self.inputQ.get()
+
+    # functions required for a data device.
+    def _fetch_data(self):
+        # need to return data fetched from interupt driven state chnages.
+        if self.inputQ.empty():
+            return None
+        temps = self.inputQ.get()
+        if len(temps) == 1:
+            outtemps = temps[0]
+        else:
+            outtemps = temps
+        # print(self.inputQ.get())
+        _logger.debug("Temp readings are %s" % str(outtemps))
+        return outtemps
+
+    def abort(self):
+        pass
+
+    def _do_enable(self):
+        return True
+
+    def _do_shutdown(self) -> None:
+        # need to kill threads.
+        self.stopEvent.set()
+
+        # return the list of current temperatures.
+
+    def get_temperature(self):
+        return self.temperature
+
+    # function to change updatePeriod
+    def tempUpdatePeriod(self, period):
+        self.updatePeriod = period
+
+    # function to change readsPerUpdate
+    def tempReadsPerUpdate(self, reads):
+        self.readsPerUpdate = reads
+
+    # needs to be re-written to push data into a queue which _fetch_data can
+    # then send out to the server.
+
+    # function to read temperature at set update frequency.
+    # runs in a separate thread.
+    def updateTemps(self):
+        """Runs in a separate thread publish status updates."""
+        self.temperature = [None] * len(self._sensors)
+        tempave = [None] * len(self._sensors)
+
+        #        self.create_rotating_log()
+
+        if len(self._sensors) == 0:
+            return ()
+
+        while True:
+            if self.stopEvent.is_set():
+                break
+            # zero the new averages.
+            for i in range(len(self._sensors)):
+                tempave[i] = 0.0
+            # take readsPerUpdate measurements and average to reduce digitisation
+            # errors and give better accuracy.
+            for i in range(int(self.readsPerUpdate)):
+                for i in range(len(self._sensors)):
+                    try:
+                        tempave[i] += self._sensors[i].readTempC()
+                    except:
+                        localTemperature = None
+                time.sleep(self.updatePeriod / self.readsPerUpdate)
+            for i in range(len(self._sensors)):
+                self.temperature[i] = tempave[i] / self.readsPerUpdate
+                _logger.debug(
+                    "Temperature-%s =  %s" % (i, self.temperature[i])
+                )
+            self.inputQ.put(self.temperature)