def test_tick(self):
"""
Testing Sensor.tick
"""
sensor = Sensor('127.0.0.1', '8000')
sensor.measure = MagicMock(return_value=10)
pump = Pump('127.0.0.1', '8000')
pump.get_state = MagicMock(return_value='PUMP_OFF')
pump.set_state = MagicMock(return_value='PUMP_OFF')
decider = Decider(10, 0.1)
decider.decide = MagicMock(return_value='PUMP_OFF')
controller = Controller(sensor, pump, decider)
self.assertTrue(controller.tick())
def test_integration_set_pump_state_fail(self):
decider = Decider(target_height=3000, margin=500)
pump = Pump('127.0.0.1', 8000)
sensor = Sensor('127.0.0.1', 8000)
pump.set_state = MagicMock(return_value=False)
pump.get_state = MagicMock(return_value=Pump.PUMP_OFF)
sensor.measure = MagicMock(return_value=3500)
controller = Controller(sensor, pump, decider)
result = controller.tick()
self.assertEqual(result, False)
def test_decider_current_action_pumpoff_height_in_target_and_margin_range(
self):
decider = Decider(target_height=5000, margin=1000)
pump = Pump('127.0.0.1', 8000)
sensor = Sensor('127.0.0.1', 8000)
controller = Controller(sensor, pump, decider)
#equal to target + margin case
result = decider.decide(current_height=4000,
current_action=Pump.PUMP_OFF,
actions=controller.actions)
self.assertEqual(result, Pump.PUMP_OFF)
#equal to target + margin case
result = decider.decide(current_height=4000,
current_action=Pump.PUMP_OFF,
actions=controller.actions)
self.assertEqual(result, Pump.PUMP_OFF)
#in the range of (target - margin to target + margin)
result = decider.decide(current_height=5800,
current_action=Pump.PUMP_OFF,
actions=controller.actions)
self.assertEqual(result, Pump.PUMP_OFF)
#in the range of (target - margin to target + margin)
result = decider.decide(current_height=4200,
current_action=Pump.PUMP_OFF,
actions=controller.actions)
self.assertEqual(result, Pump.PUMP_OFF)
def setUp(self):
"""Set up controller for test"""
self.sensor = Sensor('127.0.0.1', 8000)
self.pump = Pump('127.0.0.1', 8000)
self.decider = Decider(10, 0.05)
self.controller = Controller(self.sensor, self.pump, self.decider)
def setUp(self):
"""
This method does a setup for integration testing raterregulation
"""
self.pump = Pump('127.0.0.1', 1000)
self.sensor = Sensor('127.0.0.2', 2000)
self.decider = Decider(100, 0.05)
self.controller = Controller(self.sensor, self.pump, self.decider)
class ControllerTests(unittest.TestCase):
"""
Unit tests for the Controller class
"""
def setUp(self):
"""
Set up method for test_controller
"""
self.sensor = Sensor('127.0.0.1', 8000)
self.sensor.measure = MagicMock(return_value=100)
self.pump = Pump('127.0.0.1', 8000)
self.pump.set_state = MagicMock(return_value=True)
self.pump.get_state = MagicMock(return_value=self.pump.PUMP_OFF)
self.decider = Decider(100, .10)
self.decider.decide = MagicMock(return_value=self.pump.PUMP_OFF)
self.controller = Controller(self.sensor, self.pump, self.decider)
self.controller.tick()
self.actions = {
'PUMP_IN': self.pump.PUMP_IN,
'PUMP_OUT': self.pump.PUMP_OUT,
'PUMP_OFF': self.pump.PUMP_OFF
}
def test_controller(self):
"""
Test controller and tick:
1: Check sensor.measure for accuracy
2: test pump.get_state for correct return
3: decider.decide for correct 'decision'
4: Test pump.set_state for expected mocked output
5: Test sensor.measure return val is correct type
6: Round-a-bout way of testing the try/except
block of controller.tick() -- if pump.set_state
returns False, it is because of a TypeError,
checking that if it is False, it raises TypeError
"""
self.assertEqual(100, self.sensor.measure()) # 1
self.assertEqual(0, self.pump.get_state()) # 2
self.assertEqual(0, self.decider.decide(100, 0, self.actions)) # 3
self.assertEqual(True,
self.pump.set_state(self.actions['PUMP_OFF'])) # 4
self.assertTrue(self.sensor.measure() == float(100)) # 5
if self.pump.set_state(False): # 6
self.assertRaises(TypeError)
def test_decider_current_action_pump_off_height_less_than_target(self):
decider = Decider(target_height=10000, margin=1000)
pump = Pump('127.0.0.1', 8000)
sensor = Sensor('127.0.0.1', 8000)
controller = Controller(sensor, pump, decider)
result = decider.decide(current_height=5000,
current_action=Pump.PUMP_OFF,
actions=controller.actions)
self.assertEqual(result, Pump.PUMP_IN)
def setUp(self):
"""
This method does a setup for unit testing Controller
"""
self.pump = Pump('127.0.0.1', 1000)
self.sensor = Sensor('127.0.0.2', 2000)
self.decider = Decider(100, 0.05)
self.controller = Controller(self.sensor, self.pump, self.decider)
def setUp(self):
"""
Set up method for test_controller
"""
self.sensor = Sensor('127.0.0.1', 8000)
self.sensor.measure = MagicMock(return_value=100)
self.pump = Pump('127.0.0.1', 8000)
self.pump.set_state = MagicMock(return_value=True)
self.pump.get_state = MagicMock(return_value=self.pump.PUMP_OFF)
self.decider = Decider(100, .10)
self.decider.decide = MagicMock(return_value=self.pump.PUMP_OFF)
self.controller = Controller(self.sensor, self.pump, self.decider)
self.controller.tick()
self.actions = {
'PUMP_IN': self.pump.PUMP_IN,
'PUMP_OUT': self.pump.PUMP_OUT,
'PUMP_OFF': self.pump.PUMP_OFF
}
def setUp(self):
"""
setup
:return:
"""
self.pump = Pump('127.0.0.1', 8000)
self.sensor = Sensor('127.1.1.3', 9000)
self.decider = Decider(100, 0.05)
self.controller = Controller(self.sensor, self.pump, self.decider)
def test_decider_current_action_pumpoff_height_greater_target_and_margin(
self):
decider = Decider(target_height=1000, margin=200)
pump = Pump('127.0.0.1', 8000)
sensor = Sensor('127.0.0.1', 8000)
controller = Controller(sensor, pump, decider)
result = decider.decide(current_height=1250,
current_action=Pump.PUMP_OFF,
actions=controller.actions)
self.assertEqual(result, Pump.PUMP_OUT)
def setUp(self):
"""
Setup for test_tick
"""
self.sensor = Sensor('127.0.0.1', '8000')
self.pump = Pump('127.0.0.1', '8001')
self.decider = Decider(30, 0.05)
self.sensor.measure = MagicMock(return_value=True)
self.pump.set_state = MagicMock(return_value=True)
self.pump.get_state = MagicMock(return_value="PUMP_IN")
self.controller = Controller(self.sensor, self.pump, self.decider)
class SensorTests(unittest.TestCase):
"""
This method does a setup for unit testing Sensor
"""
def setUp(self):
"""
This method does a setup for unit testing Sensor
"""
self.sensor = Sensor('127.0.0.2', 2000)
def test_set_state(self):
"""
This method tests the set_state for Sensor
"""
self.sensor.measure = MagicMock(return_value=True)
self.assertEqual(self.sensor.measure(), True)
def test_get_state(self):
"""
This method tests the get_state for Sensor
"""
self.sensor.get_state = MagicMock(return_value=1)
self.assertEqual(self.sensor.get_state(), 1)
def main_loop(conf_file, log_path, controll_method):
Led.change(False)
pilot = Pilot(controll_method)
print("Ready")
cmd = Pilot.CMD_NOP
while True:
last_cmd = cmd
cmd = pilot.get_cmd()
if cmd == Pilot.CMD_NOP:
pass
elif last_cmd == Pilot.CMD_NOP and cmd == Pilot.CMD_THROTTLE_ZERO:
# start
try:
params = yaml.load(open(conf_file, "rt"))
except:
print("ERROR can not read conf file")
raise
if log_path is not None:
# over write log_path if --log option is specifed
params["log"]["path"] = log_path
sensor = Sensor()
dt = sensor.sampling_interval()
controller = Controller(dt=dt, **params["controller"])
print("ctrl start")
pilot.initialize()
alog = AttitudeLog(**params["log"])
Led.change(True)
with Thrust(params["body_const"]) as thrust:
control_loop(pilot, sensor, controller, thrust, alog)
print("ctrl end")
Led.change(False)
alog.add_info('param', params)
alog.save()
print("seve end")
time.sleep(0.5)
Led.toggle()
class SensorTests(unittest.TestCase):
"""
Unit tests for the Sensor class
"""
def setUp(self):
"""
setup for PumpTest class
:return:
"""
self.sensor = Sensor('127.1.1.3', 9000)
def test_set_state(self):
"""
test setting the state of pump
:return:
"""
self.sensor.measure = MagicMock(return_value=True)
self.assertEqual(self.sensor.measure(), True)
def test_all(self):
"""
Run full test on all components of waterregulation
"""
pump_address = Pump('127.0.0.1', '2048')
sensor_address = Sensor('127.0.0.1', '2048')
decider_margins = Decider(100, .10)
controller_all = Controller(sensor_address, pump_address,
decider_margins)
controller_all.pump.set_state = MagicMock(return_value=True)
for action in controller_all.actions.values():
for water_level in range(25, 150, 100):
# water level (mocked)
controller_all.sensor.measure = \
MagicMock(return_value=water_level)
# pump state (mocked)
controller_all.pump.get_state = MagicMock(
return_value=decider_margins.decide(
water_level, action, controller_all.actions))
controller_all.tick()
def setUp(self):
"""
setup for PumpTest class
:return:
"""
self.sensor = Sensor('127.1.1.3', 9000)
def setUp(self):
self.sensor = Sensor('127.0.0.1', '168')
self.pump = Pump('127.0.0.1', '168')
self.decider = Decider(10, 0.5)
self.controller = Controller(self.sensor, self.pump, self.decider)
def setUp(self):
"""
This method does a setup for unit testing Sensor
"""
self.sensor = Sensor('127.0.0.2', 2000)
def get_args() -> Dict:
ap = ArgumentParser()
ap.add_argument("-f",
"--" + CONFIG_FILE_PATH_OPT,
required=True,
help="Path to configuration file to be used by node.")
ap.add_argument("-c",
"--" + CONFIG_HEADER_OPT,
required=True,
help="Which section of config file to use.")
return vars(ap.parse_args())
if __name__ == "__main__":
logger.info("Starting up.")
args = get_args()
config = Configuration(args[CONFIG_FILE_PATH_OPT], args[CONFIG_HEADER_OPT])
logger.info("Configuration parsed: " + str(config))
logger.info("Starting sensor.")
try:
sensor = Sensor(config)
sensor.start()
except KeyboardInterrupt as e:
logger.info("Keyboard interrupt. Stopping sensor")
sensor.stop()