Class: OpenHAB::DSL::Rules::BuilderDSL

Examples:

rule "Between guard" do
  changed MotionSensor, to: OPEN
  between "6:05".."14:05:05" # Include end
  run { Light.on }
end

rule "Between guard" do
  changed MotionSensor, to: OPEN
  between "6:05".."14:05:05" # Excludes end second
  run { Light.on }
end

rule "Between guard" do
  changed MotionSensor, to: OPEN
  between LocalTime.of(6, 5)..LocalTime.of(14, 15, 5)
  run { Light.on }
end

rule 'Log an entry if started between 3:30:04 and midnight using strings' do
  on_load
  run { logger.info ("Started at #{LocalTime.now}")}
  between '3:30:04'..LocalTime::MIDNIGHT
end

rule 'Log an entry if started between 3:30:04 and midnight using LocalTime objects' do
  on_load
  run { logger.info ("Started at #{LocalTime.now}")}
  between LocalTime.of(3, 30, 4)..LocalTime::MIDNIGHT
end

rule 'Log an entry if started between March 9th and April 10ths' do
  on_load
  run { logger.info ("Started at #{Time.now}")}
  between '03-09'..'04-10'
end

rule 'Log an entry if started between March 9th and April 10ths' do
  on_load
  run { logger.info ("Started at #{Time.now}")}
  between MonthDay.of(03,09)..'04-06'
end

Examples:

rule "Execute rule when either sensor changed" do
  changed FrontMotion_Sensor, RearMotion_Sensor
  run { |event| logger.info("Motion detected by #{event.item.name}") }
end

rule "Execute rule when member changed" do
  changed Sensors.members
  run { |event| logger.info("Motion detected by #{event.item.name}") }
end

Alarm_Delay << 20

rule "Execute rule when item is changed for specified duration" do
  changed Alarm_Mode, for: -> { Alarm_Delay.state }
  run { logger.info("Alarm Mode Updated") }
end

rule "Execute rule when item is changed to specific number, from specific number, for specified duration" do
  changed Alarm_Mode, from: 8, to: [14,12], for: 12.seconds
  run { logger.info("Alarm Mode Updated") }
end

rule "Execute when item changed to a range of numbers, from a range of numbers, for specified duration" do
  changed Alarm_Mode, from: 8..10, to: 12..14, for: 12.seconds
  run { logger.info("Alarm Mode Updated") }
end

rule "Execute rule when item is changed to any number greater than 12"
  changed Alarm_Mode, to: (12..)   # Parenthesis required for endless ranges
  run { logger.info("Alarm Mode Updated") }
end

rule "Execute when item state is changed from an odd number, to an even number, for specified duration" do
  changed Alarm_Mode, from: proc { |from| from.odd? }, to: proc {|to| to.even? }, for: 12.seconds
  run { logger.info("Alarm Mode Updated") }
end

rule "Execute when item state is changed from an odd number, to an even number, for specified duration" do
  changed Alarm_Mode, from: -> from { from.odd? }, to: -> to { to.even? }, for: 12.seconds
  run { logger.info("Alarm Mode Updated") }
end

rule "Execute when item state is changed to something matching a regex" do
  changed Alarm_Mode, to: /armed/
  run { logger.info("Alarm armed") }
end

rule "Execute rule when thing is changed" do
  changed things["astro:sun:home"], :from => :online, :to => :uninitialized
  run { |event| logger.info("Thing #{event.uid} status <trigger> to #{event.status}") }
end

rule "Log (or notify) when an exterior door is left open for more than 5 minutes" do
  changed ExteriorDoors.members, to: OPEN, for: 5.minutes
  triggered {|door| logger.info("#{door.name} has been left open!") }
end

Examples:

rule "Execute rule when channel is triggered" do
  channel "astro:sun:home:rise#event"
  run { logger.info("Channel triggered") }
end
# The above is the same as each of the below

rule "Execute rule when channel is triggered" do
  channel "rise#event", thing: "astro:sun:home"
  run { logger.info("Channel triggered") }
end

rule "Execute rule when channel is triggered" do
  channel "rise#event", thing: things["astro:sun:home"]
  run { logger.info("Channel triggered") }
end

rule "Execute rule when channel is triggered" do
  channel "rise#event", thing: things["astro:sun:home"].uid
  run { logger.info("Channel triggered") }
end

rule "Execute rule when channel is triggered" do
  channel "rise#event", thing: ["astro:sun:home"]
  run { logger.info("Channel triggered") }
end

rule "Execute rule when channel is triggered" do
  channel things["astro:sun:home"].channels["rise#event"]
  run { logger.info("Channel triggered") }
end

rule "Execute rule when channel is triggered" do
  channel things["astro:sun:home"].channels["rise#event"].uid
  run { logger.info("Channel triggered") }
end

rule "Rule provides access to channel trigger events in run block" do
  channel "astro:sun:home:rise#event", triggered: 'START'
  run { |trigger| logger.info("Channel(#{trigger.channel}) triggered event: #{trigger.event}") }
end

rule "Keypad Code Received test" do
  channel "mqtt:homie300:mosquitto:backgate:keypad#code"
  run do |event|
    logger.info("Received keycode from #{event.channel.thing.uid.id}")
  end
end

rule "Rules support multiple channels" do
  channel "rise#event", "set#event", thing: "astro:sun:home"
  run { logger.info("Channel triggered") }
end

rule "Rules support multiple channels and triggers" do
  channel "rise#event", "set#event", thing: "astro:sun:home", triggered: ["START", "STOP"]
  run { logger.info("Channel triggered") }
end

rule "Rules support multiple things" do
  channel "keypad#code", thing: ["mqtt:homie300:keypad1", "mqtt:homie300:keypad2"]
  run { logger.info("Channel triggered") }
end

Examples:

rule "channel linked" do
  channel_linked
  run do |event|
    logger.info("#{event.link.item.name} linked to #{event.link.channel_uid}.")
  end
end

Examples:

rule "channel unlinked" do
  channel_unlinked
  run do |event|
    logger.info("#{event.link.item_name} unlinked from #{event.link.channel_uid}.")
  end
end

Examples:

rule do
  changed Item1
  debounce_for 1.minute
  run { ... }
end

# Note: When combined with a state check (only_if), this becomes functionally
# equivalent to the changed duration feature.
rule "Door alert" do
  changed Door_State
  debounce_for 10.minutes
  only_if { Door_State.open? }
  run { notify("The Door has been open for 10 minutes!") }
end

Examples:

rule "delay execution" do
  changed MotionSensor, to: CLOSED
  delay 5.seconds
  run { Light.off }
end

rule 'Delay sleeps between execution elements' do
  on_load
  run { logger.info("Sleeping") }
  delay 5.seconds
  run { logger.info("Awake") }
end

rule 'Multiple delays can exist in a rule' do
  on_load
  run { logger.info("Sleeping") }
  delay 5.seconds
  run { logger.info("Sleeping Again") }
  delay 5.seconds
  run { logger.info("Awake") }
end

rule 'Dim a switch on system startup over 100 seconds' do
  on_load
  100.times do
    run { DimmerSwitch.dim }
    delay 1.second
  end
end

Examples:

rule do |rule|
  changed Item1, Item2, Item3
  only_if { rule.dependencies.all?(&:state?) }
  run { FormulaItem.update(Item3.state - (Item1.state + Item2.state)) }
end

Examples:

rule "disabled rule" do
  enabled(false)
end

Examples:

rule "thing updated" do
  event("openhab/things/*/updated", types: "ThingUpdatedEvent")
  run do |event|
    logger.info("#{event.thing.uid} updated")
  end
end

Examples:

rule "Daily" do
  every :day, at: '5:15'
  run do
    Light.on
  end
end

rule "Daily" do
  every :day, at: LocalTime.of(5, 15)
  run { Light.on }
end

rule "Weekly" do
  every :monday, at: '5:15'
  run do
    Light.on
  end
end

rule "Often" do
  every :minute
  run do
    Light.on
  end
end

rule "Hourly" do
  every :hour
  run do
    Light.on
  end
end

rule "Often" do
  every 5.minutes
  run do
    Light.on
  end
end

rule 'Every 14th of Feb at 2pm' do
  every '02-14', at: '2pm'
  run { logger.info "Happy Valentine's Day!" }
end

rule "Every day at sunset" do
  every :day, at: Sunset_Time
  run { logger.info "It's getting dark" }
end

Examples:

rule "item added" do
  item_added
  run do |event|
    logger.info("#{event.item.name} added.")
  end
end

Examples:

rule "item removed" do
  item_removed
  run do |event|
    logger.info("#{event.item.name} removed.")
  end
end

Examples:

rule "item updated" do
  item_updated
  run do |event|
    logger.info("#{event.item.name} updated.")
  end
end

Examples:

rule "Set OutsideDimmer to 50% if LightSwtich turned on and OtherSwitch is OFF" do
  changed LightSwitch, to: ON
  run { OutsideDimmer << 50 }
  not_if { OtherSwitch.on? }
end

rule "Set OutsideDimmer to 50% if LightSwitch turned on and OtherSwitch is OFF and Door is not CLOSED" do
  changed LightSwitch, to: ON
  run { OutsideDimmer << 50 }
  not_if { OtherSwitch.on? }
  not_if { Door.closed? }
end

Examples:

rule "script startup rule" do
  on_load
  run do
    <calculate some item state>
  end
end

rule "Ensure all security lights are on" do
  on_load
  run { Security_Lights.on }
end

Examples:

rule "Trigger at openHAB system start" do
  on_start # trigger at the default startlevel 100
  run { logger.info "openHAB start up complete." }
end

rule "Trigger after things are loaded" do
  on_start at_level: :things
  run { logger.info "Things are ready!" }
end

rule "Multiple start up triggers" do
  on_start at_levels: %i[ui things complete]
  run do |event|
    logger.info "openHAB startlevel has reached level #{event.startlevel}"
  end
end

Examples:

rule "Aircon Vent Control" do
  changed BedRoom_Temperature
  only_every 10.minutes
  run do
    # Adjust BedRoom_Aircon_Vent
  end
end

# They can keep pressing the door bell as often as they like,
# but the bell will only ring at most once every minute
rule do
  updated DoorBell_Button, to: "single"
  only_every 1.minute
  run { Audio.play_stream "doorbell.mp3" }
end

rule "Display update" do
  updated Power_Usage
  only_every :minute
  run { Power_Usage_Display.update "Current power usage: #{Power_Usage.average_since(1.minute.ago)}" }
end

Examples:

rule "Set OutsideDimmer to 50% if LightSwitch turned on and OtherSwitch is also ON" do
  changed LightSwitch, to: ON
  run { OutsideDimmer << 50 }
  only_if { OtherSwitch.on? }
end

rule "Set OutsideDimmer to 50% if LightSwitch turned on and OtherSwitch is also ON and Door is closed" do
  changed LightSwitch, to: ON
  run { OutsideDimmer << 50 }
  only_if { OtherSwitch.on? }
  only_if { Door.closed? }
end

rule "Set OutsideDimmer to 50% if any switch in group Switches starting with Outside is switched On" do
  changed Switches.items, to: ON
  run { OutsideDimmer << 50 }
  only_if { |event| event.item.name.start_with?("Outside") }
end

Examples:

rule 'Turn switch ON or OFF based on value of another switch' do
  on_load
  run { TestSwitch << ON }
  otherwise { TestSwitch << OFF }
  only_if { OtherSwitch.on? }
end

Examples:

rule 'Execute rule when item received command' do
  received_command Alarm_Mode
  run { |event| logger.info("Item received command: #{event.command}" ) }
end

rule 'Execute rule when item receives specific command' do
  received_command Alarm_Mode, command: 7
  run { |event| logger.info("Item received command: #{event.command}" ) }
end

rule 'Execute rule when item receives one of many specific commands' do
  received_command Alarm_Mode, commands: [7,14]
  run { |event| logger.info("Item received command: #{event.command}" ) }
end

rule 'Execute rule when group receives a specific command' do
  received_command AlarmModes
  triggered { |item| logger.info("Group #{item.name} received command")}
end

rule 'Execute rule when member of group receives any command' do
  received_command AlarmModes.members
  triggered { |item| logger.info("Group item #{item.name} received command")}
end

rule 'Execute rule when member of group is changed to one of many states' do
  received_command AlarmModes.members, commands: [7, 14]
  triggered { |item| logger.info("Group item #{item.name} received command")}
end

rule 'Execute rule when item receives a range of commands' do
  received_command Alarm_Mode, commands: 7..14
  run { |event| logger.info("Item received command: #{event.command}" ) }
end

rule 'Execute rule when Alarm Mode command is odd' do
  received_command Alarm_Mode, command: proc { |c| c.odd? }
  run { |event| logger.info("Item received command: #{event.command}" ) }
end

rule 'Execute rule when Alarm Mode command is odd' do
  received_command Alarm_Mode, command: -> c { c.odd? }
  run { |event| logger.info("Item received command: #{event.command}" ) }
end

rule 'Execute rule when Alarm Mode command matches a substring' do
  received_command Alarm_Mode, command: /arm/
  run { |event| logger.info("Item received command: #{event.command}" ) }
end

Examples:

rule 'Access Event Properties' do
  changed TestSwitch
  run { |event| logger.info("#{event.item.name} triggered from #{event.was} to #{event.state}") }
end

rule 'Multi Line Run Block' do
  changed TestSwitch
  run do |event|
    logger.info("#{event.item.name} triggered")
    logger.info("from #{event.was}") if event.was?
    logger.info("to #{event.state}") if event.state?
   end
end

rule 'Multiple Run Blocks' do
  changed TestSwitch
  run { |event| logger.info("#{event.item.name} triggered") }
  run { |event| logger.info("from #{event.was}") if event.was? }
  run { |event| logger.info("to #{event.state}") if event.state?  }
end

Examples:

rule "tagged rule" do
  tags "lighting", "security"
end

Examples:

rule "thing added" do
  thing_added
  run do |event|
    logger.info("#{event.thing.uid} added.")
  end
end

Examples:

rule "thing removed" do
  thing_removed
  run do |event|
    logger.info("#{event.thing.uid} removed.")
  end
end

Examples:

rule "thing updated" do
  thing_updated
  run do |event|
    logger.info("#{event.thing.uid} updated.")
  end
end

Examples:

rule "Update Power Summary " do |rule|
  changed Power_From_Solar, Power_Load, Power_From_Grid
  throttle_for 1.second
  only_if { rule.dependencies.all?(&:state?) } # make sure all items have a state
  run do
    msg = []
    msg << Power_Load.state.negate.to_unit("kW").format("Load: %.2f %unit%")
    msg << Power_From_Solar.state.to_unit("kW").format("PV: %.2f %unit%")
    if Power_From_Grid.positive?
      msg << Power_From_Grid.state.to_unit("kW").format("From Grid: %.1f %unit%")
    else
      msg << Power_From_Grid.state.negate.to_unit("kW").format("To Grid: %.1f %unit%")
    end
    Power_Summary.update(msg.join(", "))
  end
end

Examples:

rule 'PID Control' do
  trigger 'pidcontroller.trigger',
    input: InputItem.name,
    setpoint: SetPointItem.name,
    kp: 10,
    ki: 10,
    kd: 10,
    kdTimeConstant: 1,
    loopTime: 1000

  run do |event|
    logger.info("PID controller command: #{event.command}")
    ControlItem << event.command
  end
end

rule 'DateTime Trigger' do
  description 'Triggers at a time specified in MyDateTimeItem'
  trigger 'timer.DateTimeTrigger', itemName: MyDateTimeItem.name
  run do
    logger.info("DateTimeTrigger has been triggered")
  end
end

Examples:

rule "motion sensor triggered" do
  changed MotionSensor.members, to: :OPEN
  triggered do |item|
    logger.info("#{item.name} detected motion")
  end
end

rule 'Triggered has access directly to item triggered' do
  changed TestSwitch
  triggered { |item| logger.info("#{item.name} triggered") }
end

# Switches is a group of Switch items
rule 'Triggered item is item changed when a group item is changed.' do
  changed Switches.members
  triggered { |item| logger.info("Switch #{item.name} changed to #{item.state}")}
end

rule 'Turn off any switch that changes' do
  changed Switches.members
  triggered(&:off)
end

rule 'Turn a switch off and log it, 5 seconds after turning it on' do
  changed Switches.members, to: ON
  delay 5.seconds
  triggered(&:off)
  triggered {|item| logger.info("#{item.label} turned off") }
end

Examples:

rule 'Execute rule when item is updated to any value' do
  updated Alarm_Mode
  run { logger.info("Alarm Mode Updated") }
end

rule 'Execute rule when item is updated to specific number' do
  updated Alarm_Mode, to: 7
  run { logger.info("Alarm Mode Updated") }
end

rule 'Execute rule when item is updated to one of many specific states' do
  updated Alarm_Mode, to: [7, 14]
  run { logger.info("Alarm Mode Updated")}
end

rule 'Execute rule when item is within a range' do
  updated Alarm_Mode, to: 7..14
  run { logger.info("Alarm Mode Updated to a value between 7 and 14")}
end

rule 'Execute rule when group is updated to any state' do
  updated AlarmModes
  triggered { |item| logger.info("Group #{item.name} updated")}
end

rule 'Execute rule when member of group is changed to any state' do
  updated AlarmModes.members
  triggered { |item| logger.info("Group item #{item.name} updated")}
end

rule 'Execute rule when member of group is changed to one of many states' do
  updated AlarmModes.members, to: [7, 14]
  triggered { |item| logger.info("Group item #{item.name} updated")}
end

rule 'Execute rule when member of group is changed to an odd state' do
  updated AlarmModes.members, to: proc { |t| t.odd? }
  triggered { |item| logger.info("Group item #{item.name} updated")}
end

rule 'Execute rule when member of group is changed to an odd state' do
  updated AlarmModes.members, to: -> t { t.odd? }
  triggered { |item| logger.info("Group item #{item.name} updated")}
end

rule 'Execute rule when member of group is changed to a substring' do
  updated AlarmModes.members, to: /armed/
  triggered { |item| logger.info("Group item #{item.name} updated")}
end

rule 'Execute rule when thing is updated' do
   updated things['astro:sun:home'], :to => :uninitialized
   run { |event| logger.info("Thing #{event.uid} status <trigger> to #{event.status}") }
end

Examples:

rule 'watch directory' do
  watch OpenHAB::Core.config_folder / 'items'
  run { |event| logger.info("#{event.path.basename} - #{event.type}") }
end

rule 'watch directory' do
  watch OpenHAB::Core.config_folder / 'items', glob: '*.erb'
  run { |event| logger.info("#{event.path.basename} - #{event.type}") }
end

rule 'watch directory' do
  watch OpenHAB::Core.config_folder / 'items/foo.items'
  run { |event| logger.info("#{event.path.basename} - #{event.type}") }
end

rule 'watch directory' do
  watch OpenHAB::Core.config_folder / 'items/*.items'
  run { |event| logger.info("#{event.path.basename} - #{event.type}") }
end

rule 'watch directory' do
  watch OpenHAB::Core.config_folder / 'items/*.items', for: [:deleted, :created]
  run { |event| logger.info("#{event.path.basename} - #{event.type}") }
end

rule "Watch recursively" do
  watch OpenHAB::Core.config_folder / "automation/ruby/lib/**"
  run { |event| logger.info("#{event.path} - #{event.type}") }
end

rule "Monitor changes in the list of installed gems" do
  watch ENV['GEM_HOME'], glob: "gems/*"
  run { |event| logger.info("#{event.path} - #{event.type}") }
end

rule "Watch recursively" do
  watch OpenHAB::Core.config_folder / "automation/ruby/lib", glob: "**"
  run { |event| logger.info("#{event.path} - #{event.type}") }
end