def make_a_state() -> State:
state = State()
state.environment = {
"sensor": {
"desired": {},
"reported": {}
},
"actuator": {
"desired": {},
"reported": {}
},
"reported_sensor_stats": {
"individual": {
"instantaneous": {},
"average": {}
},
"group": {
"instantaneous": {},
"average": {}
},
},
}
state.recipe = {
"recipe_uuid": None,
"start_timestamp_minutes": None,
"last_update_minute": None,
}
return state
def test_update_controller_positive() -> None:
manager = PIDControllerManager(name="test_update_controller_positive",
state=State(),
config=controller_config)
manager.initialize_controller()
sensor_name = controller_config["parameters"]["variables"]["sensor_name"]
# Set reported value just below desired threshold
manager.state.set_environment_desired_sensor_value(sensor_name, 24)
manager.state.set_environment_reported_sensor_value(
"SHT25", sensor_name, 21.9)
manager.update_controller()
assert manager.desired_positive_actuator_percent == 100.0
assert manager.desired_negative_actuator_percent == 0.0
# Set reported value just below desired setpoint, should be no actuation
manager.state.set_environment_desired_sensor_value(sensor_name, 24)
manager.state.set_environment_reported_sensor_value(
"SHT25", sensor_name, 23.9)
manager.update_controller()
manager.update_controller(
) # call twice because PID needs to settle out for small vals
assert manager.desired_positive_actuator_percent == 0.0
assert manager.desired_negative_actuator_percent == 0.0
# Set reported value just above desired setpoint, should be no actuation
manager.state.set_environment_desired_sensor_value(sensor_name, 24)
manager.state.set_environment_reported_sensor_value(
"SHT25", sensor_name, 24.1)
manager.update_controller()
manager.update_controller()
assert manager.desired_positive_actuator_percent == 0.0
assert manager.desired_negative_actuator_percent == 0.0
def run(self, *args: Any, **kwargs: Any) -> None:
"""Runs driver."""
# Run parent class
super().run(*args, **kwargs)
# Instantiate manager
self.manager = self.Manager(
name=self.args.name,
i2c_lock=threading.RLock(),
state=State(),
config=self.peripheral_config,
)
# Initialize manager
self.manager.initialize()
# Check if setting up
if self.args.setup:
self.manager.setup()
# Check if updating
if self.args.update:
self.manager.update()
# Check if resetting
if self.args.reset:
self.manager.reset()
# Check if shutting down
if self.args.shutdown:
self.manager.shutdown()
def test_update_controller_negative() -> None:
manager = HystereticControllerManager(name="Test",
state=State(),
config=controller_config)
manager.initialize_controller()
sensor_name = controller_config["parameters"]["variables"]["sensor_name"]
# Set reported value just above desired threshold
manager.state.set_environment_desired_sensor_value(sensor_name, 24)
manager.state.set_environment_reported_sensor_value(
"SHT25", sensor_name, 26.1)
manager.update_controller()
assert manager.desired_positive_actuator_percent == 0.0
assert manager.desired_negative_actuator_percent == 100.0
# Set reported value just above desired setpoint
manager.state.set_environment_desired_sensor_value(sensor_name, 24)
manager.state.set_environment_reported_sensor_value(
"SHT25", sensor_name, 24.1)
manager.update_controller()
assert manager.desired_positive_actuator_percent == 0.0
assert manager.desired_negative_actuator_percent == 100.0
# Set reported value just below desired setpoint
manager.state.set_environment_desired_sensor_value(sensor_name, 24)
manager.state.set_environment_reported_sensor_value(
"SHT25", sensor_name, 23.9)
manager.update_controller()
assert manager.desired_positive_actuator_percent == 0.0
assert manager.desired_negative_actuator_percent == 0.0
def test_init() -> None:
manager = PeripheralManager(
name="Test",
state=State(),
config=peripheral_config,
i2c_lock=threading.RLock(),
simulate=True,
)
def test_update_controller_no_sensor_values() -> None:
manager = PIDControllerManager(
name="test_update_controller_no_sensor_values",
state=State(),
config=controller_config,
)
manager.initialize_controller()
manager.update_controller()
def test_init() -> None:
manager = ActuatorPCF8574Manager(
name="Test",
i2c_lock=threading.RLock(),
state=State(),
config=peripheral_config,
simulate=True,
mux_simulator=MuxSimulator(),
)
def test_run_reset_mode() -> None:
manager = PeripheralManager(
name="Test",
state=State(),
config=peripheral_config,
i2c_lock=threading.RLock(),
simulate=True,
)
manager.run_reset_mode()
assert manager.mode == modes.INIT
def test_peripheral_initialize() -> None:
manager = ActuatorDAC5578Manager(
name="Test",
i2c_lock=threading.RLock(),
state=State(),
config=peripheral_config,
simulate=True,
mux_simulator=MuxSimulator(),
)
manager.initialize_peripheral()
def test_shutdown_peripheral() -> None:
manager = AtlasPHManager(
name="Test",
i2c_lock=threading.RLock(),
state=State(),
config=peripheral_config,
simulate=True,
mux_simulator=MuxSimulator(),
)
manager.initialize_peripheral()
manager.shutdown_peripheral()
def test_peripheral_setup() -> None:
manager = ActuatorGroveRGBLCDManager(
name="Test",
i2c_lock=threading.RLock(),
state=State(),
config=peripheral_config,
simulate=True,
mux_simulator=MuxSimulator(),
)
manager.initialize_peripheral()
manager.setup_peripheral()
def test_reset_peripheral() -> None:
manager = USBCameraManager(
name="Test",
i2c_lock=threading.RLock(),
state=State(),
config=peripheral_config,
simulate=True,
mux_simulator=MuxSimulator(),
)
manager.initialize_peripheral()
manager.reset_peripheral()
def test_update_peripheral() -> None:
manager = AdafruitSoilManager(
name="Test",
i2c_lock=threading.RLock(),
state=State(),
config=peripheral_config,
simulate=True,
mux_simulator=MuxSimulator(),
)
manager.initialize_peripheral()
manager.update_peripheral()
def test_set_sampling_interval() -> None:
manager = PeripheralManager(
name="Test",
state=State(),
config=peripheral_config,
i2c_lock=threading.RLock(),
simulate=True,
)
assert manager.sampling_interval == 5 # default to 5 seconds
manager.create_event({"type": events.SET_SAMPLING_INTERVAL, "value": 33})
manager.check_events()
assert manager.sampling_interval == 33
def test_init() -> None:
state = State()
recipe = RecipeManager(state)
iot = IotManager(state, recipe)
pubsub = PubSub(
ref_self=iot,
on_connect=on_connect,
on_disconnect=on_disconnect,
on_publish=on_publish,
on_message=on_message,
on_subscribe=on_subscribe,
on_log=on_log,
)
def test_clear_calibration() -> None:
manager = AtlasPHManager(
name="Test",
i2c_lock=threading.RLock(),
state=State(),
config=peripheral_config,
simulate=True,
mux_simulator=MuxSimulator(),
)
manager.initialize_peripheral()
manager.mode = modes.CALIBRATE
message, status = manager.create_event(request={"type": events.CLEAR_CALIBRATION})
assert status == 200
manager.check_events()
def __init__(self) -> None:
"""Initializes coordinator."""
# Initialize parent class
super().__init__()
# Initialize logger
self.logger = Logger("Coordinator", "coordinator")
self.logger.debug("Initializing coordinator")
# Initialize state
self.state = State()
# Initialize environment state dict, TODO: remove this
self.state.environment = {
"sensor": {"desired": {}, "reported": {}},
"actuator": {"desired": {}, "reported": {}},
"reported_sensor_stats": {
"individual": {"instantaneous": {}, "average": {}},
"group": {"instantaneous": {}, "average": {}},
},
}
# Initialize recipe state dict, TODO: remove this
self.state.recipe = {
"recipe_uuid": None,
"start_timestamp_minutes": None,
"last_update_minute": None,
}
# Initialize managers
self.recipe = RecipeManager(self.state)
self.iot = IotManager(self.state, self.recipe) # type: ignore
self.resource = ResourceManager(self.state, self.iot) # type: ignore
self.network = NetworkManager(self.state) # type: ignore
self.upgrade = UpgradeManager(self.state) # type: ignore
# Initialize state machine transitions
self.transitions = {
modes.INIT: [modes.CONFIG, modes.ERROR, modes.SHUTDOWN],
modes.CONFIG: [modes.SETUP, modes.ERROR, modes.SHUTDOWN],
modes.SETUP: [modes.NORMAL, modes.ERROR, modes.SHUTDOWN],
modes.NORMAL: [modes.LOAD, modes.ERROR, modes.SHUTDOWN],
modes.LOAD: [modes.CONFIG, modes.ERROR, modes.SHUTDOWN],
modes.RESET: [modes.INIT, modes.SHUTDOWN],
modes.ERROR: [modes.RESET, modes.SHUTDOWN],
}
# Initialize state machine mode
self.mode = modes.INIT
def test_calibrate_single() -> None:
manager = AtlasECManager(
name="Test",
i2c_lock=threading.RLock(),
state=State(),
config=peripheral_config,
simulate=True,
mux_simulator=MuxSimulator(),
)
manager.initialize_peripheral()
manager.mode = modes.CALIBRATE
message, status = manager.create_event(request={
"type": events.CALIBRATE_SINGLE,
"value": 7.0
})
assert status == 400
manager.check_events()
def test_init() -> None:
state = State()
manager = ResourceManager(state, IotManager(state, RecipeManager(state)))
def test_init() -> None:
manager = PIDControllerManager(name="test_init",
state=State(),
config=controller_config)
def test_initialize_controller() -> None:
manager = PIDControllerManager(name="test_initialize_controller",
state=State(),
config=controller_config)
manager.initialize_controller()
def test_init() -> None:
manager = WaterAerationControllerManager(name="Test",
state=State(),
config=controller_config)
def test_shutdown_controller() -> None:
manager = WaterAerationControllerManager(name="Test",
state=State(),
config=controller_config)
manager.initialize_controller()
manager.shutdown_controller()
def test_run_reset_mode() -> None:
manager = ControllerManager(name="Test",
state=State(),
config=controller_config)
manager.run_reset_mode()
assert manager.mode == modes.INIT
def test_initialize_controller() -> None:
manager = HystereticControllerManager(name="Test",
state=State(),
config=controller_config)
manager.initialize_controller()
def test_update_controller_no_sensor_values() -> None:
manager = HystereticControllerManager(name="Test",
state=State(),
config=controller_config)
manager.initialize_controller()
manager.update_controller()
def test_init() -> None:
state = State()
upgrade = manager.UpgradeManager(State())
def test_init() -> None:
state = State()
recipe = RecipeManager(state)
iot = manager.IotManager(state, recipe)
