An Automation receives Events from some sensors and decides what to do, controlling the actuators. It is implemented as a reactive-banana event network description.

For example, let's make an automation for a fridge, which has a temperature sensor and a relay controlling its power, and should run as needed to keep the temperature in a safe range, while minimizing compressor starts.

 data Sensors = Sensors { fridgeTemperature :: EventSource (Sensed Double) }
 data Actuators = FridgePower PowerChange deriving (Show)
 
 fridge :: Automation Sensors Actuators
 fridge sensors actuators = do
	btemperature <- sensedBehavior (fridgeTemperature sensors)
	let bpowerchange = calcpowerchange <$> btemperature
	onBehaviorChange bpowerchange (actuators . FridgePower)
   where
	calcpowerchange (Sensed temp)
		| temp `belowRange` allowedtemp = Just PowerOff
		| temp `aboveRange` allowedtemp = Just PowerOn
		| otherwise = Nothing
	calcpowerchange SensorUnavailable = Nothing
	allowedtemp = Range 1 4

This is simply a wrapper around reactive-banana's MomentIO, but without the MonadIO instance, so an Automation using this monad is limited to using its sensors and actuators for IO. That allows it to be fully tested using observeAutomation.

All of Reactive.Banana.Combinators can be used with this monad.

Runs an Automation, given a constructor for the sensors, an IO action to drive the actuators, and an IO action that feeds data into the sensors.

Continuing the above example of a fridge, here's how to run it:

mkSensors :: IO Sensors
mkSensors = Sensors <$> newAddHandler

driveActuators :: Actuators -> IO ()
driveActuators = print

getFridgeTemperature :: IO Double
getFridgeTemperature = ...

main = runAutomation fridge mkSensors driveActuators $ \sensors -> do
	getFridgeTemperature >>= sensed (fridgeTemperature sensors)

Note that this function does not return; the sensor feeding action is run in a loop.

Allows observing what an Automation does. Designed to be especially useful for testing.

The Automation is started, and a runner action is returned. The runner allows updating the sensors, and returns what the Automation wants to do in response.

For example, in ghci:

> runner <- observeAutomation fridge mkSensors
> runner $ \sensors -> fridgeTemperature sensors =: 6
[FridgeRelay PowerOn]
> runner $ \sensors -> fridgeTemperature sensors =: 3
[]
> runner $ \sensors -> fridgeTemperature sensors =: 0.5
[FridgeRelay PowerOff]

Note that internal state is maintained between calls to the runner.

A source of events.

Call this to trigger an event.

Get an Event from an EventSource.

Runs an action when an event occurs.

A value read from a sensor.

Sensors are sometimes not available, or have not provided a value yet.

Create an Event from sensed values.

The Event only contains values when the sensor provided a reading, not times when it was unavailable.

Create a Behavior from sensed values.

This is essentially just an application of the stepper combinator.

Call when a sensor has sensed a value.

getFridgeTemperature >>= sensed (fridgeTemperature sensors)

Same as sensed

fridgeTemperature sensors =: 0

A timestamped value.

In reactive-banana, an Event is tagged with its time of occurrence, but that internal representation of time is never exposed. It can be useful to have an Event timestamped as occurring at a specific wall clock time.

See motionActivatedLight for an example of using timestamped values, and how to test code that uses them.

Class of values that are timestamps.

Call when a sensor has sensed a value, which will be Timestamped with the current time.

Call when a sensor sensed a value with a particular timestamp.

Given a Timestamped Event and a function, produces an Event that contains the elapsed time since the function last matched the event's value.

motionActivatedLight has a good example of using this.

For controlling relays and other things that can have their power turned on and off.

Runs an action when a behavior's value changes.

Variant of onBehaviorChange that does nothing when a behavior changes to Nothing.

The range between two values (inclusive).

Note that the position of the two values in the Range constructor is not significant; Range 1 10 == Range 10 1

Check if a value is below a range.

Check if a value is above a range.

Check if a value is within a range.

Extends a range up/down to a value.