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)