alarm.yaml

---
substitutions:
  name: alarm
  friendly_name: Alarm
  wifi_reboot_timeout: 0s

  alarm_master_code: !secret alarm_master_code

  zone1: GPIO4
  zone2: GPIO2
  zone3: GPIO15
  zone4: GPIO13
  zone5: GPIO18
  zone6: GPIO14
  zone7: GPIO33
  zone8: GPIO32
  zone9: GPIO36
  zone10: GPIO39
  zone11: GPIO34
  zone12: GPIO35
  alarm1: GPIO12
  alarm2: GPIO5
  out1: GPIO23
  out2: GPIO5
  status_led: GPIO3

######### Exposed to HA ##########

# sensor.alarm_state
#   - disarmed
#   - arming
#   - armed_away
#   - armed_home
#   - armed_night
#   - pending
#   - triggered

# service.esphome_${name}_arm
# service.esphome_${name}_arm_away

# service.esphome_${name}_disarm
#   data:
#     code: "XXXXXXX"

##################################

packages:
  common: !include modules/common-32-idf.yaml
  wifi: !include modules/common/wifi.yaml

  master: !include
    file: modules/alarm/zone.yaml
    vars:
      name: Master PIR Motion
      zone: 1
      device_class: motion
  garage: !include
    file: modules/alarm/zone.yaml
    vars:
      name: Garage PIR Motion
      zone: 2
      device_class: motion
  lounge: !include
    file: modules/alarm/zone.yaml
    vars:
      name: Lounge PIR Motion
      zone: 3
      device_class: motion

  smoke: !include
    file: modules/alarm/zone.yaml
    vars:
      name: Smoke
      zone: 4
      inverted: 'true'
      device_class: smoke

external_components:
  source: github://muxa/esphome-state-machine
  components:
    - state_machine

logger:
  logs:
    sensor: INFO

api:
  services:
    - service: arm
      then:
        - state_machine.transition: arm_away
    - service: arm_away
      then:
        - state_machine.transition: arm_away

    - service: disarm
      variables:
        code: string
      then:
        - if:
            condition:
              lambda: |-
                for (int i = 0; i < id(code_count); i++) {
                  if (strcmp(id(codes)[i], code.c_str()) == 0) {
                    id(last_used_code_index) = i;
                    return true;
                  }
                }
                return false;
            then:
              - state_machine.transition: disarm
              - homeassistant.event:
                  event: esphome.alarm_disarmed
                  data:
                    alarm: ${name}
                    code: !lambda 'return id(codes)[id(last_used_code_index)].name;'
            else:
              - state_machine.transition: failed_code
              - homeassistant.event:
                  event: esphome.alarm_failed_code
                  data:
                    alarm: ${name}
                    code: !lambda 'return code;'
        - globals.set:
            id: last_used_code_index
            value: '-1'

    - service: add_code
      variables:
        master_code: string
        new_code: string
        name: string
      then:
        - lambda: |-
            if (master_code != "${alarm_master_code}") {
              ESP_LOGD("alarm", "Invalid master code");
              return;
            }
            for (uint8_t i = 0; i < id(code_count); i++) {
              if (strcmp(id(codes)[i], new_code.c_str()) == 0) {
                ESP_LOGD("alarm", "Code already exists");
                return;
              }
            }
            if (id(code_count) >= 10) {
              ESP_LOGD("alarm", "Max codes reached");
              return;
            }
            memcpy(id(codes)[id(code_count)], new_code.c_str(), new_code.length());
            memcpy(id(code_names)[id(code_count)], name.c_str(), name.length());

            id(code_count)++;
            ESP_LOGD("alarm", "Added code for %s", name);

    - service: remove_code
      variables:
        master_code: string
        name: string
      then:
        - lambda: |-
            if (master_code != "${alarm_master_code}") {
              ESP_LOGD("alarm", "Invalid master code");
              return;
            }
            for (uint8_t i = 0; i < id(code_count); i++) {
              if (strcmp(id(code_names)[i], name.c_str()) == 0) {
                id(codes)[i] = "";
                id(code_names)[i] = "";
                id(code_count)--;
                if (i != id(code_count)) {
                  id(codes)[i] = id(codes)[id(code_count)];
                  id(code_names)[i] = id(code_names)[id(code_count)];
                  id(codes)[id(code_count)] = "";
                  id(code_names)[id(code_count)] = "";
                }
                ESP_LOGD("alarm", "Removed code for %s", name);
                return;
              }
            }
            ESP_LOGD("alarm", "Code not found");

script:
  - id: evaluate_alarm
    then:
      - if:
          condition:
            and:
              - or:
                  - state_machine.state: armed_away
                  - state_machine.state: armed_home
                  - state_machine.state: armed_night
              - or:
                  - lambda: return id(zone1).state;
                  - lambda: return id(zone2).state;
                  - lambda: return id(zone3).state;
                  - lambda: return id(zone4).state;
          then:
            - state_machine.transition: trip

globals:
  - id: incorrect_codes
    type: 'uint8_t'
    restore_value: true
    initial_value: '0'
  - id: codes
    type: 'char[10][10]'
    restore_value: true
    initial_value: '{"${alarm_master_code}","","","","","","","","",""}'
  - id: code_names
    type: 'char[10][10]'
    restore_value: true
    initial_value: '{"Master","","","","","","","","",""}'
  - id: code_count
    type: 'uint8_t'
    restore_value: true
    initial_value: '1'
  - id: last_used_code_index
    type: 'int8_t'
    restore_value: false
    initial_value: '-1'

switch:
  - platform: template
    name: Config Mode
    icon: mdi:shield-edit
    optimistic: true
    entity_category: config

  - platform: template
    name: Trigger Sirens
    id: trigger_sirens
    icon: mdi:bullhorn
    optimistic: true
    entity_category: config
    restore_mode: RESTORE_DEFAULT_OFF

  - id: sirens
    name: Sirens
    pin: $alarm1
    platform: gpio
    icon: mdi:bullhorn

  - id: alarm2
    name: Alarm 2
    pin: $alarm2
    platform: gpio
    icon: mdi:bullhorn

sensor:
  - platform: template
    id: incorrect_codes_sensor
    name: 'Incorrect Codes'
    lambda: return id(incorrect_codes);
    update_interval: never

text_sensor:
  - platform: state_machine
    id: alarm_state_text
    name: State

number:
  - platform: template
    id: arming_timeout
    name: Arming Timeout
    restore_value: true
    initial_value: 60
    unit_of_measurement: seconds
    min_value: 0
    max_value: 300
    step: 1
    mode: box
    optimistic: true
    entity_category: config

  - platform: template
    id: pending_timeout
    name: Pending Timeout
    restore_value: true
    initial_value: 60
    unit_of_measurement: seconds
    min_value: 0
    max_value: 300
    step: 1
    mode: box
    optimistic: true
    entity_category: config

  - platform: template
    id: trigger_timeout
    name: Trigger Timeout
    restore_value: true
    initial_value: 5
    unit_of_measurement: minutes
    min_value: 1
    max_value: 20
    step: 1
    mode: box
    optimistic: true
    entity_category: config

state_machine:
  initial_state: 'disarmed'
  states:
    - name: 'disarmed'

    - name: 'arming'
      on_enter:
        - homeassistant.event:
            event: esphome.alarm_buzzer_start
            data:
              type: arming
              length: !lambda return id(arming_timeout).state;
        - delay: !lambda return id(arming_timeout).state * 1000;
        - state_machine.transition: arm_away
      on_leave:
        - homeassistant.event:
            event: esphome.alarm_buzzer_stop

    - name: 'armed_away'
    - name: 'armed_home'
    - name: 'armed_night'

    - name: 'pending'
      on_enter:
        - homeassistant.event:
            event: esphome.alarm_buzzer_start
            data:
              type: pending
              length: !lambda return id(pending_timeout).state;
        - delay: !lambda return id(pending_timeout).state * 1000;
        - state_machine.transition: trigger
      on_leave:
        - homeassistant.event:
            event: esphome.alarm_buzzer_stop

    - name: 'triggered'
      on_enter:
        - if:
            condition:
              switch.is_on: trigger_sirens
            then:
              - switch.turn_on: sirens
        - homeassistant.event:
            event: esphome.alarm_buzzer_start
            data:
              type: triggered
              length: !lambda return id(trigger_timeout).state;

        - delay: !lambda return id(trigger_timeout).state * 60 * 1000;
        - state_machine.transition: arm_away
      on_leave:
        - switch.turn_off: sirens
        - homeassistant.event:
            event: esphome.alarm_buzzer_stop

  inputs:
    - name: arm_away
      transitions:
        - disarmed -> arming
        - arming -> armed_away
        - triggered -> armed_away

    - name: arm_home
      transitions:
        - disarmed -> armed_home

    - name: arm_night
      transitions:
        - disarmed -> armed_night

    - name: disarm
      transitions:
        - arming -> disarmed
        - armed_away -> disarmed
        - armed_home -> disarmed
        - armed_night -> disarmed
        - pending -> disarmed
        - triggered -> disarmed

    - name: trip
      transitions:
        - armed_away -> pending
        - armed_home -> pending
        - armed_night -> pending

    - name: trigger
      transitions:
        - armed_away -> triggered
        - armed_home -> triggered
        - armed_night -> triggered
        - pending -> triggered

    - name: failed_code
      on_input:
        - lambda: id(incorrect_codes) += 1;
        - component.update: incorrect_codes_sensor
        - if:
            condition:
              lambda: return id(incorrect_codes) >= 3;
            then:
              - state_machine.transition: trigger