Support multiple web relays, provide dynamic status, and enable signal analyzer power cycling.

pyproject.toml

@@ -41,8 +41,9 @@ classifiers = [
 ]
 
 dependencies = [
+    "environs>=9.5.0",
     "django>=3.2.15,<4.0",
-    "its_preselector @ git+https://github.com/NTIA/Preselector@1.0.0",
+    "its_preselector @ git+https://github.com/NTIA/Preselector@2.0.0",
     "numexpr>=2.8.3",
     "numpy>=1.22.0",
     "python-dateutil>=2.0",

scos_actions/__init__.py

@@ -1 +1 @@
-__version__ = "3.0.1"
+__version__ = "4.0.0"

scos_actions/actions/calibrate_y_factor.py

@@ -78,8 +78,9 @@
 
 from scos_actions import utils
 from scos_actions.actions.interfaces.action import Action
+from scos_actions.calibration import sensor_calibration
 from scos_actions.hardware import gps as mock_gps
-from scos_actions.settings import SENSOR_CALIBRATION_FILE, sensor_calibration
+from scos_actions.settings import SENSOR_CALIBRATION_FILE
 from scos_actions.signal_processing.calibration import (
     get_linear_enr,
     get_temperature,

scos_actions/actions/interfaces/action.py

@@ -5,7 +5,6 @@
 from scos_actions.capabilities import capabilities
 from scos_actions.hardware import gps as mock_gps
 from scos_actions.hardware import preselector
-from scos_actions.hardware import sigan as mock_sigan
 from scos_actions.utils import get_parameter
 
 logger = logging.getLogger(__name__)
@@ -32,7 +31,7 @@ class Action(ABC):
 
     PRESELECTOR_PATH_KEY = "rf_path"
 
-    def __init__(self, parameters, sigan=mock_sigan, gps=mock_gps):
+    def __init__(self, parameters, sigan, gps=mock_gps):
         self.parameters = deepcopy(parameters)
         self.sigan = sigan
         self.gps = gps

scos_actions/actions/interfaces/measurement_action.py

@@ -4,7 +4,6 @@
 from scos_actions.actions.interfaces.action import Action
 from scos_actions.actions.interfaces.signals import measurement_action_completed
 from scos_actions.hardware import gps as mock_gps
-from scos_actions.hardware import sigan as mock_sigan
 from scos_actions.metadata.annotations.calibration_annotation import (
     CalibrationAnnotation,
 )
@@ -23,7 +22,7 @@ class MeasurementAction(Action):
 
     """
 
-    def __init__(self, parameters, sigan=mock_sigan, gps=mock_gps):
+    def __init__(self, parameters, sigan, gps=mock_gps):
         super().__init__(parameters, sigan, gps)
         self.received_samples = 0
 

scos_actions/actions/interfaces/signals.py

@@ -8,3 +8,6 @@
 
 # Provides arguments: 'sigan_healthy'
 monitor_action_completed = Signal()
+
+# Provides argument: 'component'
+register_component_with_status = Signal()

scos_actions/actions/sync_gps.py

@@ -5,15 +5,14 @@
 
 from scos_actions.actions.interfaces.action import Action
 from scos_actions.actions.interfaces.signals import location_action_completed
-from scos_actions.hardware import sigan as mock_sigan
 
 logger = logging.getLogger(__name__)
 
 
 class SyncGps(Action):
     """Query the GPS and synchronize time and location."""
 
-    def __init__(self, gps, parameters={}, sigan=mock_sigan):
+    def __init__(self, gps, parameters, sigan):
         super().__init__(parameters=parameters, sigan=sigan, gps=gps)
 
     def __call__(self, schedule_entry_json, task_id):

scos_actions/calibration/__init__.py

@@ -0,0 +1,36 @@
+import logging
+
+from scos_actions.calibration.calibration import load_from_json
+from scos_actions.settings import SENSOR_CALIBRATION_FILE, SIGAN_CALIBRATION_FILE
+
+logger = logging.getLogger(__name__)
+
+
+def get_sigan_calibration(sigan_cal_file):
+    try:
+        sigan_cal = load_from_json(sigan_cal_file)
+    except Exception as err:
+        logger.error("Unable to load sigan calibration data, reverting to none")
+        logger.exception(err)
+        sigan_cal = None
+
+    return sigan_cal
+
+
+def get_sensor_calibration(sensor_cal_file):
+    """Get calibration data from sensor_cal_file and sigan_cal_file."""
+    try:
+        sensor_cal = load_from_json(sensor_cal_file)
+    except Exception as err:
+        logger.error("Unable to load sensor calibration data, reverting to none")
+        logger.exception(err)
+        sensor_cal = None
+    return sensor_cal
+
+
+logger.info(f"Loading sensor cal file: {SENSOR_CALIBRATION_FILE}")
+sensor_calibration = get_sensor_calibration(SENSOR_CALIBRATION_FILE)
+logger.info(f"Loading sigan cal file: {SIGAN_CALIBRATION_FILE}")
+sigan_calibration = get_sigan_calibration(SIGAN_CALIBRATION_FILE)
+if sensor_calibration:
+    logger.info(f"last sensor cal: {sensor_calibration.calibration_datetime}")

scos_actions/calibration.py → scos_actions/calibration/calibration.py

@@ -41,7 +41,7 @@ def get_calibration_dict(self, args):
             cal_data = filter_by_parameter(cal_data, setting, setting_value)
             if "calibration_datetime" not in cal_data:
                 cal_data["calibration_datetime"] = self.calibration_datetime
-        logger.info("Cal Data: " + str(cal_data))
+        logger.info(f"Cal Data: {cal_data}")
         return cal_data
 
     def update(self, params, calibration_datetime, gain, noise_figure, temp, file_path):
@@ -135,7 +135,7 @@ def filter_by_parameter(calibrations, parameter, value):
 
 def check_floor_of_parameter(calibrations, parameter, value):
     value = math.floor(value)
-    logger.debug("Checking floor value of: " + str(value))
+    logger.debug(f"Checking floor value of: {value}")
     if value in calibrations:
         return calibrations[value]
     else:
@@ -144,7 +144,7 @@ def check_floor_of_parameter(calibrations, parameter, value):
 
 def check_ceiling_of_parameter(calibrations, parameter, value):
     value = math.ceil(value)
-    logger.debug("Checking ceiling at: " + str(value))
+    logger.debug(f"Checking ceiling at: {value}")
     if value in calibrations:
         return calibrations[value]
     else:

scos_actions/tests/test_calibration.py → scos_actions/calibration/tests/test_calibration.py

@@ -11,10 +11,15 @@
 import pytz
 from pytz import timezone
 
-from scos_actions import calibration, utils
-from scos_actions.calibration import Calibration
-from scos_actions.settings import sensor_calibration, sigan_calibration
+from scos_actions.calibration import sensor_calibration, sigan_calibration
+from scos_actions.calibration.calibration import (
+    Calibration,
+    convert_keys,
+    filter_by_parameter,
+    load_from_json,
+)
 from scos_actions.tests.resources.utils import easy_gain
+from scos_actions.utils import get_datetime_str_now
 
 
 class TestCalibrationFile:
@@ -180,7 +185,7 @@ def setup_calibration_file(self, tmpdir):
             json.dump(cal_data, file, indent=4)
 
         # Load the data back in
-        self.sample_cal = calibration.load_from_json(self.calibration_file)
+        self.sample_cal = load_from_json(self.calibration_file)
 
         # Create a list of previous points to ensure that we don't repeat
         self.pytest_points = []
@@ -200,7 +205,7 @@ def setup_calibration_file(self, tmpdir):
     def test_filter_by_parameter_out_of_range(self):
         calibrations = {200.0: {"some_cal_data"}, 300.0: {"more cal data"}}
         with pytest.raises(Exception) as e_info:
-            cal = calibration.filter_by_parameter(calibrations, "frequency", 400.0)
+            cal = filter_by_parameter(calibrations, "frequency", 400.0)
         assert (
             e_info.value.args[0]
             == "No calibration was performed with frequency at 400.0"
@@ -212,7 +217,7 @@ def test_filter_by_parameter_in_range_requires_match(self):
             300.0: {"Gain": "Gain at 300.0"},
         }
         with pytest.raises(Exception) as e_info:
-            cal = calibration.filter_by_parameter(calibrations, "frequency", 150.0)
+            cal = filter_by_parameter(calibrations, "frequency", 150.0)
         assert (
             e_info.value.args[0]
             == "No calibration was performed with frequency at 150.0"
@@ -259,7 +264,7 @@ def test_convert_keys(self):
             "100": {"2000": {"40": {"cal_data": 5}}},
             "200": {"2000": {"40": {"cal_data": 6}}},
         }
-        converted_cal = calibration.convert_keys(test_cal)
+        converted_cal = convert_keys(test_cal)
         keys = list(test_cal.keys())
         assert keys[0] == 100.0
         second_level_keys = list(converted_cal[100.0].keys())
@@ -301,9 +306,9 @@ def test_update(self):
             clock_rate_lookup_by_sample_rate,
         )
         action_params = {"sample_rate": 100.0, "frequency": 200.0}
-        update_time = utils.get_datetime_str_now()
+        update_time = get_datetime_str_now()
         cal.update(action_params, update_time, 30.0, 5.0, 21, "test_calibration.json")
-        cal_from_file = calibration.load_from_json("test_calibration.json")
+        cal_from_file = load_from_json("test_calibration.json")
         os.remove("test_calibration.json")
         local = timezone("US/Mountain")
         local_cal_time = local.localize(cal.calibration_datetime)
@@ -331,10 +336,10 @@ def test_default_sigan_cal_location(self):
 
     def test_filter_by_paramter_floor(self):
         calibrations = {200.0: {"some_cal_data"}, 300.0: {"more cal data"}}
-        filtered_data = calibration.filter_by_parameter(calibrations, "", 200.1234567)
+        filtered_data = filter_by_parameter(calibrations, "", 200.1234567)
         assert filtered_data is not None
 
     def test_filter_by_parameter_ceil(self):
         calibrations = {700.5e6: {"some_cal_data"}, 300.0: {"more cal data"}}
-        filtered_data = calibration.filter_by_parameter(calibrations, "", 700499999.999)
+        filtered_data = filter_by_parameter(calibrations, "", 700499999.999)
         assert filtered_data is not None

scos_actions/discover/__init__.py

@@ -1,17 +1,24 @@
-# from scos_actions.actions import action_classes
 from scos_actions.actions import action_classes
+from scos_actions.actions.interfaces.signals import register_component_with_status
 from scos_actions.actions.logger import Logger
 from scos_actions.actions.monitor_sigan import MonitorSignalAnalyzer
 from scos_actions.actions.sync_gps import SyncGps
 from scos_actions.discover.yaml import load_from_yaml
 from scos_actions.hardware import gps as mock_gps
-from scos_actions.hardware import sigan as mock_sigan
-from scos_actions.settings import ACTION_DEFINITIONS_DIR
+from scos_actions.hardware.mocks.mock_sigan import MockSignalAnalyzer
+from scos_actions.settings import ACTION_DEFINITIONS_DIR, MOCK_SIGAN
 
+mock_sigan = MockSignalAnalyzer(randomize_values=True)
+if MOCK_SIGAN:
+    register_component_with_status.send(mock_sigan.__class__, component=mock_sigan)
 actions = {"logger": Logger()}
 test_actions = {
-    "test_sync_gps": SyncGps(gps=mock_gps),
-    "test_monitor_sigan": MonitorSignalAnalyzer(sigan=mock_sigan),
+    "test_sync_gps": SyncGps(
+        parameters={"name": "test_sync_gps"}, sigan=mock_sigan, gps=mock_gps
+    ),
+    "test_monitor_sigan": MonitorSignalAnalyzer(
+        parameters={"name": "test_monitor_sigan"}, sigan=mock_sigan
+    ),
     "logger": Logger(),
 }
 
@@ -37,7 +44,3 @@ def init(
 yaml_actions, yaml_test_actions = init()
 actions.update(yaml_actions)
 test_actions.update(yaml_test_actions)
-
-
-def get_last_calibration_time():
-    return None

scos_actions/discover/tests/test_yaml.py

@@ -5,7 +5,8 @@
 
 from scos_actions import actions
 from scos_actions.discover.yaml import load_from_yaml
-from scos_actions.hardware import gps, sigan
+from scos_actions.hardware import gps
+from scos_actions.hardware.mocks.mock_sigan import MockSignalAnalyzer
 
 INVALID_YAML = b"""\
 single_frequency_fft:
@@ -22,6 +23,8 @@
     name: test_expected_failure
 """
 
+sigan = MockSignalAnalyzer()
+
 
 def test_load_from_yaml_existing():
     """Any existing action definitions should be valid yaml."""

scos_actions/hardware/__init__.py

@@ -1,29 +1,78 @@
 import importlib
+import logging
+import os
+
+from its_preselector.configuration_exception import ConfigurationException
+from its_preselector.controlbyweb_web_relay import ControlByWebWebRelay
 
 from scos_actions import utils
+from scos_actions.actions.interfaces.signals import register_component_with_status
 from scos_actions.capabilities import capabilities
 from scos_actions.hardware.mocks.mock_gps import MockGPS
-from scos_actions.hardware.mocks.mock_sigan import MockSignalAnalyzer
 from scos_actions.settings import (
     PRESELECTOR_CLASS,
     PRESELECTOR_CONFIG_FILE,
     PRESELECTOR_MODULE,
+    SWITCH_CONFIGS_DIR,
 )
+from scos_actions.status.status_registration_handler import status_registration_handler
+
+logger = logging.getLogger(__name__)
+
+
+def load_switches(switch_dir) -> dict:
+    switch_dict = {}
+    if switch_dir is not None and os.path.isdir(switch_dir):
+        files = os.listdir(switch_dir)
+        for f in files:
+            file_path = os.path.join(switch_dir, f)
+            logger.info(f"loading switch config {file_path}")
+            conf = utils.load_from_json(file_path)
+            try:
+                switch = ControlByWebWebRelay(conf)
+                logger.info(f"Adding {switch.id}")
 
+                switch_dict[switch.id] = switch
+                logger.info(f"Registering switch status for {switch.name}")
+                register_component_with_status.send(__name__, component=switch)
+            except (ConfigurationException):
+                logger.error(f"Unable to configure switch defined in: {file_path}")
 
-def load_preselector(preselector_config_file):
+    return switch_dict
+
+
+def load_preslector_from_file(preselector_config_file):
     if preselector_config_file is None:
-        preselector_config = {}
+        return None
     else:
-        preselector_config = utils.load_from_json(preselector_config_file)
+        try:
+            preselector_config = utils.load_from_json(preselector_config_file)
+            return load_preselector(
+                preselector_config, PRESELECTOR_MODULE, PRESELECTOR_CLASS
+            )
+        except ConfigurationException:
+            logger.error(
+                f"Unable to create preselector defined in: {preselector_config_file}"
+            )
+    return None
 
-    preselector_module = importlib.import_module(PRESELECTOR_MODULE)
-    preselector_class = getattr(preselector_module, PRESELECTOR_CLASS)
-    preselector = preselector_class(capabilities["sensor"], preselector_config)
 
-    return preselector
+def load_preselector(preselector_config, module, preselector_class_name):
+    if module is not None and preselector_class_name is not None:
+        preselector_module = importlib.import_module(module)
+        preselector_constructor = getattr(preselector_module, preselector_class_name)
+        ps = preselector_constructor(capabilities["sensor"], preselector_config)
+        if ps and ps.name:
+            logger.info(f"Registering {ps.name} as status provider")
+            register_component_with_status.send(__name__, component=ps)
+    else:
+        ps = None
+    return ps
 
 
-sigan = MockSignalAnalyzer(randomize_values=True)
+register_component_with_status.connect(status_registration_handler)
+logger.info("Connected status registration handler")
 gps = MockGPS()
-preselector = load_preselector(PRESELECTOR_CONFIG_FILE)
+preselector = load_preslector_from_file(PRESELECTOR_CONFIG_FILE)
+switches = load_switches(SWITCH_CONFIGS_DIR)
+logger.info("Loaded {switch_count} switches.".format(switch_count=(len(switches))))

scos_actions/hardware/hardware_configuration_exception.py

@@ -0,0 +1,3 @@
+class HardwareConfigurationException(Exception):
+    def __init__(self, message: str):
+        super().__init__(message)