def test_single(self):
self.machine.default_platform.set_pulse_on_hit_and_enable_and_release_rule = MagicMock(
)
self.machine.flippers["f_test_single"].enable()
self.assertEqual(
1,
len(self.machine.default_platform.
set_pulse_on_hit_and_enable_and_release_rule.
_mock_call_args_list))
self.machine.default_platform.set_pulse_on_hit_and_enable_and_release_rule.assert_called_once_with(
SwitchSettings(
hw_switch=self.machine.switches["s_flipper"].hw_switch,
invert=False,
debounce=False),
DriverSettings(
hw_driver=self.machine.coils["c_flipper_main"].hw_driver,
pulse_settings=PulseSettings(power=1.0, duration=10),
hold_settings=HoldSettings(power=0.125),
recycle=False))
self.machine.default_platform.clear_hw_rule = MagicMock()
self.machine.flippers["f_test_single"].disable()
self.assertEqual(1, self.machine.default_platform.clear_hw_rule.called)
self.machine.default_platform.clear_hw_rule.assert_called_once_with(
SwitchSettings(
hw_switch=self.machine.switches["s_flipper"].hw_switch,
invert=False,
debounce=False),
DriverSettings(
hw_driver=self.machine.coils["c_flipper_main"].hw_driver,
pulse_settings=PulseSettings(power=1.0, duration=10),
hold_settings=HoldSettings(power=0.125),
recycle=False))
def test_enable_and_disable(self):
coil = self.machine.coils['coil_1']
coil.hw_driver.enable = MagicMock()
coil.hw_driver.pulse = MagicMock()
coil.hw_driver.disable = MagicMock()
self.machine.events.post('event4')
self.advance_time_and_run()
coil.hw_driver.enable.assert_called_with(
PulseSettings(power=1.0, duration=10), HoldSettings(power=1.0))
assert not coil.hw_driver.pulse.called
self.machine.events.post('event5')
self.advance_time_and_run()
coil.hw_driver.disable.assert_called_with()
# same again but use on and off instead of enable and disable
coil.hw_driver.enable = MagicMock()
coil.hw_driver.pulse = MagicMock()
coil.hw_driver.disable = MagicMock()
self.machine.events.post('event10')
self.advance_time_and_run()
coil.hw_driver.enable.assert_called_with(
PulseSettings(power=1.0, duration=10), HoldSettings(power=1.0))
assert not coil.hw_driver.pulse.called
self.machine.events.post('event11')
self.advance_time_and_run()
coil.hw_driver.disable.assert_called_with()
def test_flipper_with_settings(self):
flipper = self.machine.flippers.f_test_flippers_with_settings
self.machine.default_platform.set_pulse_on_hit_and_enable_and_release_rule = MagicMock(
)
flipper.enable()
self.assertEqual(
1,
len(self.machine.default_platform.
set_pulse_on_hit_and_enable_and_release_rule.
_mock_call_args_list))
self.machine.default_platform.set_pulse_on_hit_and_enable_and_release_rule.assert_called_once_with(
SwitchSettings(hw_switch=self.machine.switches.s_flipper.hw_switch,
invert=False,
debounce=False),
DriverSettings(
hw_driver=self.machine.coils.c_flipper_main.hw_driver,
pulse_settings=PulseSettings(power=1.0, duration=10),
hold_settings=HoldSettings(power=0.125),
recycle=False))
self.machine.default_platform.clear_hw_rule = MagicMock()
flipper.disable()
self.assertEqual(1, self.machine.default_platform.clear_hw_rule.called)
self.machine.default_platform.clear_hw_rule.assert_called_once_with(
SwitchSettings(hw_switch=self.machine.switches.s_flipper.hw_switch,
invert=False,
debounce=False),
DriverSettings(
hw_driver=self.machine.coils.c_flipper_main.hw_driver,
pulse_settings=PulseSettings(power=1.0, duration=10),
hold_settings=HoldSettings(power=0.125),
recycle=False))
self.machine.settings.set_setting_value("flipper_power", 0.8)
self.advance_time_and_run()
self.machine.default_platform.set_pulse_on_hit_and_enable_and_release_rule = MagicMock(
)
flipper.enable()
self.assertEqual(
1,
len(self.machine.default_platform.
set_pulse_on_hit_and_enable_and_release_rule.
_mock_call_args_list))
self.machine.default_platform.set_pulse_on_hit_and_enable_and_release_rule.assert_called_once_with(
SwitchSettings(hw_switch=self.machine.switches.s_flipper.hw_switch,
invert=False,
debounce=False),
DriverSettings(
hw_driver=self.machine.coils.c_flipper_main.hw_driver,
pulse_settings=PulseSettings(power=1.0, duration=8),
hold_settings=HoldSettings(power=0.125),
recycle=False))
self.assertEqual(8, flipper._get_pulse_ms())
def testBasicFunctions(self):
# Make sure hardware devices have been configured for tests
self.assertIn('coil_01', self.machine.coils)
self.assertIn('coil_02', self.machine.coils)
# Setup platform function mock to test coil
self.machine.coils.coil_01.hw_driver.disable = MagicMock()
self.machine.coils.coil_01.hw_driver.enable = MagicMock()
self.machine.coils.coil_01.hw_driver.pulse = MagicMock()
self.machine.coils.coil_01.enable()
self.machine.coils.coil_01.hw_driver.enable.assert_called_with(
PulseSettings(power=1.0, duration=30), HoldSettings(power=1.0))
self.machine.coils.coil_01.pulse(100)
self.machine.coils.coil_01.hw_driver.pulse.assert_called_with(
PulseSettings(power=1.0, duration=100))
self.machine.coils.coil_01.disable()
self.machine.coils.coil_01.hw_driver.disable.assert_called_with()
self.machine.coils.coil_03.hw_driver.disable = MagicMock()
self.machine.coils.coil_03.hw_driver.enable = MagicMock()
self.machine.coils.coil_03.hw_driver.pulse = MagicMock()
# test default pulse_ms
self.machine.config['mpf']['default_pulse_ms'] = 23
self.machine.coils.coil_03.pulse()
self.machine.coils.coil_03.hw_driver.pulse.assert_called_with(
PulseSettings(power=1.0, duration=23))
# test power
self.machine.config['mpf']['default_pulse_ms'] = 40
self.machine.coils.coil_03.pulse(pulse_power=1.0)
self.machine.coils.coil_03.hw_driver.pulse.assert_called_with(
PulseSettings(power=1.0, duration=40))
self.machine.coils.coil_03.pulse(pulse_power=0.5)
self.machine.coils.coil_03.hw_driver.pulse.assert_called_with(
PulseSettings(power=0.5, duration=40))
self.machine.coils.coil_01.enable(pulse_power=0.7, hold_power=0.3)
self.machine.coils.coil_01.hw_driver.enable.assert_called_with(
PulseSettings(power=0.7, duration=30), HoldSettings(power=0.3))
# test long pulse with delay
self.machine.coils.coil_03.hw_driver.pulse = MagicMock()
self.machine.coils.coil_03.hw_driver.enable = MagicMock()
self.machine.coils.coil_03.hw_driver.disable = MagicMock()
self.machine.coils.coil_03.pulse(pulse_ms=500)
self.machine.coils.coil_03.hw_driver.enable.assert_called_with(
PulseSettings(power=1.0, duration=0), HoldSettings(power=1.0))
self.machine.coils.coil_03.hw_driver.pulse.assert_not_called()
self.advance_time_and_run(.5)
self.machine.coils.coil_03.hw_driver.disable.assert_called_with()
def configure_driver(self, config: DriverConfig, number: str, platform_settings: dict):
"""Configure a driver.
Args:
config: Config dict.
"""
if not self.opp_connection:
self.raise_config_error("A request was made to configure an OPP solenoid, "
"but no OPP connection is available", 4)
number = self._get_dict_index(number)
if number not in self.solDict:
self.raise_config_error("A request was made to configure an OPP solenoid "
"with number {} which doesn't exist".format(number), 5)
# Use new update individual solenoid command
opp_sol = self.solDict[number]
opp_sol.config = config
opp_sol.platform_settings = platform_settings
self.log.debug("Configure driver %s", number)
default_pulse = PulseSettings(config.default_pulse_power, config.default_pulse_ms)
default_hold = HoldSettings(config.default_hold_power)
opp_sol.reconfigure_driver(default_pulse, default_hold)
# Removing the default input is not necessary since the
# CFG_SOL_USE_SWITCH is not being set
return opp_sol
def remove_switch_rule(self):
"""Remove switch rule."""
self.switch_rule = None
self.reconfigure_driver(
PulseSettings(duration=self.config.default_pulse_ms
if self.config.default_pulse_ms is not None else 10,
power=self.config.default_pulse_power),
HoldSettings(power=self.config.default_hold_power), True)
def test_hold_with_eos(self):
self.machine.default_platform.set_pulse_on_hit_and_release_and_disable_rule = MagicMock()
self.machine.default_platform.set_pulse_on_hit_and_enable_and_release_rule = MagicMock()
self.machine.flippers["f_test_hold_eos"].enable()
self.machine.default_platform.set_pulse_on_hit_and_enable_and_release_rule.assert_called_once_with(
SwitchSettings(hw_switch=self.machine.switches["s_flipper"].hw_switch, invert=False, debounce=False),
DriverSettings(hw_driver=self.machine.coils["c_flipper_hold"].hw_driver,
pulse_settings=PulseSettings(power=1.0, duration=10),
hold_settings=HoldSettings(power=1.0), recycle=False)
)
self.machine.default_platform.set_pulse_on_hit_and_release_and_disable_rule.assert_called_with(
SwitchSettings(hw_switch=self.machine.switches["s_flipper"].hw_switch, invert=False, debounce=False),
SwitchSettings(hw_switch=self.machine.switches["s_flipper_eos"].hw_switch, invert=False, debounce=False),
DriverSettings(hw_driver=self.machine.coils["c_flipper_main"].hw_driver,
pulse_settings=PulseSettings(power=1.0, duration=10),
hold_settings=None, recycle=False),
RepulseSettings(enable_repulse=False)
)
self.machine.default_platform.clear_hw_rule = MagicMock()
self.machine.flippers["f_test_hold_eos"].disable()
self.machine.default_platform.clear_hw_rule.assert_has_calls([
call(
SwitchSettings(hw_switch=self.machine.switches["s_flipper"].hw_switch, invert=False, debounce=False),
DriverSettings(hw_driver=self.machine.coils["c_flipper_main"].hw_driver,
pulse_settings=PulseSettings(power=1.0, duration=10),
hold_settings=None, recycle=False)
),
call(
SwitchSettings(hw_switch=self.machine.switches["s_flipper_eos"].hw_switch, invert=False, debounce=False),
DriverSettings(hw_driver=self.machine.coils["c_flipper_main"].hw_driver,
pulse_settings=PulseSettings(power=1.0, duration=10),
hold_settings=None, recycle=False)
),
call(
SwitchSettings(hw_switch=self.machine.switches["s_flipper"].hw_switch, invert=False, debounce=False),
DriverSettings(hw_driver=self.machine.coils["c_flipper_hold"].hw_driver,
pulse_settings=PulseSettings(power=1.0, duration=10),
hold_settings=HoldSettings(power=1.0), recycle=False)
),
], any_order=True)
def test_express_config(self):
# coil with allow_enable set
coil = self.machine.coils['coil_1']
coil.hw_driver.pulse = MagicMock()
coil.hw_driver.enable = MagicMock()
self.machine.events.post('event1')
self.advance_time_and_run()
coil.hw_driver.pulse.assert_called_with(
PulseSettings(power=1.0, duration=10))
assert not coil.hw_driver.enable.called
# coil without allow_enable
coil = self.machine.coils['coil_2']
coil.hw_driver.pulse = MagicMock()
coil.hw_driver.enable = MagicMock()
self.machine.events.post('event6')
self.advance_time_and_run()
coil.hw_driver.pulse.assert_called_with(
PulseSettings(power=1.0, duration=10))
assert not coil.hw_driver.enable.called
coil = self.machine.coils['coil_3']
coil.hw_driver.pulse = MagicMock()
coil.hw_driver.enable = MagicMock()
coil.hw_driver.disable = MagicMock()
self.post_event("event7")
self.advance_time_and_run()
coil.hw_driver.enable.assert_called_with(
PulseSettings(power=1.0, duration=10), HoldSettings(power=0.5))
assert not coil.hw_driver.disable.called
assert not coil.hw_driver.pulse.called
coil.hw_driver.pulse = MagicMock()
coil.hw_driver.enable = MagicMock()
coil.hw_driver.disable = MagicMock()
self.post_event("event8")
self.advance_time_and_run()
coil.hw_driver.disable.assert_called_with()
assert not coil.hw_driver.enable.called
assert not coil.hw_driver.pulse.called
coil.hw_driver.pulse = MagicMock()
coil.hw_driver.enable = MagicMock()
coil.hw_driver.disable = MagicMock()
self.post_event("event9")
self.advance_time_and_run()
coil.hw_driver.pulse.assert_called_with(
PulseSettings(power=1.0, duration=30))
assert not coil.hw_driver.disable.called
assert not coil.hw_driver.enable.called
def test_ac_switch_and_enable(self):
c_side_a2 = self._get_a_driver(self.machine.coils.c_side_a2)
c_side_c2 = self._get_c_driver(self.machine.coils.c_side_c2)
c_side_a2.enable = MagicMock()
c_side_a2.disable = MagicMock()
c_side_c2.enable = MagicMock()
c_side_c2.disable = MagicMock()
c_ac_relay = self.machine.coils.c_ac_relay
c_ac_relay.enable = MagicMock()
c_ac_relay.disable = MagicMock()
self.advance_time_and_run(0.10)
# test enable on c side
self.machine.coils.c_side_c2.enable()
self.machine_run()
c_ac_relay.enable.assert_called_with()
c_ac_relay.enable = MagicMock()
assert not c_side_c2.enable.called
self.advance_time_and_run(0.075)
c_side_c2.enable.assert_called_with(
PulseSettings(power=1.0, duration=10), HoldSettings(power=0.5))
# a side has preference. it should transition
self.machine.coils.c_side_a2.enable()
self.machine_run()
c_side_c2.disable.assert_called_with()
c_ac_relay.disable.assert_called_with()
c_ac_relay.disable = MagicMock()
assert not c_side_a2.enable.called
# it should enable a side coils now
self.advance_time_and_run(0.075)
c_side_a2.enable.assert_called_with(
PulseSettings(power=1.0, duration=10), HoldSettings(power=0.5))
# disable driver on a side.
self.machine.coils.c_side_a2.disable()
self.advance_time_and_run(0.2)
def enable(self):
"""Enable digital output."""
if self.type == "driver":
self.hw_driver.enable(PulseSettings(power=1.0, duration=0),
HoldSettings(power=1.0))
elif self.type == "light":
self.hw_driver.set_fade(1.0, -1, 1.0, -1)
self.platform.light_sync()
self.delay.remove(name='timed_disable')
else:
raise AssertionError(INVALID_TYPE_ERROR.format(self.type))
def enable(self):
"""Enable digital output."""
if self.type == "driver":
self.hw_driver.enable(PulseSettings(power=1.0, duration=0),
HoldSettings(power=1.0))
elif self.type == "light":
self.hw_driver.set_fade(partial(self._get_state, state=True))
self.platform.light_sync()
self.delay.remove(name='timed_disable')
else:
raise AssertionError("Invalid type {}".format(self.type))
def enable(self, **kwargs):
"""Enable digital output."""
del kwargs
if self.type == "driver":
self.hw_driver.enable(PulseSettings(power=1.0, duration=0),
HoldSettings(power=1.0))
elif self.type == "light":
self.hw_driver.set_fade(partial(self._get_state, state=True))
self.platform.light_sync()
else:
raise AssertionError("Invalid type {}".format(self.type))
def _get_configured_driver_with_optional_hold(driver: DriverRuleSettings, pulse_setting: PulseRuleSettings,
hold_settings: HoldRuleSettings) -> DriverSettings:
"""Return configured driver for rule which might have hold."""
pulse_duration = driver.driver.get_and_verify_pulse_ms(pulse_setting.duration if pulse_setting else None)
pulse_power = driver.driver.get_and_verify_pulse_power(pulse_setting.power if pulse_setting else None)
hold_power = driver.driver.get_and_verify_hold_power(hold_settings.power if hold_settings else None)
return DriverSettings(
hw_driver=driver.driver.hw_driver,
pulse_settings=PulseSettings(duration=pulse_duration, power=pulse_power),
hold_settings=HoldSettings(power=hold_power),
recycle=driver.recycle)
def enable(self,
pulse_ms: int = None,
pulse_power: float = None,
hold_power: float = None):
"""Enable a driver by holding it 'on'.
Args:
----
pulse_ms: The number of milliseconds the driver should be
enabled for. If no value is provided, the driver will be
enabled for the value specified in the config dictionary.
pulse_power: The pulse power. A float between 0.0 and 1.0.
hold_power: The pulse power. A float between 0.0 and 1.0.
If this driver is configured with a holdpatter, then this method will use
that holdpatter to pwm pulse the driver.
If not, then this method will just enable the driver. As a safety
precaution, if you want to enable() this driver without pwm, then you
have to add the following option to this driver in your machine
configuration files:
allow_enable: True
"""
assert self.hw_driver is not None
pulse_ms = self.get_and_verify_pulse_ms(pulse_ms)
pulse_power = self.get_and_verify_pulse_power(pulse_power)
hold_power = self.get_and_verify_hold_power(hold_power)
if hold_power == 0.0:
raise DriverLimitsError("Cannot enable driver with hold_power 0.0")
self.info_log(
"Enabling Driver with power %s (pulse_ms %sms and pulse_power %s)",
hold_power, pulse_ms, pulse_power)
self.hw_driver.enable(
PulseSettings(power=pulse_power, duration=pulse_ms),
HoldSettings(power=hold_power))
if self.config['max_hold_duration']:
self.delay.add_if_doesnt_exist(
self.config['max_hold_duration'] * 1000,
self._enable_limit_reached, "enable_limit_reached")
# inform bcp clients
self.machine.bcp.interface.send_driver_event(
action="enable",
name=self.name,
number=self.config['number'],
pulse_ms=pulse_ms,
pulse_power=pulse_power,
hold_power=hold_power)
def _get_configured_driver_with_hold(driver: DriverRuleSettings, pulse_setting: PulseRuleSettings,
hold_settings: HoldRuleSettings) -> DriverSettings:
"""Return configured driver with hold > 0 for rule."""
pulse_duration = driver.driver.get_and_verify_pulse_ms(pulse_setting.duration if pulse_setting else None)
pulse_power = driver.driver.get_and_verify_pulse_power(pulse_setting.power if pulse_setting else None)
hold_power = driver.driver.get_and_verify_hold_power(hold_settings.power if hold_settings else None)
if hold_power == 0.0:
raise AssertionError("Cannot enable driver with hold_power 0.0")
return DriverSettings(
hw_driver=driver.driver.hw_driver,
pulse_settings=PulseSettings(duration=pulse_duration, power=pulse_power),
hold_settings=HoldSettings(power=hold_power),
recycle=driver.recycle)
def _pulse_now(self, pulse_ms: int, pulse_power: float) -> None:
"""Pulse this driver now."""
if 0 < pulse_ms <= self.platform.features['max_pulse']:
self.info_log("Pulsing Driver for %sms (%s pulse_power)", pulse_ms, pulse_power)
self.hw_driver.pulse(PulseSettings(power=pulse_power, duration=pulse_ms))
else:
self.info_log("Enabling Driver for %sms (%s pulse_power)", pulse_ms, pulse_power)
self.delay.reset(name='timed_disable',
ms=pulse_ms,
callback=self.disable)
self.hw_driver.enable(PulseSettings(power=pulse_power, duration=0),
HoldSettings(power=pulse_power))
# inform bcp clients
self.machine.bcp.interface.send_driver_event(action="pulse", name=self.name, number=self.config['number'],
pulse_ms=pulse_ms, pulse_power=pulse_power)
def enable(self,
pulse_ms: int = None,
pulse_power: float = None,
hold_power: float = None,
**kwargs):
"""Enable a driver by holding it 'on'.
Args:
pulse_ms: The number of milliseconds the driver should be
enabled for. If no value is provided, the driver will be
enabled for the value specified in the config dictionary.
pulse_power: The pulse power. A float between 0.0 and 1.0.
hold_power: The pulse power. A float between 0.0 and 1.0.
If this driver is configured with a holdpatter, then this method will use
that holdpatter to pwm pulse the driver.
If not, then this method will just enable the driver. As a safety
precaution, if you want to enable() this driver without pwm, then you
have to add the following option to this driver in your machine
configuration files:
allow_enable: True
"""
del kwargs
pulse_ms = self.get_and_verify_pulse_ms(pulse_ms)
pulse_power = self.get_and_verify_pulse_power(pulse_power)
hold_power = self.get_and_verify_hold_power(hold_power)
if hold_power == 0.0:
raise AssertionError("Cannot enable driver with hold_power 0.0")
self.time_when_done = -1
self.time_last_changed = self.machine.clock.get_time()
self.debug_log("Enabling Driver")
self.hw_driver.enable(
PulseSettings(power=pulse_power, duration=pulse_ms),
HoldSettings(power=hold_power))
# inform bcp clients
self.machine.bcp.interface.send_driver_event(
action="enable",
name=self.name,
number=self.config['number'],
pulse_ms=pulse_ms,
pulse_power=pulse_power,
hold_power=hold_power)
def test_coil_player_in_mode(self):
coil = self.machine.coils['coil_3']
coil.hw_driver.enable = MagicMock()
coil.hw_driver.disable = MagicMock()
# start mode
self.post_event("start_mode1", 1)
self.assertFalse(coil.hw_driver.enable.called)
self.assertFalse(coil.hw_driver.disable.called)
# enable coil
self.post_event("event1_mode", 1)
coil.hw_driver.enable.assert_called_with(
PulseSettings(power=1.0, duration=10), HoldSettings(power=1.0))
coil.hw_driver.enable = MagicMock()
self.assertFalse(coil.hw_driver.disable.called)
# on mode stop the coil player should disable the coil
self.post_event("stop_mode1", 1)
self.assertFalse(coil.hw_driver.enable.called)
coil.hw_driver.disable.assert_called_with()
def _enable_now(self,
pulse_ms: int = None,
pulse_power: float = None,
hold_power: float = None):
self.info_log(
"Enabling Driver with power %s (pulse_ms %sms and pulse_power %s)",
hold_power, pulse_ms, pulse_power)
self.hw_driver.enable(
PulseSettings(power=pulse_power, duration=pulse_ms),
HoldSettings(power=hold_power))
if self.config['max_hold_duration']:
self.delay.add_if_doesnt_exist(
self.config['max_hold_duration'] * 1000,
self._enable_limit_reached, "enable_limit_reached")
# inform bcp clients
self.machine.bcp.interface.send_driver_event(
action="enable",
name=self.name,
number=self.config['number'],
pulse_ms=pulse_ms,
pulse_power=pulse_power,
hold_power=hold_power)
def testBasicFunctions(self):
c_power = self.machine.coils["c_power"].hw_driver
c_hold = self.machine.coils["c_hold"].hw_driver
c_power.enable = MagicMock()
c_power.disable = MagicMock()
c_power.pulse = MagicMock()
c_hold.enable = MagicMock()
c_hold.disable = MagicMock()
c_hold.pulse = MagicMock()
# test enable
self.machine.coils["c_test"].enable()
c_power.pulse.assert_called_with(PulseSettings(power=1.0, duration=20))
c_power.pulse = MagicMock()
assert not c_power.enable.called
c_hold.enable.assert_called_with(PulseSettings(power=1.0, duration=10),
HoldSettings(power=1.0))
c_hold.enable = MagicMock()
assert not c_hold.pulse.called
# test disable
self.machine.coils["c_test"].disable()
c_power.disable.assert_called_with()
c_power.disable = MagicMock()
c_hold.disable.assert_called_with()
c_hold.disable = MagicMock()
# test pulse
self.machine.coils["c_test"].pulse(17)
c_power.pulse.assert_called_with(PulseSettings(power=1.0, duration=17))
c_hold.pulse.assert_called_with(PulseSettings(power=1.0, duration=17))
# test default pulse
self.machine.coils["c_test"].pulse()
c_power.pulse.assert_called_with(PulseSettings(power=1.0, duration=20))
c_hold.pulse.assert_called_with(PulseSettings(power=1.0, duration=10))
def test_dual_wound_flipper_with_software_eos_repulse(self):
self.machine.coils[
"c_flipper_dual_wound_main"].hw_driver.pulse = MagicMock()
self.machine.coils[
"c_flipper_dual_wound_main"].hw_driver.enable = MagicMock()
self.machine.coils[
"c_flipper_dual_wound_main"].hw_driver.disable = MagicMock()
# nothing should happen on EOS close without flipper button active
self.hit_switch_and_run("s_flipper_dual_wound_eos", 1)
self.machine.coils[
"c_flipper_dual_wound_main"].hw_driver.pulse.assert_not_called()
self.machine.coils[
"c_flipper_dual_wound_main"].hw_driver.enable.assert_not_called()
self.machine.coils[
"c_flipper_dual_wound_main"].hw_driver.disable.assert_not_called()
# nothing should happen on EOS open without flipper button active
self.release_switch_and_run("s_flipper_dual_wound_eos", 1)
self.machine.coils[
"c_flipper_dual_wound_main"].hw_driver.pulse.assert_not_called()
self.machine.coils[
"c_flipper_dual_wound_main"].hw_driver.enable.assert_not_called()
self.machine.coils[
"c_flipper_dual_wound_main"].hw_driver.disable.assert_not_called()
# flipper activation should also not yet do what
self.hit_switch_and_run("s_flipper_dual_wound", 1)
self.machine.coils[
"c_flipper_dual_wound_main"].hw_driver.pulse.assert_not_called()
self.machine.coils[
"c_flipper_dual_wound_main"].hw_driver.enable.assert_not_called()
self.machine.coils[
"c_flipper_dual_wound_main"].hw_driver.disable.assert_not_called()
# EOS closes. nothing happens yet
self.hit_switch_and_run("s_flipper_dual_wound_eos", 1)
self.machine.coils[
"c_flipper_dual_wound_main"].hw_driver.pulse.assert_not_called()
self.machine.coils[
"c_flipper_dual_wound_main"].hw_driver.enable.assert_not_called()
self.machine.coils[
"c_flipper_dual_wound_main"].hw_driver.disable.assert_not_called()
# EOS opens. nothing should happen as flipper is not enabled
self.release_switch_and_run("s_flipper_dual_wound_eos", 1)
self.machine.coils[
"c_flipper_dual_wound_main"].hw_driver.pulse.assert_not_called()
self.machine.coils[
"c_flipper_dual_wound_main"].hw_driver.enable.assert_not_called()
self.machine.coils[
"c_flipper_dual_wound_main"].hw_driver.disable.assert_not_called()
# release flipper prior to enabling the flipper
self.release_switch_and_run("s_flipper_dual_wound", 1)
self.machine.default_platform.set_pulse_on_hit_and_release_and_disable_rule = MagicMock(
)
self.machine.default_platform.set_pulse_on_hit_and_enable_and_release_rule = MagicMock(
)
self.assertPlaceholderEvaluates(
False, "device.flippers.dual_wound_flipper.enabled")
# enable flipper
self.post_event("enable_flipper_dual_wound")
self.assertPlaceholderEvaluates(
True, "device.flippers.dual_wound_flipper.enabled")
self.assertEqual(
1,
len(self.machine.default_platform.
set_pulse_on_hit_and_release_and_disable_rule.
_mock_call_args_list))
self.assertEqual(
1,
len(self.machine.default_platform.
set_pulse_on_hit_and_enable_and_release_rule.
_mock_call_args_list))
self.machine.default_platform.set_pulse_on_hit_and_release_and_disable_rule.assert_called_once_with(
SwitchSettings(hw_switch=self.machine.
switches["s_flipper_dual_wound"].hw_switch,
invert=False,
debounce=False),
SwitchSettings(hw_switch=self.machine.
switches["s_flipper_dual_wound_eos"].hw_switch,
invert=False,
debounce=False),
DriverSettings(hw_driver=self.machine.
coils["c_flipper_dual_wound_main"].hw_driver,
pulse_settings=PulseSettings(power=1.0,
duration=30),
hold_settings=None,
recycle=False),
None # this is not passed as we implement it in software
)
self.machine.default_platform.set_pulse_on_hit_and_enable_and_release_rule.assert_called_once_with(
SwitchSettings(hw_switch=self.machine.
switches["s_flipper_dual_wound"].hw_switch,
invert=False,
debounce=False),
DriverSettings(hw_driver=self.machine.
coils["c_flipper_dual_wound_hold"].hw_driver,
pulse_settings=PulseSettings(power=1.0,
duration=10),
hold_settings=HoldSettings(power=1.0),
recycle=False))
# nothing should happen on EOS close without flipper button active
self.hit_switch_and_run("s_flipper_dual_wound_eos", 1)
self.machine.coils[
"c_flipper_dual_wound_main"].hw_driver.pulse.assert_not_called()
self.machine.coils[
"c_flipper_dual_wound_main"].hw_driver.enable.assert_not_called()
self.machine.coils[
"c_flipper_dual_wound_main"].hw_driver.disable.assert_not_called()
# nothing should happen on EOS open without flipper button active
self.release_switch_and_run("s_flipper_dual_wound_eos", 1)
self.machine.coils[
"c_flipper_dual_wound_main"].hw_driver.pulse.assert_not_called()
self.machine.coils[
"c_flipper_dual_wound_main"].hw_driver.enable.assert_not_called()
self.machine.coils[
"c_flipper_dual_wound_main"].hw_driver.disable.assert_not_called()
# flipper activation should also not yet do what
self.hit_switch_and_run("s_flipper_dual_wound", 1)
self.machine.coils[
"c_flipper_dual_wound_main"].hw_driver.pulse.assert_not_called()
self.machine.coils[
"c_flipper_dual_wound_main"].hw_driver.enable.assert_not_called()
self.machine.coils[
"c_flipper_dual_wound_main"].hw_driver.disable.assert_not_called()
# EOS closes. nothing happens yet
self.hit_switch_and_run("s_flipper_dual_wound_eos", 1)
self.machine.coils[
"c_flipper_dual_wound_main"].hw_driver.pulse.assert_not_called()
self.machine.coils[
"c_flipper_dual_wound_main"].hw_driver.enable.assert_not_called()
self.machine.coils[
"c_flipper_dual_wound_main"].hw_driver.disable.assert_not_called()
# EOS opens. it should repulse
self.release_switch_and_run("s_flipper_dual_wound_eos", 1)
self.machine.coils[
"c_flipper_dual_wound_main"].hw_driver.pulse.assert_called_with(
PulseSettings(power=1.0, duration=30))
self.machine.coils[
"c_flipper_dual_wound_main"].hw_driver.pulse = MagicMock()
self.machine.coils[
"c_flipper_dual_wound_main"].hw_driver.enable.assert_not_called()
self.machine.coils[
"c_flipper_dual_wound_main"].hw_driver.disable.assert_not_called()
# EOS closes only shortly
self.hit_switch_and_run("s_flipper_dual_wound_eos", .1)
self.machine.coils[
"c_flipper_dual_wound_main"].hw_driver.pulse.assert_not_called()
self.machine.coils[
"c_flipper_dual_wound_main"].hw_driver.enable.assert_not_called()
self.machine.coils[
"c_flipper_dual_wound_main"].hw_driver.disable.assert_not_called()
# EOS opens. it should not repulse yet
self.release_switch_and_run("s_flipper_dual_wound_eos", 1)
self.machine.coils[
"c_flipper_dual_wound_main"].hw_driver.pulse.assert_not_called()
self.machine.coils[
"c_flipper_dual_wound_main"].hw_driver.enable.assert_not_called()
self.machine.coils[
"c_flipper_dual_wound_main"].hw_driver.disable.assert_not_called()
# EOS closes. nothing happens yet
self.hit_switch_and_run("s_flipper_dual_wound_eos", 1)
self.machine.coils[
"c_flipper_dual_wound_main"].hw_driver.pulse.assert_not_called()
self.machine.coils[
"c_flipper_dual_wound_main"].hw_driver.enable.assert_not_called()
self.machine.coils[
"c_flipper_dual_wound_main"].hw_driver.disable.assert_not_called()
# EOS opens. it should repulse
self.release_switch_and_run("s_flipper_dual_wound_eos", 1)
self.machine.coils[
"c_flipper_dual_wound_main"].hw_driver.pulse.assert_called_with(
PulseSettings(power=1.0, duration=30))
self.machine.coils[
"c_flipper_dual_wound_main"].hw_driver.pulse = MagicMock()
self.machine.coils[
"c_flipper_dual_wound_main"].hw_driver.enable.assert_not_called()
self.machine.coils[
"c_flipper_dual_wound_main"].hw_driver.disable.assert_not_called()
# EOS closes. nothing happens yet
self.hit_switch_and_run("s_flipper_dual_wound_eos", 1)
self.machine.coils[
"c_flipper_dual_wound_main"].hw_driver.pulse.assert_not_called()
self.machine.coils[
"c_flipper_dual_wound_main"].hw_driver.enable.assert_not_called()
self.machine.coils[
"c_flipper_dual_wound_main"].hw_driver.disable.assert_not_called()
# flipper button releases
self.release_switch_and_run("s_flipper_dual_wound", 1)
# eos opens - nothing should happen
self.release_switch_and_run("s_flipper_dual_wound_eos", 1)
self.machine.coils[
"c_flipper_dual_wound_main"].hw_driver.pulse.assert_not_called()
self.machine.coils[
"c_flipper_dual_wound_main"].hw_driver.enable.assert_not_called()
self.machine.coils[
"c_flipper_dual_wound_main"].hw_driver.disable.assert_called_with(
)
self.machine.coils[
"c_flipper_dual_wound_main"].hw_driver.disable = MagicMock()
# disable flipper
self.post_event("disable_flipper_dual_wound")
self.assertPlaceholderEvaluates(
False, "device.flippers.dual_wound_flipper.enabled")
# nothing should happen on EOS close without flipper button active
self.hit_switch_and_run("s_flipper_dual_wound_eos", 1)
self.machine.coils[
"c_flipper_dual_wound_main"].hw_driver.pulse.assert_not_called()
self.machine.coils[
"c_flipper_dual_wound_main"].hw_driver.enable.assert_not_called()
self.machine.coils[
"c_flipper_dual_wound_main"].hw_driver.disable.assert_not_called()
# nothing should happen on EOS open without flipper button active
self.release_switch_and_run("s_flipper_dual_wound_eos", 1)
self.machine.coils[
"c_flipper_dual_wound_main"].hw_driver.pulse.assert_not_called()
self.machine.coils[
"c_flipper_dual_wound_main"].hw_driver.enable.assert_not_called()
self.machine.coils[
"c_flipper_dual_wound_main"].hw_driver.disable.assert_not_called()
# flipper activation should also not yet do what
self.hit_switch_and_run("s_flipper_dual_wound", 1)
self.machine.coils[
"c_flipper_dual_wound_main"].hw_driver.pulse.assert_not_called()
self.machine.coils[
"c_flipper_dual_wound_main"].hw_driver.enable.assert_not_called()
self.machine.coils[
"c_flipper_dual_wound_main"].hw_driver.disable.assert_not_called()
# EOS closes. nothing happens yet
self.hit_switch_and_run("s_flipper_dual_wound_eos", 1)
self.machine.coils[
"c_flipper_dual_wound_main"].hw_driver.pulse.assert_not_called()
self.machine.coils[
"c_flipper_dual_wound_main"].hw_driver.enable.assert_not_called()
self.machine.coils[
"c_flipper_dual_wound_main"].hw_driver.disable.assert_not_called()
# EOS opens. nothing should happen as flipper is not enabled
self.release_switch_and_run("s_flipper_dual_wound_eos", 1)
self.machine.coils[
"c_flipper_dual_wound_main"].hw_driver.pulse.assert_not_called()
self.machine.coils[
"c_flipper_dual_wound_main"].hw_driver.enable.assert_not_called()
self.machine.coils[
"c_flipper_dual_wound_main"].hw_driver.disable.assert_not_called()
# release flipper prior to enabling the flipper
self.release_switch_and_run("s_flipper_dual_wound", 1)
def test_hold_no_eos(self):
self.machine.default_platform.set_pulse_on_hit_and_release_rule = MagicMock()
self.machine.default_platform.set_pulse_on_hit_and_enable_and_release_rule = MagicMock()
# Config uses enable_events to enable the flipper on boot
self.assertTrue(self.machine.flippers["left_flipper"]._enabled)
self.machine.flippers["left_flipper"].disable()
self.assertFalse(self.machine.flippers["left_flipper"]._enabled)
self.machine.flippers["left_flipper"].enable()
# def set_hw_rule(self, sw_name, sw_activity, driver_name, driver_action,
# disable_on_release=True, drive_now=False,
# **driver_settings_overrides):
self.assertEqual(1, len(self.machine.default_platform.set_pulse_on_hit_and_release_rule._mock_call_args_list))
self.assertEqual(1, len(self.machine.default_platform.set_pulse_on_hit_and_enable_and_release_rule.
_mock_call_args_list))
self.machine.default_platform.set_pulse_on_hit_and_release_rule.assert_called_once_with(
SwitchSettings(hw_switch=self.machine.switches["s_left_flipper"].hw_switch, invert=False, debounce=False),
DriverSettings(hw_driver=self.machine.coils["c_flipper_left_main"].hw_driver,
pulse_settings=PulseSettings(power=1.0, duration=30),
hold_settings=None, recycle=False)
)
self.machine.default_platform.set_pulse_on_hit_and_enable_and_release_rule.assert_called_once_with(
SwitchSettings(hw_switch=self.machine.switches["s_left_flipper"].hw_switch, invert=False, debounce=False),
DriverSettings(hw_driver=self.machine.coils["c_flipper_left_hold"].hw_driver,
pulse_settings=PulseSettings(power=1.0, duration=10),
hold_settings=HoldSettings(power=1.0), recycle=False)
)
self.machine.default_platform.clear_hw_rule = MagicMock()
self.machine.flippers["left_flipper"].disable()
self.assertFalse(self.machine.flippers["left_flipper"]._enabled)
self.machine.default_platform.clear_hw_rule.assert_has_calls(
[call(
SwitchSettings(hw_switch=self.machine.switches["s_left_flipper"].hw_switch, invert=False, debounce=False),
DriverSettings(hw_driver=self.machine.coils["c_flipper_left_main"].hw_driver,
pulse_settings=PulseSettings(power=1.0, duration=30),
hold_settings=None, recycle=False)
),
call(
SwitchSettings(hw_switch=self.machine.switches["s_left_flipper"].hw_switch, invert=False, debounce=False),
DriverSettings(hw_driver=self.machine.coils["c_flipper_left_hold"].hw_driver,
pulse_settings=PulseSettings(power=1.0, duration=10),
hold_settings=HoldSettings(power=1.0), recycle=False)
)
], any_order=True)
self.machine.default_platform.set_pulse_on_hit_and_release_rule = MagicMock()
self.machine.default_platform.set_pulse_on_hit_and_enable_and_release_rule = MagicMock()
self.machine.flippers["left_flipper"].enable()
self.machine.default_platform.set_pulse_on_hit_and_release_rule.assert_called_once_with(
SwitchSettings(hw_switch=self.machine.switches["s_left_flipper"].hw_switch, invert=False, debounce=False),
DriverSettings(hw_driver=self.machine.coils["c_flipper_left_main"].hw_driver,
pulse_settings=PulseSettings(power=1.0, duration=30),
hold_settings=None, recycle=False)
)
self.machine.default_platform.set_pulse_on_hit_and_enable_and_release_rule.assert_called_once_with(
SwitchSettings(hw_switch=self.machine.switches["s_left_flipper"].hw_switch, invert=False, debounce=False),
DriverSettings(hw_driver=self.machine.coils["c_flipper_left_hold"].hw_driver,
pulse_settings=PulseSettings(power=1.0, duration=10),
hold_settings=HoldSettings(power=1.0), recycle=False)
)
