Code cleaned up

Dockerfile

@@ -61,6 +61,11 @@ COPY --from=build /python /python
 COPY --from=build /app/.venv /app/.venv
 ENV PATH=/app/.venv/bin:$PATH
 
+# Make directory to run inside and generate bob files
+RUN mkdir -p /epics/opi
+
+WORKDIR /epics/opi
+
 # change this entrypoint if it is not the same as the repo
 ENTRYPOINT ["fastcsflame"]
 CMD ["--version"]

README.md

@@ -5,29 +5,37 @@
 
 # fastcsflame
 
-EPICS driver for the OceanOptics flame mini spectrometer
+EPICS driver for the OceanOptics Flame mini spectrometer
 
-This is where you should write a short paragraph that describes what your module does,
-how it does it, and why people should use it.
+When started, the script connects to a spectrometer at a specific IP and port and interacts with it using the TelNet protocol. An IOC for interacting with this device is started. This allows users to interact with the device using channel access (controller name is FLAME) or through a Phoebus UI (opi files are generated in the opi directory). Users can create a file holding collected data by starting the a capture period (set Capture to 1). This will create a h5 file at the location specified by the FilePath PV with the value of the FileName PV as its name. Every time the Scan command is run scan data from the device will be added to this file. To end the capture period set Capture to 0 again. This will close the file and future scans will not be added.
 
 What            | Where
 :---:           | :---:
-Source          | <https://github.com//fastcsflame>
-Docker          | `docker run ghcr.io//fastcsflame:latest`
-Releases        | <https://github.com//fastcsflame/releases>
+Source          | <https://gitlab.diamond.ac.uk/controls/containers/beamline/fastcs-flame>
 
-This is where you should put some images or code snippets that illustrate
-some relevant examples. If it is a library then you might put some
-introductory code here:
+# PVs of the Flame IOC
+- IntegrationTime
+- LastScanData
+- Scan
+- FilePath
+- FileName
+- Capture
 
-```python
-from fastcsflame import __version__
+Start the IOC:
+`fastcsflame`
+(in future this will have options for the address and port to communicate to the device on) 
 
-print(f"Hello fastcsflame {__version__}")
-```
+Set integration time to 10:
+`caput FLAME:IntegrationTime 10`
 
-Or if it is a commandline tool then you might put some example commands here:
+Get the data from the last scan:
+`caget FLAME:LastScanData`
 
-```
-python -m fastcsflame --version
-```
+Trigger a scan on the Flame:
+`caput FLAME:Scan 1`
+
+Start the capture period (creates the h5 file)
+`caput FLAME:Capture 1`
+
+Stop the capture period (closes the h5 file, allowing users to view it)
+`caput FLAME:Capture 0`

pyproject.toml

@@ -13,7 +13,11 @@ classifiers = [
     "Programming Language :: Python :: 3.14",
 ]
 description = "EPICS driver for the OceanOptics flame mini spectrometer"
-dependencies = [] # Add project dependencies here, e.g. ["click", "numpy"]
+dependencies = [
+    "fastcs[epicsca]",
+    "h5py",
+    "numpy",
+] # Add project dependencies here, e.g. ["click", "numpy"]
 dynamic = ["version"]
 license.file = "LICENSE"
 readme = "README.md"
@@ -25,6 +29,7 @@ dev = [
     "pre-commit",
     "pyright",
     "pytest",
+    "pytest-asyncio",
     "pytest-cov",
     "ruff",
     "tox-uv",
@@ -46,7 +51,7 @@ version_file = "src/fastcsflame/_version.py"
 
 [tool.pyright]
 typeCheckingMode = "standard"
-reportMissingImports = false # Ignore missing stubs in imported modules
+reportMissingImports = false  # Ignore missing stubs in imported modules
 
 [tool.pytest.ini_options]
 # Run pytest with all our checkers, and don't spam us with massive tracebacks on error

src/fastcsflame/TODO.md

@@ -0,0 +1,27 @@
+# To Do list
+
+## SpectrometerTelecommunicator
+
+### Big Things
+- Accept ascii communications from the device
+- Maybe make a message queue so we dont send message that talk over each other and wait for each others responses
+    (At the moment this should be handled for us by FastCS)
+
+### Small Things
+- Interpret metadata from scan messages more, dont just disregard it
+
+## Hdf5FileBuilder
+Sorted
+
+## FlameControllerAttributes
+
+### Big Things
+- Combine DummyBoolIO and DummyStrIO into one class that uses generics
+    (Same for Refs)
+
+## FlameController
+Looks fine??
+
+## __main__
+- Add CLI arguments for Controller arguments
+- Change title

src/fastcsflame/__main__.py

@@ -2,6 +2,14 @@
 
 from argparse import ArgumentParser
 from collections.abc import Sequence
+from pathlib import Path
+
+from fastcs.launch import FastCS
+from fastcs.logging import configure_logging
+from fastcs.transports.epics import EpicsGUIOptions
+from fastcs.transports.epics.ca import EpicsCATransport
+
+from fastcsflame.flame_controller import FlameController
 
 from . import __version__
 
@@ -11,13 +19,49 @@
 def main(args: Sequence[str] | None = None) -> None:
     """Argument parser for the CLI."""
     parser = ArgumentParser()
+    parser.add_argument(
+        "ip",
+        type=str,
+        help="IP Address of the terminal server (or other device) "
+        "the flame spectrometer is connect to",
+    )
+    parser.add_argument(
+        "port",
+        type=int,
+        help="The port of the terminal server (or other device) "
+        "the flame spectrometer is connected to",
+    )
+    parser.add_argument(
+        "mount-path",
+        type=str,
+        help="The path in the container to the mounted filesystem for saving data",
+    )
     parser.add_argument(
         "-v",
         "--version",
         action="version",
         version=__version__,
     )
-    parser.parse_args(args)
+    arguments_object = parser.parse_args(args)
+
+    configure_logging()
+
+    gui_options = EpicsGUIOptions(
+        output_dir=Path("epics/opi"), title="Flame Spectrometer Controller"
+    )
+    epics_ca = EpicsCATransport(gui=gui_options)
+
+    flame_controller = FlameController(
+        arguments_object.ip,
+        arguments_object.port,
+        mount_path="/dls/science/b21",
+        default_file_name="data",
+    )
+    flame_controller.set_path(["FLAME"])
+
+    fastcs = FastCS(flame_controller, [epics_ca])
+
+    fastcs.run()
 
 
 if __name__ == "__main__":

src/fastcsflame/file_builder.py

@@ -0,0 +1,173 @@
+import h5py
+import numpy as np
+from numpy.typing import NDArray
+
+STRING_DTYPE = h5py.string_dtype(encoding="utf-8")
+
+
+class NoOpenFileError(Exception):
+    pass
+
+
+class OpenFileError(Exception):
+    pass
+
+
+class ScanLengthError(Exception):
+    pass
+
+
+class FileBuilder:
+    """
+    Builds h5 files containing data collected from the Flame
+    """
+
+    _wavelengths: NDArray[np.float64]
+    _mount_path: str
+    file: h5py.File | None = None
+    scans_added: int = 0
+
+    def __init__(self, mount_path: str, wavelengths: NDArray[np.float64]):
+        """
+        wavelengths: An array of wavelength values in nanometers
+            Represents wavelengths of intensity data points collected by flame
+            Should be the same length as the scan data collected by flame
+        """
+        self.mount_path = mount_path
+        self._wavelengths = wavelengths
+
+    def create_file(self, file_path: str, file_name: str, auto_close=False):
+        """
+        Creates and structures an h5 file for Flame data
+        file_path: Where to create the file
+            Both relative and absolute file paths are valid
+            Do not include final /
+        file_name: What to call the file
+            Do not include extension
+        auto_close: If this object already has an open file it closes it and does not
+            raise an exception
+        raises:
+            OpenFileError
+                When this object already has an open file and auto_close is false
+        If a h5 file exist at the file_path location with a matching name it will
+        be replaced without warning
+        This method may be called multiple times from this class to create multiple
+        files
+        """
+        if self.file is not None:
+            if auto_close:
+                self.file.close()
+            else:
+                raise OpenFileError(
+                    "Close previously created file before creating a new file"
+                )
+
+        self.file = h5py.File(f"{self.mount_path}{file_path}/{file_name}.h5", "w")
+
+        entry_group = self.file.create_group("entry")
+
+        self._create_data_group(entry_group)
+        self._create_instrument_group(entry_group)
+
+    def _create_data_group(self, parent_group: h5py.Group):
+        """
+        Creates and structures the data group of the h5 file
+        parent_group: Group to create the data group under
+        """
+        data_group = parent_group.create_group("data")
+
+        # Dataset starts empty but will have scan data added to it as scans are taken
+        # maxshape with first argument None allows this
+        data_group.create_dataset(
+            "data",
+            shape=(0, len(self._wavelengths)),
+            dtype=np.int64,
+            chunks=True,
+            maxshape=(None, len(self._wavelengths)),
+        )
+
+        data_group.attrs["axes"] = "Scan x Wavelength"
+        data_group.attrs["signal"] = "Intensity"
+
+        wavelength_axis = data_group.create_dataset(
+            "wavelength_axis", data=self._wavelengths
+        )
+        wavelength_axis.attrs["long_name"] = "Wavelength"
+        wavelength_axis.attrs["units"] = "nm"
+
+        self.scans_added = 0
+
+    def _create_instrument_group(self, parent_group: h5py.Group):
+        """
+        Creates and structures the instrument group of the h5 file
+        parent_group: Group to create the instrument group under
+        """
+        instrument_group = parent_group.create_group("instrument")
+
+        instrument_group.create_dataset(
+            "make",
+            data=np.array(["Flame Miniature Spectrometer"], dtype=STRING_DTYPE),
+        )
+        instrument_group.create_dataset(
+            "model", data=np.array(["FLAME-S"], dtype=STRING_DTYPE)
+        )
+        instrument_group.create_dataset(
+            "manufacturer", data=np.array(["OceanOptics"], dtype=STRING_DTYPE)
+        )
+
+    def add_scan(self, data: NDArray[np.int64]):
+        """
+        Adds scan data to the last created h5 file
+        data: Scan data from the flame
+        raises:
+            NoOpenFileError
+                When no file has been created or the previously created file was closed
+            FileNotFoundError
+                When the scan data dataset couldnt be found in the h5 file
+            ScanLengthError
+                When scan data length does not match wavelength array length
+        """
+
+        if self.file is None:
+            raise NoOpenFileError(
+                "No file has been created or last created file was closed.\n"
+                "Nowhere to add scan to"
+            )
+
+        dataset_path = "entry/data/data"
+        dataset = self.file[dataset_path]
+        if not isinstance(dataset, h5py.Dataset):
+            raise FileNotFoundError(
+                f"Could not find dataset in h5 file at: {dataset_path}"
+            )
+
+        if self._wavelengths.shape[0] != data.shape[0]:
+            raise ScanLengthError(
+                "Scan data length does not match wavelength array length.\n"
+                f"Scan data length: {data.shape[0]} \n"
+                f"Wavelength array length: {self._wavelengths.shape[0]} \n"
+                "Could not add data to file"
+            )
+
+        # Adds an extra space for the new scan data
+        dataset.resize(self.scans_added + 1, axis=0)
+        # Places new scan data at the end of the array
+        dataset[self.scans_added] = data
+
+        self.scans_added += 1
+
+    def close_file(self):
+        """
+        Closes last created h5 file
+        raises:
+            NoOpenFileError
+                When no file has been created or the previously created file was closed
+        """
+        if self.file is None:
+            raise NoOpenFileError(
+                "No file has been created or last created file was closed.\n"
+                "No file to close"
+            )
+
+        self.file.close()
+        self.file = None