def test_state_value(self): """Test with state value.""" with tempfile.TemporaryDirectory() as tempdirname: path = os.path.join(tempdirname, 'switch_status') test_switch = { 'command_state': 'cat {}'.format(path), 'command_on': 'echo 1 > {}'.format(path), 'command_off': 'echo 0 > {}'.format(path), 'value_template': '{{ value=="1" }}' } self.assertTrue(setup_component(self.hass, switch.DOMAIN, { 'switch': { 'platform': 'command_line', 'switches': { 'test': test_switch } } })) state = self.hass.states.get('switch.test') self.assertEqual(STATE_OFF, state.state) switch.turn_on(self.hass, 'switch.test') self.hass.block_till_done() state = self.hass.states.get('switch.test') self.assertEqual(STATE_ON, state.state) switch.turn_off(self.hass, 'switch.test') self.hass.block_till_done() state = self.hass.states.get('switch.test') self.assertEqual(STATE_OFF, state.state)
def test_sending_mqtt_commands_and_optimistic(self): """Test the sending MQTT commands in optimistic mode.""" assert setup_component(self.hass, switch.DOMAIN, { switch.DOMAIN: { 'platform': 'mqtt', 'name': 'test', 'command_topic': 'command-topic', 'payload_on': 'beer on', 'payload_off': 'beer off', 'qos': '2' } }) state = self.hass.states.get('switch.test') self.assertEqual(STATE_OFF, state.state) self.assertTrue(state.attributes.get(ATTR_ASSUMED_STATE)) switch.turn_on(self.hass, 'switch.test') self.hass.block_till_done() self.assertEqual(('command-topic', 'beer on', 2, False), self.mock_publish.mock_calls[-2][1]) state = self.hass.states.get('switch.test') self.assertEqual(STATE_ON, state.state) switch.turn_off(self.hass, 'switch.test') self.hass.block_till_done() self.assertEqual(('command-topic', 'beer off', 2, False), self.mock_publish.mock_calls[-2][1]) state = self.hass.states.get('switch.test') self.assertEqual(STATE_OFF, state.state)
def test_sending_mqtt_commands_and_optimistic(self): self.assertTrue(switch.setup(self.hass, { 'switch': { 'platform': 'mqtt', 'name': 'test', 'command_topic': 'command-topic', 'payload_on': 'beer on', 'payload_off': 'beer off', 'qos': 2 } })) state = self.hass.states.get('switch.test') self.assertEqual(STATE_OFF, state.state) switch.turn_on(self.hass, 'switch.test') self.hass.pool.block_till_done() self.assertEqual(('command-topic', 'beer on', 2, False), self.mock_publish.mock_calls[-1][1]) state = self.hass.states.get('switch.test') self.assertEqual(STATE_ON, state.state) switch.turn_off(self.hass, 'switch.test') self.hass.pool.block_till_done() self.assertEqual(('command-topic', 'beer off', 2, False), self.mock_publish.mock_calls[-1][1]) state = self.hass.states.get('switch.test') self.assertEqual(STATE_OFF, state.state)
def test_state_json_value(self): """Test with state JSON value.""" with tempfile.TemporaryDirectory() as tempdirname: path = os.path.join(tempdirname, 'switch_status') oncmd = json.dumps({'status': 'ok'}) offcmd = json.dumps({'status': 'nope'}) test_switch = { 'command_state': 'cat {}'.format(path), 'command_on': 'echo \'{}\' > {}'.format(oncmd, path), 'command_off': 'echo \'{}\' > {}'.format(offcmd, path), 'value_template': '{{ value_json.status=="ok" }}' } self.assertTrue(setup_component(self.hass, switch.DOMAIN, { 'switch': { 'platform': 'command_line', 'switches': { 'test': test_switch } } })) state = self.hass.states.get('switch.test') self.assertEqual(STATE_OFF, state.state) switch.turn_on(self.hass, 'switch.test') self.hass.block_till_done() state = self.hass.states.get('switch.test') self.assertEqual(STATE_ON, state.state) switch.turn_off(self.hass, 'switch.test') self.hass.block_till_done() state = self.hass.states.get('switch.test') self.assertEqual(STATE_OFF, state.state)
def test_valid_hostname(self): """Test with valid hostname.""" global TEST_STATE TEST_STATE = False self.assertTrue( setup_component( self.hass, switch.DOMAIN, { 'switch': { 'platform': 'wake_on_lan', 'mac_address': '00-01-02-03-04-05', 'host': 'validhostname', } })) state = self.hass.states.get('switch.wake_on_lan') self.assertEqual(STATE_OFF, state.state) TEST_STATE = True switch.turn_on(self.hass, 'switch.wake_on_lan') self.hass.block_till_done() state = self.hass.states.get('switch.wake_on_lan') self.assertEqual(STATE_ON, state.state) switch.turn_off(self.hass, 'switch.wake_on_lan') self.hass.block_till_done() state = self.hass.states.get('switch.wake_on_lan') self.assertEqual(STATE_ON, state.state)
def test_state_json_value(self): with tempfile.TemporaryDirectory() as tempdirname: path = os.path.join(tempdirname, 'switch_status') oncmd = json.dumps({'status': 'ok'}) offcmd = json.dumps({'status': 'nope'}) test_switch = { 'statecmd': 'cat {}'.format(path), 'oncmd': 'echo \'{}\' > {}'.format(oncmd, path), 'offcmd': 'echo \'{}\' > {}'.format(offcmd, path), 'value_template': '{{ value_json.status=="ok" }}' } self.assertTrue(switch.setup(self.hass, { 'switch': { 'platform': 'command_switch', 'switches': { 'test': test_switch } } })) state = self.hass.states.get('switch.test') self.assertEqual(STATE_OFF, state.state) switch.turn_on(self.hass, 'switch.test') self.hass.pool.block_till_done() state = self.hass.states.get('switch.test') self.assertEqual(STATE_ON, state.state) switch.turn_off(self.hass, 'switch.test') self.hass.pool.block_till_done() state = self.hass.states.get('switch.test') self.assertEqual(STATE_OFF, state.state)
def test_state_none(self): """Test with none state.""" with tempfile.TemporaryDirectory() as tempdirname: path = os.path.join(tempdirname, 'switch_status') test_switch = { 'oncmd': 'echo 1 > {}'.format(path), 'offcmd': 'echo 0 > {}'.format(path), } self.assertTrue( switch.setup( self.hass, { 'switch': { 'platform': 'command_line', 'switches': { 'test': test_switch } } })) state = self.hass.states.get('switch.test') self.assertEqual(STATE_OFF, state.state) switch.turn_on(self.hass, 'switch.test') self.hass.pool.block_till_done() state = self.hass.states.get('switch.test') self.assertEqual(STATE_ON, state.state) switch.turn_off(self.hass, 'switch.test') self.hass.pool.block_till_done() state = self.hass.states.get('switch.test') self.assertEqual(STATE_OFF, state.state)
def test_valid_hostname(self): """Test with valid hostname.""" global TEST_STATE TEST_STATE = False self.assertTrue(setup_component(self.hass, switch.DOMAIN, { 'switch': { 'platform': 'wake_on_lan', 'mac_address': '00-01-02-03-04-05', 'host': 'validhostname', } })) state = self.hass.states.get('switch.wake_on_lan') self.assertEqual(STATE_OFF, state.state) TEST_STATE = True switch.turn_on(self.hass, 'switch.wake_on_lan') self.hass.block_till_done() state = self.hass.states.get('switch.wake_on_lan') self.assertEqual(STATE_ON, state.state) switch.turn_off(self.hass, 'switch.wake_on_lan') self.hass.block_till_done() state = self.hass.states.get('switch.wake_on_lan') self.assertEqual(STATE_ON, state.state)
def test_state_none(self): with tempfile.TemporaryDirectory() as tempdirname: path = os.path.join(tempdirname, 'switch_status') test_switch = { 'oncmd': 'echo 1 > {}'.format(path), 'offcmd': 'echo 0 > {}'.format(path), } self.assertTrue(switch.setup(self.hass, { 'switch': { 'platform': 'command_switch', 'switches': { 'test': test_switch } } })) state = self.hass.states.get('switch.test') self.assertEqual(STATE_OFF, state.state) switch.turn_on(self.hass, 'switch.test') self.hass.pool.block_till_done() state = self.hass.states.get('switch.test') self.assertEqual(STATE_ON, state.state) switch.turn_off(self.hass, 'switch.test') self.hass.pool.block_till_done() state = self.hass.states.get('switch.test') self.assertEqual(STATE_OFF, state.state)
def test_sending_mqtt_commands_and_optimistic(self): self.assertTrue(switch.setup(self.hass, { 'switch': { 'platform': 'mqtt', 'name': 'test', 'command_topic': 'command-topic', 'payload_on': 'beer on', 'payload_off': 'beer off', 'qos': 2 } })) state = self.hass.states.get('switch.test') self.assertEqual(STATE_OFF, state.state) self.assertTrue(state.attributes.get(ATTR_ASSUMED_STATE)) switch.turn_on(self.hass, 'switch.test') self.hass.pool.block_till_done() self.assertEqual(('command-topic', 'beer on', 2, False), self.mock_publish.mock_calls[-1][1]) state = self.hass.states.get('switch.test') self.assertEqual(STATE_ON, state.state) switch.turn_off(self.hass, 'switch.test') self.hass.pool.block_till_done() self.assertEqual(('command-topic', 'beer off', 2, False), self.mock_publish.mock_calls[-1][1]) state = self.hass.states.get('switch.test') self.assertEqual(STATE_OFF, state.state)
def test_on_off(self): """Test turning the switch on and off.""" assert self.switch().state == 'off' assert self.other_switch().state == 'off' assert not switch.is_on(self.hass, ENTITY_SWITCH) switch.turn_on(self.hass, ENTITY_SWITCH) self.hass.block_till_done() self.mock_lj.press_switch.assert_called_with(ENTITY_SWITCH_NUMBER) switch.turn_off(self.hass, ENTITY_SWITCH) self.hass.block_till_done() self.mock_lj.release_switch.assert_called_with(ENTITY_SWITCH_NUMBER)
def test_methods(self): """Test is_on, turn_on, turn_off methods.""" self.assertTrue( setup_component(self.hass, switch.DOMAIN, {switch.DOMAIN: { CONF_PLATFORM: 'test' }})) self.assertTrue(switch.is_on(self.hass)) self.assertEqual( STATE_ON, self.hass.states.get(switch.ENTITY_ID_ALL_SWITCHES).state) self.assertTrue(switch.is_on(self.hass, self.switch_1.entity_id)) self.assertFalse(switch.is_on(self.hass, self.switch_2.entity_id)) self.assertFalse(switch.is_on(self.hass, self.switch_3.entity_id)) switch.turn_off(self.hass, self.switch_1.entity_id) switch.turn_on(self.hass, self.switch_2.entity_id) self.hass.block_till_done() self.assertTrue(switch.is_on(self.hass)) self.assertFalse(switch.is_on(self.hass, self.switch_1.entity_id)) self.assertTrue(switch.is_on(self.hass, self.switch_2.entity_id)) # Turn all off switch.turn_off(self.hass) self.hass.block_till_done() self.assertFalse(switch.is_on(self.hass)) self.assertEqual( STATE_OFF, self.hass.states.get(switch.ENTITY_ID_ALL_SWITCHES).state) self.assertFalse(switch.is_on(self.hass, self.switch_1.entity_id)) self.assertFalse(switch.is_on(self.hass, self.switch_2.entity_id)) self.assertFalse(switch.is_on(self.hass, self.switch_3.entity_id)) # Turn all on switch.turn_on(self.hass) self.hass.block_till_done() self.assertTrue(switch.is_on(self.hass)) self.assertEqual( STATE_ON, self.hass.states.get(switch.ENTITY_ID_ALL_SWITCHES).state) self.assertTrue(switch.is_on(self.hass, self.switch_1.entity_id)) self.assertTrue(switch.is_on(self.hass, self.switch_2.entity_id)) self.assertTrue(switch.is_on(self.hass, self.switch_3.entity_id))
def test_methods(self): """Test is_on, turn_on, turn_off methods.""" self.assertTrue(setup_component( self.hass, switch.DOMAIN, {switch.DOMAIN: {CONF_PLATFORM: 'test'}} )) self.assertTrue(switch.is_on(self.hass)) self.assertEqual( STATE_ON, self.hass.states.get(switch.ENTITY_ID_ALL_SWITCHES).state) self.assertTrue(switch.is_on(self.hass, self.switch_1.entity_id)) self.assertFalse(switch.is_on(self.hass, self.switch_2.entity_id)) self.assertFalse(switch.is_on(self.hass, self.switch_3.entity_id)) switch.turn_off(self.hass, self.switch_1.entity_id) switch.turn_on(self.hass, self.switch_2.entity_id) self.hass.block_till_done() self.assertTrue(switch.is_on(self.hass)) self.assertFalse(switch.is_on(self.hass, self.switch_1.entity_id)) self.assertTrue(switch.is_on(self.hass, self.switch_2.entity_id)) # Turn all off switch.turn_off(self.hass) self.hass.block_till_done() self.assertFalse(switch.is_on(self.hass)) self.assertEqual( STATE_OFF, self.hass.states.get(switch.ENTITY_ID_ALL_SWITCHES).state) self.assertFalse(switch.is_on(self.hass, self.switch_1.entity_id)) self.assertFalse(switch.is_on(self.hass, self.switch_2.entity_id)) self.assertFalse(switch.is_on(self.hass, self.switch_3.entity_id)) # Turn all on switch.turn_on(self.hass) self.hass.block_till_done() self.assertTrue(switch.is_on(self.hass)) self.assertEqual( STATE_ON, self.hass.states.get(switch.ENTITY_ID_ALL_SWITCHES).state) self.assertTrue(switch.is_on(self.hass, self.switch_1.entity_id)) self.assertTrue(switch.is_on(self.hass, self.switch_2.entity_id)) self.assertTrue(switch.is_on(self.hass, self.switch_3.entity_id))
def _control_heating(self): """Check if we need to turn heating on or off.""" if not self._active and None not in (self._cur_temp, self._target_temp): self._active = True _LOGGER.info('Obtained current and target temperature. ' 'Generic thermostat active.') if not self._active: return if self.min_cycle_duration: if self._is_device_active: current_state = STATE_ON else: current_state = STATE_OFF long_enough = condition.state(self.hass, self.heater_entity_id, current_state, self.min_cycle_duration) if not long_enough: return if self.ac_mode: is_cooling = self._is_device_active if is_cooling: too_cold = self._target_temp - self._cur_temp > self._tolerance if too_cold: _LOGGER.info('Turning off AC %s', self.heater_entity_id) switch.turn_off(self.hass, self.heater_entity_id) else: too_hot = self._cur_temp - self._target_temp > self._tolerance if too_hot: _LOGGER.info('Turning on AC %s', self.heater_entity_id) switch.turn_on(self.hass, self.heater_entity_id) else: is_heating = self._is_device_active if is_heating: too_hot = self._cur_temp - self._target_temp > self._tolerance if too_hot: _LOGGER.info('Turning off heater %s', self.heater_entity_id) switch.turn_off(self.hass, self.heater_entity_id) else: too_cold = self._target_temp - self._cur_temp > self._tolerance if too_cold: _LOGGER.info('Turning on heater %s', self.heater_entity_id) switch.turn_on(self.hass, self.heater_entity_id)
def test_methods(self): """ Test is_on, turn_on, turn_off methods. """ self.assertTrue(switch.is_on(self.hass)) self.assertEqual( STATE_ON, self.hass.states.get(switch.ENTITY_ID_ALL_SWITCHES).state) self.assertTrue(switch.is_on(self.hass, self.switch_1.entity_id)) self.assertFalse(switch.is_on(self.hass, self.switch_2.entity_id)) self.assertFalse(switch.is_on(self.hass, self.switch_3.entity_id)) switch.turn_off(self.hass, self.switch_1.entity_id) switch.turn_on(self.hass, self.switch_2.entity_id) self.hass.pool.block_till_done() self.assertTrue(switch.is_on(self.hass)) self.assertFalse(switch.is_on(self.hass, self.switch_1.entity_id)) self.assertTrue(switch.is_on(self.hass, self.switch_2.entity_id)) # Turn all off switch.turn_off(self.hass) self.hass.pool.block_till_done() self.assertFalse(switch.is_on(self.hass)) self.assertEqual( STATE_OFF, self.hass.states.get(switch.ENTITY_ID_ALL_SWITCHES).state) self.assertFalse(switch.is_on(self.hass, self.switch_1.entity_id)) self.assertFalse(switch.is_on(self.hass, self.switch_2.entity_id)) self.assertFalse(switch.is_on(self.hass, self.switch_3.entity_id)) # Turn all on switch.turn_on(self.hass) self.hass.pool.block_till_done() self.assertTrue(switch.is_on(self.hass)) self.assertEqual( STATE_ON, self.hass.states.get(switch.ENTITY_ID_ALL_SWITCHES).state) self.assertTrue(switch.is_on(self.hass, self.switch_1.entity_id)) self.assertTrue(switch.is_on(self.hass, self.switch_2.entity_id)) self.assertTrue(switch.is_on(self.hass, self.switch_3.entity_id))
def _control_heating(self): """ Check if we need to turn heating on or off. """ if not self._active and None not in (self._cur_temp, self._target_temp): self._active = True _LOGGER.info('Obtained current and target temperature. ' 'Heat control active.') if not self._active: return too_cold = self._target_temp - self._cur_temp > TOL_TEMP is_heating = self._is_heating if too_cold and not is_heating: _LOGGER.info('Turning on heater %s', self.heater_entity_id) switch.turn_on(self.hass, self.heater_entity_id) elif not too_cold and is_heating: _LOGGER.info('Turning off heater %s', self.heater_entity_id) switch.turn_off(self.hass, self.heater_entity_id)
def _control_heating(self): """Check if we need to turn heating on or off.""" if not self._active and None not in (self._cur_temp, self._target_temp): self._active = True _LOGGER.info('Obtained current and target temperature. ' 'Heat control active.') if not self._active: return too_cold = self._target_temp - self._cur_temp > TOL_TEMP is_heating = self._is_heating if too_cold and not is_heating: _LOGGER.info('Turning on heater %s', self.heater_entity_id) switch.turn_on(self.hass, self.heater_entity_id) elif not too_cold and is_heating: _LOGGER.info('Turning off heater %s', self.heater_entity_id) switch.turn_off(self.hass, self.heater_entity_id)
def test_sending_mqtt_commands_and_optimistic(self): """Test the sending MQTT commands in optimistic mode.""" fake_state = ha.State('switch.test', 'on') with patch('homeassistant.components.switch.mqtt.async_get_last_state', return_value=mock_coro(fake_state)): assert setup_component( self.hass, switch.DOMAIN, { switch.DOMAIN: { 'platform': 'mqtt', 'name': 'test', 'command_topic': 'command-topic', 'payload_on': 'beer on', 'payload_off': 'beer off', 'qos': '2' } }) state = self.hass.states.get('switch.test') self.assertEqual(STATE_ON, state.state) self.assertTrue(state.attributes.get(ATTR_ASSUMED_STATE)) switch.turn_on(self.hass, 'switch.test') self.hass.block_till_done() self.mock_publish.async_publish.assert_called_once_with( 'command-topic', 'beer on', 2, False) self.mock_publish.async_publish.reset_mock() state = self.hass.states.get('switch.test') self.assertEqual(STATE_ON, state.state) switch.turn_off(self.hass, 'switch.test') self.hass.block_till_done() self.mock_publish.async_publish.assert_called_once_with( 'command-topic', 'beer off', 2, False) state = self.hass.states.get('switch.test') self.assertEqual(STATE_OFF, state.state)
def test_off_script(self): """Test with turn off script.""" global TEST_STATE TEST_STATE = False self.assertTrue( setup_component( self.hass, switch.DOMAIN, { 'switch': { 'platform': 'wake_on_lan', 'mac_address': '00-01-02-03-04-05', 'host': 'validhostname', 'turn_off': { 'service': 'shell_command.turn_off_TARGET', }, } })) calls = mock_service(self.hass, 'shell_command', 'turn_off_TARGET') state = self.hass.states.get('switch.wake_on_lan') self.assertEqual(STATE_OFF, state.state) TEST_STATE = True switch.turn_on(self.hass, 'switch.wake_on_lan') self.hass.block_till_done() state = self.hass.states.get('switch.wake_on_lan') self.assertEqual(STATE_ON, state.state) assert len(calls) == 0 TEST_STATE = False switch.turn_off(self.hass, 'switch.wake_on_lan') self.hass.block_till_done() state = self.hass.states.get('switch.wake_on_lan') self.assertEqual(STATE_OFF, state.state) assert len(calls) == 1
def test_sending_mqtt_commands_and_optimistic(self): """Test the sending MQTT commands in optimistic mode.""" fake_state = ha.State('switch.test', 'on') with patch('homeassistant.components.switch.mqtt.async_get_last_state', return_value=mock_coro(fake_state)): assert setup_component(self.hass, switch.DOMAIN, { switch.DOMAIN: { 'platform': 'mqtt', 'name': 'test', 'command_topic': 'command-topic', 'payload_on': 'beer on', 'payload_off': 'beer off', 'qos': '2' } }) state = self.hass.states.get('switch.test') self.assertEqual(STATE_ON, state.state) self.assertTrue(state.attributes.get(ATTR_ASSUMED_STATE)) switch.turn_on(self.hass, 'switch.test') self.hass.block_till_done() self.mock_publish.async_publish.assert_called_once_with( 'command-topic', 'beer on', 2, False) self.mock_publish.async_publish.reset_mock() state = self.hass.states.get('switch.test') self.assertEqual(STATE_ON, state.state) switch.turn_off(self.hass, 'switch.test') self.hass.block_till_done() self.mock_publish.async_publish.assert_called_once_with( 'command-topic', 'beer off', 2, False) state = self.hass.states.get('switch.test') self.assertEqual(STATE_OFF, state.state)
def test_off_script(self): """Test with turn off script.""" global TEST_STATE TEST_STATE = False self.assertTrue(setup_component(self.hass, switch.DOMAIN, { 'switch': { 'platform': 'wake_on_lan', 'mac_address': '00-01-02-03-04-05', 'host': 'validhostname', 'turn_off': { 'service': 'shell_command.turn_off_TARGET', }, } })) calls = mock_service(self.hass, 'shell_command', 'turn_off_TARGET') state = self.hass.states.get('switch.wake_on_lan') self.assertEqual(STATE_OFF, state.state) TEST_STATE = True switch.turn_on(self.hass, 'switch.wake_on_lan') self.hass.block_till_done() state = self.hass.states.get('switch.wake_on_lan') self.assertEqual(STATE_ON, state.state) assert len(calls) == 0 TEST_STATE = False switch.turn_off(self.hass, 'switch.wake_on_lan') self.hass.block_till_done() state = self.hass.states.get('switch.wake_on_lan') self.assertEqual(STATE_OFF, state.state) assert len(calls) == 1
def process_event(self, event): old = self._state # Update state if applicable if event == Events.Disarm: self._state = STATE_ALARM_DISARMED elif event == Events.Trigger: self._state = STATE_ALARM_TRIGGERED elif old == STATE_ALARM_DISARMED: if event == Events.ArmHome: self._state = STATE_ALARM_ARMED_HOME elif event == Events.ArmAway: self._state = STATE_ALARM_PENDING elif event == Events.ArmPerimeter: self._state = STATE_ALARM_ARMED_PERIMETER elif old == STATE_ALARM_PENDING: if event == Events.Timeout: self._state = STATE_ALARM_ARMED_AWAY elif old == STATE_ALARM_ARMED_HOME or \ old == STATE_ALARM_ARMED_AWAY or \ old == STATE_ALARM_ARMED_PERIMETER: if event == Events.ImmediateTrip: self._state = STATE_ALARM_TRIGGERED elif event == Events.DelayedTrip: self._state = STATE_ALARM_WARNING elif old == STATE_ALARM_WARNING: if event == Events.Timeout: self._state = STATE_ALARM_TRIGGERED elif old == STATE_ALARM_TRIGGERED: if event == Events.Timeout: self._state = self._returnto new = self._state if old != new: _LOGGER.debug("Alarm changing from {} to {}".format(old, new)) # Things to do on entering state if new == STATE_ALARM_WARNING: _LOGGER.debug("Turning on warning") switch.turn_on(self._hass, self._warning) self._timeoutat = now() + self._pending_time elif new == STATE_ALARM_TRIGGERED: _LOGGER.debug("Turning on alarm") switch.turn_on(self._hass, self._alarm) self._timeoutat = now() + self._trigger_time elif new == STATE_ALARM_PENDING: _LOGGER.debug("Pending user leaving house") switch.turn_on(self._hass, self._warning) self._timeoutat = now() + self._pending_time self._returnto = STATE_ALARM_ARMED_AWAY self.setsignals(Events.ArmAway) elif new == STATE_ALARM_ARMED_HOME: self._returnto = new self.setsignals(Events.ArmHome) elif new == STATE_ALARM_ARMED_AWAY: self._returnto = new self.setsignals(Events.ArmAway) elif new == STATE_ALARM_ARMED_PERIMETER: self._returnto = new self.setsignals(Events.ArmPerimeter) elif new == STATE_ALARM_DISARMED: self._returnto = new self.clearsignals() # Things to do on leaving state if old == STATE_ALARM_WARNING or old == STATE_ALARM_PENDING: _LOGGER.debug("Turning off warning") switch.turn_off(self._hass, self._warning) elif old == STATE_ALARM_TRIGGERED: _LOGGER.debug("Turning off alarm") switch.turn_off(self._hass, self._alarm) # Let HA know that something changed self.schedule_update_ha_state()
def process_event(self, event): """ WARNING THIS CODE HAS CHANGED. NOTE LIKELY INCORRECT. This is the core logic function. The possible states and things that can change our state are: Actions: isensor dsensor timeout arm_home arm_away disarm trigger Current State: disarmed X X X armh pend * trig pending(T1) X X arma X X dis trig armed(h/a) trig warn X X X dis trig warning(T1) X X trig X X dis trig triggered(T2) X X last X X dis * As the only non-timed states are disarmed, armed_home and armed_away, they are the only ones we can return to after an alarm. """ old = self._state # Update state if applicable if event == Events.Disarm: self._state = STATE_ALARM_DISARMED elif event == Events.Trigger: self._state = STATE_ALARM_TRIGGERED elif old == STATE_ALARM_DISARMED: if event == Events.ArmHome: self._state = STATE_ALARM_ARMED_HOME elif event == Events.ArmAway: self._state = STATE_ALARM_PENDING elif event == Events.ArmPerimeter: self._state = STATE_ALARM_ARMED_PERIMETER elif old == STATE_ALARM_PENDING: if event == Events.Timeout: self._state = STATE_ALARM_ARMED_AWAY elif old == STATE_ALARM_ARMED_HOME or \ old == STATE_ALARM_ARMED_AWAY or \ old == STATE_ALARM_ARMED_PERIMETER: if event == Events.ImmediateTrip: self._state = STATE_ALARM_TRIGGERED elif event == Events.DelayedTrip: self._state = STATE_ALARM_WARNING elif old == STATE_ALARM_WARNING: if event == Events.Timeout: self._state = STATE_ALARM_TRIGGERED elif old == STATE_ALARM_TRIGGERED: if event == Events.Timeout: self._state = self._returnto new = self._state if old != new: _LOGGER.debug("Alarm changing from {} to {}".format(old, new)) # Things to do on entering state if new == STATE_ALARM_WARNING: _LOGGER.debug("Turning on warning") switch.turn_on(self._hass, self._warning) self._timeoutat = now() + self._pending_time elif new == STATE_ALARM_TRIGGERED: _LOGGER.debug("Turning on alarm") switch.turn_on(self._hass, self._alarm) self._timeoutat = now() + self._trigger_time elif new == STATE_ALARM_PENDING: _LOGGER.debug("Pending user leaving house") switch.turn_on(self._hass, self._warning) self._timeoutat = now() + self._pending_time self._returnto = STATE_ALARM_ARMED_AWAY #self.setsignals(False) self.setsignals(Events.ArmAway) elif new == STATE_ALARM_ARMED_HOME: self._returnto = new #self.setsignals(True) self.setsignals(Events.ArmHome) elif new == STATE_ALARM_ARMED_AWAY: self._returnto = new #self.setsignals(False) self.setsignals(Events.ArmAway) elif new == STATE_ALARM_ARMED_PERIMETER: self._returnto = new #self.setsignals(False) self.setsignals(Events.ArmPerimeter) elif new == STATE_ALARM_DISARMED: self._returnto = new self.clearsignals() # Things to do on leaving state if old == STATE_ALARM_WARNING or old == STATE_ALARM_PENDING: _LOGGER.debug("Turning off warning") switch.turn_off(self._hass, self._warning) elif old == STATE_ALARM_TRIGGERED: _LOGGER.debug("Turning off alarm") switch.turn_off(self._hass, self._alarm) # Let HA know that something changed self.schedule_update_ha_state()
def process_event(self, event): """ This is the core logic function. The possible states and things that can change our state are: Actions: isensor dsensor timeout arm_home arm_away disarm trigger Current State: disarmed X X X armh pend * trig pending(T1) X X arma X X dis trig armed(h/a) trig warn X X X dis trig warning(T1) X X trig X X dis trig triggered(T2) X X last X X dis * As the only non-timed states are disarmed, armed_home and armed_away, they are the only ones we can return to after an alarm. """ old = self._state # Update state if applicable if event == Events.Disarm: self._state = STATE_ALARM_DISARMED elif event == Events.Trigger: self._state = STATE_ALARM_TRIGGERED elif old == STATE_ALARM_DISARMED: if event == Events.ArmHome: self._state = STATE_ALARM_ARMED_HOME elif event == Events.ArmAway: self._state = STATE_ALARM_PENDING elif old == STATE_ALARM_PENDING: if event == Events.Timeout: self._state = STATE_ALARM_ARMED_AWAY elif old == STATE_ALARM_ARMED_HOME or \ old == STATE_ALARM_ARMED_AWAY: if event == Events.ImmediateTrip: self._state = STATE_ALARM_TRIGGERED elif event == Events.DelayedTrip: self._state = STATE_ALARM_WARNING elif old == STATE_ALARM_WARNING: if event == Events.Timeout: self._state = STATE_ALARM_TRIGGERED elif old == STATE_ALARM_TRIGGERED: if event == Events.Timeout: self._state = self._returnto new = self._state if old != new: _LOGGER.debug("Alarm changing from {} to {}".format(old, new)) # Things to do on entering state if new == STATE_ALARM_WARNING: _LOGGER.debug("Turning on warning") switch.turn_on(self._hass, self._warning) self._timeoutat = now() + self._pending_time elif new == STATE_ALARM_TRIGGERED: _LOGGER.debug("Turning on alarm") switch.turn_on(self._hass, self._alarm) self._timeoutat = now() + self._trigger_time elif new == STATE_ALARM_PENDING: _LOGGER.debug("Pending user leaving house") switch.turn_on(self._hass, self._warning) self._timeoutat = now() + self._pending_time self._returnto = STATE_ALARM_ARMED_AWAY self.setsignals(False) elif new == STATE_ALARM_ARMED_HOME: self._returnto = new self.setsignals(True) elif new == STATE_ALARM_DISARMED: self._returnto = new self.clearsignals() # Things to do on leaving state if old == STATE_ALARM_WARNING or old == STATE_ALARM_PENDING: _LOGGER.debug("Turning off warning") switch.turn_off(self._hass, self._warning) elif old == STATE_ALARM_TRIGGERED: _LOGGER.debug("Turning off alarm") switch.turn_off(self._hass, self._alarm) # Let HA know that something changed self.schedule_update_ha_state()
def process_event(self, event, override_pending_time=False): old_state = self._state #Update the state of the alarm panel if event == Events.Disarm: self._state = STATE_ALARM_DISARMED elif event == Events.Trigger: self._state = STATE_ALARM_TRIGGERED #If there is a pending time set in either of the state configs then drop into pending mode else simply arm the alarm elif old_state == STATE_ALARM_DISARMED: if event == Events.ArmHome: if (datetime.timedelta(seconds=self._pending_time_by_state[STATE_ALARM_ARMED_HOME]) and override_pending_time == False): self._state = STATE_ALARM_PENDING else: self._state = STATE_ALARM_ARMED_HOME self._armstate = STATE_ALARM_ARMED_HOME elif event == Events.ArmAway: if (datetime.timedelta(seconds=self._pending_time_by_state[STATE_ALARM_ARMED_AWAY]) and override_pending_time == False): self._armstate = STATE_ALARM_ARMED_AWAY self._state = STATE_ALARM_PENDING else: self._state = STATE_ALARM_ARMED_AWAY self._armstate = STATE_ALARM_ARMED_AWAY elif event == Events.ArmPerimeter: if (datetime.timedelta(seconds=self._pending_time_by_state[STATE_ALARM_ARMED_PERIMETER]) and override_pending_time == False): self._armstate = STATE_ALARM_ARMED_PERIMETER self._state = STATE_ALARM_PENDING else: self._state = STATE_ALARM_ARMED_PERIMETER self._armstate = STATE_ALARM_ARMED_PERIMETER elif old_state == STATE_ALARM_PENDING: if event == Events.Timeout: self._state = self._armstate elif old_state == STATE_ALARM_ARMED_HOME or \ old_state == STATE_ALARM_ARMED_AWAY or \ old_state == STATE_ALARM_ARMED_PERIMETER: if event == Events.ImmediateTrip: self._state = STATE_ALARM_TRIGGERED elif event == Events.DelayedTrip: self._state = STATE_ALARM_WARNING elif old_state == STATE_ALARM_WARNING: if event == Events.Timeout: self._state = STATE_ALARM_TRIGGERED elif old_state == STATE_ALARM_TRIGGERED: if event == Events.Timeout: self._state = self._returnto new_state = self._state if old_state != new_state: _LOGGER.debug("[ALARM] Alarm changing from {} to {}".format(old_state, new_state)) # Things to do on entering state if new_state == STATE_ALARM_WARNING: _LOGGER.debug("[ALARM] Turning on warning") switch.turn_on(self._hass, self._warning) self._timeoutat = now() + datetime.timedelta(seconds=self._pending_time_by_state[self._armstate]) elif new_state == STATE_ALARM_TRIGGERED: _LOGGER.debug("[ALARM] Turning on alarm") switch.turn_on(self._hass, self._alarm) self._timeoutat = now() + datetime.timedelta(seconds=self._trigger_time_by_state[self._armstate]) elif new_state == STATE_ALARM_PENDING: _LOGGER.debug("[ALARM] Pending user leaving house") switch.turn_on(self._hass, self._warning) self._timeoutat = now() + datetime.timedelta(seconds=self._pending_time_by_state[self._armstate]) #self._returnto = STATE_ALARM_ARMED_AWAY self.setsignals(self._armstate) elif new_state == STATE_ALARM_ARMED_HOME: self._returnto = new_state self.setsignals(STATE_ALARM_ARMED_HOME) elif new_state == STATE_ALARM_ARMED_AWAY: self._returnto = new_state self.setsignals(STATE_ALARM_ARMED_AWAY) elif new_state == STATE_ALARM_ARMED_PERIMETER: self._returnto = new_state self.setsignals(STATE_ALARM_ARMED_PERIMETER) elif new_state == STATE_ALARM_DISARMED: self._returnto = new_state self.clearsignals() # Things to do on leaving state if old_state == STATE_ALARM_WARNING or old_state == STATE_ALARM_PENDING: _LOGGER.debug("[ALARM] Turning off warning") switch.turn_off(self._hass, self._warning) elif old_state == STATE_ALARM_TRIGGERED: _LOGGER.debug("[ALARM] Turning off alarm") switch.turn_off(self._hass, self._alarm) # Let HA know that something changed if self._persistence: self.save_alarm_state() self.schedule_update_ha_state()