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

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

Parameters:

• range (Range)

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

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

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

rule "Execute when item changed to a range of numbers, from a range of numbers" do
  changed Alarm_Mode, from: 8..10, to: 12..14
  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" do
  changed Alarm_Mode, from: proc { |from| from.odd? }, to: proc {|to| to.even? }
  run { logger.info("Alarm Mode Updated") }
end

rule "Execute when item state is changed from an odd number, to an even number" do
  changed Alarm_Mode, from: -> from { from.odd? }, to: -> to { to.even? }
  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 item is changed for specified duration" do
  changed Closet_Door, to: CLOSED, for: 10.seconds
  run do
    Closet_Light.off
  end
end

Alarm_Delay << 20

rule "Execute rule when item is changed for specified duration" do
  changed Alarm_Mode, for: -> { Alarm_Delay.state.to_i.seconds }
  run { logger.info("Alarm Mode Updated") }
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 "Thing status monitoring" do
  changed things, to: :offline
  run do |event|
    Notification.send("Thing #{event.thing.uid} is offline")
  end
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

Parameters:

• items (Item, GroupItem::Members, Thing, ThingUID, Things::Registry) —

  Objects to create trigger for.

• from (State, Array<State>, #===, nil) (defaults to: nil) —

  Only execute rule if previous state matches from state(s).

• to (State, Array<State>, #===, nil) (defaults to: nil) —

  Only execute rule if new state matches to state(s).

• for (java.time.temporal.TemporalAmount, Proc, nil) (defaults to: nil) —

  Duration for which the item/thing must remain in the same state before executing the execution blocks. When a proc is provided, it will be called when the rule is triggered to get the duration.

• attach (Object, nil) (defaults to: nil) —

  object to be attached to the trigger

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

Parameters:

• channels (String, Core::Things::Channel, Core::Things::ChannelUID) —

  channels to create triggers for in form of 'binding_id:type_id:thing_id#channel_id' or 'channel_id' if thing is provided.

• thing (String, Core::Things::Thing, Core::Things::ThingUID) (defaults to: nil) —

  Thing(s) to create trigger for if not specified with the channel.

• triggered (String, Array<String>) (defaults to: nil) —

  Only execute rule if the event on the channel matches this/these event/events.

• attach (Object) (defaults to: nil) —

  object to be attached to the trigger

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

Parameters:

• item (Item, String, nil) (defaults to: nil) —

  The item to create a trigger for. If nil, all items are matched.

• channel (Core::Things::Channel, Core::Things::ChannelUID, String, nil) (defaults to: nil) —

  The channel to create a trigger for. If nil, all channels are matched.

• attach (Object) (defaults to: nil) —

  object to be attached to the trigger

Since:

• openHAB 4.0 Support for filtering with item and channel was added

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

Parameters:

• item (Item, String, nil) (defaults to: nil) —

  The item to create a trigger for. If nil, all items are matched.

• channel (Core::Things::Channel, Core::Things::ChannelUID, String, nil) (defaults to: nil) —

  The channel to create a trigger for. If nil, all channels are matched.

• attach (Object) (defaults to: nil) —

  object to be attached to the trigger

Since:

• openHAB 4.0 Support for filtering with item and channel was added

Overloads:

• #cron(expression, attach: nil) ⇒ void

  Examples:

  Using a cron expression

  rule "cron expression" do
    cron "43 46 13 ? * ?"
    run { Light.on }
  end

  Parameters:

  • expression (String, nil) —

    openHAB style cron expression

  • attach (Object) (defaults to: nil) —

    object to be attached to the trigger

• #cron(second: nil, minute: nil, hour: nil, dom: nil, month: nil, dow: nil, year: nil, attach: nil) ⇒ void

  The trigger can be created by specifying each field as keyword arguments.

  When certain fields were omitted:

  • The more specific fields will default to 0 for hour, minute, and second, to MON for dow, and to 1 for dom and month.
  • The less specific fields will default to * or ? as appropriate.

  Each field is optional, but at least one must be specified.

  The same rules for the standard cron expression apply for each field. For example, multiple values can be separated with a comma within a string, and ranges can be specified with a dash or with a Ruby Range.

  Examples:

  Using String values

  # Run every 3 minutes on Monday to Friday
  # equivalent to the cron expression "0 */3 * ? * MON-FRI *"
  rule "Using cron fields" do
    cron minute: "*/3", dow: "MON-FRI"
    run { logger.info "Cron rule executed" }
  end

  Defaults for unspecified fields

  # Run at midnight on the first day of January, February, and March
  # equivalent to the cron expression "0 0 0 1 JAN-MAR ? *"
  rule "Using cron fields" do
    cron month: "JAN-MAR"
    run { logger.info "Cron rule executed" }
  end

  Using Ruby Range values

  # Run on the hour, every hour between 1pm and 5pm
  # equivalent to the cron expression "0 0 13-17 ? * ? *"
  rule "Using cron fields" do
    cron hour: 13..17
    run { logger.info "Cron rule executed" }
  end

  Parameters:

  • second (Integer, String, Range, nil) (defaults to: nil)
  • minute (Integer, String, Range, nil) (defaults to: nil)
  • hour (Integer, String, Range, nil) (defaults to: nil)
  • dom (Integer, String, Symbol, Range, nil) (defaults to: nil)
  • month (Integer, String, Symbol, Range, nil) (defaults to: nil)
  • dow (Integer, String, Symbol, Range, nil) (defaults to: nil)
  • year (Integer, String, Range, nil) (defaults to: nil)
  • attach (Object) (defaults to: nil) —

    object to be attached to the trigger

Raises:

• (ArgumentError)

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 { Notification.send("The Door has been open for 10 minutes!") }
end

Parameters:

• debounce_time (Duration, Range) —

  The minimum interval between two consecutive triggers before the rules are allowed to run.

  When specified just as a Duration or an endless range, it sets the minimum interval between two consecutive triggers before rules are executed. It will wait endlessly unless this condition is met or an end of range was specified.

  When the end of the range is specified, it sets the maximum amount of time to wait from the first trigger before the rule will execute, even when triggers continue to occur more frequently than the minimum interval.

  When an equal beginning and ending values are given, it will behave just like #throttle_for.

See Also:

• #throttle_for
• #only_every

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

Parameters:

• duration (java.time.temporal.TemporalAmount) —

  How long to delay for.

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

Parameters:

• trigger_types (Symbol, Array<Symbol>) (defaults to: %i[changed updated]) —

  Trigger types to search for dependencies

Returns:

• (Array<Item, GroupItem::Members>)

Parameters:

• value (String)

rule "disabled rule" do
  enabled(false)
end

Parameters:

• value (true, false)

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

Parameters:

• topic (String) —

  The topic to trigger on; can contain the wildcard *.

• source (String, nil) (defaults to: nil) —

  The sender of the event to trigger on. Default does not filter on source.

• types (String, Array<String>, nil) (defaults to: nil) —

  Only subscribe to certain event types. Default does not filter on event types.

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 "Every day at sunset" do
  every :day, at: Sunset_Time
  run { logger.info "It's getting dark" }
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 "Weekend" do
  every :saturday, :sunday, at: "10:00"
  run { logger.info "It's the weekend!" }
end

Parameters:

• values (String, Duration, java.time.MonthDay, :second, :minute, :hour, :day, :week, :month, :year, :monday, :tuesday, :wednesday, :thursday, :friday, :saturday, :sunday) —

  When to execute rule. Multiple day-of-week can be specified. Otherwise, only one value is allowed.

• at (LocalTime, String, Core::Items::DateTimeItem, nil) (defaults to: nil) —

  What time of day to execute rule If value is :day, at can be a DateTimeItem, and the trigger will run every day at the (time only portion of) current state of the item. If the item is NULL or UNDEF, the trigger will not run.

• attach (Object) (defaults to: nil) —

  Object to be attached to the trigger

Raises:

• (ArgumentError)

See Also:

• #at
• #cron

Returns:

• (String)

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

Parameters:

• pattern (String, nil) (defaults to: "*") —

  The pattern to match items against

• attach (Object) (defaults to: nil) —

  object to be attached to the trigger

Since:

• openHAB 4.0 Support for pattern filter was added

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

Parameters:

• pattern (String, nil) (defaults to: "*") —

  The pattern to match items against

• attach (Object) (defaults to: nil) —

  object to be attached to the trigger

Since:

• openHAB 4.0 Support for pattern filter was added

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

Parameters:

• pattern (String, nil) (defaults to: "*") —

  The pattern to match items against

• attach (Object) (defaults to: nil) —

  object to be attached to the trigger

Parameters:

• value (String)

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

Yield Parameters:

• event (Core::Events::AbstractEvent) —

  The event data that is about to trigger the rule.

Yield Returns:

• (Boolean) —

  A value indicating if the rule should not run.

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

Parameters:

• delay (Duration) (defaults to: nil) —

  The amount of time to wait before executing the rule. When nil, execute immediately.

• attach (Object) (defaults to: nil) —

  Object to be attached to the trigger

Raises:

• (ArgumentError)

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

Parameters:

• at_level (Integer, :rules, :ruleengine, :ui, :things, :complete) (defaults to: nil) —

  Zero or more start levels. Note that Startlevels less than 40 are not available as triggers because the rule engine needs to start up first before it can execute any rules

  Symbol	Start Level
  :osgi	10
  :model	20
  :state	30
  :rules	40
  :ruleengine	50
  :ui	70
  :things	80
  :complete	100

• at_levels (Array<Integer,:rules,:ruleengine,:ui,:things,:complete>) (defaults to: nil) —

  Fluent alias for at_level

• attach (Object) (defaults to: nil) —

  Object to be attached to the trigger

See Also:

• System based triggers

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

Parameters:

• interval (Duration, :second, :minute, :hour, :day) —

  The period during which subsequent triggers are ignored.

See Also:

• #debounce_for
• #throttle_for

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

Yield Parameters:

• event (Core::Events::AbstractEvent) —

  The event data that is about to trigger the rule.

Yield Returns:

• (Boolean) —

  A value indicating if the rule should run.

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

Yield Parameters:

• event (Core::Events::AbstractEvent)

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

Parameters:

• items (Item, GroupItem::Members) —

  Items to create trigger for

• command (Core::Types::Command, Array<Core::Types::Command>, #===, nil) (defaults to: nil) —

  commands to match for trigger

• commands (Array<Core::Types::Command>, #===, nil) (defaults to: nil) —

  Fluent alias for command

• attach (Object) (defaults to: nil) —

  object to be attached to the trigger

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

Yield Parameters:

• event (Core::Events::AbstractEvent)

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

Parameters:

• tags (String, Symbol, Semantics::Tag) —

  A list of tags to assign to the rule.

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

Parameters:

• pattern (String, nil) (defaults to: "*") —

  The pattern to match things against

• attach (Object) (defaults to: nil) —

  object to be attached to the trigger

Since:

• openHAB 4.0 Support for pattern filter was added

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

Parameters:

• pattern (String, nil) (defaults to: "*") —

  The pattern to match things against

• attach (Object) (defaults to: nil) —

  object to be attached to the trigger

Since:

• openHAB 4.0 Support for pattern filter was added

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

Parameters:

• pattern (String, nil) (defaults to: "*") —

  The pattern to match things against

• attach (Object) (defaults to: nil) —

  object to be attached to the trigger

Since:

• openHAB 4.0 Support for pattern filter was added

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

Parameters:

• duration (Duration) —

  The minimum amount of time to wait inbetween rule executions.

See Also:

• #debounce_for
• #only_every

rule 'Execute rule when item time series is updated' do
  time_series_updated MyItem
  run do |event|
    logger.info("Item time series updated: #{event.item.name}.")
    logger.info("  TimeSeries size: #{event.time_series.size}, policy: #{event.time_series.policy}")
    event.time_series.each do |entry|
      timestamp = entry.timestamp.to_time.strftime("%Y-%m-%d %H:%M:%S")
      logger.info("    Entry: #{timestamp}: State: #{entry.state}")
    end
  end
end

Parameters:

• items (Item) —

  Items to create trigger for.

• attach (Object) (defaults to: nil) —

  Object to be attached to the trigger.

See Also:

• TimeSeries
• GenericItem#time_series=

Since:

• openHAB 4.1

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

Parameters:

• type (String) —

  Trigger type UID

• attach (Object) (defaults to: nil) —

  object to be attached to the trigger

• configuration (Hash) —

  A hash containing the trigger configuration entries

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

Yield Parameters:

• item (Item)

Parameters:

• id (String)

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

Parameters:

• items (Item, GroupItem::Members, Thing) —

  Objects to create trigger for.

• to (State, Array<State>, Symbol, String, #===, nil) (defaults to: nil) —

  Only execute rule if the state matches to state(s). If the updated element is a Core::Things::Thing, the to accepts symbols and strings that match supported thing statuses.

• attach (Object) (defaults to: nil) —

  object to be attached to the trigger

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

Parameters:

• path (String) —

  Path to watch. Can be a directory or a file.

• glob (String) (defaults to: "*") —

  Limit events to paths matching this glob. Globs are matched using glob PathMatcher rules.

• for (Array<:created, :deleted, :modified>, :created, :deleted, :modified) (defaults to: %i[created deleted modified]) —

  Types of changes to watch for.

• attach (Object) (defaults to: nil) —

  object to be attached to the trigger